diff --git a/.gitattributes b/.gitattributes index ec56fd3c2008af01e34fa02686aaff10da90a455..cf4c6bbfc0f4773d13b62b2019317718984aba6a 100644 --- a/.gitattributes +++ b/.gitattributes @@ -352,3 +352,31 @@ shared/package-files/40/40da9341758e7d778e7c5310207d327b76aa8836101f4ea7e94e9067 shared/package-files/41/4141415c8a105e52fdfd45e0c3c9d0cd9a4adc4c9eb69b7426eb268e53a196b5/blob filter=lfs diff=lfs merge=lfs -text shared/package-files/41/4175c7f0363ada56cf3dbce13f6b8afc3dea3b08bba96c648e7912f87511b6fe/blob filter=lfs diff=lfs merge=lfs -text shared/package-files/41/417f32ec19ff77404494c4aa49d4e4477ac8904c23661e6df70620ce6e26ab11/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/41/41c6e13b296e71c76e86fa20b1e5a184c2a99c931e77f95fb3486f73a06f00d7/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/41/41cac51c9f92ffe7a4bbf83041bf6f9317b714ece180b65187a5edb1884d1c29/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/41/41d4d08956f385ba5968965511255f4ba72050c2448ca6916896bddcde3dc346/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/41/41ee96f160ccca37ebf3ed10fa95b98e0803be54b448083ef92c6ac8cf6f6312/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/42/4210969f70fd62d78c425c5faec9ce171bbcad9d8e851023bf698ba81fdb88c0/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/42/4239de96773a37e2874fd38becafee81909702e58f06eb9c932a683d47a6946a/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/42/42444a4411d59e501e080a8876abe6cb9d9d94c5df6f4f289b468679accdc07f/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/42/42864efe330a0d47c29afc480949e810cc082ac3417d30d43702c2dc5548be69/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/42/42c5c2abcc858ac5d3bc6f1f8304158a313ee39db243aa30493a5f3ce3366795/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/42/42cf224dd64557e7d427094be7ae18395c17df0bbb849c9bf7ab8f238d7628ff/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/43100d30c34d2eb13e03cb4a808748d14681b69c6fdc2f2e7ae97bf23513609a/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/4333610e3354704d33815f7b3767626d93f46ff8bd6c69f417d90b9d5734e4d2/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/433df3699d3ca5610697eeea3d2fcbadd6b70ccc6f2309e65bffc9e33b97aa56/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/434278a2390e651df0f7a19061ca835b9f2817a57529b85dcd1324963abe4a85/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/4358374c599427b08746241c6294a33661daf0fc5c421a6cafb69d0c4b7b3354/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/436381bdecd5b99ce2b56bfab79ef225058735c09ef10350b7a6e08a008e8bb1/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/437ffecdb57c1d8357a8d275df3e54bd4c96a9a58e6671dfe0b25fbc51b26ef1/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/43/43a7e71d6a2aefd310629e7cd71f9979702cc406eb2b0e12586fb6f56eebec3f/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/44/441a5d7750bc07db39b7bc0372bf3f38e7b7e2a11c5b8e6bd3e83534ee5a5eea/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/44/449ac6908a5ffa64670b1bdd0c1742729d396eb69323440a537605a0f1a394ef/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/44/449b4b5a9343bc4bc1f97aaf7fd3c0864ed43cca1048cc823cd0b5b4679f3934/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/44/44df135283655f5881633bfdcadb42f9e2e211463aa1484992c9156529d200ec/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/44/44feebba310d24561afa6f498beef670d38e4fa91eb3da58ef919b170a6839b3/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/45/453349bb31bd4758057336ad43d3952dc870c6fd837280d7870b47cbfe67de24/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/45/456fe124e1b71c1475a9e79a2994a4479bb135308d992d06200d53a0ad7d941e/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/45/45888f066fa3f2d823c10d1635eb9cb1a82d54ce95589b5b425d0bdfd23fb18c/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/45/458bb348a5bed943199eaf3618b9ed541e65fad61c438af1a6cb72250ff567e8/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/45/45f810caf95292f82800ffc82c958c18bf17436116a063d82a472189b9880a27/blob filter=lfs diff=lfs merge=lfs -text diff --git a/shared/package-files/41/41afc530ff9989deed3854cd88d8e756b622ed890ae212ad70626202ff3ce01c/blob b/shared/package-files/41/41afc530ff9989deed3854cd88d8e756b622ed890ae212ad70626202ff3ce01c/blob new file mode 100644 index 0000000000000000000000000000000000000000..4c86d873bd11fb45676d8db37a5d60b032276ecc --- /dev/null +++ b/shared/package-files/41/41afc530ff9989deed3854cd88d8e756b622ed890ae212ad70626202ff3ce01c/blob @@ -0,0 +1,372 @@ +""" +Module for reading and writing matlab (TM) .mat files +""" +# Authors: Travis Oliphant, Matthew Brett + +from contextlib import contextmanager + +from ._miobase import _get_matfile_version, docfiller +from ._mio4 import MatFile4Reader, MatFile4Writer +from ._mio5 import MatFile5Reader, MatFile5Writer + +__all__ = ['loadmat', 'savemat', 'whosmat'] + + +@contextmanager +def _open_file_context(file_like, appendmat, mode='rb'): + f, opened = _open_file(file_like, appendmat, mode) + try: + yield f + finally: + if opened: + f.close() + + +def _open_file(file_like, appendmat, mode='rb'): + """ + Open `file_like` and return as file-like object. First, check if object is + already file-like; if so, return it as-is. Otherwise, try to pass it + to open(). If that fails, and `file_like` is a string, and `appendmat` is true, + append '.mat' and try again. + """ + reqs = {'read'} if set(mode) & set('r+') else set() + if set(mode) & set('wax+'): + reqs.add('write') + if reqs.issubset(dir(file_like)): + return file_like, False + + try: + return open(file_like, mode), True + except OSError as e: + # Probably "not found" + if isinstance(file_like, str): + if appendmat and not file_like.endswith('.mat'): + file_like += '.mat' + return open(file_like, mode), True + else: + raise OSError( + 'Reader needs file name or open file-like object' + ) from e + + +@docfiller +def mat_reader_factory(file_name, appendmat=True, **kwargs): + """ + Create reader for matlab .mat format files. + + Parameters + ---------- + %(file_arg)s + %(append_arg)s + %(load_args)s + %(struct_arg)s + + Returns + ------- + matreader : MatFileReader object + Initialized instance of MatFileReader class matching the mat file + type detected in `filename`. + file_opened : bool + Whether the file was opened by this routine. + + """ + byte_stream, file_opened = _open_file(file_name, appendmat) + mjv, mnv = _get_matfile_version(byte_stream) + if mjv == 0: + return MatFile4Reader(byte_stream, **kwargs), file_opened + elif mjv == 1: + return MatFile5Reader(byte_stream, **kwargs), file_opened + elif mjv == 2: + raise NotImplementedError('Please use HDF reader for matlab v7.3 ' + 'files, e.g. h5py') + else: + raise TypeError(f'Did not recognize version {mjv}') + + +@docfiller +def loadmat(file_name, mdict=None, appendmat=True, *, spmatrix=True, **kwargs): + """ + Load MATLAB file. + + Parameters + ---------- + file_name : str + Name of the mat file (do not need .mat extension if + appendmat==True). Can also pass open file-like object. + mdict : dict, optional + Dictionary in which to insert matfile variables. + appendmat : bool, optional + True to append the .mat extension to the end of the given + filename, if not already present. Default is True. + spmatrix : bool, optional (default: True) + If ``True``, return sparse ``coo_matrix``. Otherwise return ``coo_array``. + Only relevant for sparse variables. + byte_order : str or None, optional + None by default, implying byte order guessed from mat + file. Otherwise can be one of ('native', '=', 'little', '<', + 'BIG', '>'). + mat_dtype : bool, optional + If True, return arrays in same dtype as would be loaded into + MATLAB (instead of the dtype with which they are saved). + squeeze_me : bool, optional + Whether to squeeze unit matrix dimensions or not. + chars_as_strings : bool, optional + Whether to convert char arrays to string arrays. + matlab_compatible : bool, optional + Returns matrices as would be loaded by MATLAB (implies + squeeze_me=False, chars_as_strings=False, mat_dtype=True, + struct_as_record=True). + struct_as_record : bool, optional + Whether to load MATLAB structs as NumPy record arrays, or as + old-style NumPy arrays with dtype=object. Setting this flag to + False replicates the behavior of scipy version 0.7.x (returning + NumPy object arrays). The default setting is True, because it + allows easier round-trip load and save of MATLAB files. + verify_compressed_data_integrity : bool, optional + Whether the length of compressed sequences in the MATLAB file + should be checked, to ensure that they are not longer than we expect. + It is advisable to enable this (the default) because overlong + compressed sequences in MATLAB files generally indicate that the + files have experienced some sort of corruption. + variable_names : None or sequence + If None (the default) - read all variables in file. Otherwise, + `variable_names` should be a sequence of strings, giving names of the + MATLAB variables to read from the file. The reader will skip any + variable with a name not in this sequence, possibly saving some read + processing. + simplify_cells : False, optional + If True, return a simplified dict structure (which is useful if the mat + file contains cell arrays). Note that this only affects the structure + of the result and not its contents (which is identical for both output + structures). If True, this automatically sets `struct_as_record` to + False and `squeeze_me` to True, which is required to simplify cells. + uint16_codec : str, optional + The codec to use for decoding characters, which are stored as uint16 + values. The default uses the system encoding, but this can be manually + set to other values such as 'ascii', 'latin1', and 'utf-8'. This + parameter is relevant only for files stored as v6 and above, and not + for files stored as v4. + + Returns + ------- + mat_dict : dict + dictionary with variable names as keys, and loaded matrices as values. + + Notes + ----- + v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported. + + You will need an HDF5 Python library to read MATLAB 7.3 format mat + files. Because SciPy does not supply one, we do not implement the + HDF5 / 7.3 interface here. + + Examples + -------- + >>> from os.path import dirname, join as pjoin + >>> import scipy.io as sio + + Get the filename for an example .mat file from the tests/data directory. + + >>> data_dir = pjoin(dirname(sio.__file__), 'matlab', 'tests', 'data') + >>> mat_fname = pjoin(data_dir, 'testdouble_7.4_GLNX86.mat') + + Load the .mat file contents. + + >>> mat_contents = sio.loadmat(mat_fname, spmatrix=False) + + The result is a dictionary, one key/value pair for each variable: + + >>> sorted(mat_contents.keys()) + ['__globals__', '__header__', '__version__', 'testdouble'] + >>> mat_contents['testdouble'] + array([[0. , 0.78539816, 1.57079633, 2.35619449, 3.14159265, + 3.92699082, 4.71238898, 5.49778714, 6.28318531]]) + + By default SciPy reads MATLAB structs as structured NumPy arrays where the + dtype fields are of type `object` and the names correspond to the MATLAB + struct field names. This can be disabled by setting the optional argument + `struct_as_record=False`. + + Get the filename for an example .mat file that contains a MATLAB struct + called `teststruct` and load the contents. + + >>> matstruct_fname = pjoin(data_dir, 'teststruct_7.4_GLNX86.mat') + >>> matstruct_contents = sio.loadmat(matstruct_fname) + >>> teststruct = matstruct_contents['teststruct'] + >>> teststruct.dtype + dtype([('stringfield', 'O'), ('doublefield', 'O'), ('complexfield', 'O')]) + + The size of the structured array is the size of the MATLAB struct, not the + number of elements in any particular field. The shape defaults to 2-D + unless the optional argument `squeeze_me=True`, in which case all length 1 + dimensions are removed. + + >>> teststruct.size + 1 + >>> teststruct.shape + (1, 1) + + Get the 'stringfield' of the first element in the MATLAB struct. + + >>> teststruct[0, 0]['stringfield'] + array(['Rats live on no evil star.'], + dtype='>> teststruct['doublefield'][0, 0] + array([[ 1.41421356, 2.71828183, 3.14159265]]) + + Load the MATLAB struct, squeezing out length 1 dimensions, and get the item + from the 'complexfield'. + + >>> matstruct_squeezed = sio.loadmat(matstruct_fname, squeeze_me=True) + >>> matstruct_squeezed['teststruct'].shape + () + >>> matstruct_squeezed['teststruct']['complexfield'].shape + () + >>> matstruct_squeezed['teststruct']['complexfield'].item() + array([ 1.41421356+1.41421356j, 2.71828183+2.71828183j, + 3.14159265+3.14159265j]) + """ + variable_names = kwargs.pop('variable_names', None) + with _open_file_context(file_name, appendmat) as f: + MR, _ = mat_reader_factory(f, **kwargs) + matfile_dict = MR.get_variables(variable_names) + if spmatrix: + from scipy.sparse import issparse, coo_matrix + for name, var in list(matfile_dict.items()): + if issparse(var): + matfile_dict[name] = coo_matrix(var) + + if mdict is not None: + mdict.update(matfile_dict) + else: + mdict = matfile_dict + + return mdict + + +@docfiller +def savemat(file_name, mdict, + appendmat=True, + format='5', + long_field_names=False, + do_compression=False, + oned_as='row'): + """ + Save a dictionary of names and arrays into a MATLAB-style .mat file. + + This saves the array objects in the given dictionary to a MATLAB- + style .mat file. + + Parameters + ---------- + file_name : str or file-like object + Name of the .mat file (.mat extension not needed if ``appendmat == + True``). + Can also pass open file_like object. + mdict : dict + Dictionary from which to save matfile variables. + appendmat : bool, optional + True (the default) to append the .mat extension to the end of the + given filename, if not already present. + format : {'5', '4'}, string, optional + '5' (the default) for MATLAB 5 and up (to 7.2), + '4' for MATLAB 4 .mat files. + long_field_names : bool, optional + False (the default) - maximum field name length in a structure is + 31 characters which is the documented maximum length. + True - maximum field name length in a structure is 63 characters + which works for MATLAB 7.6+. + do_compression : bool, optional + Whether or not to compress matrices on write. Default is False. + oned_as : {'row', 'column'}, optional + If 'column', write 1-D NumPy arrays as column vectors. + If 'row', write 1-D NumPy arrays as row vectors. + + Examples + -------- + >>> from scipy.io import savemat + >>> import numpy as np + >>> a = np.arange(20) + >>> mdic = {"a": a, "label": "experiment"} + >>> mdic + {'a': array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19]), + 'label': 'experiment'} + >>> savemat("matlab_matrix.mat", mdic) + """ + with _open_file_context(file_name, appendmat, 'wb') as file_stream: + if format == '4': + if long_field_names: + message = "Long field names are not available for version 4 files" + raise ValueError(message) + MW = MatFile4Writer(file_stream, oned_as) + elif format == '5': + MW = MatFile5Writer(file_stream, + do_compression=do_compression, + unicode_strings=True, + long_field_names=long_field_names, + oned_as=oned_as) + else: + raise ValueError("Format should be '4' or '5'") + MW.put_variables(mdict) + + +@docfiller +def whosmat(file_name, appendmat=True, **kwargs): + """ + List variables inside a MATLAB file. + + Parameters + ---------- + %(file_arg)s + %(append_arg)s + %(load_args)s + %(struct_arg)s + + Returns + ------- + variables : list of tuples + A list of tuples, where each tuple holds the matrix name (a string), + its shape (tuple of ints), and its data class (a string). + Possible data classes are: int8, uint8, int16, uint16, int32, uint32, + int64, uint64, single, double, cell, struct, object, char, sparse, + function, opaque, logical, unknown. + + Notes + ----- + v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported. + + You will need an HDF5 python library to read matlab 7.3 format mat + files (e.g. h5py). Because SciPy does not supply one, we do not implement the + HDF5 / 7.3 interface here. + + .. versionadded:: 0.12.0 + + Examples + -------- + >>> from io import BytesIO + >>> import numpy as np + >>> from scipy.io import savemat, whosmat + + Create some arrays, and use `savemat` to write them to a ``BytesIO`` + instance. + + >>> a = np.array([[10, 20, 30], [11, 21, 31]], dtype=np.int32) + >>> b = np.geomspace(1, 10, 5) + >>> f = BytesIO() + >>> savemat(f, {'a': a, 'b': b}) + + Use `whosmat` to inspect ``f``. Each tuple in the output list gives + the name, shape and data type of the array in ``f``. + + >>> whosmat(f) + [('a', (2, 3), 'int32'), ('b', (1, 5), 'double')] + + """ + with _open_file_context(file_name, appendmat) as f: + ML, file_opened = mat_reader_factory(f, **kwargs) + variables = ML.list_variables() + return variables diff --git a/shared/package-files/41/41b0189d71536ce4b79f53a7b5a096235c775c86d65fdea8470cb203d039bd9c/blob b/shared/package-files/41/41b0189d71536ce4b79f53a7b5a096235c775c86d65fdea8470cb203d039bd9c/blob new file mode 100644 index 0000000000000000000000000000000000000000..40a7044b139832f40d0489728379b8443240803c --- /dev/null +++ b/shared/package-files/41/41b0189d71536ce4b79f53a7b5a096235c775c86d65fdea8470cb203d039bd9c/blob @@ -0,0 +1,17 @@ +from typing import Tuple + +from . import _LangModelType + +KOI8R_char_to_order_map: Tuple[int, ...] +win1251_char_to_order_map: Tuple[int, ...] +latin5_char_to_order_map: Tuple[int, ...] +macCyrillic_char_to_order_map: Tuple[int, ...] +IBM855_char_to_order_map: Tuple[int, ...] +IBM866_char_to_order_map: Tuple[int, ...] +RussianLangModel: Tuple[int, ...] +Koi8rModel: _LangModelType +Win1251CyrillicModel: _LangModelType +Latin5CyrillicModel: _LangModelType +MacCyrillicModel: _LangModelType +Ibm866Model: _LangModelType +Ibm855Model: _LangModelType diff --git a/shared/package-files/41/41b0c932922029d59dd6b99c62e4a11c41827599ee5a29a217cbffb77a77793b/blob b/shared/package-files/41/41b0c932922029d59dd6b99c62e4a11c41827599ee5a29a217cbffb77a77793b/blob new file mode 100644 index 0000000000000000000000000000000000000000..a8e2e5bc1bfdfd29d61048147286d0256de4c9e0 --- /dev/null +++ b/shared/package-files/41/41b0c932922029d59dd6b99c62e4a11c41827599ee5a29a217cbffb77a77793b/blob @@ -0,0 +1,108 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates +from typing import Dict, Union + +import torch +import torch.distributed._tensor.random as random +import torch.nn as nn +from torch.distributed._tensor import ( + DeviceMesh, +) +from torch.distributed._tensor.random import ( + is_rng_supported_mesh, + TensorParallelRNGTracker, +) +from torch.distributed.tensor.parallel._utils import _validate_tp_mesh_dim +from torch.distributed.tensor.parallel.style import ( + ParallelStyle, +) + + +__all__ = [ + "parallelize_module", +] + + +def parallelize_module( # type: ignore[return] + module: nn.Module, + device_mesh: DeviceMesh, + parallelize_plan: Union[ParallelStyle, Dict[str, ParallelStyle]], +) -> nn.Module: + """ + Apply Tensor Parallelism in PyTorch by parallelizing modules or sub-modules based on a user-specified plan. + + We parallelize module or sub_modules based on a parallelize_plan. The parallelize_plan contains + :class:`ParallelStyle`, which indicates how user wants the module or sub_module + to be parallelized. + + User can also specify different parallel style per module fully qualified name (FQN). + + Note that ``parallelize_module`` only accepts a 1-D :class:`DeviceMesh`, if you have a 2-D or N-D :class:`DeviceMesh`, + slice the DeviceMesh to a 1-D sub DeviceMesh first then pass to this API(i.e. ``device_mesh[\"tp\"]``) + + Args: + module (:class:`nn.Module`): + Module to be parallelized. + device_mesh (:class:`DeviceMesh`): + Object which describes the mesh topology + of devices for the DTensor. + parallelize_plan (Union[:class:`ParallelStyle`, Dict[str, :class:`ParallelStyle`]]): + The plan used to parallelize the module. It can be either a + :class:`ParallelStyle` object which contains how + we prepare input/output for Tensor Parallelism or it can be a + dict of module FQN and its corresponding :class:`ParallelStyle` object. + Return: + A :class:`nn.Module` object parallelized. + + Example:: + >>> # xdoctest: +SKIP("distributed") + >>> from torch.distributed.tensor.parallel import parallelize_module, ColwiseParallel + >>> from torch.distributed.device_mesh import init_device_mesh + >>> + >>> # Define the module. + >>> m = Model(...) + >>> tp_mesh = init_device_mesh("cuda", (8,)) + >>> m = parallelize_module(m, tp_mesh, {"w1": ColwiseParallel(), "w2": RowwiseParallel()}) + >>> + + .. note:: For complex module architecture like Attention, MLP layers, we recommend composing + different ParallelStyles together (i.e. ``ColwiseParallel`` and ``RowwiseParallel``) and pass + as a parallelize_plan, to achieves the desired sharding computation. + """ + torch._C._log_api_usage_once("torch.distributed.tensor.parallel.parallelize_module") + + _validate_tp_mesh_dim(device_mesh) + + # instantiate a TP RNG state tracker if it's not there + if is_rng_supported_mesh(device_mesh) and not isinstance( + random._rng_tracker, TensorParallelRNGTracker + ): + random._rng_tracker = TensorParallelRNGTracker(device_mesh.device_type) + # TODO: we should allow user to pass in the default seed from a config + random._rng_tracker._manual_seed(device_mesh, base_seed=1234) + # By default we execute random ops in non-tensor-parallel region. If users want + # to execute in tensor-parallel region, they can manually set this field to True + # after parallelizing the model. + random._rng_tracker.distribute_region_enabled = False + + if isinstance(parallelize_plan, ParallelStyle): + return parallelize_plan._apply(module, device_mesh) + elif isinstance(parallelize_plan, dict): + for module_path, parallelize_style in parallelize_plan.items(): + sub_module = module.get_submodule(module_path) + parent_module = module + if "." in module_path: + parent_module_path = ".".join(module_path.split(".")[:-1]) + parent_module = module.get_submodule(parent_module_path) + module_path = module_path.split(".")[-1] + parent_module.register_module( # type: ignore[call-arg] # pyre-ignore[20] + module_path, + parallelize_module( # type: ignore[arg-type] + sub_module, device_mesh, parallelize_style # type: ignore[arg-type] # pyre-ignore[6] + ), + ) + return module + else: + raise RuntimeError( # pyre-ignore[7] + "Expect Union[ParallelStyle, Dict[str, ParallelStyle]] for" + f" parallelize_plan, {type(parallelize_plan)} found!" + ) diff --git a/shared/package-files/41/41b37281c4f21f309f4a934aef0159409d9d109d5ddae2142546232e5b2f9011/blob b/shared/package-files/41/41b37281c4f21f309f4a934aef0159409d9d109d5ddae2142546232e5b2f9011/blob new file mode 100644 index 0000000000000000000000000000000000000000..84c81f1844fdb7dec5d86564a2a3ead6f4ca8436 --- /dev/null +++ b/shared/package-files/41/41b37281c4f21f309f4a934aef0159409d9d109d5ddae2142546232e5b2f9011/blob @@ -0,0 +1,112 @@ +# +# The Python Imaging Library. +# $Id$ +# +# transform wrappers +# +# History: +# 2002-04-08 fl Created +# +# Copyright (c) 2002 by Secret Labs AB +# Copyright (c) 2002 by Fredrik Lundh +# +# See the README file for information on usage and redistribution. +# +from __future__ import annotations + +from typing import Sequence + +from . import Image + + +class Transform(Image.ImageTransformHandler): + method: Image.Transform + + def __init__(self, data: Sequence[int]) -> None: + self.data = data + + def getdata(self) -> tuple[int, Sequence[int]]: + return self.method, self.data + + def transform( + self, + size: tuple[int, int], + image: Image.Image, + **options: dict[str, str | int | tuple[int, ...] | list[int]], + ) -> Image.Image: + # can be overridden + method, data = self.getdata() + return image.transform(size, method, data, **options) + + +class AffineTransform(Transform): + """ + Define an affine image transform. + + This function takes a 6-tuple (a, b, c, d, e, f) which contain the first + two rows from an affine transform matrix. For each pixel (x, y) in the + output image, the new value is taken from a position (a x + b y + c, + d x + e y + f) in the input image, rounded to nearest pixel. + + This function can be used to scale, translate, rotate, and shear the + original image. + + See :py:meth:`~PIL.Image.Image.transform` + + :param matrix: A 6-tuple (a, b, c, d, e, f) containing the first two rows + from an affine transform matrix. + """ + + method = Image.Transform.AFFINE + + +class ExtentTransform(Transform): + """ + Define a transform to extract a subregion from an image. + + Maps a rectangle (defined by two corners) from the image to a rectangle of + the given size. The resulting image will contain data sampled from between + the corners, such that (x0, y0) in the input image will end up at (0,0) in + the output image, and (x1, y1) at size. + + This method can be used to crop, stretch, shrink, or mirror an arbitrary + rectangle in the current image. It is slightly slower than crop, but about + as fast as a corresponding resize operation. + + See :py:meth:`~PIL.Image.Image.transform` + + :param bbox: A 4-tuple (x0, y0, x1, y1) which specifies two points in the + input image's coordinate system. See :ref:`coordinate-system`. + """ + + method = Image.Transform.EXTENT + + +class QuadTransform(Transform): + """ + Define a quad image transform. + + Maps a quadrilateral (a region defined by four corners) from the image to a + rectangle of the given size. + + See :py:meth:`~PIL.Image.Image.transform` + + :param xy: An 8-tuple (x0, y0, x1, y1, x2, y2, x3, y3) which contain the + upper left, lower left, lower right, and upper right corner of the + source quadrilateral. + """ + + method = Image.Transform.QUAD + + +class MeshTransform(Transform): + """ + Define a mesh image transform. A mesh transform consists of one or more + individual quad transforms. + + See :py:meth:`~PIL.Image.Image.transform` + + :param data: A list of (bbox, quad) tuples. + """ + + method = Image.Transform.MESH diff --git a/shared/package-files/41/41b5052fe85ce699fef7db72e3cec88ff2434b925f5883da732441b95fa1a437/blob b/shared/package-files/41/41b5052fe85ce699fef7db72e3cec88ff2434b925f5883da732441b95fa1a437/blob new file mode 100644 index 0000000000000000000000000000000000000000..3b88038a894ffdd320f80a82157573ad7a4f8de4 --- /dev/null +++ b/shared/package-files/41/41b5052fe85ce699fef7db72e3cec88ff2434b925f5883da732441b95fa1a437/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API int64_t _fused_sdp_choice_cpp(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const c10::optional & attn_mask={}, double dropout_p=0.0, bool is_causal=false, c10::optional scale=c10::nullopt); +TORCH_API int64_t _fused_sdp_choice_cuda(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const c10::optional & attn_mask={}, double dropout_p=0.0, bool is_causal=false, c10::optional scale=c10::nullopt); +TORCH_API int64_t _fused_sdp_choice_meta(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const c10::optional & attn_mask={}, double dropout_p=0.0, bool is_causal=false, c10::optional scale=c10::nullopt); +} // namespace native +} // namespace at diff --git a/shared/package-files/41/41b64e0aa22f9da2b45ce1f791a49705efa6ff5fd16f7de9b2af04f963120535/blob b/shared/package-files/41/41b64e0aa22f9da2b45ce1f791a49705efa6ff5fd16f7de9b2af04f963120535/blob new file mode 100644 index 0000000000000000000000000000000000000000..bdb6ce66ce79b808f044124156db4b803dab155e Binary files /dev/null and b/shared/package-files/41/41b64e0aa22f9da2b45ce1f791a49705efa6ff5fd16f7de9b2af04f963120535/blob differ diff --git a/shared/package-files/41/41b65e49401b21d55f0d478d672cb2fa5f01a9b2b2f0bf947936bcf0073444dc/blob b/shared/package-files/41/41b65e49401b21d55f0d478d672cb2fa5f01a9b2b2f0bf947936bcf0073444dc/blob new file mode 100644 index 0000000000000000000000000000000000000000..bf3b3596d1beea8b50c9c81db74d91ffcb42c16b --- /dev/null +++ b/shared/package-files/41/41b65e49401b21d55f0d478d672cb2fa5f01a9b2b2f0bf947936bcf0073444dc/blob @@ -0,0 +1,27 @@ +import abc +import torch.nn as nn + +class Sharder(abc.ABC): + """ + This is an interface which allows user to create more advanced + sharding strategies that are not easily be composed by the + `ShardingSpec`. + + :class:`torch.distributed._shard.sharding_plan.ShardingPlan` could + take an object of the `Sharder` and call `shard` to shard the module, + then replace the original module with sharded module returned. + """ + @abc.abstractmethod + def shard(self, module: nn.Module) -> nn.Module: + """ + Shard a module base on the implementation of this method, and + return the sharded version of the module. + + Args: + module (:class:`torch.nn.Module`): + The module to apply sharding to. + Returns: + A :class:`torch.nn.Module` object that represents a module + that's already been sharded. + """ + pass diff --git a/shared/package-files/41/41b8ab7ebbcab1e626accda42e31c784d18d80ee83b07252d6772e1f93e73d3e/blob b/shared/package-files/41/41b8ab7ebbcab1e626accda42e31c784d18d80ee83b07252d6772e1f93e73d3e/blob new file mode 100644 index 0000000000000000000000000000000000000000..19a16e2436048c5fc044008fefe850e03764bd30 --- /dev/null +++ b/shared/package-files/41/41b8ab7ebbcab1e626accda42e31c784d18d80ee83b07252d6772e1f93e73d3e/blob @@ -0,0 +1,2387 @@ +""" +This is our testing framework. + +Goals: + +* it should be compatible with py.test and operate very similarly + (or identically) +* does not require any external dependencies +* preferably all the functionality should be in this file only +* no magic, just import the test file and execute the test functions, that's it +* portable + +""" + +import os +import sys +import platform +import inspect +import traceback +import pdb +import re +import linecache +import time +from fnmatch import fnmatch +from timeit import default_timer as clock +import doctest as pdoctest # avoid clashing with our doctest() function +from doctest import DocTestFinder, DocTestRunner +import random +import subprocess +import shutil +import signal +import stat +import tempfile +import warnings +from contextlib import contextmanager +from inspect import unwrap + +from sympy.core.cache import clear_cache +from sympy.external import import_module +from sympy.external.gmpy import GROUND_TYPES, HAS_GMPY + +IS_WINDOWS = (os.name == 'nt') +ON_CI = os.getenv('CI', None) + +# empirically generated list of the proportion of time spent running +# an even split of tests. This should periodically be regenerated. +# A list of [.6, .1, .3] would mean that if the tests are evenly split +# into '1/3', '2/3', '3/3', the first split would take 60% of the time, +# the second 10% and the third 30%. These lists are normalized to sum +# to 1, so [60, 10, 30] has the same behavior as [6, 1, 3] or [.6, .1, .3]. +# +# This list can be generated with the code: +# from time import time +# import sympy +# import os +# os.environ["CI"] = 'true' # Mock CI to get more correct densities +# delays, num_splits = [], 30 +# for i in range(1, num_splits + 1): +# tic = time() +# sympy.test(split='{}/{}'.format(i, num_splits), time_balance=False) # Add slow=True for slow tests +# delays.append(time() - tic) +# tot = sum(delays) +# print([round(x / tot, 4) for x in delays]) +SPLIT_DENSITY = [ + 0.0059, 0.0027, 0.0068, 0.0011, 0.0006, + 0.0058, 0.0047, 0.0046, 0.004, 0.0257, + 0.0017, 0.0026, 0.004, 0.0032, 0.0016, + 0.0015, 0.0004, 0.0011, 0.0016, 0.0014, + 0.0077, 0.0137, 0.0217, 0.0074, 0.0043, + 0.0067, 0.0236, 0.0004, 0.1189, 0.0142, + 0.0234, 0.0003, 0.0003, 0.0047, 0.0006, + 0.0013, 0.0004, 0.0008, 0.0007, 0.0006, + 0.0139, 0.0013, 0.0007, 0.0051, 0.002, + 0.0004, 0.0005, 0.0213, 0.0048, 0.0016, + 0.0012, 0.0014, 0.0024, 0.0015, 0.0004, + 0.0005, 0.0007, 0.011, 0.0062, 0.0015, + 0.0021, 0.0049, 0.0006, 0.0006, 0.0011, + 0.0006, 0.0019, 0.003, 0.0044, 0.0054, + 0.0057, 0.0049, 0.0016, 0.0006, 0.0009, + 0.0006, 0.0012, 0.0006, 0.0149, 0.0532, + 0.0076, 0.0041, 0.0024, 0.0135, 0.0081, + 0.2209, 0.0459, 0.0438, 0.0488, 0.0137, + 0.002, 0.0003, 0.0008, 0.0039, 0.0024, + 0.0005, 0.0004, 0.003, 0.056, 0.0026] +SPLIT_DENSITY_SLOW = [0.0086, 0.0004, 0.0568, 0.0003, 0.0032, 0.0005, 0.0004, 0.0013, 0.0016, 0.0648, 0.0198, 0.1285, 0.098, 0.0005, 0.0064, 0.0003, 0.0004, 0.0026, 0.0007, 0.0051, 0.0089, 0.0024, 0.0033, 0.0057, 0.0005, 0.0003, 0.001, 0.0045, 0.0091, 0.0006, 0.0005, 0.0321, 0.0059, 0.1105, 0.216, 0.1489, 0.0004, 0.0003, 0.0006, 0.0483] + +class Skipped(Exception): + pass + +class TimeOutError(Exception): + pass + +class DependencyError(Exception): + pass + + +def _indent(s, indent=4): + """ + Add the given number of space characters to the beginning of + every non-blank line in ``s``, and return the result. + If the string ``s`` is Unicode, it is encoded using the stdout + encoding and the ``backslashreplace`` error handler. + """ + # This regexp matches the start of non-blank lines: + return re.sub('(?m)^(?!$)', indent*' ', s) + + +pdoctest._indent = _indent # type: ignore + +# override reporter to maintain windows and python3 + + +def _report_failure(self, out, test, example, got): + """ + Report that the given example failed. + """ + s = self._checker.output_difference(example, got, self.optionflags) + s = s.encode('raw_unicode_escape').decode('utf8', 'ignore') + out(self._failure_header(test, example) + s) + + +if IS_WINDOWS: + DocTestRunner.report_failure = _report_failure # type: ignore + + +def convert_to_native_paths(lst): + """ + Converts a list of '/' separated paths into a list of + native (os.sep separated) paths and converts to lowercase + if the system is case insensitive. + """ + newlst = [] + for i, rv in enumerate(lst): + rv = os.path.join(*rv.split("/")) + # on windows the slash after the colon is dropped + if sys.platform == "win32": + pos = rv.find(':') + if pos != -1: + if rv[pos + 1] != '\\': + rv = rv[:pos + 1] + '\\' + rv[pos + 1:] + newlst.append(os.path.normcase(rv)) + return newlst + + +def get_sympy_dir(): + """ + Returns the root SymPy directory and set the global value + indicating whether the system is case sensitive or not. + """ + this_file = os.path.abspath(__file__) + sympy_dir = os.path.join(os.path.dirname(this_file), "..", "..") + sympy_dir = os.path.normpath(sympy_dir) + return os.path.normcase(sympy_dir) + + +def setup_pprint(): + from sympy.interactive.printing import init_printing + from sympy.printing.pretty.pretty import pprint_use_unicode + import sympy.interactive.printing as interactive_printing + + # force pprint to be in ascii mode in doctests + use_unicode_prev = pprint_use_unicode(False) + + # hook our nice, hash-stable strprinter + init_printing(pretty_print=False) + + # Prevent init_printing() in doctests from affecting other doctests + interactive_printing.NO_GLOBAL = True + return use_unicode_prev + + +@contextmanager +def raise_on_deprecated(): + """Context manager to make DeprecationWarning raise an error + + This is to catch SymPyDeprecationWarning from library code while running + tests and doctests. It is important to use this context manager around + each individual test/doctest in case some tests modify the warning + filters. + """ + with warnings.catch_warnings(): + warnings.filterwarnings('error', '.*', DeprecationWarning, module='sympy.*') + yield + + +def run_in_subprocess_with_hash_randomization( + function, function_args=(), + function_kwargs=None, command=sys.executable, + module='sympy.testing.runtests', force=False): + """ + Run a function in a Python subprocess with hash randomization enabled. + + If hash randomization is not supported by the version of Python given, it + returns False. Otherwise, it returns the exit value of the command. The + function is passed to sys.exit(), so the return value of the function will + be the return value. + + The environment variable PYTHONHASHSEED is used to seed Python's hash + randomization. If it is set, this function will return False, because + starting a new subprocess is unnecessary in that case. If it is not set, + one is set at random, and the tests are run. Note that if this + environment variable is set when Python starts, hash randomization is + automatically enabled. To force a subprocess to be created even if + PYTHONHASHSEED is set, pass ``force=True``. This flag will not force a + subprocess in Python versions that do not support hash randomization (see + below), because those versions of Python do not support the ``-R`` flag. + + ``function`` should be a string name of a function that is importable from + the module ``module``, like "_test". The default for ``module`` is + "sympy.testing.runtests". ``function_args`` and ``function_kwargs`` + should be a repr-able tuple and dict, respectively. The default Python + command is sys.executable, which is the currently running Python command. + + This function is necessary because the seed for hash randomization must be + set by the environment variable before Python starts. Hence, in order to + use a predetermined seed for tests, we must start Python in a separate + subprocess. + + Hash randomization was added in the minor Python versions 2.6.8, 2.7.3, + 3.1.5, and 3.2.3, and is enabled by default in all Python versions after + and including 3.3.0. + + Examples + ======== + + >>> from sympy.testing.runtests import ( + ... run_in_subprocess_with_hash_randomization) + >>> # run the core tests in verbose mode + >>> run_in_subprocess_with_hash_randomization("_test", + ... function_args=("core",), + ... function_kwargs={'verbose': True}) # doctest: +SKIP + # Will return 0 if sys.executable supports hash randomization and tests + # pass, 1 if they fail, and False if it does not support hash + # randomization. + + """ + cwd = get_sympy_dir() + # Note, we must return False everywhere, not None, as subprocess.call will + # sometimes return None. + + # First check if the Python version supports hash randomization + # If it does not have this support, it won't recognize the -R flag + p = subprocess.Popen([command, "-RV"], stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, cwd=cwd) + p.communicate() + if p.returncode != 0: + return False + + hash_seed = os.getenv("PYTHONHASHSEED") + if not hash_seed: + os.environ["PYTHONHASHSEED"] = str(random.randrange(2**32)) + else: + if not force: + return False + + function_kwargs = function_kwargs or {} + + # Now run the command + commandstring = ("import sys; from %s import %s;sys.exit(%s(*%s, **%s))" % + (module, function, function, repr(function_args), + repr(function_kwargs))) + + try: + p = subprocess.Popen([command, "-R", "-c", commandstring], cwd=cwd) + p.communicate() + except KeyboardInterrupt: + p.wait() + finally: + # Put the environment variable back, so that it reads correctly for + # the current Python process. + if hash_seed is None: + del os.environ["PYTHONHASHSEED"] + else: + os.environ["PYTHONHASHSEED"] = hash_seed + return p.returncode + + +def run_all_tests(test_args=(), test_kwargs=None, + doctest_args=(), doctest_kwargs=None, + examples_args=(), examples_kwargs=None): + """ + Run all tests. + + Right now, this runs the regular tests (bin/test), the doctests + (bin/doctest), and the examples (examples/all.py). + + This is what ``setup.py test`` uses. + + You can pass arguments and keyword arguments to the test functions that + support them (for now, test, doctest, and the examples). See the + docstrings of those functions for a description of the available options. + + For example, to run the solvers tests with colors turned off: + + >>> from sympy.testing.runtests import run_all_tests + >>> run_all_tests(test_args=("solvers",), + ... test_kwargs={"colors:False"}) # doctest: +SKIP + + """ + tests_successful = True + + test_kwargs = test_kwargs or {} + doctest_kwargs = doctest_kwargs or {} + examples_kwargs = examples_kwargs or {'quiet': True} + + try: + # Regular tests + if not test(*test_args, **test_kwargs): + # some regular test fails, so set the tests_successful + # flag to false and continue running the doctests + tests_successful = False + + # Doctests + print() + if not doctest(*doctest_args, **doctest_kwargs): + tests_successful = False + + # Examples + print() + sys.path.append("examples") # examples/all.py + from all import run_examples # type: ignore + if not run_examples(*examples_args, **examples_kwargs): + tests_successful = False + + if tests_successful: + return + else: + # Return nonzero exit code + sys.exit(1) + except KeyboardInterrupt: + print() + print("DO *NOT* COMMIT!") + sys.exit(1) + + +def test(*paths, subprocess=True, rerun=0, **kwargs): + """ + Run tests in the specified test_*.py files. + + Tests in a particular test_*.py file are run if any of the given strings + in ``paths`` matches a part of the test file's path. If ``paths=[]``, + tests in all test_*.py files are run. + + Notes: + + - If sort=False, tests are run in random order (not default). + - Paths can be entered in native system format or in unix, + forward-slash format. + - Files that are on the blacklist can be tested by providing + their path; they are only excluded if no paths are given. + + **Explanation of test results** + + ====== =============================================================== + Output Meaning + ====== =============================================================== + . passed + F failed + X XPassed (expected to fail but passed) + f XFAILed (expected to fail and indeed failed) + s skipped + w slow + T timeout (e.g., when ``--timeout`` is used) + K KeyboardInterrupt (when running the slow tests with ``--slow``, + you can interrupt one of them without killing the test runner) + ====== =============================================================== + + + Colors have no additional meaning and are used just to facilitate + interpreting the output. + + Examples + ======== + + >>> import sympy + + Run all tests: + + >>> sympy.test() # doctest: +SKIP + + Run one file: + + >>> sympy.test("sympy/core/tests/test_basic.py") # doctest: +SKIP + >>> sympy.test("_basic") # doctest: +SKIP + + Run all tests in sympy/functions/ and some particular file: + + >>> sympy.test("sympy/core/tests/test_basic.py", + ... "sympy/functions") # doctest: +SKIP + + Run all tests in sympy/core and sympy/utilities: + + >>> sympy.test("/core", "/util") # doctest: +SKIP + + Run specific test from a file: + + >>> sympy.test("sympy/core/tests/test_basic.py", + ... kw="test_equality") # doctest: +SKIP + + Run specific test from any file: + + >>> sympy.test(kw="subs") # doctest: +SKIP + + Run the tests with verbose mode on: + + >>> sympy.test(verbose=True) # doctest: +SKIP + + Do not sort the test output: + + >>> sympy.test(sort=False) # doctest: +SKIP + + Turn on post-mortem pdb: + + >>> sympy.test(pdb=True) # doctest: +SKIP + + Turn off colors: + + >>> sympy.test(colors=False) # doctest: +SKIP + + Force colors, even when the output is not to a terminal (this is useful, + e.g., if you are piping to ``less -r`` and you still want colors) + + >>> sympy.test(force_colors=False) # doctest: +SKIP + + The traceback verboseness can be set to "short" or "no" (default is + "short") + + >>> sympy.test(tb='no') # doctest: +SKIP + + The ``split`` option can be passed to split the test run into parts. The + split currently only splits the test files, though this may change in the + future. ``split`` should be a string of the form 'a/b', which will run + part ``a`` of ``b``. For instance, to run the first half of the test suite: + + >>> sympy.test(split='1/2') # doctest: +SKIP + + The ``time_balance`` option can be passed in conjunction with ``split``. + If ``time_balance=True`` (the default for ``sympy.test``), SymPy will attempt + to split the tests such that each split takes equal time. This heuristic + for balancing is based on pre-recorded test data. + + >>> sympy.test(split='1/2', time_balance=True) # doctest: +SKIP + + You can disable running the tests in a separate subprocess using + ``subprocess=False``. This is done to support seeding hash randomization, + which is enabled by default in the Python versions where it is supported. + If subprocess=False, hash randomization is enabled/disabled according to + whether it has been enabled or not in the calling Python process. + However, even if it is enabled, the seed cannot be printed unless it is + called from a new Python process. + + Hash randomization was added in the minor Python versions 2.6.8, 2.7.3, + 3.1.5, and 3.2.3, and is enabled by default in all Python versions after + and including 3.3.0. + + If hash randomization is not supported ``subprocess=False`` is used + automatically. + + >>> sympy.test(subprocess=False) # doctest: +SKIP + + To set the hash randomization seed, set the environment variable + ``PYTHONHASHSEED`` before running the tests. This can be done from within + Python using + + >>> import os + >>> os.environ['PYTHONHASHSEED'] = '42' # doctest: +SKIP + + Or from the command line using + + $ PYTHONHASHSEED=42 ./bin/test + + If the seed is not set, a random seed will be chosen. + + Note that to reproduce the same hash values, you must use both the same seed + as well as the same architecture (32-bit vs. 64-bit). + + """ + # count up from 0, do not print 0 + print_counter = lambda i : (print("rerun %d" % (rerun-i)) + if rerun-i else None) + + if subprocess: + # loop backwards so last i is 0 + for i in range(rerun, -1, -1): + print_counter(i) + ret = run_in_subprocess_with_hash_randomization("_test", + function_args=paths, function_kwargs=kwargs) + if ret is False: + break + val = not bool(ret) + # exit on the first failure or if done + if not val or i == 0: + return val + + # rerun even if hash randomization is not supported + for i in range(rerun, -1, -1): + print_counter(i) + val = not bool(_test(*paths, **kwargs)) + if not val or i == 0: + return val + + +def _test(*paths, + verbose=False, tb="short", kw=None, pdb=False, colors=True, + force_colors=False, sort=True, seed=None, timeout=False, + fail_on_timeout=False, slow=False, enhance_asserts=False, split=None, + time_balance=True, blacklist=(), + fast_threshold=None, slow_threshold=None): + """ + Internal function that actually runs the tests. + + All keyword arguments from ``test()`` are passed to this function except for + ``subprocess``. + + Returns 0 if tests passed and 1 if they failed. See the docstring of + ``test()`` for more information. + """ + kw = kw or () + # ensure that kw is a tuple + if isinstance(kw, str): + kw = (kw,) + post_mortem = pdb + if seed is None: + seed = random.randrange(100000000) + if ON_CI and timeout is False: + timeout = 595 + fail_on_timeout = True + if ON_CI: + blacklist = list(blacklist) + ['sympy/plotting/pygletplot/tests'] + blacklist = convert_to_native_paths(blacklist) + r = PyTestReporter(verbose=verbose, tb=tb, colors=colors, + force_colors=force_colors, split=split) + t = SymPyTests(r, kw, post_mortem, seed, + fast_threshold=fast_threshold, + slow_threshold=slow_threshold) + + test_files = t.get_test_files('sympy') + + not_blacklisted = [f for f in test_files + if not any(b in f for b in blacklist)] + + if len(paths) == 0: + matched = not_blacklisted + else: + paths = convert_to_native_paths(paths) + matched = [] + for f in not_blacklisted: + basename = os.path.basename(f) + for p in paths: + if p in f or fnmatch(basename, p): + matched.append(f) + break + + density = None + if time_balance: + if slow: + density = SPLIT_DENSITY_SLOW + else: + density = SPLIT_DENSITY + + if split: + matched = split_list(matched, split, density=density) + + t._testfiles.extend(matched) + + return int(not t.test(sort=sort, timeout=timeout, slow=slow, + enhance_asserts=enhance_asserts, fail_on_timeout=fail_on_timeout)) + + +def doctest(*paths, subprocess=True, rerun=0, **kwargs): + r""" + Runs doctests in all \*.py files in the SymPy directory which match + any of the given strings in ``paths`` or all tests if paths=[]. + + Notes: + + - Paths can be entered in native system format or in unix, + forward-slash format. + - Files that are on the blacklist can be tested by providing + their path; they are only excluded if no paths are given. + + Examples + ======== + + >>> import sympy + + Run all tests: + + >>> sympy.doctest() # doctest: +SKIP + + Run one file: + + >>> sympy.doctest("sympy/core/basic.py") # doctest: +SKIP + >>> sympy.doctest("polynomial.rst") # doctest: +SKIP + + Run all tests in sympy/functions/ and some particular file: + + >>> sympy.doctest("/functions", "basic.py") # doctest: +SKIP + + Run any file having polynomial in its name, doc/src/modules/polynomial.rst, + sympy/functions/special/polynomials.py, and sympy/polys/polynomial.py: + + >>> sympy.doctest("polynomial") # doctest: +SKIP + + The ``split`` option can be passed to split the test run into parts. The + split currently only splits the test files, though this may change in the + future. ``split`` should be a string of the form 'a/b', which will run + part ``a`` of ``b``. Note that the regular doctests and the Sphinx + doctests are split independently. For instance, to run the first half of + the test suite: + + >>> sympy.doctest(split='1/2') # doctest: +SKIP + + The ``subprocess`` and ``verbose`` options are the same as with the function + ``test()`` (see the docstring of that function for more information) except + that ``verbose`` may also be set equal to ``2`` in order to print + individual doctest lines, as they are being tested. + """ + # count up from 0, do not print 0 + print_counter = lambda i : (print("rerun %d" % (rerun-i)) + if rerun-i else None) + + if subprocess: + # loop backwards so last i is 0 + for i in range(rerun, -1, -1): + print_counter(i) + ret = run_in_subprocess_with_hash_randomization("_doctest", + function_args=paths, function_kwargs=kwargs) + if ret is False: + break + val = not bool(ret) + # exit on the first failure or if done + if not val or i == 0: + return val + + # rerun even if hash randomization is not supported + for i in range(rerun, -1, -1): + print_counter(i) + val = not bool(_doctest(*paths, **kwargs)) + if not val or i == 0: + return val + + +def _get_doctest_blacklist(): + '''Get the default blacklist for the doctests''' + blacklist = [] + + blacklist.extend([ + "doc/src/modules/plotting.rst", # generates live plots + "doc/src/modules/physics/mechanics/autolev_parser.rst", + "sympy/codegen/array_utils.py", # raises deprecation warning + "sympy/core/compatibility.py", # backwards compatibility shim, importing it triggers a deprecation warning + "sympy/core/trace.py", # backwards compatibility shim, importing it triggers a deprecation warning + "sympy/galgebra.py", # no longer part of SymPy + "sympy/parsing/autolev/_antlr/autolevlexer.py", # generated code + "sympy/parsing/autolev/_antlr/autolevlistener.py", # generated code + "sympy/parsing/autolev/_antlr/autolevparser.py", # generated code + "sympy/parsing/latex/_antlr/latexlexer.py", # generated code + "sympy/parsing/latex/_antlr/latexparser.py", # generated code + "sympy/plotting/pygletplot/__init__.py", # crashes on some systems + "sympy/plotting/pygletplot/plot.py", # crashes on some systems + "sympy/printing/ccode.py", # backwards compatibility shim, importing it breaks the codegen doctests + "sympy/printing/cxxcode.py", # backwards compatibility shim, importing it breaks the codegen doctests + "sympy/printing/fcode.py", # backwards compatibility shim, importing it breaks the codegen doctests + "sympy/testing/randtest.py", # backwards compatibility shim, importing it triggers a deprecation warning + "sympy/this.py", # prints text + ]) + # autolev parser tests + num = 12 + for i in range (1, num+1): + blacklist.append("sympy/parsing/autolev/test-examples/ruletest" + str(i) + ".py") + blacklist.extend(["sympy/parsing/autolev/test-examples/pydy-example-repo/mass_spring_damper.py", + "sympy/parsing/autolev/test-examples/pydy-example-repo/chaos_pendulum.py", + "sympy/parsing/autolev/test-examples/pydy-example-repo/double_pendulum.py", + "sympy/parsing/autolev/test-examples/pydy-example-repo/non_min_pendulum.py"]) + + if import_module('numpy') is None: + blacklist.extend([ + "sympy/plotting/experimental_lambdify.py", + "sympy/plotting/plot_implicit.py", + "examples/advanced/autowrap_integrators.py", + "examples/advanced/autowrap_ufuncify.py", + "examples/intermediate/sample.py", + "examples/intermediate/mplot2d.py", + "examples/intermediate/mplot3d.py", + "doc/src/modules/numeric-computation.rst" + ]) + else: + if import_module('matplotlib') is None: + blacklist.extend([ + "examples/intermediate/mplot2d.py", + "examples/intermediate/mplot3d.py" + ]) + else: + # Use a non-windowed backend, so that the tests work on CI + import matplotlib + matplotlib.use('Agg') + + if ON_CI or import_module('pyglet') is None: + blacklist.extend(["sympy/plotting/pygletplot"]) + + if import_module('aesara') is None: + blacklist.extend([ + "sympy/printing/aesaracode.py", + "doc/src/modules/numeric-computation.rst", + ]) + + if import_module('cupy') is None: + blacklist.extend([ + "doc/src/modules/numeric-computation.rst", + ]) + + if import_module('jax') is None: + blacklist.extend([ + "doc/src/modules/numeric-computation.rst", + ]) + + if import_module('antlr4') is None: + blacklist.extend([ + "sympy/parsing/autolev/__init__.py", + "sympy/parsing/latex/_parse_latex_antlr.py", + ]) + + if import_module('lfortran') is None: + #throws ImportError when lfortran not installed + blacklist.extend([ + "sympy/parsing/sym_expr.py", + ]) + + if import_module("scipy") is None: + # throws ModuleNotFoundError when scipy not installed + blacklist.extend([ + "doc/src/guides/solving/solve-numerically.md", + "doc/src/guides/solving/solve-ode.md", + ]) + + if import_module("numpy") is None: + # throws ModuleNotFoundError when numpy not installed + blacklist.extend([ + "doc/src/guides/solving/solve-ode.md", + "doc/src/guides/solving/solve-numerically.md", + ]) + + # disabled because of doctest failures in asmeurer's bot + blacklist.extend([ + "sympy/utilities/autowrap.py", + "examples/advanced/autowrap_integrators.py", + "examples/advanced/autowrap_ufuncify.py" + ]) + + blacklist.extend([ + "sympy/conftest.py", # Depends on pytest + ]) + + # These are deprecated stubs to be removed: + blacklist.extend([ + "sympy/utilities/tmpfiles.py", + "sympy/utilities/pytest.py", + "sympy/utilities/runtests.py", + "sympy/utilities/quality_unicode.py", + "sympy/utilities/randtest.py", + ]) + + blacklist = convert_to_native_paths(blacklist) + return blacklist + + +def _doctest(*paths, **kwargs): + """ + Internal function that actually runs the doctests. + + All keyword arguments from ``doctest()`` are passed to this function + except for ``subprocess``. + + Returns 0 if tests passed and 1 if they failed. See the docstrings of + ``doctest()`` and ``test()`` for more information. + """ + from sympy.printing.pretty.pretty import pprint_use_unicode + + normal = kwargs.get("normal", False) + verbose = kwargs.get("verbose", False) + colors = kwargs.get("colors", True) + force_colors = kwargs.get("force_colors", False) + blacklist = kwargs.get("blacklist", []) + split = kwargs.get('split', None) + + blacklist.extend(_get_doctest_blacklist()) + + # Use a non-windowed backend, so that the tests work on CI + if import_module('matplotlib') is not None: + import matplotlib + matplotlib.use('Agg') + + # Disable warnings for external modules + import sympy.external + sympy.external.importtools.WARN_OLD_VERSION = False + sympy.external.importtools.WARN_NOT_INSTALLED = False + + # Disable showing up of plots + from sympy.plotting.plot import unset_show + unset_show() + + r = PyTestReporter(verbose, split=split, colors=colors,\ + force_colors=force_colors) + t = SymPyDocTests(r, normal) + + test_files = t.get_test_files('sympy') + test_files.extend(t.get_test_files('examples', init_only=False)) + + not_blacklisted = [f for f in test_files + if not any(b in f for b in blacklist)] + if len(paths) == 0: + matched = not_blacklisted + else: + # take only what was requested...but not blacklisted items + # and allow for partial match anywhere or fnmatch of name + paths = convert_to_native_paths(paths) + matched = [] + for f in not_blacklisted: + basename = os.path.basename(f) + for p in paths: + if p in f or fnmatch(basename, p): + matched.append(f) + break + + matched.sort() + + if split: + matched = split_list(matched, split) + + t._testfiles.extend(matched) + + # run the tests and record the result for this *py portion of the tests + if t._testfiles: + failed = not t.test() + else: + failed = False + + # N.B. + # -------------------------------------------------------------------- + # Here we test *.rst and *.md files at or below doc/src. Code from these + # must be self supporting in terms of imports since there is no importing + # of necessary modules by doctest.testfile. If you try to pass *.py files + # through this they might fail because they will lack the needed imports + # and smarter parsing that can be done with source code. + # + test_files_rst = t.get_test_files('doc/src', '*.rst', init_only=False) + test_files_md = t.get_test_files('doc/src', '*.md', init_only=False) + test_files = test_files_rst + test_files_md + test_files.sort() + + not_blacklisted = [f for f in test_files + if not any(b in f for b in blacklist)] + + if len(paths) == 0: + matched = not_blacklisted + else: + # Take only what was requested as long as it's not on the blacklist. + # Paths were already made native in *py tests so don't repeat here. + # There's no chance of having a *py file slip through since we + # only have *rst files in test_files. + matched = [] + for f in not_blacklisted: + basename = os.path.basename(f) + for p in paths: + if p in f or fnmatch(basename, p): + matched.append(f) + break + + if split: + matched = split_list(matched, split) + + first_report = True + for rst_file in matched: + if not os.path.isfile(rst_file): + continue + old_displayhook = sys.displayhook + try: + use_unicode_prev = setup_pprint() + out = sympytestfile( + rst_file, module_relative=False, encoding='utf-8', + optionflags=pdoctest.ELLIPSIS | pdoctest.NORMALIZE_WHITESPACE | + pdoctest.IGNORE_EXCEPTION_DETAIL) + finally: + # make sure we return to the original displayhook in case some + # doctest has changed that + sys.displayhook = old_displayhook + # The NO_GLOBAL flag overrides the no_global flag to init_printing + # if True + import sympy.interactive.printing as interactive_printing + interactive_printing.NO_GLOBAL = False + pprint_use_unicode(use_unicode_prev) + + rstfailed, tested = out + if tested: + failed = rstfailed or failed + if first_report: + first_report = False + msg = 'rst/md doctests start' + if not t._testfiles: + r.start(msg=msg) + else: + r.write_center(msg) + print() + # use as the id, everything past the first 'sympy' + file_id = rst_file[rst_file.find('sympy') + len('sympy') + 1:] + print(file_id, end=" ") + # get at least the name out so it is know who is being tested + wid = r.terminal_width - len(file_id) - 1 # update width + test_file = '[%s]' % (tested) + report = '[%s]' % (rstfailed or 'OK') + print(''.join( + [test_file, ' '*(wid - len(test_file) - len(report)), report]) + ) + + # the doctests for *py will have printed this message already if there was + # a failure, so now only print it if there was intervening reporting by + # testing the *rst as evidenced by first_report no longer being True. + if not first_report and failed: + print() + print("DO *NOT* COMMIT!") + + return int(failed) + +sp = re.compile(r'([0-9]+)/([1-9][0-9]*)') + +def split_list(l, split, density=None): + """ + Splits a list into part a of b + + split should be a string of the form 'a/b'. For instance, '1/3' would give + the split one of three. + + If the length of the list is not divisible by the number of splits, the + last split will have more items. + + `density` may be specified as a list. If specified, + tests will be balanced so that each split has as equal-as-possible + amount of mass according to `density`. + + >>> from sympy.testing.runtests import split_list + >>> a = list(range(10)) + >>> split_list(a, '1/3') + [0, 1, 2] + >>> split_list(a, '2/3') + [3, 4, 5] + >>> split_list(a, '3/3') + [6, 7, 8, 9] + """ + m = sp.match(split) + if not m: + raise ValueError("split must be a string of the form a/b where a and b are ints") + i, t = map(int, m.groups()) + + if not density: + return l[(i - 1)*len(l)//t : i*len(l)//t] + + # normalize density + tot = sum(density) + density = [x / tot for x in density] + + def density_inv(x): + """Interpolate the inverse to the cumulative + distribution function given by density""" + if x <= 0: + return 0 + if x >= sum(density): + return 1 + + # find the first time the cumulative sum surpasses x + # and linearly interpolate + cumm = 0 + for i, d in enumerate(density): + cumm += d + if cumm >= x: + break + frac = (d - (cumm - x)) / d + return (i + frac) / len(density) + + lower_frac = density_inv((i - 1) / t) + higher_frac = density_inv(i / t) + return l[int(lower_frac*len(l)) : int(higher_frac*len(l))] + +from collections import namedtuple +SymPyTestResults = namedtuple('SymPyTestResults', 'failed attempted') + +def sympytestfile(filename, module_relative=True, name=None, package=None, + globs=None, verbose=None, report=True, optionflags=0, + extraglobs=None, raise_on_error=False, + parser=pdoctest.DocTestParser(), encoding=None): + + """ + Test examples in the given file. Return (#failures, #tests). + + Optional keyword arg ``module_relative`` specifies how filenames + should be interpreted: + + - If ``module_relative`` is True (the default), then ``filename`` + specifies a module-relative path. By default, this path is + relative to the calling module's directory; but if the + ``package`` argument is specified, then it is relative to that + package. To ensure os-independence, ``filename`` should use + "/" characters to separate path segments, and should not + be an absolute path (i.e., it may not begin with "/"). + + - If ``module_relative`` is False, then ``filename`` specifies an + os-specific path. The path may be absolute or relative (to + the current working directory). + + Optional keyword arg ``name`` gives the name of the test; by default + use the file's basename. + + Optional keyword argument ``package`` is a Python package or the + name of a Python package whose directory should be used as the + base directory for a module relative filename. If no package is + specified, then the calling module's directory is used as the base + directory for module relative filenames. It is an error to + specify ``package`` if ``module_relative`` is False. + + Optional keyword arg ``globs`` gives a dict to be used as the globals + when executing examples; by default, use {}. A copy of this dict + is actually used for each docstring, so that each docstring's + examples start with a clean slate. + + Optional keyword arg ``extraglobs`` gives a dictionary that should be + merged into the globals that are used to execute examples. By + default, no extra globals are used. + + Optional keyword arg ``verbose`` prints lots of stuff if true, prints + only failures if false; by default, it's true iff "-v" is in sys.argv. + + Optional keyword arg ``report`` prints a summary at the end when true, + else prints nothing at the end. In verbose mode, the summary is + detailed, else very brief (in fact, empty if all tests passed). + + Optional keyword arg ``optionflags`` or's together module constants, + and defaults to 0. Possible values (see the docs for details): + + - DONT_ACCEPT_TRUE_FOR_1 + - DONT_ACCEPT_BLANKLINE + - NORMALIZE_WHITESPACE + - ELLIPSIS + - SKIP + - IGNORE_EXCEPTION_DETAIL + - REPORT_UDIFF + - REPORT_CDIFF + - REPORT_NDIFF + - REPORT_ONLY_FIRST_FAILURE + + Optional keyword arg ``raise_on_error`` raises an exception on the + first unexpected exception or failure. This allows failures to be + post-mortem debugged. + + Optional keyword arg ``parser`` specifies a DocTestParser (or + subclass) that should be used to extract tests from the files. + + Optional keyword arg ``encoding`` specifies an encoding that should + be used to convert the file to unicode. + + Advanced tomfoolery: testmod runs methods of a local instance of + class doctest.Tester, then merges the results into (or creates) + global Tester instance doctest.master. Methods of doctest.master + can be called directly too, if you want to do something unusual. + Passing report=0 to testmod is especially useful then, to delay + displaying a summary. Invoke doctest.master.summarize(verbose) + when you're done fiddling. + """ + if package and not module_relative: + raise ValueError("Package may only be specified for module-" + "relative paths.") + + # Relativize the path + text, filename = pdoctest._load_testfile( + filename, package, module_relative, encoding) + + # If no name was given, then use the file's name. + if name is None: + name = os.path.basename(filename) + + # Assemble the globals. + if globs is None: + globs = {} + else: + globs = globs.copy() + if extraglobs is not None: + globs.update(extraglobs) + if '__name__' not in globs: + globs['__name__'] = '__main__' + + if raise_on_error: + runner = pdoctest.DebugRunner(verbose=verbose, optionflags=optionflags) + else: + runner = SymPyDocTestRunner(verbose=verbose, optionflags=optionflags) + runner._checker = SymPyOutputChecker() + + # Read the file, convert it to a test, and run it. + test = parser.get_doctest(text, globs, name, filename, 0) + runner.run(test) + + if report: + runner.summarize() + + if pdoctest.master is None: + pdoctest.master = runner + else: + pdoctest.master.merge(runner) + + return SymPyTestResults(runner.failures, runner.tries) + + +class SymPyTests: + + def __init__(self, reporter, kw="", post_mortem=False, + seed=None, fast_threshold=None, slow_threshold=None): + self._post_mortem = post_mortem + self._kw = kw + self._count = 0 + self._root_dir = get_sympy_dir() + self._reporter = reporter + self._reporter.root_dir(self._root_dir) + self._testfiles = [] + self._seed = seed if seed is not None else random.random() + + # Defaults in seconds, from human / UX design limits + # http://www.nngroup.com/articles/response-times-3-important-limits/ + # + # These defaults are *NOT* set in stone as we are measuring different + # things, so others feel free to come up with a better yardstick :) + if fast_threshold: + self._fast_threshold = float(fast_threshold) + else: + self._fast_threshold = 8 + if slow_threshold: + self._slow_threshold = float(slow_threshold) + else: + self._slow_threshold = 10 + + def test(self, sort=False, timeout=False, slow=False, + enhance_asserts=False, fail_on_timeout=False): + """ + Runs the tests returning True if all tests pass, otherwise False. + + If sort=False run tests in random order. + """ + if sort: + self._testfiles.sort() + elif slow: + pass + else: + random.seed(self._seed) + random.shuffle(self._testfiles) + self._reporter.start(self._seed) + for f in self._testfiles: + try: + self.test_file(f, sort, timeout, slow, + enhance_asserts, fail_on_timeout) + except KeyboardInterrupt: + print(" interrupted by user") + self._reporter.finish() + raise + return self._reporter.finish() + + def _enhance_asserts(self, source): + from ast import (NodeTransformer, Compare, Name, Store, Load, Tuple, + Assign, BinOp, Str, Mod, Assert, parse, fix_missing_locations) + + ops = {"Eq": '==', "NotEq": '!=', "Lt": '<', "LtE": '<=', + "Gt": '>', "GtE": '>=', "Is": 'is', "IsNot": 'is not', + "In": 'in', "NotIn": 'not in'} + + class Transform(NodeTransformer): + def visit_Assert(self, stmt): + if isinstance(stmt.test, Compare): + compare = stmt.test + values = [compare.left] + compare.comparators + names = [ "_%s" % i for i, _ in enumerate(values) ] + names_store = [ Name(n, Store()) for n in names ] + names_load = [ Name(n, Load()) for n in names ] + target = Tuple(names_store, Store()) + value = Tuple(values, Load()) + assign = Assign([target], value) + new_compare = Compare(names_load[0], compare.ops, names_load[1:]) + msg_format = "\n%s " + "\n%s ".join([ ops[op.__class__.__name__] for op in compare.ops ]) + "\n%s" + msg = BinOp(Str(msg_format), Mod(), Tuple(names_load, Load())) + test = Assert(new_compare, msg, lineno=stmt.lineno, col_offset=stmt.col_offset) + return [assign, test] + else: + return stmt + + tree = parse(source) + new_tree = Transform().visit(tree) + return fix_missing_locations(new_tree) + + def test_file(self, filename, sort=True, timeout=False, slow=False, + enhance_asserts=False, fail_on_timeout=False): + reporter = self._reporter + funcs = [] + try: + gl = {'__file__': filename} + try: + open_file = lambda: open(filename, encoding="utf8") + + with open_file() as f: + source = f.read() + if self._kw: + for l in source.splitlines(): + if l.lstrip().startswith('def '): + if any(l.lower().find(k.lower()) != -1 for k in self._kw): + break + else: + return + + if enhance_asserts: + try: + source = self._enhance_asserts(source) + except ImportError: + pass + + code = compile(source, filename, "exec", flags=0, dont_inherit=True) + exec(code, gl) + except (SystemExit, KeyboardInterrupt): + raise + except ImportError: + reporter.import_error(filename, sys.exc_info()) + return + except Exception: + reporter.test_exception(sys.exc_info()) + + clear_cache() + self._count += 1 + random.seed(self._seed) + disabled = gl.get("disabled", False) + if not disabled: + # we need to filter only those functions that begin with 'test_' + # We have to be careful about decorated functions. As long as + # the decorator uses functools.wraps, we can detect it. + funcs = [] + for f in gl: + if (f.startswith("test_") and (inspect.isfunction(gl[f]) + or inspect.ismethod(gl[f]))): + func = gl[f] + # Handle multiple decorators + while hasattr(func, '__wrapped__'): + func = func.__wrapped__ + + if inspect.getsourcefile(func) == filename: + funcs.append(gl[f]) + if slow: + funcs = [f for f in funcs if getattr(f, '_slow', False)] + # Sorting of XFAILed functions isn't fixed yet :-( + funcs.sort(key=lambda x: inspect.getsourcelines(x)[1]) + i = 0 + while i < len(funcs): + if inspect.isgeneratorfunction(funcs[i]): + # some tests can be generators, that return the actual + # test functions. We unpack it below: + f = funcs.pop(i) + for fg in f(): + func = fg[0] + args = fg[1:] + fgw = lambda: func(*args) + funcs.insert(i, fgw) + i += 1 + else: + i += 1 + # drop functions that are not selected with the keyword expression: + funcs = [x for x in funcs if self.matches(x)] + + if not funcs: + return + except Exception: + reporter.entering_filename(filename, len(funcs)) + raise + + reporter.entering_filename(filename, len(funcs)) + if not sort: + random.shuffle(funcs) + + for f in funcs: + start = time.time() + reporter.entering_test(f) + try: + if getattr(f, '_slow', False) and not slow: + raise Skipped("Slow") + with raise_on_deprecated(): + if timeout: + self._timeout(f, timeout, fail_on_timeout) + else: + random.seed(self._seed) + f() + except KeyboardInterrupt: + if getattr(f, '_slow', False): + reporter.test_skip("KeyboardInterrupt") + else: + raise + except Exception: + if timeout: + signal.alarm(0) # Disable the alarm. It could not be handled before. + t, v, tr = sys.exc_info() + if t is AssertionError: + reporter.test_fail((t, v, tr)) + if self._post_mortem: + pdb.post_mortem(tr) + elif t.__name__ == "Skipped": + reporter.test_skip(v) + elif t.__name__ == "XFail": + reporter.test_xfail() + elif t.__name__ == "XPass": + reporter.test_xpass(v) + else: + reporter.test_exception((t, v, tr)) + if self._post_mortem: + pdb.post_mortem(tr) + else: + reporter.test_pass() + taken = time.time() - start + if taken > self._slow_threshold: + filename = os.path.relpath(filename, reporter._root_dir) + reporter.slow_test_functions.append( + (filename + "::" + f.__name__, taken)) + if getattr(f, '_slow', False) and slow: + if taken < self._fast_threshold: + filename = os.path.relpath(filename, reporter._root_dir) + reporter.fast_test_functions.append( + (filename + "::" + f.__name__, taken)) + reporter.leaving_filename() + + def _timeout(self, function, timeout, fail_on_timeout): + def callback(x, y): + signal.alarm(0) + if fail_on_timeout: + raise TimeOutError("Timed out after %d seconds" % timeout) + else: + raise Skipped("Timeout") + signal.signal(signal.SIGALRM, callback) + signal.alarm(timeout) # Set an alarm with a given timeout + function() + signal.alarm(0) # Disable the alarm + + def matches(self, x): + """ + Does the keyword expression self._kw match "x"? Returns True/False. + + Always returns True if self._kw is "". + """ + if not self._kw: + return True + for kw in self._kw: + if x.__name__.lower().find(kw.lower()) != -1: + return True + return False + + def get_test_files(self, dir, pat='test_*.py'): + """ + Returns the list of test_*.py (default) files at or below directory + ``dir`` relative to the SymPy home directory. + """ + dir = os.path.join(self._root_dir, convert_to_native_paths([dir])[0]) + + g = [] + for path, folders, files in os.walk(dir): + g.extend([os.path.join(path, f) for f in files if fnmatch(f, pat)]) + + return sorted([os.path.normcase(gi) for gi in g]) + + +class SymPyDocTests: + + def __init__(self, reporter, normal): + self._count = 0 + self._root_dir = get_sympy_dir() + self._reporter = reporter + self._reporter.root_dir(self._root_dir) + self._normal = normal + + self._testfiles = [] + + def test(self): + """ + Runs the tests and returns True if all tests pass, otherwise False. + """ + self._reporter.start() + for f in self._testfiles: + try: + self.test_file(f) + except KeyboardInterrupt: + print(" interrupted by user") + self._reporter.finish() + raise + return self._reporter.finish() + + def test_file(self, filename): + clear_cache() + + from io import StringIO + import sympy.interactive.printing as interactive_printing + from sympy.printing.pretty.pretty import pprint_use_unicode + + rel_name = filename[len(self._root_dir) + 1:] + dirname, file = os.path.split(filename) + module = rel_name.replace(os.sep, '.')[:-3] + + if rel_name.startswith("examples"): + # Examples files do not have __init__.py files, + # So we have to temporarily extend sys.path to import them + sys.path.insert(0, dirname) + module = file[:-3] # remove ".py" + try: + module = pdoctest._normalize_module(module) + tests = SymPyDocTestFinder().find(module) + except (SystemExit, KeyboardInterrupt): + raise + except ImportError: + self._reporter.import_error(filename, sys.exc_info()) + return + finally: + if rel_name.startswith("examples"): + del sys.path[0] + + tests = [test for test in tests if len(test.examples) > 0] + # By default tests are sorted by alphabetical order by function name. + # We sort by line number so one can edit the file sequentially from + # bottom to top. However, if there are decorated functions, their line + # numbers will be too large and for now one must just search for these + # by text and function name. + tests.sort(key=lambda x: -x.lineno) + + if not tests: + return + self._reporter.entering_filename(filename, len(tests)) + for test in tests: + assert len(test.examples) != 0 + + if self._reporter._verbose: + self._reporter.write("\n{} ".format(test.name)) + + # check if there are external dependencies which need to be met + if '_doctest_depends_on' in test.globs: + try: + self._check_dependencies(**test.globs['_doctest_depends_on']) + except DependencyError as e: + self._reporter.test_skip(v=str(e)) + continue + + runner = SymPyDocTestRunner(verbose=self._reporter._verbose==2, + optionflags=pdoctest.ELLIPSIS | + pdoctest.NORMALIZE_WHITESPACE | + pdoctest.IGNORE_EXCEPTION_DETAIL) + runner._checker = SymPyOutputChecker() + old = sys.stdout + new = old if self._reporter._verbose==2 else StringIO() + sys.stdout = new + # If the testing is normal, the doctests get importing magic to + # provide the global namespace. If not normal (the default) then + # then must run on their own; all imports must be explicit within + # a function's docstring. Once imported that import will be + # available to the rest of the tests in a given function's + # docstring (unless clear_globs=True below). + if not self._normal: + test.globs = {} + # if this is uncommented then all the test would get is what + # comes by default with a "from sympy import *" + #exec('from sympy import *') in test.globs + old_displayhook = sys.displayhook + use_unicode_prev = setup_pprint() + + try: + f, t = runner.run(test, + out=new.write, clear_globs=False) + except KeyboardInterrupt: + raise + finally: + sys.stdout = old + if f > 0: + self._reporter.doctest_fail(test.name, new.getvalue()) + else: + self._reporter.test_pass() + sys.displayhook = old_displayhook + interactive_printing.NO_GLOBAL = False + pprint_use_unicode(use_unicode_prev) + + self._reporter.leaving_filename() + + def get_test_files(self, dir, pat='*.py', init_only=True): + r""" + Returns the list of \*.py files (default) from which docstrings + will be tested which are at or below directory ``dir``. By default, + only those that have an __init__.py in their parent directory + and do not start with ``test_`` will be included. + """ + def importable(x): + """ + Checks if given pathname x is an importable module by checking for + __init__.py file. + + Returns True/False. + + Currently we only test if the __init__.py file exists in the + directory with the file "x" (in theory we should also test all the + parent dirs). + """ + init_py = os.path.join(os.path.dirname(x), "__init__.py") + return os.path.exists(init_py) + + dir = os.path.join(self._root_dir, convert_to_native_paths([dir])[0]) + + g = [] + for path, folders, files in os.walk(dir): + g.extend([os.path.join(path, f) for f in files + if not f.startswith('test_') and fnmatch(f, pat)]) + if init_only: + # skip files that are not importable (i.e. missing __init__.py) + g = [x for x in g if importable(x)] + + return [os.path.normcase(gi) for gi in g] + + def _check_dependencies(self, + executables=(), + modules=(), + disable_viewers=(), + python_version=(3, 5)): + """ + Checks if the dependencies for the test are installed. + + Raises ``DependencyError`` it at least one dependency is not installed. + """ + + for executable in executables: + if not shutil.which(executable): + raise DependencyError("Could not find %s" % executable) + + for module in modules: + if module == 'matplotlib': + matplotlib = import_module( + 'matplotlib', + import_kwargs={'fromlist': + ['pyplot', 'cm', 'collections']}, + min_module_version='1.0.0', catch=(RuntimeError,)) + if matplotlib is None: + raise DependencyError("Could not import matplotlib") + else: + if not import_module(module): + raise DependencyError("Could not import %s" % module) + + if disable_viewers: + tempdir = tempfile.mkdtemp() + os.environ['PATH'] = '%s:%s' % (tempdir, os.environ['PATH']) + + vw = ('#!/usr/bin/env python3\n' + 'import sys\n' + 'if len(sys.argv) <= 1:\n' + ' exit("wrong number of args")\n') + + for viewer in disable_viewers: + with open(os.path.join(tempdir, viewer), 'w') as fh: + fh.write(vw) + + # make the file executable + os.chmod(os.path.join(tempdir, viewer), + stat.S_IREAD | stat.S_IWRITE | stat.S_IXUSR) + + if python_version: + if sys.version_info < python_version: + raise DependencyError("Requires Python >= " + '.'.join(map(str, python_version))) + + if 'pyglet' in modules: + # monkey-patch pyglet s.t. it does not open a window during + # doctesting + import pyglet + class DummyWindow: + def __init__(self, *args, **kwargs): + self.has_exit = True + self.width = 600 + self.height = 400 + + def set_vsync(self, x): + pass + + def switch_to(self): + pass + + def push_handlers(self, x): + pass + + def close(self): + pass + + pyglet.window.Window = DummyWindow + + +class SymPyDocTestFinder(DocTestFinder): + """ + A class used to extract the DocTests that are relevant to a given + object, from its docstring and the docstrings of its contained + objects. Doctests can currently be extracted from the following + object types: modules, functions, classes, methods, staticmethods, + classmethods, and properties. + + Modified from doctest's version to look harder for code that + appears comes from a different module. For example, the @vectorize + decorator makes it look like functions come from multidimensional.py + even though their code exists elsewhere. + """ + + def _find(self, tests, obj, name, module, source_lines, globs, seen): + """ + Find tests for the given object and any contained objects, and + add them to ``tests``. + """ + if self._verbose: + print('Finding tests in %s' % name) + + # If we've already processed this object, then ignore it. + if id(obj) in seen: + return + seen[id(obj)] = 1 + + # Make sure we don't run doctests for classes outside of sympy, such + # as in numpy or scipy. + if inspect.isclass(obj): + if obj.__module__.split('.')[0] != 'sympy': + return + + # Find a test for this object, and add it to the list of tests. + test = self._get_test(obj, name, module, globs, source_lines) + if test is not None: + tests.append(test) + + if not self._recurse: + return + + # Look for tests in a module's contained objects. + if inspect.ismodule(obj): + for rawname, val in obj.__dict__.items(): + # Recurse to functions & classes. + if inspect.isfunction(val) or inspect.isclass(val): + # Make sure we don't run doctests functions or classes + # from different modules + if val.__module__ != module.__name__: + continue + + assert self._from_module(module, val), \ + "%s is not in module %s (rawname %s)" % (val, module, rawname) + + try: + valname = '%s.%s' % (name, rawname) + self._find(tests, val, valname, module, + source_lines, globs, seen) + except KeyboardInterrupt: + raise + + # Look for tests in a module's __test__ dictionary. + for valname, val in getattr(obj, '__test__', {}).items(): + if not isinstance(valname, str): + raise ValueError("SymPyDocTestFinder.find: __test__ keys " + "must be strings: %r" % + (type(valname),)) + if not (inspect.isfunction(val) or inspect.isclass(val) or + inspect.ismethod(val) or inspect.ismodule(val) or + isinstance(val, str)): + raise ValueError("SymPyDocTestFinder.find: __test__ values " + "must be strings, functions, methods, " + "classes, or modules: %r" % + (type(val),)) + valname = '%s.__test__.%s' % (name, valname) + self._find(tests, val, valname, module, source_lines, + globs, seen) + + + # Look for tests in a class's contained objects. + if inspect.isclass(obj): + for valname, val in obj.__dict__.items(): + # Special handling for staticmethod/classmethod. + if isinstance(val, staticmethod): + val = getattr(obj, valname) + if isinstance(val, classmethod): + val = getattr(obj, valname).__func__ + + + # Recurse to methods, properties, and nested classes. + if ((inspect.isfunction(unwrap(val)) or + inspect.isclass(val) or + isinstance(val, property)) and + self._from_module(module, val)): + # Make sure we don't run doctests functions or classes + # from different modules + if isinstance(val, property): + if hasattr(val.fget, '__module__'): + if val.fget.__module__ != module.__name__: + continue + else: + if val.__module__ != module.__name__: + continue + + assert self._from_module(module, val), \ + "%s is not in module %s (valname %s)" % ( + val, module, valname) + + valname = '%s.%s' % (name, valname) + self._find(tests, val, valname, module, source_lines, + globs, seen) + + def _get_test(self, obj, name, module, globs, source_lines): + """ + Return a DocTest for the given object, if it defines a docstring; + otherwise, return None. + """ + + lineno = None + + # Extract the object's docstring. If it does not have one, + # then return None (no test for this object). + if isinstance(obj, str): + # obj is a string in the case for objects in the polys package. + # Note that source_lines is a binary string (compiled polys + # modules), which can't be handled by _find_lineno so determine + # the line number here. + + docstring = obj + + matches = re.findall(r"line \d+", name) + assert len(matches) == 1, \ + "string '%s' does not contain lineno " % name + + # NOTE: this is not the exact linenumber but its better than no + # lineno ;) + lineno = int(matches[0][5:]) + + else: + try: + if obj.__doc__ is None: + docstring = '' + else: + docstring = obj.__doc__ + if not isinstance(docstring, str): + docstring = str(docstring) + except (TypeError, AttributeError): + docstring = '' + + # Don't bother if the docstring is empty. + if self._exclude_empty and not docstring: + return None + + # check that properties have a docstring because _find_lineno + # assumes it + if isinstance(obj, property): + if obj.fget.__doc__ is None: + return None + + # Find the docstring's location in the file. + if lineno is None: + obj = unwrap(obj) + # handling of properties is not implemented in _find_lineno so do + # it here + if hasattr(obj, 'func_closure') and obj.func_closure is not None: + tobj = obj.func_closure[0].cell_contents + elif isinstance(obj, property): + tobj = obj.fget + else: + tobj = obj + lineno = self._find_lineno(tobj, source_lines) + + if lineno is None: + return None + + # Return a DocTest for this object. + if module is None: + filename = None + else: + filename = getattr(module, '__file__', module.__name__) + if filename[-4:] in (".pyc", ".pyo"): + filename = filename[:-1] + + globs['_doctest_depends_on'] = getattr(obj, '_doctest_depends_on', {}) + + return self._parser.get_doctest(docstring, globs, name, + filename, lineno) + + +class SymPyDocTestRunner(DocTestRunner): + """ + A class used to run DocTest test cases, and accumulate statistics. + The ``run`` method is used to process a single DocTest case. It + returns a tuple ``(f, t)``, where ``t`` is the number of test cases + tried, and ``f`` is the number of test cases that failed. + + Modified from the doctest version to not reset the sys.displayhook (see + issue 5140). + + See the docstring of the original DocTestRunner for more information. + """ + + def run(self, test, compileflags=None, out=None, clear_globs=True): + """ + Run the examples in ``test``, and display the results using the + writer function ``out``. + + The examples are run in the namespace ``test.globs``. If + ``clear_globs`` is true (the default), then this namespace will + be cleared after the test runs, to help with garbage + collection. If you would like to examine the namespace after + the test completes, then use ``clear_globs=False``. + + ``compileflags`` gives the set of flags that should be used by + the Python compiler when running the examples. If not + specified, then it will default to the set of future-import + flags that apply to ``globs``. + + The output of each example is checked using + ``SymPyDocTestRunner.check_output``, and the results are + formatted by the ``SymPyDocTestRunner.report_*`` methods. + """ + self.test = test + + # Remove ``` from the end of example, which may appear in Markdown + # files + for example in test.examples: + example.want = example.want.replace('```\n', '') + example.exc_msg = example.exc_msg and example.exc_msg.replace('```\n', '') + + + if compileflags is None: + compileflags = pdoctest._extract_future_flags(test.globs) + + save_stdout = sys.stdout + if out is None: + out = save_stdout.write + sys.stdout = self._fakeout + + # Patch pdb.set_trace to restore sys.stdout during interactive + # debugging (so it's not still redirected to self._fakeout). + # Note that the interactive output will go to *our* + # save_stdout, even if that's not the real sys.stdout; this + # allows us to write test cases for the set_trace behavior. + save_set_trace = pdb.set_trace + self.debugger = pdoctest._OutputRedirectingPdb(save_stdout) + self.debugger.reset() + pdb.set_trace = self.debugger.set_trace + + # Patch linecache.getlines, so we can see the example's source + # when we're inside the debugger. + self.save_linecache_getlines = pdoctest.linecache.getlines + linecache.getlines = self.__patched_linecache_getlines + + # Fail for deprecation warnings + with raise_on_deprecated(): + try: + return self.__run(test, compileflags, out) + finally: + sys.stdout = save_stdout + pdb.set_trace = save_set_trace + linecache.getlines = self.save_linecache_getlines + if clear_globs: + test.globs.clear() + + +# We have to override the name mangled methods. +monkeypatched_methods = [ + 'patched_linecache_getlines', + 'run', + 'record_outcome' +] +for method in monkeypatched_methods: + oldname = '_DocTestRunner__' + method + newname = '_SymPyDocTestRunner__' + method + setattr(SymPyDocTestRunner, newname, getattr(DocTestRunner, oldname)) + + +class SymPyOutputChecker(pdoctest.OutputChecker): + """ + Compared to the OutputChecker from the stdlib our OutputChecker class + supports numerical comparison of floats occurring in the output of the + doctest examples + """ + + def __init__(self): + # NOTE OutputChecker is an old-style class with no __init__ method, + # so we can't call the base class version of __init__ here + + got_floats = r'(\d+\.\d*|\.\d+)' + + # floats in the 'want' string may contain ellipses + want_floats = got_floats + r'(\.{3})?' + + front_sep = r'\s|\+|\-|\*|,' + back_sep = front_sep + r'|j|e' + + fbeg = r'^%s(?=%s|$)' % (got_floats, back_sep) + fmidend = r'(?<=%s)%s(?=%s|$)' % (front_sep, got_floats, back_sep) + self.num_got_rgx = re.compile(r'(%s|%s)' %(fbeg, fmidend)) + + fbeg = r'^%s(?=%s|$)' % (want_floats, back_sep) + fmidend = r'(?<=%s)%s(?=%s|$)' % (front_sep, want_floats, back_sep) + self.num_want_rgx = re.compile(r'(%s|%s)' %(fbeg, fmidend)) + + def check_output(self, want, got, optionflags): + """ + Return True iff the actual output from an example (`got`) + matches the expected output (`want`). These strings are + always considered to match if they are identical; but + depending on what option flags the test runner is using, + several non-exact match types are also possible. See the + documentation for `TestRunner` for more information about + option flags. + """ + # Handle the common case first, for efficiency: + # if they're string-identical, always return true. + if got == want: + return True + + # TODO parse integers as well ? + # Parse floats and compare them. If some of the parsed floats contain + # ellipses, skip the comparison. + matches = self.num_got_rgx.finditer(got) + numbers_got = [match.group(1) for match in matches] # list of strs + matches = self.num_want_rgx.finditer(want) + numbers_want = [match.group(1) for match in matches] # list of strs + if len(numbers_got) != len(numbers_want): + return False + + if len(numbers_got) > 0: + nw_ = [] + for ng, nw in zip(numbers_got, numbers_want): + if '...' in nw: + nw_.append(ng) + continue + else: + nw_.append(nw) + + if abs(float(ng)-float(nw)) > 1e-5: + return False + + got = self.num_got_rgx.sub(r'%s', got) + got = got % tuple(nw_) + + # can be used as a special sequence to signify a + # blank line, unless the DONT_ACCEPT_BLANKLINE flag is used. + if not (optionflags & pdoctest.DONT_ACCEPT_BLANKLINE): + # Replace in want with a blank line. + want = re.sub(r'(?m)^%s\s*?$' % re.escape(pdoctest.BLANKLINE_MARKER), + '', want) + # If a line in got contains only spaces, then remove the + # spaces. + got = re.sub(r'(?m)^\s*?$', '', got) + if got == want: + return True + + # This flag causes doctest to ignore any differences in the + # contents of whitespace strings. Note that this can be used + # in conjunction with the ELLIPSIS flag. + if optionflags & pdoctest.NORMALIZE_WHITESPACE: + got = ' '.join(got.split()) + want = ' '.join(want.split()) + if got == want: + return True + + # The ELLIPSIS flag says to let the sequence "..." in `want` + # match any substring in `got`. + if optionflags & pdoctest.ELLIPSIS: + if pdoctest._ellipsis_match(want, got): + return True + + # We didn't find any match; return false. + return False + + +class Reporter: + """ + Parent class for all reporters. + """ + pass + + +class PyTestReporter(Reporter): + """ + Py.test like reporter. Should produce output identical to py.test. + """ + + def __init__(self, verbose=False, tb="short", colors=True, + force_colors=False, split=None): + self._verbose = verbose + self._tb_style = tb + self._colors = colors + self._force_colors = force_colors + self._xfailed = 0 + self._xpassed = [] + self._failed = [] + self._failed_doctest = [] + self._passed = 0 + self._skipped = 0 + self._exceptions = [] + self._terminal_width = None + self._default_width = 80 + self._split = split + self._active_file = '' + self._active_f = None + + # TODO: Should these be protected? + self.slow_test_functions = [] + self.fast_test_functions = [] + + # this tracks the x-position of the cursor (useful for positioning + # things on the screen), without the need for any readline library: + self._write_pos = 0 + self._line_wrap = False + + def root_dir(self, dir): + self._root_dir = dir + + @property + def terminal_width(self): + if self._terminal_width is not None: + return self._terminal_width + + def findout_terminal_width(): + if sys.platform == "win32": + # Windows support is based on: + # + # http://code.activestate.com/recipes/ + # 440694-determine-size-of-console-window-on-windows/ + + from ctypes import windll, create_string_buffer + + h = windll.kernel32.GetStdHandle(-12) + csbi = create_string_buffer(22) + res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi) + + if res: + import struct + (_, _, _, _, _, left, _, right, _, _, _) = \ + struct.unpack("hhhhHhhhhhh", csbi.raw) + return right - left + else: + return self._default_width + + if hasattr(sys.stdout, 'isatty') and not sys.stdout.isatty(): + return self._default_width # leave PIPEs alone + + try: + process = subprocess.Popen(['stty', '-a'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + stdout, stderr = process.communicate() + stdout = stdout.decode("utf-8") + except OSError: + pass + else: + # We support the following output formats from stty: + # + # 1) Linux -> columns 80 + # 2) OS X -> 80 columns + # 3) Solaris -> columns = 80 + + re_linux = r"columns\s+(?P\d+);" + re_osx = r"(?P\d+)\s*columns;" + re_solaris = r"columns\s+=\s+(?P\d+);" + + for regex in (re_linux, re_osx, re_solaris): + match = re.search(regex, stdout) + + if match is not None: + columns = match.group('columns') + + try: + width = int(columns) + except ValueError: + pass + if width != 0: + return width + + return self._default_width + + width = findout_terminal_width() + self._terminal_width = width + + return width + + def write(self, text, color="", align="left", width=None, + force_colors=False): + """ + Prints a text on the screen. + + It uses sys.stdout.write(), so no readline library is necessary. + + Parameters + ========== + + color : choose from the colors below, "" means default color + align : "left"/"right", "left" is a normal print, "right" is aligned on + the right-hand side of the screen, filled with spaces if + necessary + width : the screen width + + """ + color_templates = ( + ("Black", "0;30"), + ("Red", "0;31"), + ("Green", "0;32"), + ("Brown", "0;33"), + ("Blue", "0;34"), + ("Purple", "0;35"), + ("Cyan", "0;36"), + ("LightGray", "0;37"), + ("DarkGray", "1;30"), + ("LightRed", "1;31"), + ("LightGreen", "1;32"), + ("Yellow", "1;33"), + ("LightBlue", "1;34"), + ("LightPurple", "1;35"), + ("LightCyan", "1;36"), + ("White", "1;37"), + ) + + colors = {} + + for name, value in color_templates: + colors[name] = value + c_normal = '\033[0m' + c_color = '\033[%sm' + + if width is None: + width = self.terminal_width + + if align == "right": + if self._write_pos + len(text) > width: + # we don't fit on the current line, create a new line + self.write("\n") + self.write(" "*(width - self._write_pos - len(text))) + + if not self._force_colors and hasattr(sys.stdout, 'isatty') and not \ + sys.stdout.isatty(): + # the stdout is not a terminal, this for example happens if the + # output is piped to less, e.g. "bin/test | less". In this case, + # the terminal control sequences would be printed verbatim, so + # don't use any colors. + color = "" + elif sys.platform == "win32": + # Windows consoles don't support ANSI escape sequences + color = "" + elif not self._colors: + color = "" + + if self._line_wrap: + if text[0] != "\n": + sys.stdout.write("\n") + + # Avoid UnicodeEncodeError when printing out test failures + if IS_WINDOWS: + text = text.encode('raw_unicode_escape').decode('utf8', 'ignore') + elif not sys.stdout.encoding.lower().startswith('utf'): + text = text.encode(sys.stdout.encoding, 'backslashreplace' + ).decode(sys.stdout.encoding) + + if color == "": + sys.stdout.write(text) + else: + sys.stdout.write("%s%s%s" % + (c_color % colors[color], text, c_normal)) + sys.stdout.flush() + l = text.rfind("\n") + if l == -1: + self._write_pos += len(text) + else: + self._write_pos = len(text) - l - 1 + self._line_wrap = self._write_pos >= width + self._write_pos %= width + + def write_center(self, text, delim="="): + width = self.terminal_width + if text != "": + text = " %s " % text + idx = (width - len(text)) // 2 + t = delim*idx + text + delim*(width - idx - len(text)) + self.write(t + "\n") + + def write_exception(self, e, val, tb): + # remove the first item, as that is always runtests.py + tb = tb.tb_next + t = traceback.format_exception(e, val, tb) + self.write("".join(t)) + + def start(self, seed=None, msg="test process starts"): + self.write_center(msg) + executable = sys.executable + v = tuple(sys.version_info) + python_version = "%s.%s.%s-%s-%s" % v + implementation = platform.python_implementation() + if implementation == 'PyPy': + implementation += " %s.%s.%s-%s-%s" % sys.pypy_version_info + self.write("executable: %s (%s) [%s]\n" % + (executable, python_version, implementation)) + from sympy.utilities.misc import ARCH + self.write("architecture: %s\n" % ARCH) + from sympy.core.cache import USE_CACHE + self.write("cache: %s\n" % USE_CACHE) + version = '' + if GROUND_TYPES =='gmpy': + if HAS_GMPY == 1: + import gmpy + elif HAS_GMPY == 2: + import gmpy2 as gmpy + version = gmpy.version() + self.write("ground types: %s %s\n" % (GROUND_TYPES, version)) + numpy = import_module('numpy') + self.write("numpy: %s\n" % (None if not numpy else numpy.__version__)) + if seed is not None: + self.write("random seed: %d\n" % seed) + from sympy.utilities.misc import HASH_RANDOMIZATION + self.write("hash randomization: ") + hash_seed = os.getenv("PYTHONHASHSEED") or '0' + if HASH_RANDOMIZATION and (hash_seed == "random" or int(hash_seed)): + self.write("on (PYTHONHASHSEED=%s)\n" % hash_seed) + else: + self.write("off\n") + if self._split: + self.write("split: %s\n" % self._split) + self.write('\n') + self._t_start = clock() + + def finish(self): + self._t_end = clock() + self.write("\n") + global text, linelen + text = "tests finished: %d passed, " % self._passed + linelen = len(text) + + def add_text(mytext): + global text, linelen + """Break new text if too long.""" + if linelen + len(mytext) > self.terminal_width: + text += '\n' + linelen = 0 + text += mytext + linelen += len(mytext) + + if len(self._failed) > 0: + add_text("%d failed, " % len(self._failed)) + if len(self._failed_doctest) > 0: + add_text("%d failed, " % len(self._failed_doctest)) + if self._skipped > 0: + add_text("%d skipped, " % self._skipped) + if self._xfailed > 0: + add_text("%d expected to fail, " % self._xfailed) + if len(self._xpassed) > 0: + add_text("%d expected to fail but passed, " % len(self._xpassed)) + if len(self._exceptions) > 0: + add_text("%d exceptions, " % len(self._exceptions)) + add_text("in %.2f seconds" % (self._t_end - self._t_start)) + + if self.slow_test_functions: + self.write_center('slowest tests', '_') + sorted_slow = sorted(self.slow_test_functions, key=lambda r: r[1]) + for slow_func_name, taken in sorted_slow: + print('%s - Took %.3f seconds' % (slow_func_name, taken)) + + if self.fast_test_functions: + self.write_center('unexpectedly fast tests', '_') + sorted_fast = sorted(self.fast_test_functions, + key=lambda r: r[1]) + for fast_func_name, taken in sorted_fast: + print('%s - Took %.3f seconds' % (fast_func_name, taken)) + + if len(self._xpassed) > 0: + self.write_center("xpassed tests", "_") + for e in self._xpassed: + self.write("%s: %s\n" % (e[0], e[1])) + self.write("\n") + + if self._tb_style != "no" and len(self._exceptions) > 0: + for e in self._exceptions: + filename, f, (t, val, tb) = e + self.write_center("", "_") + if f is None: + s = "%s" % filename + else: + s = "%s:%s" % (filename, f.__name__) + self.write_center(s, "_") + self.write_exception(t, val, tb) + self.write("\n") + + if self._tb_style != "no" and len(self._failed) > 0: + for e in self._failed: + filename, f, (t, val, tb) = e + self.write_center("", "_") + self.write_center("%s:%s" % (filename, f.__name__), "_") + self.write_exception(t, val, tb) + self.write("\n") + + if self._tb_style != "no" and len(self._failed_doctest) > 0: + for e in self._failed_doctest: + filename, msg = e + self.write_center("", "_") + self.write_center("%s" % filename, "_") + self.write(msg) + self.write("\n") + + self.write_center(text) + ok = len(self._failed) == 0 and len(self._exceptions) == 0 and \ + len(self._failed_doctest) == 0 + if not ok: + self.write("DO *NOT* COMMIT!\n") + return ok + + def entering_filename(self, filename, n): + rel_name = filename[len(self._root_dir) + 1:] + self._active_file = rel_name + self._active_file_error = False + self.write(rel_name) + self.write("[%d] " % n) + + def leaving_filename(self): + self.write(" ") + if self._active_file_error: + self.write("[FAIL]", "Red", align="right") + else: + self.write("[OK]", "Green", align="right") + self.write("\n") + if self._verbose: + self.write("\n") + + def entering_test(self, f): + self._active_f = f + if self._verbose: + self.write("\n" + f.__name__ + " ") + + def test_xfail(self): + self._xfailed += 1 + self.write("f", "Green") + + def test_xpass(self, v): + message = str(v) + self._xpassed.append((self._active_file, message)) + self.write("X", "Green") + + def test_fail(self, exc_info): + self._failed.append((self._active_file, self._active_f, exc_info)) + self.write("F", "Red") + self._active_file_error = True + + def doctest_fail(self, name, error_msg): + # the first line contains "******", remove it: + error_msg = "\n".join(error_msg.split("\n")[1:]) + self._failed_doctest.append((name, error_msg)) + self.write("F", "Red") + self._active_file_error = True + + def test_pass(self, char="."): + self._passed += 1 + if self._verbose: + self.write("ok", "Green") + else: + self.write(char, "Green") + + def test_skip(self, v=None): + char = "s" + self._skipped += 1 + if v is not None: + message = str(v) + if message == "KeyboardInterrupt": + char = "K" + elif message == "Timeout": + char = "T" + elif message == "Slow": + char = "w" + if self._verbose: + if v is not None: + self.write(message + ' ', "Blue") + else: + self.write(" - ", "Blue") + self.write(char, "Blue") + + def test_exception(self, exc_info): + self._exceptions.append((self._active_file, self._active_f, exc_info)) + if exc_info[0] is TimeOutError: + self.write("T", "Red") + else: + self.write("E", "Red") + self._active_file_error = True + + def import_error(self, filename, exc_info): + self._exceptions.append((filename, None, exc_info)) + rel_name = filename[len(self._root_dir) + 1:] + self.write(rel_name) + self.write("[?] Failed to import", "Red") + self.write(" ") + self.write("[FAIL]", "Red", align="right") + self.write("\n") diff --git a/shared/package-files/41/41bb9b06cff1425bcac1e027bab8721e320ae238bbec68781bebac5ee97a5d53/blob b/shared/package-files/41/41bb9b06cff1425bcac1e027bab8721e320ae238bbec68781bebac5ee97a5d53/blob new file mode 100644 index 0000000000000000000000000000000000000000..184cb6a83b3392d0492c42297531c85e7e38c4f5 Binary files /dev/null and b/shared/package-files/41/41bb9b06cff1425bcac1e027bab8721e320ae238bbec68781bebac5ee97a5d53/blob differ diff --git a/shared/package-files/41/41bd0efdfefcabe0ad1da6ef1d2ed54499a771b92eaa8c164c5dff76b98c8312/blob b/shared/package-files/41/41bd0efdfefcabe0ad1da6ef1d2ed54499a771b92eaa8c164c5dff76b98c8312/blob new file mode 100644 index 0000000000000000000000000000000000000000..c2d1f320b868cd2c3661afbb607a4924cf90aa62 --- /dev/null +++ b/shared/package-files/41/41bd0efdfefcabe0ad1da6ef1d2ed54499a771b92eaa8c164c5dff76b98c8312/blob @@ -0,0 +1,3360 @@ +""" +This file contains some classical ciphers and routines +implementing a linear-feedback shift register (LFSR) +and the Diffie-Hellman key exchange. + +.. warning:: + + This module is intended for educational purposes only. Do not use the + functions in this module for real cryptographic applications. If you wish + to encrypt real data, we recommend using something like the `cryptography + `_ module. + +""" + +from string import whitespace, ascii_uppercase as uppercase, printable +from functools import reduce +import warnings + +from itertools import cycle + +from sympy.core import Symbol +from sympy.core.numbers import igcdex, mod_inverse, igcd, Rational +from sympy.core.random import _randrange, _randint +from sympy.matrices import Matrix +from sympy.ntheory import isprime, primitive_root, factorint +from sympy.ntheory import totient as _euler +from sympy.ntheory import reduced_totient as _carmichael +from sympy.ntheory.generate import nextprime +from sympy.ntheory.modular import crt +from sympy.polys.domains import FF +from sympy.polys.polytools import gcd, Poly +from sympy.utilities.misc import as_int, filldedent, translate +from sympy.utilities.iterables import uniq, multiset + + +class NonInvertibleCipherWarning(RuntimeWarning): + """A warning raised if the cipher is not invertible.""" + def __init__(self, msg): + self.fullMessage = msg + + def __str__(self): + return '\n\t' + self.fullMessage + + def warn(self, stacklevel=3): + warnings.warn(self, stacklevel=stacklevel) + + +def AZ(s=None): + """Return the letters of ``s`` in uppercase. In case more than + one string is passed, each of them will be processed and a list + of upper case strings will be returned. + + Examples + ======== + + >>> from sympy.crypto.crypto import AZ + >>> AZ('Hello, world!') + 'HELLOWORLD' + >>> AZ('Hello, world!'.split()) + ['HELLO', 'WORLD'] + + See Also + ======== + + check_and_join + + """ + if not s: + return uppercase + t = isinstance(s, str) + if t: + s = [s] + rv = [check_and_join(i.upper().split(), uppercase, filter=True) + for i in s] + if t: + return rv[0] + return rv + +bifid5 = AZ().replace('J', '') +bifid6 = AZ() + '0123456789' +bifid10 = printable + + +def padded_key(key, symbols): + """Return a string of the distinct characters of ``symbols`` with + those of ``key`` appearing first. A ValueError is raised if + a) there are duplicate characters in ``symbols`` or + b) there are characters in ``key`` that are not in ``symbols``. + + Examples + ======== + + >>> from sympy.crypto.crypto import padded_key + >>> padded_key('PUPPY', 'OPQRSTUVWXY') + 'PUYOQRSTVWX' + >>> padded_key('RSA', 'ARTIST') + Traceback (most recent call last): + ... + ValueError: duplicate characters in symbols: T + + """ + syms = list(uniq(symbols)) + if len(syms) != len(symbols): + extra = ''.join(sorted({ + i for i in symbols if symbols.count(i) > 1})) + raise ValueError('duplicate characters in symbols: %s' % extra) + extra = set(key) - set(syms) + if extra: + raise ValueError( + 'characters in key but not symbols: %s' % ''.join( + sorted(extra))) + key0 = ''.join(list(uniq(key))) + # remove from syms characters in key0 + return key0 + translate(''.join(syms), None, key0) + + +def check_and_join(phrase, symbols=None, filter=None): + """ + Joins characters of ``phrase`` and if ``symbols`` is given, raises + an error if any character in ``phrase`` is not in ``symbols``. + + Parameters + ========== + + phrase + String or list of strings to be returned as a string. + + symbols + Iterable of characters allowed in ``phrase``. + + If ``symbols`` is ``None``, no checking is performed. + + Examples + ======== + + >>> from sympy.crypto.crypto import check_and_join + >>> check_and_join('a phrase') + 'a phrase' + >>> check_and_join('a phrase'.upper().split()) + 'APHRASE' + >>> check_and_join('a phrase!'.upper().split(), 'ARE', filter=True) + 'ARAE' + >>> check_and_join('a phrase!'.upper().split(), 'ARE') + Traceback (most recent call last): + ... + ValueError: characters in phrase but not symbols: "!HPS" + + """ + rv = ''.join(''.join(phrase)) + if symbols is not None: + symbols = check_and_join(symbols) + missing = ''.join(sorted(set(rv) - set(symbols))) + if missing: + if not filter: + raise ValueError( + 'characters in phrase but not symbols: "%s"' % missing) + rv = translate(rv, None, missing) + return rv + + +def _prep(msg, key, alp, default=None): + if not alp: + if not default: + alp = AZ() + msg = AZ(msg) + key = AZ(key) + else: + alp = default + else: + alp = ''.join(alp) + key = check_and_join(key, alp, filter=True) + msg = check_and_join(msg, alp, filter=True) + return msg, key, alp + + +def cycle_list(k, n): + """ + Returns the elements of the list ``range(n)`` shifted to the + left by ``k`` (so the list starts with ``k`` (mod ``n``)). + + Examples + ======== + + >>> from sympy.crypto.crypto import cycle_list + >>> cycle_list(3, 10) + [3, 4, 5, 6, 7, 8, 9, 0, 1, 2] + + """ + k = k % n + return list(range(k, n)) + list(range(k)) + + +######## shift cipher examples ############ + + +def encipher_shift(msg, key, symbols=None): + """ + Performs shift cipher encryption on plaintext msg, and returns the + ciphertext. + + Parameters + ========== + + key : int + The secret key. + + msg : str + Plaintext of upper-case letters. + + Returns + ======= + + str + Ciphertext of upper-case letters. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_shift, decipher_shift + >>> msg = "GONAVYBEATARMY" + >>> ct = encipher_shift(msg, 1); ct + 'HPOBWZCFBUBSNZ' + + To decipher the shifted text, change the sign of the key: + + >>> encipher_shift(ct, -1) + 'GONAVYBEATARMY' + + There is also a convenience function that does this with the + original key: + + >>> decipher_shift(ct, 1) + 'GONAVYBEATARMY' + + Notes + ===== + + ALGORITHM: + + STEPS: + 0. Number the letters of the alphabet from 0, ..., N + 1. Compute from the string ``msg`` a list ``L1`` of + corresponding integers. + 2. Compute from the list ``L1`` a new list ``L2``, given by + adding ``(k mod 26)`` to each element in ``L1``. + 3. Compute from the list ``L2`` a string ``ct`` of + corresponding letters. + + The shift cipher is also called the Caesar cipher, after + Julius Caesar, who, according to Suetonius, used it with a + shift of three to protect messages of military significance. + Caesar's nephew Augustus reportedly used a similar cipher, but + with a right shift of 1. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Caesar_cipher + .. [2] https://mathworld.wolfram.com/CaesarsMethod.html + + See Also + ======== + + decipher_shift + + """ + msg, _, A = _prep(msg, '', symbols) + shift = len(A) - key % len(A) + key = A[shift:] + A[:shift] + return translate(msg, key, A) + + +def decipher_shift(msg, key, symbols=None): + """ + Return the text by shifting the characters of ``msg`` to the + left by the amount given by ``key``. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_shift, decipher_shift + >>> msg = "GONAVYBEATARMY" + >>> ct = encipher_shift(msg, 1); ct + 'HPOBWZCFBUBSNZ' + + To decipher the shifted text, change the sign of the key: + + >>> encipher_shift(ct, -1) + 'GONAVYBEATARMY' + + Or use this function with the original key: + + >>> decipher_shift(ct, 1) + 'GONAVYBEATARMY' + + """ + return encipher_shift(msg, -key, symbols) + +def encipher_rot13(msg, symbols=None): + """ + Performs the ROT13 encryption on a given plaintext ``msg``. + + Explanation + =========== + + ROT13 is a substitution cipher which substitutes each letter + in the plaintext message for the letter furthest away from it + in the English alphabet. + + Equivalently, it is just a Caeser (shift) cipher with a shift + key of 13 (midway point of the alphabet). + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/ROT13 + + See Also + ======== + + decipher_rot13 + encipher_shift + + """ + return encipher_shift(msg, 13, symbols) + +def decipher_rot13(msg, symbols=None): + """ + Performs the ROT13 decryption on a given plaintext ``msg``. + + Explanation + ============ + + ``decipher_rot13`` is equivalent to ``encipher_rot13`` as both + ``decipher_shift`` with a key of 13 and ``encipher_shift`` key with a + key of 13 will return the same results. Nonetheless, + ``decipher_rot13`` has nonetheless been explicitly defined here for + consistency. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13 + >>> msg = 'GONAVYBEATARMY' + >>> ciphertext = encipher_rot13(msg);ciphertext + 'TBANILORNGNEZL' + >>> decipher_rot13(ciphertext) + 'GONAVYBEATARMY' + >>> encipher_rot13(msg) == decipher_rot13(msg) + True + >>> msg == decipher_rot13(ciphertext) + True + + """ + return decipher_shift(msg, 13, symbols) + +######## affine cipher examples ############ + + +def encipher_affine(msg, key, symbols=None, _inverse=False): + r""" + Performs the affine cipher encryption on plaintext ``msg``, and + returns the ciphertext. + + Explanation + =========== + + Encryption is based on the map `x \rightarrow ax+b` (mod `N`) + where ``N`` is the number of characters in the alphabet. + Decryption is based on the map `x \rightarrow cx+d` (mod `N`), + where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`). + In particular, for the map to be invertible, we need + `\mathrm{gcd}(a, N) = 1` and an error will be raised if this is + not true. + + Parameters + ========== + + msg : str + Characters that appear in ``symbols``. + + a, b : int, int + A pair integers, with ``gcd(a, N) = 1`` (the secret key). + + symbols + String of characters (default = uppercase letters). + + When no symbols are given, ``msg`` is converted to upper case + letters and all other characters are ignored. + + Returns + ======= + + ct + String of characters (the ciphertext message) + + Notes + ===== + + ALGORITHM: + + STEPS: + 0. Number the letters of the alphabet from 0, ..., N + 1. Compute from the string ``msg`` a list ``L1`` of + corresponding integers. + 2. Compute from the list ``L1`` a new list ``L2``, given by + replacing ``x`` by ``a*x + b (mod N)``, for each element + ``x`` in ``L1``. + 3. Compute from the list ``L2`` a string ``ct`` of + corresponding letters. + + This is a straightforward generalization of the shift cipher with + the added complexity of requiring 2 characters to be deciphered in + order to recover the key. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Affine_cipher + + See Also + ======== + + decipher_affine + + """ + msg, _, A = _prep(msg, '', symbols) + N = len(A) + a, b = key + assert gcd(a, N) == 1 + if _inverse: + c = mod_inverse(a, N) + d = -b*c + a, b = c, d + B = ''.join([A[(a*i + b) % N] for i in range(N)]) + return translate(msg, A, B) + + +def decipher_affine(msg, key, symbols=None): + r""" + Return the deciphered text that was made from the mapping, + `x \rightarrow ax+b` (mod `N`), where ``N`` is the + number of characters in the alphabet. Deciphering is done by + reciphering with a new key: `x \rightarrow cx+d` (mod `N`), + where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`). + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_affine, decipher_affine + >>> msg = "GO NAVY BEAT ARMY" + >>> key = (3, 1) + >>> encipher_affine(msg, key) + 'TROBMVENBGBALV' + >>> decipher_affine(_, key) + 'GONAVYBEATARMY' + + See Also + ======== + + encipher_affine + + """ + return encipher_affine(msg, key, symbols, _inverse=True) + + +def encipher_atbash(msg, symbols=None): + r""" + Enciphers a given ``msg`` into its Atbash ciphertext and returns it. + + Explanation + =========== + + Atbash is a substitution cipher originally used to encrypt the Hebrew + alphabet. Atbash works on the principle of mapping each alphabet to its + reverse / counterpart (i.e. a would map to z, b to y etc.) + + Atbash is functionally equivalent to the affine cipher with ``a = 25`` + and ``b = 25`` + + See Also + ======== + + decipher_atbash + + """ + return encipher_affine(msg, (25, 25), symbols) + + +def decipher_atbash(msg, symbols=None): + r""" + Deciphers a given ``msg`` using Atbash cipher and returns it. + + Explanation + =========== + + ``decipher_atbash`` is functionally equivalent to ``encipher_atbash``. + However, it has still been added as a separate function to maintain + consistency. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash + >>> msg = 'GONAVYBEATARMY' + >>> encipher_atbash(msg) + 'TLMZEBYVZGZINB' + >>> decipher_atbash(msg) + 'TLMZEBYVZGZINB' + >>> encipher_atbash(msg) == decipher_atbash(msg) + True + >>> msg == encipher_atbash(encipher_atbash(msg)) + True + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Atbash + + See Also + ======== + + encipher_atbash + + """ + return decipher_affine(msg, (25, 25), symbols) + +#################### substitution cipher ########################### + + +def encipher_substitution(msg, old, new=None): + r""" + Returns the ciphertext obtained by replacing each character that + appears in ``old`` with the corresponding character in ``new``. + If ``old`` is a mapping, then new is ignored and the replacements + defined by ``old`` are used. + + Explanation + =========== + + This is a more general than the affine cipher in that the key can + only be recovered by determining the mapping for each symbol. + Though in practice, once a few symbols are recognized the mappings + for other characters can be quickly guessed. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_substitution, AZ + >>> old = 'OEYAG' + >>> new = '034^6' + >>> msg = AZ("go navy! beat army!") + >>> ct = encipher_substitution(msg, old, new); ct + '60N^V4B3^T^RM4' + + To decrypt a substitution, reverse the last two arguments: + + >>> encipher_substitution(ct, new, old) + 'GONAVYBEATARMY' + + In the special case where ``old`` and ``new`` are a permutation of + order 2 (representing a transposition of characters) their order + is immaterial: + + >>> old = 'NAVY' + >>> new = 'ANYV' + >>> encipher = lambda x: encipher_substitution(x, old, new) + >>> encipher('NAVY') + 'ANYV' + >>> encipher(_) + 'NAVY' + + The substitution cipher, in general, is a method + whereby "units" (not necessarily single characters) of plaintext + are replaced with ciphertext according to a regular system. + + >>> ords = dict(zip('abc', ['\\%i' % ord(i) for i in 'abc'])) + >>> print(encipher_substitution('abc', ords)) + \97\98\99 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Substitution_cipher + + """ + return translate(msg, old, new) + + +###################################################################### +#################### Vigenere cipher examples ######################## +###################################################################### + +def encipher_vigenere(msg, key, symbols=None): + """ + Performs the Vigenere cipher encryption on plaintext ``msg``, and + returns the ciphertext. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_vigenere, AZ + >>> key = "encrypt" + >>> msg = "meet me on monday" + >>> encipher_vigenere(msg, key) + 'QRGKKTHRZQEBPR' + + Section 1 of the Kryptos sculpture at the CIA headquarters + uses this cipher and also changes the order of the + alphabet [2]_. Here is the first line of that section of + the sculpture: + + >>> from sympy.crypto.crypto import decipher_vigenere, padded_key + >>> alp = padded_key('KRYPTOS', AZ()) + >>> key = 'PALIMPSEST' + >>> msg = 'EMUFPHZLRFAXYUSDJKZLDKRNSHGNFIVJ' + >>> decipher_vigenere(msg, key, alp) + 'BETWEENSUBTLESHADINGANDTHEABSENC' + + Explanation + =========== + + The Vigenere cipher is named after Blaise de Vigenere, a sixteenth + century diplomat and cryptographer, by a historical accident. + Vigenere actually invented a different and more complicated cipher. + The so-called *Vigenere cipher* was actually invented + by Giovan Batista Belaso in 1553. + + This cipher was used in the 1800's, for example, during the American + Civil War. The Confederacy used a brass cipher disk to implement the + Vigenere cipher (now on display in the NSA Museum in Fort + Meade) [1]_. + + The Vigenere cipher is a generalization of the shift cipher. + Whereas the shift cipher shifts each letter by the same amount + (that amount being the key of the shift cipher) the Vigenere + cipher shifts a letter by an amount determined by the key (which is + a word or phrase known only to the sender and receiver). + + For example, if the key was a single letter, such as "C", then the + so-called Vigenere cipher is actually a shift cipher with a + shift of `2` (since "C" is the 2nd letter of the alphabet, if + you start counting at `0`). If the key was a word with two + letters, such as "CA", then the so-called Vigenere cipher will + shift letters in even positions by `2` and letters in odd positions + are left alone (shifted by `0`, since "A" is the 0th letter, if + you start counting at `0`). + + + ALGORITHM: + + INPUT: + + ``msg``: string of characters that appear in ``symbols`` + (the plaintext) + + ``key``: a string of characters that appear in ``symbols`` + (the secret key) + + ``symbols``: a string of letters defining the alphabet + + + OUTPUT: + + ``ct``: string of characters (the ciphertext message) + + STEPS: + 0. Number the letters of the alphabet from 0, ..., N + 1. Compute from the string ``key`` a list ``L1`` of + corresponding integers. Let ``n1 = len(L1)``. + 2. Compute from the string ``msg`` a list ``L2`` of + corresponding integers. Let ``n2 = len(L2)``. + 3. Break ``L2`` up sequentially into sublists of size + ``n1``; the last sublist may be smaller than ``n1`` + 4. For each of these sublists ``L`` of ``L2``, compute a + new list ``C`` given by ``C[i] = L[i] + L1[i] (mod N)`` + to the ``i``-th element in the sublist, for each ``i``. + 5. Assemble these lists ``C`` by concatenation into a new + list of length ``n2``. + 6. Compute from the new list a string ``ct`` of + corresponding letters. + + Once it is known that the key is, say, `n` characters long, + frequency analysis can be applied to every `n`-th letter of + the ciphertext to determine the plaintext. This method is + called *Kasiski examination* (although it was first discovered + by Babbage). If they key is as long as the message and is + comprised of randomly selected characters -- a one-time pad -- the + message is theoretically unbreakable. + + The cipher Vigenere actually discovered is an "auto-key" cipher + described as follows. + + ALGORITHM: + + INPUT: + + ``key``: a string of letters (the secret key) + + ``msg``: string of letters (the plaintext message) + + OUTPUT: + + ``ct``: string of upper-case letters (the ciphertext message) + + STEPS: + 0. Number the letters of the alphabet from 0, ..., N + 1. Compute from the string ``msg`` a list ``L2`` of + corresponding integers. Let ``n2 = len(L2)``. + 2. Let ``n1`` be the length of the key. Append to the + string ``key`` the first ``n2 - n1`` characters of + the plaintext message. Compute from this string (also of + length ``n2``) a list ``L1`` of integers corresponding + to the letter numbers in the first step. + 3. Compute a new list ``C`` given by + ``C[i] = L1[i] + L2[i] (mod N)``. + 4. Compute from the new list a string ``ct`` of letters + corresponding to the new integers. + + To decipher the auto-key ciphertext, the key is used to decipher + the first ``n1`` characters and then those characters become the + key to decipher the next ``n1`` characters, etc...: + + >>> m = AZ('go navy, beat army! yes you can'); m + 'GONAVYBEATARMYYESYOUCAN' + >>> key = AZ('gold bug'); n1 = len(key); n2 = len(m) + >>> auto_key = key + m[:n2 - n1]; auto_key + 'GOLDBUGGONAVYBEATARMYYE' + >>> ct = encipher_vigenere(m, auto_key); ct + 'MCYDWSHKOGAMKZCELYFGAYR' + >>> n1 = len(key) + >>> pt = [] + >>> while ct: + ... part, ct = ct[:n1], ct[n1:] + ... pt.append(decipher_vigenere(part, key)) + ... key = pt[-1] + ... + >>> ''.join(pt) == m + True + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Vigenere_cipher + .. [2] https://web.archive.org/web/20071116100808/https://filebox.vt.edu/users/batman/kryptos.html + (short URL: https://goo.gl/ijr22d) + + """ + msg, key, A = _prep(msg, key, symbols) + map = {c: i for i, c in enumerate(A)} + key = [map[c] for c in key] + N = len(map) + k = len(key) + rv = [] + for i, m in enumerate(msg): + rv.append(A[(map[m] + key[i % k]) % N]) + rv = ''.join(rv) + return rv + + +def decipher_vigenere(msg, key, symbols=None): + """ + Decode using the Vigenere cipher. + + Examples + ======== + + >>> from sympy.crypto.crypto import decipher_vigenere + >>> key = "encrypt" + >>> ct = "QRGK kt HRZQE BPR" + >>> decipher_vigenere(ct, key) + 'MEETMEONMONDAY' + + """ + msg, key, A = _prep(msg, key, symbols) + map = {c: i for i, c in enumerate(A)} + N = len(A) # normally, 26 + K = [map[c] for c in key] + n = len(K) + C = [map[c] for c in msg] + rv = ''.join([A[(-K[i % n] + c) % N] for i, c in enumerate(C)]) + return rv + + +#################### Hill cipher ######################## + + +def encipher_hill(msg, key, symbols=None, pad="Q"): + r""" + Return the Hill cipher encryption of ``msg``. + + Explanation + =========== + + The Hill cipher [1]_, invented by Lester S. Hill in the 1920's [2]_, + was the first polygraphic cipher in which it was practical + (though barely) to operate on more than three symbols at once. + The following discussion assumes an elementary knowledge of + matrices. + + First, each letter is first encoded as a number starting with 0. + Suppose your message `msg` consists of `n` capital letters, with no + spaces. This may be regarded an `n`-tuple M of elements of + `Z_{26}` (if the letters are those of the English alphabet). A key + in the Hill cipher is a `k x k` matrix `K`, all of whose entries + are in `Z_{26}`, such that the matrix `K` is invertible (i.e., the + linear transformation `K: Z_{N}^k \rightarrow Z_{N}^k` + is one-to-one). + + + Parameters + ========== + + msg + Plaintext message of `n` upper-case letters. + + key + A `k \times k` invertible matrix `K`, all of whose entries are + in `Z_{26}` (or whatever number of symbols are being used). + + pad + Character (default "Q") to use to make length of text be a + multiple of ``k``. + + Returns + ======= + + ct + Ciphertext of upper-case letters. + + Notes + ===== + + ALGORITHM: + + STEPS: + 0. Number the letters of the alphabet from 0, ..., N + 1. Compute from the string ``msg`` a list ``L`` of + corresponding integers. Let ``n = len(L)``. + 2. Break the list ``L`` up into ``t = ceiling(n/k)`` + sublists ``L_1``, ..., ``L_t`` of size ``k`` (with + the last list "padded" to ensure its size is + ``k``). + 3. Compute new list ``C_1``, ..., ``C_t`` given by + ``C[i] = K*L_i`` (arithmetic is done mod N), for each + ``i``. + 4. Concatenate these into a list ``C = C_1 + ... + C_t``. + 5. Compute from ``C`` a string ``ct`` of corresponding + letters. This has length ``k*t``. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Hill_cipher + .. [2] Lester S. Hill, Cryptography in an Algebraic Alphabet, + The American Mathematical Monthly Vol.36, June-July 1929, + pp.306-312. + + See Also + ======== + + decipher_hill + + """ + assert key.is_square + assert len(pad) == 1 + msg, pad, A = _prep(msg, pad, symbols) + map = {c: i for i, c in enumerate(A)} + P = [map[c] for c in msg] + N = len(A) + k = key.cols + n = len(P) + m, r = divmod(n, k) + if r: + P = P + [map[pad]]*(k - r) + m += 1 + rv = ''.join([A[c % N] for j in range(m) for c in + list(key*Matrix(k, 1, [P[i] + for i in range(k*j, k*(j + 1))]))]) + return rv + + +def decipher_hill(msg, key, symbols=None): + """ + Deciphering is the same as enciphering but using the inverse of the + key matrix. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_hill, decipher_hill + >>> from sympy import Matrix + + >>> key = Matrix([[1, 2], [3, 5]]) + >>> encipher_hill("meet me on monday", key) + 'UEQDUEODOCTCWQ' + >>> decipher_hill(_, key) + 'MEETMEONMONDAY' + + When the length of the plaintext (stripped of invalid characters) + is not a multiple of the key dimension, extra characters will + appear at the end of the enciphered and deciphered text. In order to + decipher the text, those characters must be included in the text to + be deciphered. In the following, the key has a dimension of 4 but + the text is 2 short of being a multiple of 4 so two characters will + be added. + + >>> key = Matrix([[1, 1, 1, 2], [0, 1, 1, 0], + ... [2, 2, 3, 4], [1, 1, 0, 1]]) + >>> msg = "ST" + >>> encipher_hill(msg, key) + 'HJEB' + >>> decipher_hill(_, key) + 'STQQ' + >>> encipher_hill(msg, key, pad="Z") + 'ISPK' + >>> decipher_hill(_, key) + 'STZZ' + + If the last two characters of the ciphertext were ignored in + either case, the wrong plaintext would be recovered: + + >>> decipher_hill("HD", key) + 'ORMV' + >>> decipher_hill("IS", key) + 'UIKY' + + See Also + ======== + + encipher_hill + + """ + assert key.is_square + msg, _, A = _prep(msg, '', symbols) + map = {c: i for i, c in enumerate(A)} + C = [map[c] for c in msg] + N = len(A) + k = key.cols + n = len(C) + m, r = divmod(n, k) + if r: + C = C + [0]*(k - r) + m += 1 + key_inv = key.inv_mod(N) + rv = ''.join([A[p % N] for j in range(m) for p in + list(key_inv*Matrix( + k, 1, [C[i] for i in range(k*j, k*(j + 1))]))]) + return rv + + +#################### Bifid cipher ######################## + + +def encipher_bifid(msg, key, symbols=None): + r""" + Performs the Bifid cipher encryption on plaintext ``msg``, and + returns the ciphertext. + + This is the version of the Bifid cipher that uses an `n \times n` + Polybius square. + + Parameters + ========== + + msg + Plaintext string. + + key + Short string for key. + + Duplicate characters are ignored and then it is padded with the + characters in ``symbols`` that were not in the short key. + + symbols + `n \times n` characters defining the alphabet. + + (default is string.printable) + + Returns + ======= + + ciphertext + Ciphertext using Bifid5 cipher without spaces. + + See Also + ======== + + decipher_bifid, encipher_bifid5, encipher_bifid6 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Bifid_cipher + + """ + msg, key, A = _prep(msg, key, symbols, bifid10) + long_key = ''.join(uniq(key)) or A + + n = len(A)**.5 + if n != int(n): + raise ValueError( + 'Length of alphabet (%s) is not a square number.' % len(A)) + N = int(n) + if len(long_key) < N**2: + long_key = list(long_key) + [x for x in A if x not in long_key] + + # the fractionalization + row_col = {ch: divmod(i, N) for i, ch in enumerate(long_key)} + r, c = zip(*[row_col[x] for x in msg]) + rc = r + c + ch = {i: ch for ch, i in row_col.items()} + rv = ''.join(ch[i] for i in zip(rc[::2], rc[1::2])) + return rv + + +def decipher_bifid(msg, key, symbols=None): + r""" + Performs the Bifid cipher decryption on ciphertext ``msg``, and + returns the plaintext. + + This is the version of the Bifid cipher that uses the `n \times n` + Polybius square. + + Parameters + ========== + + msg + Ciphertext string. + + key + Short string for key. + + Duplicate characters are ignored and then it is padded with the + characters in symbols that were not in the short key. + + symbols + `n \times n` characters defining the alphabet. + + (default=string.printable, a `10 \times 10` matrix) + + Returns + ======= + + deciphered + Deciphered text. + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... encipher_bifid, decipher_bifid, AZ) + + Do an encryption using the bifid5 alphabet: + + >>> alp = AZ().replace('J', '') + >>> ct = AZ("meet me on monday!") + >>> key = AZ("gold bug") + >>> encipher_bifid(ct, key, alp) + 'IEILHHFSTSFQYE' + + When entering the text or ciphertext, spaces are ignored so it + can be formatted as desired. Re-entering the ciphertext from the + preceding, putting 4 characters per line and padding with an extra + J, does not cause problems for the deciphering: + + >>> decipher_bifid(''' + ... IEILH + ... HFSTS + ... FQYEJ''', key, alp) + 'MEETMEONMONDAY' + + When no alphabet is given, all 100 printable characters will be + used: + + >>> key = '' + >>> encipher_bifid('hello world!', key) + 'bmtwmg-bIo*w' + >>> decipher_bifid(_, key) + 'hello world!' + + If the key is changed, a different encryption is obtained: + + >>> key = 'gold bug' + >>> encipher_bifid('hello world!', 'gold_bug') + 'hg2sfuei7t}w' + + And if the key used to decrypt the message is not exact, the + original text will not be perfectly obtained: + + >>> decipher_bifid(_, 'gold pug') + 'heldo~wor6d!' + + """ + msg, _, A = _prep(msg, '', symbols, bifid10) + long_key = ''.join(uniq(key)) or A + + n = len(A)**.5 + if n != int(n): + raise ValueError( + 'Length of alphabet (%s) is not a square number.' % len(A)) + N = int(n) + if len(long_key) < N**2: + long_key = list(long_key) + [x for x in A if x not in long_key] + + # the reverse fractionalization + row_col = { + ch: divmod(i, N) for i, ch in enumerate(long_key)} + rc = [i for c in msg for i in row_col[c]] + n = len(msg) + rc = zip(*(rc[:n], rc[n:])) + ch = {i: ch for ch, i in row_col.items()} + rv = ''.join(ch[i] for i in rc) + return rv + + +def bifid_square(key): + """Return characters of ``key`` arranged in a square. + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... bifid_square, AZ, padded_key, bifid5) + >>> bifid_square(AZ().replace('J', '')) + Matrix([ + [A, B, C, D, E], + [F, G, H, I, K], + [L, M, N, O, P], + [Q, R, S, T, U], + [V, W, X, Y, Z]]) + + >>> bifid_square(padded_key(AZ('gold bug!'), bifid5)) + Matrix([ + [G, O, L, D, B], + [U, A, C, E, F], + [H, I, K, M, N], + [P, Q, R, S, T], + [V, W, X, Y, Z]]) + + See Also + ======== + + padded_key + + """ + A = ''.join(uniq(''.join(key))) + n = len(A)**.5 + if n != int(n): + raise ValueError( + 'Length of alphabet (%s) is not a square number.' % len(A)) + n = int(n) + f = lambda i, j: Symbol(A[n*i + j]) + rv = Matrix(n, n, f) + return rv + + +def encipher_bifid5(msg, key): + r""" + Performs the Bifid cipher encryption on plaintext ``msg``, and + returns the ciphertext. + + Explanation + =========== + + This is the version of the Bifid cipher that uses the `5 \times 5` + Polybius square. The letter "J" is ignored so it must be replaced + with something else (traditionally an "I") before encryption. + + ALGORITHM: (5x5 case) + + STEPS: + 0. Create the `5 \times 5` Polybius square ``S`` associated + to ``key`` as follows: + + a) moving from left-to-right, top-to-bottom, + place the letters of the key into a `5 \times 5` + matrix, + b) if the key has less than 25 letters, add the + letters of the alphabet not in the key until the + `5 \times 5` square is filled. + + 1. Create a list ``P`` of pairs of numbers which are the + coordinates in the Polybius square of the letters in + ``msg``. + 2. Let ``L1`` be the list of all first coordinates of ``P`` + (length of ``L1 = n``), let ``L2`` be the list of all + second coordinates of ``P`` (so the length of ``L2`` + is also ``n``). + 3. Let ``L`` be the concatenation of ``L1`` and ``L2`` + (length ``L = 2*n``), except that consecutive numbers + are paired ``(L[2*i], L[2*i + 1])``. You can regard + ``L`` as a list of pairs of length ``n``. + 4. Let ``C`` be the list of all letters which are of the + form ``S[i, j]``, for all ``(i, j)`` in ``L``. As a + string, this is the ciphertext of ``msg``. + + Parameters + ========== + + msg : str + Plaintext string. + + Converted to upper case and filtered of anything but all letters + except J. + + key + Short string for key; non-alphabetic letters, J and duplicated + characters are ignored and then, if the length is less than 25 + characters, it is padded with other letters of the alphabet + (in alphabetical order). + + Returns + ======= + + ct + Ciphertext (all caps, no spaces). + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... encipher_bifid5, decipher_bifid5) + + "J" will be omitted unless it is replaced with something else: + + >>> round_trip = lambda m, k: \ + ... decipher_bifid5(encipher_bifid5(m, k), k) + >>> key = 'a' + >>> msg = "JOSIE" + >>> round_trip(msg, key) + 'OSIE' + >>> round_trip(msg.replace("J", "I"), key) + 'IOSIE' + >>> j = "QIQ" + >>> round_trip(msg.replace("J", j), key).replace(j, "J") + 'JOSIE' + + + Notes + ===== + + The Bifid cipher was invented around 1901 by Felix Delastelle. + It is a *fractional substitution* cipher, where letters are + replaced by pairs of symbols from a smaller alphabet. The + cipher uses a `5 \times 5` square filled with some ordering of the + alphabet, except that "J" is replaced with "I" (this is a so-called + Polybius square; there is a `6 \times 6` analog if you add back in + "J" and also append onto the usual 26 letter alphabet, the digits + 0, 1, ..., 9). + According to Helen Gaines' book *Cryptanalysis*, this type of cipher + was used in the field by the German Army during World War I. + + See Also + ======== + + decipher_bifid5, encipher_bifid + + """ + msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5) + key = padded_key(key, bifid5) + return encipher_bifid(msg, '', key) + + +def decipher_bifid5(msg, key): + r""" + Return the Bifid cipher decryption of ``msg``. + + Explanation + =========== + + This is the version of the Bifid cipher that uses the `5 \times 5` + Polybius square; the letter "J" is ignored unless a ``key`` of + length 25 is used. + + Parameters + ========== + + msg + Ciphertext string. + + key + Short string for key; duplicated characters are ignored and if + the length is less then 25 characters, it will be padded with + other letters from the alphabet omitting "J". + Non-alphabetic characters are ignored. + + Returns + ======= + + plaintext + Plaintext from Bifid5 cipher (all caps, no spaces). + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_bifid5, decipher_bifid5 + >>> key = "gold bug" + >>> encipher_bifid5('meet me on friday', key) + 'IEILEHFSTSFXEE' + >>> encipher_bifid5('meet me on monday', key) + 'IEILHHFSTSFQYE' + >>> decipher_bifid5(_, key) + 'MEETMEONMONDAY' + + """ + msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5) + key = padded_key(key, bifid5) + return decipher_bifid(msg, '', key) + + +def bifid5_square(key=None): + r""" + 5x5 Polybius square. + + Produce the Polybius square for the `5 \times 5` Bifid cipher. + + Examples + ======== + + >>> from sympy.crypto.crypto import bifid5_square + >>> bifid5_square("gold bug") + Matrix([ + [G, O, L, D, B], + [U, A, C, E, F], + [H, I, K, M, N], + [P, Q, R, S, T], + [V, W, X, Y, Z]]) + + """ + if not key: + key = bifid5 + else: + _, key, _ = _prep('', key.upper(), None, bifid5) + key = padded_key(key, bifid5) + return bifid_square(key) + + +def encipher_bifid6(msg, key): + r""" + Performs the Bifid cipher encryption on plaintext ``msg``, and + returns the ciphertext. + + This is the version of the Bifid cipher that uses the `6 \times 6` + Polybius square. + + Parameters + ========== + + msg + Plaintext string (digits okay). + + key + Short string for key (digits okay). + + If ``key`` is less than 36 characters long, the square will be + filled with letters A through Z and digits 0 through 9. + + Returns + ======= + + ciphertext + Ciphertext from Bifid cipher (all caps, no spaces). + + See Also + ======== + + decipher_bifid6, encipher_bifid + + """ + msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6) + key = padded_key(key, bifid6) + return encipher_bifid(msg, '', key) + + +def decipher_bifid6(msg, key): + r""" + Performs the Bifid cipher decryption on ciphertext ``msg``, and + returns the plaintext. + + This is the version of the Bifid cipher that uses the `6 \times 6` + Polybius square. + + Parameters + ========== + + msg + Ciphertext string (digits okay); converted to upper case + + key + Short string for key (digits okay). + + If ``key`` is less than 36 characters long, the square will be + filled with letters A through Z and digits 0 through 9. + All letters are converted to uppercase. + + Returns + ======= + + plaintext + Plaintext from Bifid cipher (all caps, no spaces). + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_bifid6, decipher_bifid6 + >>> key = "gold bug" + >>> encipher_bifid6('meet me on monday at 8am', key) + 'KFKLJJHF5MMMKTFRGPL' + >>> decipher_bifid6(_, key) + 'MEETMEONMONDAYAT8AM' + + """ + msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6) + key = padded_key(key, bifid6) + return decipher_bifid(msg, '', key) + + +def bifid6_square(key=None): + r""" + 6x6 Polybius square. + + Produces the Polybius square for the `6 \times 6` Bifid cipher. + Assumes alphabet of symbols is "A", ..., "Z", "0", ..., "9". + + Examples + ======== + + >>> from sympy.crypto.crypto import bifid6_square + >>> key = "gold bug" + >>> bifid6_square(key) + Matrix([ + [G, O, L, D, B, U], + [A, C, E, F, H, I], + [J, K, M, N, P, Q], + [R, S, T, V, W, X], + [Y, Z, 0, 1, 2, 3], + [4, 5, 6, 7, 8, 9]]) + + """ + if not key: + key = bifid6 + else: + _, key, _ = _prep('', key.upper(), None, bifid6) + key = padded_key(key, bifid6) + return bifid_square(key) + + +#################### RSA ############################# + +def _decipher_rsa_crt(i, d, factors): + """Decipher RSA using chinese remainder theorem from the information + of the relatively-prime factors of the modulus. + + Parameters + ========== + + i : integer + Ciphertext + + d : integer + The exponent component. + + factors : list of relatively-prime integers + The integers given must be coprime and the product must equal + the modulus component of the original RSA key. + + Examples + ======== + + How to decrypt RSA with CRT: + + >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key + >>> primes = [61, 53] + >>> e = 17 + >>> args = primes + [e] + >>> puk = rsa_public_key(*args) + >>> prk = rsa_private_key(*args) + + >>> from sympy.crypto.crypto import encipher_rsa, _decipher_rsa_crt + >>> msg = 65 + >>> crt_primes = primes + >>> encrypted = encipher_rsa(msg, puk) + >>> decrypted = _decipher_rsa_crt(encrypted, prk[1], primes) + >>> decrypted + 65 + """ + moduluses = [pow(i, d, p) for p in factors] + + result = crt(factors, moduluses) + if not result: + raise ValueError("CRT failed") + return result[0] + + +def _rsa_key(*args, public=True, private=True, totient='Euler', index=None, multipower=None): + r"""A private subroutine to generate RSA key + + Parameters + ========== + + public, private : bool, optional + Flag to generate either a public key, a private key. + + totient : 'Euler' or 'Carmichael' + Different notation used for totient. + + multipower : bool, optional + Flag to bypass warning for multipower RSA. + """ + + if len(args) < 2: + return False + + if totient not in ('Euler', 'Carmichael'): + raise ValueError( + "The argument totient={} should either be " \ + "'Euler', 'Carmichalel'." \ + .format(totient)) + + if totient == 'Euler': + _totient = _euler + else: + _totient = _carmichael + + if index is not None: + index = as_int(index) + if totient != 'Carmichael': + raise ValueError( + "Setting the 'index' keyword argument requires totient" + "notation to be specified as 'Carmichael'.") + + primes, e = args[:-1], args[-1] + + if not all(isprime(p) for p in primes): + new_primes = [] + for i in primes: + new_primes.extend(factorint(i, multiple=True)) + primes = new_primes + + n = reduce(lambda i, j: i*j, primes) + + tally = multiset(primes) + if all(v == 1 for v in tally.values()): + multiple = list(tally.keys()) + phi = _totient._from_distinct_primes(*multiple) + + else: + if not multipower: + NonInvertibleCipherWarning( + 'Non-distinctive primes found in the factors {}. ' + 'The cipher may not be decryptable for some numbers ' + 'in the complete residue system Z[{}], but the cipher ' + 'can still be valid if you restrict the domain to be ' + 'the reduced residue system Z*[{}]. You can pass ' + 'the flag multipower=True if you want to suppress this ' + 'warning.' + .format(primes, n, n) + # stacklevel=4 because most users will call a function that + # calls this function + ).warn(stacklevel=4) + phi = _totient._from_factors(tally) + + if igcd(e, phi) == 1: + if public and not private: + if isinstance(index, int): + e = e % phi + e += index * phi + return n, e + + if private and not public: + d = mod_inverse(e, phi) + if isinstance(index, int): + d += index * phi + return n, d + + return False + + +def rsa_public_key(*args, **kwargs): + r"""Return the RSA *public key* pair, `(n, e)` + + Parameters + ========== + + args : naturals + If specified as `p, q, e` where `p` and `q` are distinct primes + and `e` is a desired public exponent of the RSA, `n = p q` and + `e` will be verified against the totient + `\phi(n)` (Euler totient) or `\lambda(n)` (Carmichael totient) + to be `\gcd(e, \phi(n)) = 1` or `\gcd(e, \lambda(n)) = 1`. + + If specified as `p_1, p_2, \dots, p_n, e` where + `p_1, p_2, \dots, p_n` are specified as primes, + and `e` is specified as a desired public exponent of the RSA, + it will be able to form a multi-prime RSA, which is a more + generalized form of the popular 2-prime RSA. + + It can also be possible to form a single-prime RSA by specifying + the argument as `p, e`, which can be considered a trivial case + of a multiprime RSA. + + Furthermore, it can be possible to form a multi-power RSA by + specifying two or more pairs of the primes to be same. + However, unlike the two-distinct prime RSA or multi-prime + RSA, not every numbers in the complete residue system + (`\mathbb{Z}_n`) will be decryptable since the mapping + `\mathbb{Z}_{n} \rightarrow \mathbb{Z}_{n}` + will not be bijective. + (Only except for the trivial case when + `e = 1` + or more generally, + + .. math:: + e \in \left \{ 1 + k \lambda(n) + \mid k \in \mathbb{Z} \land k \geq 0 \right \} + + when RSA reduces to the identity.) + However, the RSA can still be decryptable for the numbers in the + reduced residue system (`\mathbb{Z}_n^{\times}`), since the + mapping + `\mathbb{Z}_{n}^{\times} \rightarrow \mathbb{Z}_{n}^{\times}` + can still be bijective. + + If you pass a non-prime integer to the arguments + `p_1, p_2, \dots, p_n`, the particular number will be + prime-factored and it will become either a multi-prime RSA or a + multi-power RSA in its canonical form, depending on whether the + product equals its radical or not. + `p_1 p_2 \dots p_n = \text{rad}(p_1 p_2 \dots p_n)` + + totient : bool, optional + If ``'Euler'``, it uses Euler's totient `\phi(n)` which is + :meth:`sympy.ntheory.factor_.totient` in SymPy. + + If ``'Carmichael'``, it uses Carmichael's totient `\lambda(n)` + which is :meth:`sympy.ntheory.factor_.reduced_totient` in SymPy. + + Unlike private key generation, this is a trivial keyword for + public key generation because + `\gcd(e, \phi(n)) = 1 \iff \gcd(e, \lambda(n)) = 1`. + + index : nonnegative integer, optional + Returns an arbitrary solution of a RSA public key at the index + specified at `0, 1, 2, \dots`. This parameter needs to be + specified along with ``totient='Carmichael'``. + + Similarly to the non-uniquenss of a RSA private key as described + in the ``index`` parameter documentation in + :meth:`rsa_private_key`, RSA public key is also not unique and + there is an infinite number of RSA public exponents which + can behave in the same manner. + + From any given RSA public exponent `e`, there are can be an + another RSA public exponent `e + k \lambda(n)` where `k` is an + integer, `\lambda` is a Carmichael's totient function. + + However, considering only the positive cases, there can be + a principal solution of a RSA public exponent `e_0` in + `0 < e_0 < \lambda(n)`, and all the other solutions + can be canonicalzed in a form of `e_0 + k \lambda(n)`. + + ``index`` specifies the `k` notation to yield any possible value + an RSA public key can have. + + An example of computing any arbitrary RSA public key: + + >>> from sympy.crypto.crypto import rsa_public_key + >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=0) + (3233, 17) + >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=1) + (3233, 797) + >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=2) + (3233, 1577) + + multipower : bool, optional + Any pair of non-distinct primes found in the RSA specification + will restrict the domain of the cryptosystem, as noted in the + explanation of the parameter ``args``. + + SymPy RSA key generator may give a warning before dispatching it + as a multi-power RSA, however, you can disable the warning if + you pass ``True`` to this keyword. + + Returns + ======= + + (n, e) : int, int + `n` is a product of any arbitrary number of primes given as + the argument. + + `e` is relatively prime (coprime) to the Euler totient + `\phi(n)`. + + False + Returned if less than two arguments are given, or `e` is + not relatively prime to the modulus. + + Examples + ======== + + >>> from sympy.crypto.crypto import rsa_public_key + + A public key of a two-prime RSA: + + >>> p, q, e = 3, 5, 7 + >>> rsa_public_key(p, q, e) + (15, 7) + >>> rsa_public_key(p, q, 30) + False + + A public key of a multiprime RSA: + + >>> primes = [2, 3, 5, 7, 11, 13] + >>> e = 7 + >>> args = primes + [e] + >>> rsa_public_key(*args) + (30030, 7) + + Notes + ===== + + Although the RSA can be generalized over any modulus `n`, using + two large primes had became the most popular specification because a + product of two large primes is usually the hardest to factor + relatively to the digits of `n` can have. + + However, it may need further understanding of the time complexities + of each prime-factoring algorithms to verify the claim. + + See Also + ======== + + rsa_private_key + encipher_rsa + decipher_rsa + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29 + + .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf + + .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf + + .. [4] https://www.itiis.org/digital-library/manuscript/1381 + """ + return _rsa_key(*args, public=True, private=False, **kwargs) + + +def rsa_private_key(*args, **kwargs): + r"""Return the RSA *private key* pair, `(n, d)` + + Parameters + ========== + + args : naturals + The keyword is identical to the ``args`` in + :meth:`rsa_public_key`. + + totient : bool, optional + If ``'Euler'``, it uses Euler's totient convention `\phi(n)` + which is :meth:`sympy.ntheory.factor_.totient` in SymPy. + + If ``'Carmichael'``, it uses Carmichael's totient convention + `\lambda(n)` which is + :meth:`sympy.ntheory.factor_.reduced_totient` in SymPy. + + There can be some output differences for private key generation + as examples below. + + Example using Euler's totient: + + >>> from sympy.crypto.crypto import rsa_private_key + >>> rsa_private_key(61, 53, 17, totient='Euler') + (3233, 2753) + + Example using Carmichael's totient: + + >>> from sympy.crypto.crypto import rsa_private_key + >>> rsa_private_key(61, 53, 17, totient='Carmichael') + (3233, 413) + + index : nonnegative integer, optional + Returns an arbitrary solution of a RSA private key at the index + specified at `0, 1, 2, \dots`. This parameter needs to be + specified along with ``totient='Carmichael'``. + + RSA private exponent is a non-unique solution of + `e d \mod \lambda(n) = 1` and it is possible in any form of + `d + k \lambda(n)`, where `d` is an another + already-computed private exponent, and `\lambda` is a + Carmichael's totient function, and `k` is any integer. + + However, considering only the positive cases, there can be + a principal solution of a RSA private exponent `d_0` in + `0 < d_0 < \lambda(n)`, and all the other solutions + can be canonicalzed in a form of `d_0 + k \lambda(n)`. + + ``index`` specifies the `k` notation to yield any possible value + an RSA private key can have. + + An example of computing any arbitrary RSA private key: + + >>> from sympy.crypto.crypto import rsa_private_key + >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=0) + (3233, 413) + >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=1) + (3233, 1193) + >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=2) + (3233, 1973) + + multipower : bool, optional + The keyword is identical to the ``multipower`` in + :meth:`rsa_public_key`. + + Returns + ======= + + (n, d) : int, int + `n` is a product of any arbitrary number of primes given as + the argument. + + `d` is the inverse of `e` (mod `\phi(n)`) where `e` is the + exponent given, and `\phi` is a Euler totient. + + False + Returned if less than two arguments are given, or `e` is + not relatively prime to the totient of the modulus. + + Examples + ======== + + >>> from sympy.crypto.crypto import rsa_private_key + + A private key of a two-prime RSA: + + >>> p, q, e = 3, 5, 7 + >>> rsa_private_key(p, q, e) + (15, 7) + >>> rsa_private_key(p, q, 30) + False + + A private key of a multiprime RSA: + + >>> primes = [2, 3, 5, 7, 11, 13] + >>> e = 7 + >>> args = primes + [e] + >>> rsa_private_key(*args) + (30030, 823) + + See Also + ======== + + rsa_public_key + encipher_rsa + decipher_rsa + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29 + + .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf + + .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf + + .. [4] https://www.itiis.org/digital-library/manuscript/1381 + """ + return _rsa_key(*args, public=False, private=True, **kwargs) + + +def _encipher_decipher_rsa(i, key, factors=None): + n, d = key + if not factors: + return pow(i, d, n) + + def _is_coprime_set(l): + is_coprime_set = True + for i in range(len(l)): + for j in range(i+1, len(l)): + if igcd(l[i], l[j]) != 1: + is_coprime_set = False + break + return is_coprime_set + + prod = reduce(lambda i, j: i*j, factors) + if prod == n and _is_coprime_set(factors): + return _decipher_rsa_crt(i, d, factors) + return _encipher_decipher_rsa(i, key, factors=None) + + +def encipher_rsa(i, key, factors=None): + r"""Encrypt the plaintext with RSA. + + Parameters + ========== + + i : integer + The plaintext to be encrypted for. + + key : (n, e) where n, e are integers + `n` is the modulus of the key and `e` is the exponent of the + key. The encryption is computed by `i^e \bmod n`. + + The key can either be a public key or a private key, however, + the message encrypted by a public key can only be decrypted by + a private key, and vice versa, as RSA is an asymmetric + cryptography system. + + factors : list of coprime integers + This is identical to the keyword ``factors`` in + :meth:`decipher_rsa`. + + Notes + ===== + + Some specifications may make the RSA not cryptographically + meaningful. + + For example, `0`, `1` will remain always same after taking any + number of exponentiation, thus, should be avoided. + + Furthermore, if `i^e < n`, `i` may easily be figured out by taking + `e` th root. + + And also, specifying the exponent as `1` or in more generalized form + as `1 + k \lambda(n)` where `k` is an nonnegative integer, + `\lambda` is a carmichael totient, the RSA becomes an identity + mapping. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_rsa + >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key + + Public Key Encryption: + + >>> p, q, e = 3, 5, 7 + >>> puk = rsa_public_key(p, q, e) + >>> msg = 12 + >>> encipher_rsa(msg, puk) + 3 + + Private Key Encryption: + + >>> p, q, e = 3, 5, 7 + >>> prk = rsa_private_key(p, q, e) + >>> msg = 12 + >>> encipher_rsa(msg, prk) + 3 + + Encryption using chinese remainder theorem: + + >>> encipher_rsa(msg, prk, factors=[p, q]) + 3 + """ + return _encipher_decipher_rsa(i, key, factors=factors) + + +def decipher_rsa(i, key, factors=None): + r"""Decrypt the ciphertext with RSA. + + Parameters + ========== + + i : integer + The ciphertext to be decrypted for. + + key : (n, d) where n, d are integers + `n` is the modulus of the key and `d` is the exponent of the + key. The decryption is computed by `i^d \bmod n`. + + The key can either be a public key or a private key, however, + the message encrypted by a public key can only be decrypted by + a private key, and vice versa, as RSA is an asymmetric + cryptography system. + + factors : list of coprime integers + As the modulus `n` created from RSA key generation is composed + of arbitrary prime factors + `n = {p_1}^{k_1}{p_2}^{k_2}\dots{p_n}^{k_n}` where + `p_1, p_2, \dots, p_n` are distinct primes and + `k_1, k_2, \dots, k_n` are positive integers, chinese remainder + theorem can be used to compute `i^d \bmod n` from the + fragmented modulo operations like + + .. math:: + i^d \bmod {p_1}^{k_1}, i^d \bmod {p_2}^{k_2}, \dots, + i^d \bmod {p_n}^{k_n} + + or like + + .. math:: + i^d \bmod {p_1}^{k_1}{p_2}^{k_2}, + i^d \bmod {p_3}^{k_3}, \dots , + i^d \bmod {p_n}^{k_n} + + as long as every moduli does not share any common divisor each + other. + + The raw primes used in generating the RSA key pair can be a good + option. + + Note that the speed advantage of using this is only viable for + very large cases (Like 2048-bit RSA keys) since the + overhead of using pure Python implementation of + :meth:`sympy.ntheory.modular.crt` may overcompensate the + theoretical speed advantage. + + Notes + ===== + + See the ``Notes`` section in the documentation of + :meth:`encipher_rsa` + + Examples + ======== + + >>> from sympy.crypto.crypto import decipher_rsa, encipher_rsa + >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key + + Public Key Encryption and Decryption: + + >>> p, q, e = 3, 5, 7 + >>> prk = rsa_private_key(p, q, e) + >>> puk = rsa_public_key(p, q, e) + >>> msg = 12 + >>> new_msg = encipher_rsa(msg, prk) + >>> new_msg + 3 + >>> decipher_rsa(new_msg, puk) + 12 + + Private Key Encryption and Decryption: + + >>> p, q, e = 3, 5, 7 + >>> prk = rsa_private_key(p, q, e) + >>> puk = rsa_public_key(p, q, e) + >>> msg = 12 + >>> new_msg = encipher_rsa(msg, puk) + >>> new_msg + 3 + >>> decipher_rsa(new_msg, prk) + 12 + + Decryption using chinese remainder theorem: + + >>> decipher_rsa(new_msg, prk, factors=[p, q]) + 12 + + See Also + ======== + + encipher_rsa + """ + return _encipher_decipher_rsa(i, key, factors=factors) + + +#################### kid krypto (kid RSA) ############################# + + +def kid_rsa_public_key(a, b, A, B): + r""" + Kid RSA is a version of RSA useful to teach grade school children + since it does not involve exponentiation. + + Explanation + =========== + + Alice wants to talk to Bob. Bob generates keys as follows. + Key generation: + + * Select positive integers `a, b, A, B` at random. + * Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`, + `n = (e d - 1)//M`. + * The *public key* is `(n, e)`. Bob sends these to Alice. + * The *private key* is `(n, d)`, which Bob keeps secret. + + Encryption: If `p` is the plaintext message then the + ciphertext is `c = p e \pmod n`. + + Decryption: If `c` is the ciphertext message then the + plaintext is `p = c d \pmod n`. + + Examples + ======== + + >>> from sympy.crypto.crypto import kid_rsa_public_key + >>> a, b, A, B = 3, 4, 5, 6 + >>> kid_rsa_public_key(a, b, A, B) + (369, 58) + + """ + M = a*b - 1 + e = A*M + a + d = B*M + b + n = (e*d - 1)//M + return n, e + + +def kid_rsa_private_key(a, b, A, B): + """ + Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`, + `n = (e d - 1) / M`. The *private key* is `d`, which Bob + keeps secret. + + Examples + ======== + + >>> from sympy.crypto.crypto import kid_rsa_private_key + >>> a, b, A, B = 3, 4, 5, 6 + >>> kid_rsa_private_key(a, b, A, B) + (369, 70) + + """ + M = a*b - 1 + e = A*M + a + d = B*M + b + n = (e*d - 1)//M + return n, d + + +def encipher_kid_rsa(msg, key): + """ + Here ``msg`` is the plaintext and ``key`` is the public key. + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... encipher_kid_rsa, kid_rsa_public_key) + >>> msg = 200 + >>> a, b, A, B = 3, 4, 5, 6 + >>> key = kid_rsa_public_key(a, b, A, B) + >>> encipher_kid_rsa(msg, key) + 161 + + """ + n, e = key + return (msg*e) % n + + +def decipher_kid_rsa(msg, key): + """ + Here ``msg`` is the plaintext and ``key`` is the private key. + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... kid_rsa_public_key, kid_rsa_private_key, + ... decipher_kid_rsa, encipher_kid_rsa) + >>> a, b, A, B = 3, 4, 5, 6 + >>> d = kid_rsa_private_key(a, b, A, B) + >>> msg = 200 + >>> pub = kid_rsa_public_key(a, b, A, B) + >>> pri = kid_rsa_private_key(a, b, A, B) + >>> ct = encipher_kid_rsa(msg, pub) + >>> decipher_kid_rsa(ct, pri) + 200 + + """ + n, d = key + return (msg*d) % n + + +#################### Morse Code ###################################### + +morse_char = { + ".-": "A", "-...": "B", + "-.-.": "C", "-..": "D", + ".": "E", "..-.": "F", + "--.": "G", "....": "H", + "..": "I", ".---": "J", + "-.-": "K", ".-..": "L", + "--": "M", "-.": "N", + "---": "O", ".--.": "P", + "--.-": "Q", ".-.": "R", + "...": "S", "-": "T", + "..-": "U", "...-": "V", + ".--": "W", "-..-": "X", + "-.--": "Y", "--..": "Z", + "-----": "0", ".----": "1", + "..---": "2", "...--": "3", + "....-": "4", ".....": "5", + "-....": "6", "--...": "7", + "---..": "8", "----.": "9", + ".-.-.-": ".", "--..--": ",", + "---...": ":", "-.-.-.": ";", + "..--..": "?", "-....-": "-", + "..--.-": "_", "-.--.": "(", + "-.--.-": ")", ".----.": "'", + "-...-": "=", ".-.-.": "+", + "-..-.": "/", ".--.-.": "@", + "...-..-": "$", "-.-.--": "!"} +char_morse = {v: k for k, v in morse_char.items()} + + +def encode_morse(msg, sep='|', mapping=None): + """ + Encodes a plaintext into popular Morse Code with letters + separated by ``sep`` and words by a double ``sep``. + + Examples + ======== + + >>> from sympy.crypto.crypto import encode_morse + >>> msg = 'ATTACK RIGHT FLANK' + >>> encode_morse(msg) + '.-|-|-|.-|-.-.|-.-||.-.|..|--.|....|-||..-.|.-..|.-|-.|-.-' + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Morse_code + + """ + + mapping = mapping or char_morse + assert sep not in mapping + word_sep = 2*sep + mapping[" "] = word_sep + suffix = msg and msg[-1] in whitespace + + # normalize whitespace + msg = (' ' if word_sep else '').join(msg.split()) + # omit unmapped chars + chars = set(''.join(msg.split())) + ok = set(mapping.keys()) + msg = translate(msg, None, ''.join(chars - ok)) + + morsestring = [] + words = msg.split() + for word in words: + morseword = [] + for letter in word: + morseletter = mapping[letter] + morseword.append(morseletter) + + word = sep.join(morseword) + morsestring.append(word) + + return word_sep.join(morsestring) + (word_sep if suffix else '') + + +def decode_morse(msg, sep='|', mapping=None): + """ + Decodes a Morse Code with letters separated by ``sep`` + (default is '|') and words by `word_sep` (default is '||) + into plaintext. + + Examples + ======== + + >>> from sympy.crypto.crypto import decode_morse + >>> mc = '--|---|...-|.||.|.-|...|-' + >>> decode_morse(mc) + 'MOVE EAST' + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Morse_code + + """ + + mapping = mapping or morse_char + word_sep = 2*sep + characterstring = [] + words = msg.strip(word_sep).split(word_sep) + for word in words: + letters = word.split(sep) + chars = [mapping[c] for c in letters] + word = ''.join(chars) + characterstring.append(word) + rv = " ".join(characterstring) + return rv + + +#################### LFSRs ########################################## + + +def lfsr_sequence(key, fill, n): + r""" + This function creates an LFSR sequence. + + Parameters + ========== + + key : list + A list of finite field elements, `[c_0, c_1, \ldots, c_k].` + + fill : list + The list of the initial terms of the LFSR sequence, + `[x_0, x_1, \ldots, x_k].` + + n + Number of terms of the sequence that the function returns. + + Returns + ======= + + L + The LFSR sequence defined by + `x_{n+1} = c_k x_n + \ldots + c_0 x_{n-k}`, for + `n \leq k`. + + Notes + ===== + + S. Golomb [G]_ gives a list of three statistical properties a + sequence of numbers `a = \{a_n\}_{n=1}^\infty`, + `a_n \in \{0,1\}`, should display to be considered + "random". Define the autocorrelation of `a` to be + + .. math:: + + C(k) = C(k,a) = \lim_{N\rightarrow \infty} {1\over N}\sum_{n=1}^N (-1)^{a_n + a_{n+k}}. + + In the case where `a` is periodic with period + `P` then this reduces to + + .. math:: + + C(k) = {1\over P}\sum_{n=1}^P (-1)^{a_n + a_{n+k}}. + + Assume `a` is periodic with period `P`. + + - balance: + + .. math:: + + \left|\sum_{n=1}^P(-1)^{a_n}\right| \leq 1. + + - low autocorrelation: + + .. math:: + + C(k) = \left\{ \begin{array}{cc} 1,& k = 0,\\ \epsilon, & k \ne 0. \end{array} \right. + + (For sequences satisfying these first two properties, it is known + that `\epsilon = -1/P` must hold.) + + - proportional runs property: In each period, half the runs have + length `1`, one-fourth have length `2`, etc. + Moreover, there are as many runs of `1`'s as there are of + `0`'s. + + Examples + ======== + + >>> from sympy.crypto.crypto import lfsr_sequence + >>> from sympy.polys.domains import FF + >>> F = FF(2) + >>> fill = [F(1), F(1), F(0), F(1)] + >>> key = [F(1), F(0), F(0), F(1)] + >>> lfsr_sequence(key, fill, 10) + [1 mod 2, 1 mod 2, 0 mod 2, 1 mod 2, 0 mod 2, + 1 mod 2, 1 mod 2, 0 mod 2, 0 mod 2, 1 mod 2] + + References + ========== + + .. [G] Solomon Golomb, Shift register sequences, Aegean Park Press, + Laguna Hills, Ca, 1967 + + """ + if not isinstance(key, list): + raise TypeError("key must be a list") + if not isinstance(fill, list): + raise TypeError("fill must be a list") + p = key[0].mod + F = FF(p) + s = fill + k = len(fill) + L = [] + for i in range(n): + s0 = s[:] + L.append(s[0]) + s = s[1:k] + x = sum([int(key[i]*s0[i]) for i in range(k)]) + s.append(F(x)) + return L # use [x.to_int() for x in L] for int version + + +def lfsr_autocorrelation(L, P, k): + """ + This function computes the LFSR autocorrelation function. + + Parameters + ========== + + L + A periodic sequence of elements of `GF(2)`. + L must have length larger than P. + + P + The period of L. + + k : int + An integer `k` (`0 < k < P`). + + Returns + ======= + + autocorrelation + The k-th value of the autocorrelation of the LFSR L. + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... lfsr_sequence, lfsr_autocorrelation) + >>> from sympy.polys.domains import FF + >>> F = FF(2) + >>> fill = [F(1), F(1), F(0), F(1)] + >>> key = [F(1), F(0), F(0), F(1)] + >>> s = lfsr_sequence(key, fill, 20) + >>> lfsr_autocorrelation(s, 15, 7) + -1/15 + >>> lfsr_autocorrelation(s, 15, 0) + 1 + + """ + if not isinstance(L, list): + raise TypeError("L (=%s) must be a list" % L) + P = int(P) + k = int(k) + L0 = L[:P] # slices makes a copy + L1 = L0 + L0[:k] + L2 = [(-1)**(L1[i].to_int() + L1[i + k].to_int()) for i in range(P)] + tot = sum(L2) + return Rational(tot, P) + + +def lfsr_connection_polynomial(s): + """ + This function computes the LFSR connection polynomial. + + Parameters + ========== + + s + A sequence of elements of even length, with entries in a finite + field. + + Returns + ======= + + C(x) + The connection polynomial of a minimal LFSR yielding s. + + This implements the algorithm in section 3 of J. L. Massey's + article [M]_. + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... lfsr_sequence, lfsr_connection_polynomial) + >>> from sympy.polys.domains import FF + >>> F = FF(2) + >>> fill = [F(1), F(1), F(0), F(1)] + >>> key = [F(1), F(0), F(0), F(1)] + >>> s = lfsr_sequence(key, fill, 20) + >>> lfsr_connection_polynomial(s) + x**4 + x + 1 + >>> fill = [F(1), F(0), F(0), F(1)] + >>> key = [F(1), F(1), F(0), F(1)] + >>> s = lfsr_sequence(key, fill, 20) + >>> lfsr_connection_polynomial(s) + x**3 + 1 + >>> fill = [F(1), F(0), F(1)] + >>> key = [F(1), F(1), F(0)] + >>> s = lfsr_sequence(key, fill, 20) + >>> lfsr_connection_polynomial(s) + x**3 + x**2 + 1 + >>> fill = [F(1), F(0), F(1)] + >>> key = [F(1), F(0), F(1)] + >>> s = lfsr_sequence(key, fill, 20) + >>> lfsr_connection_polynomial(s) + x**3 + x + 1 + + References + ========== + + .. [M] James L. Massey, "Shift-Register Synthesis and BCH Decoding." + IEEE Trans. on Information Theory, vol. 15(1), pp. 122-127, + Jan 1969. + + """ + # Initialization: + p = s[0].mod + x = Symbol("x") + C = 1*x**0 + B = 1*x**0 + m = 1 + b = 1*x**0 + L = 0 + N = 0 + while N < len(s): + if L > 0: + dC = Poly(C).degree() + r = min(L + 1, dC + 1) + coeffsC = [C.subs(x, 0)] + [C.coeff(x**i) + for i in range(1, dC + 1)] + d = (s[N].to_int() + sum([coeffsC[i]*s[N - i].to_int() + for i in range(1, r)])) % p + if L == 0: + d = s[N].to_int()*x**0 + if d == 0: + m += 1 + N += 1 + if d > 0: + if 2*L > N: + C = (C - d*((b**(p - 2)) % p)*x**m*B).expand() + m += 1 + N += 1 + else: + T = C + C = (C - d*((b**(p - 2)) % p)*x**m*B).expand() + L = N + 1 - L + m = 1 + b = d + B = T + N += 1 + dC = Poly(C).degree() + coeffsC = [C.subs(x, 0)] + [C.coeff(x**i) for i in range(1, dC + 1)] + return sum([coeffsC[i] % p*x**i for i in range(dC + 1) + if coeffsC[i] is not None]) + + +#################### ElGamal ############################# + + +def elgamal_private_key(digit=10, seed=None): + r""" + Return three number tuple as private key. + + Explanation + =========== + + Elgamal encryption is based on the mathematical problem + called the Discrete Logarithm Problem (DLP). For example, + + `a^{b} \equiv c \pmod p` + + In general, if ``a`` and ``b`` are known, ``ct`` is easily + calculated. If ``b`` is unknown, it is hard to use + ``a`` and ``ct`` to get ``b``. + + Parameters + ========== + + digit : int + Minimum number of binary digits for key. + + Returns + ======= + + tuple : (p, r, d) + p = prime number. + + r = primitive root. + + d = random number. + + Notes + ===== + + For testing purposes, the ``seed`` parameter may be set to control + the output of this routine. See sympy.core.random._randrange. + + Examples + ======== + + >>> from sympy.crypto.crypto import elgamal_private_key + >>> from sympy.ntheory import is_primitive_root, isprime + >>> a, b, _ = elgamal_private_key() + >>> isprime(a) + True + >>> is_primitive_root(b, a) + True + + """ + randrange = _randrange(seed) + p = nextprime(2**digit) + return p, primitive_root(p), randrange(2, p) + + +def elgamal_public_key(key): + r""" + Return three number tuple as public key. + + Parameters + ========== + + key : (p, r, e) + Tuple generated by ``elgamal_private_key``. + + Returns + ======= + + tuple : (p, r, e) + `e = r**d \bmod p` + + `d` is a random number in private key. + + Examples + ======== + + >>> from sympy.crypto.crypto import elgamal_public_key + >>> elgamal_public_key((1031, 14, 636)) + (1031, 14, 212) + + """ + p, r, e = key + return p, r, pow(r, e, p) + + +def encipher_elgamal(i, key, seed=None): + r""" + Encrypt message with public key. + + Explanation + =========== + + ``i`` is a plaintext message expressed as an integer. + ``key`` is public key (p, r, e). In order to encrypt + a message, a random number ``a`` in ``range(2, p)`` + is generated and the encryped message is returned as + `c_{1}` and `c_{2}` where: + + `c_{1} \equiv r^{a} \pmod p` + + `c_{2} \equiv m e^{a} \pmod p` + + Parameters + ========== + + msg + int of encoded message. + + key + Public key. + + Returns + ======= + + tuple : (c1, c2) + Encipher into two number. + + Notes + ===== + + For testing purposes, the ``seed`` parameter may be set to control + the output of this routine. See sympy.core.random._randrange. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_elgamal, elgamal_private_key, elgamal_public_key + >>> pri = elgamal_private_key(5, seed=[3]); pri + (37, 2, 3) + >>> pub = elgamal_public_key(pri); pub + (37, 2, 8) + >>> msg = 36 + >>> encipher_elgamal(msg, pub, seed=[3]) + (8, 6) + + """ + p, r, e = key + if i < 0 or i >= p: + raise ValueError( + 'Message (%s) should be in range(%s)' % (i, p)) + randrange = _randrange(seed) + a = randrange(2, p) + return pow(r, a, p), i*pow(e, a, p) % p + + +def decipher_elgamal(msg, key): + r""" + Decrypt message with private key. + + `msg = (c_{1}, c_{2})` + + `key = (p, r, d)` + + According to extended Eucliden theorem, + `u c_{1}^{d} + p n = 1` + + `u \equiv 1/{{c_{1}}^d} \pmod p` + + `u c_{2} \equiv \frac{1}{c_{1}^d} c_{2} \equiv \frac{1}{r^{ad}} c_{2} \pmod p` + + `\frac{1}{r^{ad}} m e^a \equiv \frac{1}{r^{ad}} m {r^{d a}} \equiv m \pmod p` + + Examples + ======== + + >>> from sympy.crypto.crypto import decipher_elgamal + >>> from sympy.crypto.crypto import encipher_elgamal + >>> from sympy.crypto.crypto import elgamal_private_key + >>> from sympy.crypto.crypto import elgamal_public_key + + >>> pri = elgamal_private_key(5, seed=[3]) + >>> pub = elgamal_public_key(pri); pub + (37, 2, 8) + >>> msg = 17 + >>> decipher_elgamal(encipher_elgamal(msg, pub), pri) == msg + True + + """ + p, _, d = key + c1, c2 = msg + u = igcdex(c1**d, p)[0] + return u * c2 % p + + +################ Diffie-Hellman Key Exchange ######################### + +def dh_private_key(digit=10, seed=None): + r""" + Return three integer tuple as private key. + + Explanation + =========== + + Diffie-Hellman key exchange is based on the mathematical problem + called the Discrete Logarithm Problem (see ElGamal). + + Diffie-Hellman key exchange is divided into the following steps: + + * Alice and Bob agree on a base that consist of a prime ``p`` + and a primitive root of ``p`` called ``g`` + * Alice choses a number ``a`` and Bob choses a number ``b`` where + ``a`` and ``b`` are random numbers in range `[2, p)`. These are + their private keys. + * Alice then publicly sends Bob `g^{a} \pmod p` while Bob sends + Alice `g^{b} \pmod p` + * They both raise the received value to their secretly chosen + number (``a`` or ``b``) and now have both as their shared key + `g^{ab} \pmod p` + + Parameters + ========== + + digit + Minimum number of binary digits required in key. + + Returns + ======= + + tuple : (p, g, a) + p = prime number. + + g = primitive root of p. + + a = random number from 2 through p - 1. + + Notes + ===== + + For testing purposes, the ``seed`` parameter may be set to control + the output of this routine. See sympy.core.random._randrange. + + Examples + ======== + + >>> from sympy.crypto.crypto import dh_private_key + >>> from sympy.ntheory import isprime, is_primitive_root + >>> p, g, _ = dh_private_key() + >>> isprime(p) + True + >>> is_primitive_root(g, p) + True + >>> p, g, _ = dh_private_key(5) + >>> isprime(p) + True + >>> is_primitive_root(g, p) + True + + """ + p = nextprime(2**digit) + g = primitive_root(p) + randrange = _randrange(seed) + a = randrange(2, p) + return p, g, a + + +def dh_public_key(key): + r""" + Return three number tuple as public key. + + This is the tuple that Alice sends to Bob. + + Parameters + ========== + + key : (p, g, a) + A tuple generated by ``dh_private_key``. + + Returns + ======= + + tuple : int, int, int + A tuple of `(p, g, g^a \mod p)` with `p`, `g` and `a` given as + parameters.s + + Examples + ======== + + >>> from sympy.crypto.crypto import dh_private_key, dh_public_key + >>> p, g, a = dh_private_key(); + >>> _p, _g, x = dh_public_key((p, g, a)) + >>> p == _p and g == _g + True + >>> x == pow(g, a, p) + True + + """ + p, g, a = key + return p, g, pow(g, a, p) + + +def dh_shared_key(key, b): + """ + Return an integer that is the shared key. + + This is what Bob and Alice can both calculate using the public + keys they received from each other and their private keys. + + Parameters + ========== + + key : (p, g, x) + Tuple `(p, g, x)` generated by ``dh_public_key``. + + b + Random number in the range of `2` to `p - 1` + (Chosen by second key exchange member (Bob)). + + Returns + ======= + + int + A shared key. + + Examples + ======== + + >>> from sympy.crypto.crypto import ( + ... dh_private_key, dh_public_key, dh_shared_key) + >>> prk = dh_private_key(); + >>> p, g, x = dh_public_key(prk); + >>> sk = dh_shared_key((p, g, x), 1000) + >>> sk == pow(x, 1000, p) + True + + """ + p, _, x = key + if 1 >= b or b >= p: + raise ValueError(filldedent(''' + Value of b should be greater 1 and less + than prime %s.''' % p)) + + return pow(x, b, p) + + +################ Goldwasser-Micali Encryption ######################### + + +def _legendre(a, p): + """ + Returns the legendre symbol of a and p + assuming that p is a prime. + + i.e. 1 if a is a quadratic residue mod p + -1 if a is not a quadratic residue mod p + 0 if a is divisible by p + + Parameters + ========== + + a : int + The number to test. + + p : prime + The prime to test ``a`` against. + + Returns + ======= + + int + Legendre symbol (a / p). + + """ + sig = pow(a, (p - 1)//2, p) + if sig == 1: + return 1 + elif sig == 0: + return 0 + else: + return -1 + + +def _random_coprime_stream(n, seed=None): + randrange = _randrange(seed) + while True: + y = randrange(n) + if gcd(y, n) == 1: + yield y + + +def gm_private_key(p, q, a=None): + r""" + Check if ``p`` and ``q`` can be used as private keys for + the Goldwasser-Micali encryption. The method works + roughly as follows. + + Explanation + =========== + + #. Pick two large primes $p$ and $q$. + #. Call their product $N$. + #. Given a message as an integer $i$, write $i$ in its bit representation $b_0, \dots, b_n$. + #. For each $k$, + + if $b_k = 0$: + let $a_k$ be a random square + (quadratic residue) modulo $p q$ + such that ``jacobi_symbol(a, p*q) = 1`` + if $b_k = 1$: + let $a_k$ be a random non-square + (non-quadratic residue) modulo $p q$ + such that ``jacobi_symbol(a, p*q) = 1`` + + returns $\left[a_1, a_2, \dots\right]$ + + $b_k$ can be recovered by checking whether or not + $a_k$ is a residue. And from the $b_k$'s, the message + can be reconstructed. + + The idea is that, while ``jacobi_symbol(a, p*q)`` + can be easily computed (and when it is equal to $-1$ will + tell you that $a$ is not a square mod $p q$), quadratic + residuosity modulo a composite number is hard to compute + without knowing its factorization. + + Moreover, approximately half the numbers coprime to $p q$ have + :func:`~.jacobi_symbol` equal to $1$ . And among those, approximately half + are residues and approximately half are not. This maximizes the + entropy of the code. + + Parameters + ========== + + p, q, a + Initialization variables. + + Returns + ======= + + tuple : (p, q) + The input value ``p`` and ``q``. + + Raises + ====== + + ValueError + If ``p`` and ``q`` are not distinct odd primes. + + """ + if p == q: + raise ValueError("expected distinct primes, " + "got two copies of %i" % p) + elif not isprime(p) or not isprime(q): + raise ValueError("first two arguments must be prime, " + "got %i of %i" % (p, q)) + elif p == 2 or q == 2: + raise ValueError("first two arguments must not be even, " + "got %i of %i" % (p, q)) + return p, q + + +def gm_public_key(p, q, a=None, seed=None): + """ + Compute public keys for ``p`` and ``q``. + Note that in Goldwasser-Micali Encryption, + public keys are randomly selected. + + Parameters + ========== + + p, q, a : int, int, int + Initialization variables. + + Returns + ======= + + tuple : (a, N) + ``a`` is the input ``a`` if it is not ``None`` otherwise + some random integer coprime to ``p`` and ``q``. + + ``N`` is the product of ``p`` and ``q``. + + """ + + p, q = gm_private_key(p, q) + N = p * q + + if a is None: + randrange = _randrange(seed) + while True: + a = randrange(N) + if _legendre(a, p) == _legendre(a, q) == -1: + break + else: + if _legendre(a, p) != -1 or _legendre(a, q) != -1: + return False + return (a, N) + + +def encipher_gm(i, key, seed=None): + """ + Encrypt integer 'i' using public_key 'key' + Note that gm uses random encryption. + + Parameters + ========== + + i : int + The message to encrypt. + + key : (a, N) + The public key. + + Returns + ======= + + list : list of int + The randomized encrypted message. + + """ + if i < 0: + raise ValueError( + "message must be a non-negative " + "integer: got %d instead" % i) + a, N = key + bits = [] + while i > 0: + bits.append(i % 2) + i //= 2 + + gen = _random_coprime_stream(N, seed) + rev = reversed(bits) + encode = lambda b: next(gen)**2*pow(a, b) % N + return [ encode(b) for b in rev ] + + + +def decipher_gm(message, key): + """ + Decrypt message 'message' using public_key 'key'. + + Parameters + ========== + + message : list of int + The randomized encrypted message. + + key : (p, q) + The private key. + + Returns + ======= + + int + The encrypted message. + + """ + p, q = key + res = lambda m, p: _legendre(m, p) > 0 + bits = [res(m, p) * res(m, q) for m in message] + m = 0 + for b in bits: + m <<= 1 + m += not b + return m + + + +########### RailFence Cipher ############# + +def encipher_railfence(message,rails): + """ + Performs Railfence Encryption on plaintext and returns ciphertext + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_railfence + >>> message = "hello world" + >>> encipher_railfence(message,3) + 'horel ollwd' + + Parameters + ========== + + message : string, the message to encrypt. + rails : int, the number of rails. + + Returns + ======= + + The Encrypted string message. + + References + ========== + .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher + + """ + r = list(range(rails)) + p = cycle(r + r[-2:0:-1]) + return ''.join(sorted(message, key=lambda i: next(p))) + + +def decipher_railfence(ciphertext,rails): + """ + Decrypt the message using the given rails + + Examples + ======== + + >>> from sympy.crypto.crypto import decipher_railfence + >>> decipher_railfence("horel ollwd",3) + 'hello world' + + Parameters + ========== + + message : string, the message to encrypt. + rails : int, the number of rails. + + Returns + ======= + + The Decrypted string message. + + """ + r = list(range(rails)) + p = cycle(r + r[-2:0:-1]) + + idx = sorted(range(len(ciphertext)), key=lambda i: next(p)) + res = [''] * len(ciphertext) + for i, c in zip(idx, ciphertext): + res[i] = c + return ''.join(res) + + +################ Blum-Goldwasser cryptosystem ######################### + +def bg_private_key(p, q): + """ + Check if p and q can be used as private keys for + the Blum-Goldwasser cryptosystem. + + Explanation + =========== + + The three necessary checks for p and q to pass + so that they can be used as private keys: + + 1. p and q must both be prime + 2. p and q must be distinct + 3. p and q must be congruent to 3 mod 4 + + Parameters + ========== + + p, q + The keys to be checked. + + Returns + ======= + + p, q + Input values. + + Raises + ====== + + ValueError + If p and q do not pass the above conditions. + + """ + + if not isprime(p) or not isprime(q): + raise ValueError("the two arguments must be prime, " + "got %i and %i" %(p, q)) + elif p == q: + raise ValueError("the two arguments must be distinct, " + "got two copies of %i. " %p) + elif (p - 3) % 4 != 0 or (q - 3) % 4 != 0: + raise ValueError("the two arguments must be congruent to 3 mod 4, " + "got %i and %i" %(p, q)) + return p, q + +def bg_public_key(p, q): + """ + Calculates public keys from private keys. + + Explanation + =========== + + The function first checks the validity of + private keys passed as arguments and + then returns their product. + + Parameters + ========== + + p, q + The private keys. + + Returns + ======= + + N + The public key. + + """ + p, q = bg_private_key(p, q) + N = p * q + return N + +def encipher_bg(i, key, seed=None): + """ + Encrypts the message using public key and seed. + + Explanation + =========== + + ALGORITHM: + 1. Encodes i as a string of L bits, m. + 2. Select a random element r, where 1 < r < key, and computes + x = r^2 mod key. + 3. Use BBS pseudo-random number generator to generate L random bits, b, + using the initial seed as x. + 4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L. + 5. x_L = x^(2^L) mod key. + 6. Return (c, x_L) + + Parameters + ========== + + i + Message, a non-negative integer + + key + The public key + + Returns + ======= + + Tuple + (encrypted_message, x_L) + + Raises + ====== + + ValueError + If i is negative. + + """ + + if i < 0: + raise ValueError( + "message must be a non-negative " + "integer: got %d instead" % i) + + enc_msg = [] + while i > 0: + enc_msg.append(i % 2) + i //= 2 + enc_msg.reverse() + L = len(enc_msg) + + r = _randint(seed)(2, key - 1) + x = r**2 % key + x_L = pow(int(x), int(2**L), int(key)) + + rand_bits = [] + for _ in range(L): + rand_bits.append(x % 2) + x = x**2 % key + + encrypt_msg = [m ^ b for (m, b) in zip(enc_msg, rand_bits)] + + return (encrypt_msg, x_L) + +def decipher_bg(message, key): + """ + Decrypts the message using private keys. + + Explanation + =========== + + ALGORITHM: + 1. Let, c be the encrypted message, y the second number received, + and p and q be the private keys. + 2. Compute, r_p = y^((p+1)/4 ^ L) mod p and + r_q = y^((q+1)/4 ^ L) mod q. + 3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N. + 4. From, recompute the bits using the BBS generator, as in the + encryption algorithm. + 5. Compute original message by XORing c and b. + + Parameters + ========== + + message + Tuple of encrypted message and a non-negative integer. + + key + Tuple of private keys. + + Returns + ======= + + orig_msg + The original message + + """ + + p, q = key + encrypt_msg, y = message + public_key = p * q + L = len(encrypt_msg) + p_t = ((p + 1)/4)**L + q_t = ((q + 1)/4)**L + r_p = pow(int(y), int(p_t), int(p)) + r_q = pow(int(y), int(q_t), int(q)) + + x = (q * mod_inverse(q, p) * r_p + p * mod_inverse(p, q) * r_q) % public_key + + orig_bits = [] + for _ in range(L): + orig_bits.append(x % 2) + x = x**2 % public_key + + orig_msg = 0 + for (m, b) in zip(encrypt_msg, orig_bits): + orig_msg = orig_msg * 2 + orig_msg += (m ^ b) + + return orig_msg diff --git a/shared/package-files/41/41bd50e0d1c86d224e72c67cbd406a68f4feb3a956a63f980f5908f4323a5dfa/blob b/shared/package-files/41/41bd50e0d1c86d224e72c67cbd406a68f4feb3a956a63f980f5908f4323a5dfa/blob new file mode 100644 index 0000000000000000000000000000000000000000..fc6552974e60b78153295e18a1cb3e3ff314a208 --- /dev/null +++ b/shared/package-files/41/41bd50e0d1c86d224e72c67cbd406a68f4feb3a956a63f980f5908f4323a5dfa/blob @@ -0,0 +1,11 @@ +def base64_len(s: bytes) -> int: ... +def header_encode(header, charset=..., keep_eols=..., maxlinelen=..., eol=...): ... +def encode(s, binary=..., maxlinelen=..., eol=...): ... + +body_encode = encode +encodestring = encode + +def decode(s, convert_eols=...): ... + +body_decode = decode +decodestring = decode diff --git a/shared/package-files/41/41c0462a4a7dfe05203ce3065dc7ee1aca9e0bb893d40006aeae590d7fa710aa/blob b/shared/package-files/41/41c0462a4a7dfe05203ce3065dc7ee1aca9e0bb893d40006aeae590d7fa710aa/blob new file mode 100644 index 0000000000000000000000000000000000000000..8c660bc500e318ed40290d1913288613225d4f5a --- /dev/null +++ b/shared/package-files/41/41c0462a4a7dfe05203ce3065dc7ee1aca9e0bb893d40006aeae590d7fa710aa/blob @@ -0,0 +1,51 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Generic + +from narwhals._compliant import LazyExprNamespace +from narwhals._compliant.any_namespace import DateTimeNamespace +from narwhals._sql.typing import SQLExprT + +if TYPE_CHECKING: + from narwhals._compliant.expr import NativeExpr + + +class SQLExprDateTimeNamesSpace( + LazyExprNamespace[SQLExprT], DateTimeNamespace[SQLExprT], Generic[SQLExprT] +): + def _function(self, name: str, *args: Any) -> NativeExpr: + return self.compliant._function(name, *args) # type: ignore[no-any-return] + + def year(self) -> SQLExprT: + return self.compliant._with_elementwise(lambda expr: self._function("year", expr)) + + def month(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("month", expr) + ) + + def day(self) -> SQLExprT: + return self.compliant._with_elementwise(lambda expr: self._function("day", expr)) + + def hour(self) -> SQLExprT: + return self.compliant._with_elementwise(lambda expr: self._function("hour", expr)) + + def minute(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("minute", expr) + ) + + def second(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("second", expr) + ) + + def ordinal_day(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("dayofyear", expr) + ) + + def date(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("to_date", expr) + ) diff --git a/shared/package-files/41/41c129c561275c7070edae8385a717253020bcf3700c79b35c5a44fc87315082/blob b/shared/package-files/41/41c129c561275c7070edae8385a717253020bcf3700c79b35c5a44fc87315082/blob new file mode 100644 index 0000000000000000000000000000000000000000..2e5c3eb35f9faab3a60fcba77a2c2a89c6550b0d --- /dev/null +++ b/shared/package-files/41/41c129c561275c7070edae8385a717253020bcf3700c79b35c5a44fc87315082/blob @@ -0,0 +1,1893 @@ +# pylint: disable-msg=W0142 +""" +Statistical power, solving for nobs, ... - trial version + +Created on Sat Jan 12 21:48:06 2013 + +Author: Josef Perktold + +Examples +-------- +roundtrip - root with respect to all variables + + calculated, desired +nobs 33.367204205 33.367204205 +effect 0.5 0.5 +alpha 0.05 0.05 +power 0.8 0.8 + + +TODO: +refactoring + - rename beta -> power, beta (type 2 error is beta = 1-power) DONE + - I think the current implementation can handle any kinds of extra keywords + (except for maybe raising meaningful exceptions + - streamline code, I think internally classes can be merged + how to extend to k-sample tests? + user interface for different tests that map to the same (internal) test class + - sequence of arguments might be inconsistent, + arg and/or kwds so python checks what's required and what can be None. + - templating for docstrings ? + + +""" + +import warnings + +import numpy as np +from scipy import optimize, special, stats + +from statsmodels.graphics.utils import _import_mpl +from statsmodels.tools.rootfinding import brentq_expanding +from statsmodels.tools.validation import string_like + +# Undocumented short form accepted for backwards compatibility by +# ttest_power, normal_power and normal_power_het. Deprecated in favor of +# the documented spelling. +_ALTERNATIVE_ALIASES = {"2s": "two-sided"} + + +def nct_cdf(x, df, nc): + return special.nctdtr(df, nc, x) + + +def nct_sf(x, df, nc): + return 1 - special.nctdtr(df, nc, x) + + +def ncf_cdf(x, dfn, dfd, nc): + return special.ncfdtr(dfn, dfd, nc, x) + + +def ncf_sf(x, dfn, dfd, nc): + return 1 - special.ncfdtr(dfn, dfd, nc, x) + + +def ncf_ppf(q, dfn, dfd, nc): + return special.ncfdtri(dfn, dfd, nc, q) + + +def ttest_power(effect_size, nobs, alpha, df=None, alternative="two-sided"): + """ + Calculate power of a ttest + + Parameters + ---------- + effect_size : float + Standardized effect size, mean divided by the standard deviation. + nobs : int or float + Sample size, number of observations. + alpha : float in interval (0,1) + Significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + df : int or float, optional + Degrees of freedom. By default this is None, and ``df = nobs - 1`` + is used. + alternative : {'two-sided', 'larger', 'smaller'}, optional + Extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + """ + d = effect_size + if df is None: + df = nobs - 1 + + alternative = string_like( + alternative, + "alternative", + options=("two-sided", "larger", "smaller"), + lower=False, + deprecated=_ALTERNATIVE_ALIASES, + removed_after="0.16", + ) + if alternative == "two-sided": + alpha_ = alpha / 2.0 # no inplace changes, does not work + else: + alpha_ = alpha + + pow_ = 0 + if alternative in ["two-sided", "larger"]: + crit_upp = stats.t.isf(alpha_, df) + # print crit_upp, df, d*np.sqrt(nobs) + # use private methods, generic methods return nan with negative d + if np.any(np.isnan(crit_upp)): + # avoid endless loop, https://github.com/scipy/scipy/issues/2667 + pow_ = np.nan + else: + # pow_ = stats.nct._sf(crit_upp, df, d*np.sqrt(nobs)) + # use scipy.special + pow_ = nct_sf(crit_upp, df, d * np.sqrt(nobs)) + if alternative in ["two-sided", "smaller"]: + crit_low = stats.t.ppf(alpha_, df) + # print crit_low, df, d*np.sqrt(nobs) + if np.any(np.isnan(crit_low)): + pow_ = np.nan + else: + # pow_ += stats.nct._cdf(crit_low, df, d*np.sqrt(nobs)) + pow_ += nct_cdf(crit_low, df, d * np.sqrt(nobs)) + return pow_ + + +def normal_power(effect_size, nobs, alpha, alternative="two-sided", sigma=1.0): + """ + Calculate power of a normal distributed test statistic + + Parameters + ---------- + effect_size : float + difference in the estimated means or statistics under the alternative + normalized by the standard deviation (without division by sqrt(nobs). + nobs : float or int + number of observations + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + sigma : float, optional + The standard deviation used to standardize the effect size. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + """ + + d = effect_size + + alternative = string_like( + alternative, + "alternative", + options=("two-sided", "larger", "smaller"), + lower=False, + deprecated=_ALTERNATIVE_ALIASES, + removed_after="0.16", + ) + if alternative == "two-sided": + alpha_ = alpha / 2.0 # no inplace changes, does not work + else: + alpha_ = alpha + + pow_ = 0 + if alternative in ["two-sided", "larger"]: + crit = stats.norm.isf(alpha_) + pow_ = stats.norm.sf(crit - d * np.sqrt(nobs) / sigma) + if alternative in ["two-sided", "smaller"]: + crit = stats.norm.ppf(alpha_) + pow_ += stats.norm.cdf(crit - d * np.sqrt(nobs) / sigma) + return pow_ + + +def normal_power_het( + diff, nobs, alpha, std_null=1.0, std_alternative=None, alternative="two-sided" +): + """ + Calculate power of a normal distributed test statistic + + This is a generalization of `normal_power` when variance under Null and + Alternative differ. + + Parameters + ---------- + diff : float + difference in the estimated means or statistics under the alternative. + nobs : float or int + number of observations + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + std_null : float, optional + standard deviation under the Null hypothesis without division by + sqrt(nobs) + std_alternative : float, optional + standard deviation under the Alternative hypothesis without division + by sqrt(nobs). If None, ``std_alternative`` is set to the value of + ``std_null``. + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + """ + + d = diff + if std_alternative is None: + std_alternative = std_null + + alternative = string_like( + alternative, + "alternative", + options=("two-sided", "larger", "smaller"), + lower=False, + deprecated=_ALTERNATIVE_ALIASES, + removed_after="0.16", + ) + if alternative == "two-sided": + alpha_ = alpha / 2.0 # no inplace changes, does not work + else: + alpha_ = alpha + + std_ratio = std_null / std_alternative + pow_ = 0 + if alternative in ["two-sided", "larger"]: + crit = stats.norm.isf(alpha_) + pow_ = stats.norm.sf(crit * std_ratio - d * np.sqrt(nobs) / std_alternative) + if alternative in ["two-sided", "smaller"]: + crit = stats.norm.ppf(alpha_) + pow_ += stats.norm.cdf(crit * std_ratio - d * np.sqrt(nobs) / std_alternative) + return pow_ + + +def normal_sample_size_one_tail(diff, power, alpha, std_null=1.0, std_alternative=None): + """ + Explicit sample size computation if only one tail is relevant + + The sample size is based on the power in one tail assuming that the + alternative is in the tail where the test has power that increases + with sample size. + Use alpha/2 to compute the one tail approximation to the two-sided + test, i.e., consider only one tail of two-sided test. + + Parameters + ---------- + diff : float + difference in the estimated means or statistics under the alternative. + power : float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a type II + error. Power is the probability that the test correctly rejects the + Null Hypothesis if the Alternative Hypothesis is true. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + Note: alpha is used for one tail. Use alpha/2 for two-sided + alternative. + std_null : float, optional + standard deviation under the Null hypothesis without division by + sqrt(nobs) + std_alternative : float, optional + standard deviation under the Alternative hypothesis without division + by sqrt(nobs). Defaults to None. If None, ``std_alternative`` is set + to the value of ``std_null``. + + Returns + ------- + nobs : float + Sample size to achieve (at least) the desired power. + If the minimum power is satisfied for all positive sample sizes, then + ``nobs`` will be zero. This will be the case when power <= alpha if + std_alternative is equal to std_null. + + """ + + if std_alternative is None: + std_alternative = std_null + + crit_power = stats.norm.isf(power) + crit = stats.norm.isf(alpha) + n1 = (np.maximum(crit * std_null - crit_power * std_alternative, 0) / diff) ** 2 + return n1 + + +def ftest_anova_power(effect_size, nobs, alpha, k_groups=2, df=None): + """ + Power for ftest for one way anova with k equal sized groups + + nobs total sample size, sum over all groups + + should be general nobs observations, k_groups restrictions ??? + + Parameters + ---------- + effect_size : float + Standardized effect size, according to Cohen's f definition. + nobs : int or float + Total sample size, sum over all groups. + alpha : float in interval (0,1) + Significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + k_groups : int, optional + Number of groups in the one-way ANOVA. Default is 2. + df : None + Unused. Included for compatibility; degrees of freedom are + computed internally from ``nobs`` and ``k_groups``. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + """ + df_num = k_groups - 1 + df_denom = nobs - k_groups + crit = stats.f.isf(alpha, df_num, df_denom) + pow_ = ncf_sf(crit, df_num, df_denom, effect_size**2 * nobs) + return pow_ + + +def ftest_power(effect_size, df2, df1, alpha, ncc=1): + """ + Calculate the power of a F-test + + Parameters + ---------- + effect_size : float + The effect size is here Cohen's ``f``, the square root of ``f2``. + df2 : int or float + Denominator degrees of freedom. + This corresponds to the df_resid in Wald tests. + df1 : int or float + Numerator degrees of freedom. + This corresponds to the number of constraints in Wald tests. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + ncc : int, optional + degrees of freedom correction for non-centrality parameter. + see Notes + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + Notes + ----- + changed in 0.14: use df2, df1 instead of df_num, df_denom as arg names. + The latter had reversed meaning. + + The sample size is given implicitly by ``df2`` with fixed number of + constraints given by numerator degrees of freedom ``df1``: + + nobs = df2 + df1 + ncc + + Set ncc=0 to match t-test, or f-test in LikelihoodModelResults. + ncc=1 matches the non-centrality parameter in R::pwr::pwr.f2.test + + ftest_power with ncc=0 should also be correct for f_test in regression + models, with df_num (df1) as number of constraints and d_denom (df2) as + df_resid. + """ + df_num, df_denom = df1, df2 + nc = effect_size**2 * (df_denom + df_num + ncc) + crit = stats.f.isf(alpha, df_num, df_denom) + # pow_ = stats.ncf.sf(crit, df_num, df_denom, nc) + # use scipy.special for ncf + pow_ = ncf_sf(crit, df_num, df_denom, nc) + return pow_ # , crit, nc + + +def ftest_power_f2(effect_size, df_num, df_denom, alpha, ncc=1): + """ + Calculate the power of a F-test + + Based on Cohen's `f^2` effect size. + + This assumes + + df_num : numerator degrees of freedom, (number of constraints) + df_denom : denominator degrees of freedom (df_resid in regression) + nobs = df_denom + df_num + ncc + nc = effect_size * nobs (noncentrality index) + + Power is computed one-sided in the upper tail. + + Parameters + ---------- + effect_size : float + Cohen's f2 effect size or noncentrality divided by nobs. + df_num : int or float + Numerator degrees of freedom. + This corresponds to the number of constraints in Wald tests. + df_denom : int or float + Denominator degrees of freedom. + This corresponds to the df_resid in Wald tests. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + ncc : int, optional + degrees of freedom correction for non-centrality parameter. + see Notes + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + Notes + ----- + The sample size is given implicitly by ``df_denom`` with fixed number of + constraints given by numerator degrees of freedom ``df_num``: + + nobs = df_denom + df_num + ncc + + Set ncc=0 to match t-test, or f-test in LikelihoodModelResults. + ncc=1 matches the non-centrality parameter in R::pwr::pwr.f2.test + + ftest_power with ncc=0 should also be correct for f_test in regression + models, with df_num (df1) as number of constraints and d_denom (df2) as + df_resid. + """ + + nc = effect_size * (df_denom + df_num + ncc) + crit = stats.f.isf(alpha, df_num, df_denom) + # pow_ = stats.ncf.sf(crit, df_num, df_denom, nc) + # use scipy.special for ncf + pow_ = ncf_sf(crit, df_num, df_denom, nc) + return pow_ + + +# class based implementation +# -------------------------- + + +class Power: + """ + Statistical Power calculations, Base Class + + so far this could all be class methods + """ + + def __init__(self): + # Populated by `solve_power`; declared here so they exist (as + # None) even before `solve_power` has been called. + self._counter = None + self.cache_fit_res = None + + # used only for instance level start values + self.start_ttp = { + "effect_size": 0.01, + "nobs": 10.0, + "alpha": 0.15, + "power": 0.6, + "nobs1": 10.0, + "ratio": 1, + "df_num": 10, + "df_denom": 3, # for FTestPower + } + # TODO: nobs1 and ratio are for ttest_ind, + # need start_ttp for each test/class separately, + # possible rootfinding problem for effect_size, starting small seems to + # work + from collections import defaultdict + + self.start_bqexp = defaultdict(dict) + for key in ["nobs", "nobs1", "df_num", "df_denom"]: + self.start_bqexp[key] = {"low": 2.0, "start_upp": 50.0} + for key in ["df_denom"]: + self.start_bqexp[key] = {"low": 1.0, "start_upp": 50.0} + for key in ["ratio"]: + self.start_bqexp[key] = {"low": 1e-8, "start_upp": 2} + for key in ["alpha"]: + self.start_bqexp[key] = {"low": 1e-12, "upp": 1 - 1e-12} + + def power(self, *args, **kwds): + raise NotImplementedError + + def _power_identity(self, *args, **kwds): + power_ = kwds.pop("power") + return self.power(*args, **kwds) - power_ + + def solve_power(self, **kwds): + """ + Solve for any one of the parameters of a t-test + + for t-test the keywords are: + effect_size, nobs, alpha, power + + exactly one needs to be ``None``, all others need numeric values + + Parameters + ---------- + **kwds + The keyword arguments of the power function for the specific + test, exactly one of which must be ``None``; the others must + be given numeric values. + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. + The value solves the power equation given the remaining + parameters. + + Notes + ----- + This method attaches the following to the instance: + + cache_fit_res : list + Cache of the result of the root finding procedure for the latest + call to ``solve_power``, mainly for debugging purposes. + The first element is the success indicator, one if successful. + The remaining elements contain the return information of the up to + three solvers that have been tried. + + """ + # TODO: maybe use explicit kwds, + # nicer but requires inspect? and not generic across tests + # I'm duplicating this in the subclass to get informative docstring + key = [k for k, v in kwds.items() if v is None] + # print kwds, key + if len(key) != 1: + raise ValueError("need exactly one keyword that is None") + key = key[0] + + if key == "power": + del kwds["power"] + return self.power(**kwds) + + if kwds["effect_size"] == 0: + import warnings + + from statsmodels.tools.sm_exceptions import HypothesisTestWarning + + warnings.warn( + "Warning: Effect size of 0 detected", + HypothesisTestWarning, + stacklevel=2, + ) + if key == "power": + return kwds["alpha"] + if key == "alpha": + return kwds["power"] + else: + raise ValueError( + "Cannot detect an effect-size of 0. Try changing your effect-size." + ) + + # GH#9378 intercept impossible one-sided cases before root finding: + # if the effect size points into the tail opposite to the + # alternative, the attained power is smaller than alpha for any + # sample size, so no solution exists unless the requested power is + # also smaller than alpha. + alternative = kwds.get("alternative") + if key in ("nobs", "nobs1", "ratio") and alternative in ( + "larger", + "smaller", + ): + effect_size = kwds["effect_size"] + wrong_sign = ( + effect_size < 0 + if alternative == "larger" + else effect_size > 0 + ) + if wrong_sign and kwds["power"] >= kwds["alpha"]: + raise ValueError( + f"No solution exists for {key}: with alternative=" + f"{alternative!r} the attained power is smaller than " + f"alpha for any {key} because effect_size is " + f"{'negative' if effect_size < 0 else 'positive'}. A " + "one-sided alternative requires an effect size with " + "matching sign: positive for 'larger', negative for " + "'smaller'." + ) + + self._counter = 0 + + def func(x): + kwds[key] = x + fval = self._power_identity(**kwds) + self._counter += 1 + # print self._counter, + if self._counter > 500: + raise RuntimeError("possible endless loop (500 NaNs)") + if np.isnan(fval): + return np.inf + else: + return fval + + # TODO: I'm using the following so I get a warning when start_ttp is not defined + try: + start_value = self.start_ttp[key] + except KeyError: + start_value = 0.9 + import warnings + + from statsmodels.tools.sm_exceptions import ValueWarning + + warnings.warn( + f"Warning: using default start_value for {key}", + ValueWarning, + stacklevel=2, + ) + + fit_kwds = self.start_bqexp[key] + fit_res = [] + # print vars() + # ensure ``val`` is bound for the warning below even if the first + # solver raises before assigning it and no backup solver runs + val = np.nan + try: + val, res = brentq_expanding(func, full_output=True, **fit_kwds) + failed = False + fit_res.append(res) + except ValueError: + failed = True + fit_res.append(None) + + success = None + if (not failed) and res.converged: + success = 1 + else: + # try backup + # TODO: check more cases to make this robust + if not np.isnan(start_value): + val, infodict, ier, msg = optimize.fsolve( + func, start_value, full_output=True + ) # scalar + # val = optimize.newton(func, start_value) # scalar + fval = infodict["fvec"] + fit_res.append(infodict) + else: + ier = -1 + fval = 1 + fit_res.append([None]) + + if ier == 1 and np.abs(fval) < 1e-4: + success = 1 + # print infodict + elif key in ["alpha", "power", "effect_size"]: + val, r = optimize.brentq( + func, 1e-8, 1 - 1e-8, full_output=True + ) # scalar + success = 1 if r.converged else 0 + fit_res.append(r) + else: + success = 0 + + if not success == 1: + import warnings + + from statsmodels.tools.sm_exceptions import ( + ConvergenceWarning, + convergence_doc, + ) + + # the root finder did not converge, so ``val`` is not a solution + # (it is the last point the solver evaluated, e.g., a bracket + # bound). Report it in the warning for diagnostics, but return + # nan instead so it cannot masquerade as a valid answer. + warnings.warn( + convergence_doc + + f"The last value evaluated by the root finder was {val}; " + "returning nan instead. Solver details are stored in the " + "``cache_fit_res`` attribute.", + ConvergenceWarning, + stacklevel=2, + ) + val = np.nan + + # attach fit_res, for reading only, should be needed only for debugging + fit_res.insert(0, success) + self.cache_fit_res = fit_res + return val + + def plot_power( + self, + dep_var="nobs", + nobs=None, + effect_size=None, + alpha=0.05, + ax=None, + title=None, + plt_kwds=None, + **kwds, + ): + """ + Plot power with number of observations or effect size on x-axis + + Parameters + ---------- + dep_var : {'nobs', 'effect_size', 'alpha'}, optional + This specifies which variable is used for the horizontal axis. + If dep_var='nobs' (default), then one curve is created for each + value of ``effect_size``. If dep_var='effect_size' or alpha, then + one curve is created for each value of ``nobs``. + nobs : array_like, optional + specifies the values of the number of observations in the plot + effect_size : array_like, optional + specifies the values of the effect_size in the plot + alpha : float or array_like, optional + The significance level (type I error) used in the power + calculation. Can only be more than a scalar, if ``dep_var='alpha'`` + ax : AxesSubplot, optional + If ax is None, than a matplotlib figure is created. If ax is a + matplotlib axis instance, then it is reused, and the plot elements + are created with it. + title : str, optional + Title for the axis. Use an empty string, ``''``, to avoid a + title. If not given, the default title "Power of Test" is used. + plt_kwds : dict, optional + Not used yet. + **kwds + These remaining keyword arguments are used as arguments to the + power function. Many power functions support ``alternative`` as + a keyword argument, two-sample tests support ``ratio``. + + Returns + ------- + Figure + If `ax` is None, the created figure. Otherwise the figure to which + `ax` is connected. + + Notes + ----- + This works only for classes where the ``power`` method has + ``effect_size``, ``nobs`` and ``alpha`` as the first three arguments. + If the second argument is ``nobs1``, then the number of observations + in the plot are those for the first sample. + TODO: fix this for FTestPower and GofChisquarePower + + TODO: maybe add line variable, if we want more than nobs and effectsize + """ + # if pwr_kwds is None: + # pwr_kwds = {} + from statsmodels.graphics import utils + from statsmodels.graphics.plottools import rainbow + + plt = _import_mpl() + fig, ax = utils.create_mpl_ax(ax) + + colormap = plt.cm.Dark2 # pylint: disable-msg=E1101 + plt_alpha = 1 # 0.75 + lw = 2 + if dep_var == "nobs": + colors = rainbow(len(effect_size)) + colors = [colormap(i) for i in np.linspace(0, 0.9, len(effect_size))] + for ii, es in enumerate(effect_size): + power = self.power(es, nobs, alpha, **kwds) + ax.plot( + nobs, + power, + lw=lw, + alpha=plt_alpha, + color=colors[ii], + label=f"es={es:4.2F}", + ) + xlabel = "Number of Observations" + elif dep_var in ["effect size", "effect_size", "es"]: + colors = rainbow(len(nobs)) + colors = [colormap(i) for i in np.linspace(0, 0.9, len(nobs))] + for ii, n in enumerate(nobs): + power = self.power(effect_size, n, alpha, **kwds) + ax.plot( + effect_size, + power, + lw=lw, + alpha=plt_alpha, + color=colors[ii], + label=f"N={n:4.2F}", + ) + xlabel = "Effect Size" + elif dep_var == "alpha": + # experimental nobs as defining separate lines + colors = rainbow(len(nobs)) + + for ii, n in enumerate(nobs): + power = self.power(effect_size, n, alpha, **kwds) + ax.plot( + alpha, + power, + lw=lw, + alpha=plt_alpha, + color=colors[ii], + label=f"N={n:4.2F}", + ) + xlabel = "alpha" + else: + raise ValueError("depvar not implemented") + + if title is None: + title = "Power of Test" + ax.set_xlabel(xlabel) + ax.set_title(title) + ax.legend(loc="lower right") + return fig + + +class TTestPower(Power): + """Statistical Power calculations for one sample or paired sample t-test""" + + def power(self, effect_size, nobs, alpha, df=None, alternative="two-sided"): + """ + Calculate the power of a t-test for one sample or paired samples + + Parameters + ---------- + effect_size : float + standardized effect size, mean divided by the standard deviation. + effect size has to be positive. + nobs : int or float + sample size, number of observations. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + df : int or float, optional + degrees of freedom. By default this is None, and the df from the + one sample or paired ttest is used, ``df = nobs1 - 1`` + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + """ + # for debugging + # print 'calling ttest power with', (effect_size, nobs, alpha, df, alternative) + return ttest_power(effect_size, nobs, alpha, df=df, alternative=alternative) + + # method is only added to have explicit keywords and docstring + def solve_power( + self, + effect_size=None, + nobs=None, + alpha=None, + power=None, + alternative="two-sided", + ): + """ + Solve for any one parameter of the power of a one sample t-test + + for the one sample t-test the keywords are: + effect_size, nobs, alpha, power + + Exactly one needs to be ``None``, all others need numeric values. + + This test can also be used for a paired t-test, where effect size is + defined in terms of the mean difference, and nobs is the number of + pairs. + + Parameters + ---------- + effect_size : None or float + Standardized effect size, mean divided by the standard + deviation. + nobs : None or int or float + sample size, number of observations. + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + Notes + ----- + This method attaches the following to the instance: + + cache_fit_res : list + Cache of the result of the root finding procedure for the latest + call to ``solve_power``, mainly for debugging purposes. + The first element is the success indicator, one if successful. + The remaining elements contain the return information of the up to + three solvers that have been tried. + + The function uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + # for debugging + # print 'calling ttest solve with', (effect_size, nobs, alpha, power, alternative) + return super().solve_power( + effect_size=effect_size, + nobs=nobs, + alpha=alpha, + power=power, + alternative=alternative, + ) + + +class TTestIndPower(Power): + """ + Statistical Power calculations for t-test for two independent sample + + currently only uses pooled variance + + """ + + def power( + self, effect_size, nobs1, alpha, ratio=1, df=None, alternative="two-sided" + ): + """ + Calculate the power of a t-test for two independent sample + + Parameters + ---------- + effect_size : float + standardized effect size, difference between the two means divided + by the standard deviation. `effect_size` has to be positive. + nobs1 : int or float + number of observations of sample 1. The number of observations of + sample two is ratio times the size of sample 1, + i.e., ``nobs2 = nobs1 * ratio`` + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + ratio : float, optional + ratio of the number of observations in sample 2 relative to + sample 1. see description of nobs1 + df : int or float, optional + degrees of freedom. By default this is None, and the df from the + ttest with pooled variance is used, ``df = (nobs1 - 1 + nobs2 - 1)`` + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + """ + + nobs2 = nobs1 * ratio + # pooled variance + if df is None: + df = nobs1 - 1 + nobs2 - 1 + + nobs = 1.0 / (1.0 / nobs1 + 1.0 / nobs2) + # print 'calling ttest power with', (effect_size, nobs, alpha, df, alternative) + return ttest_power(effect_size, nobs, alpha, df=df, alternative=alternative) + + # method is only added to have explicit keywords and docstring + def solve_power( + self, + effect_size=None, + nobs1=None, + alpha=None, + power=None, + ratio=1.0, + alternative="two-sided", + ): + """ + Solve for any one parameter of the power of a two sample t-test + + for t-test the keywords are: + effect_size, nobs1, alpha, power, ratio + + exactly one needs to be ``None``, all others need numeric values + + Parameters + ---------- + effect_size : None or float + standardized effect size, difference between the two means divided + by the standard deviation. `effect_size` has to be positive. + nobs1 : None or int or float + number of observations of sample 1. The number of observations of + sample two is ratio times the size of sample 1, + i.e., ``nobs2 = nobs1 * ratio`` + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + ratio : None or float, optional + ratio of the number of observations in sample 2 relative to + sample 1. see description of nobs1 + The default for ratio is 1; to solve for ratio given the other + arguments it has to be explicitly set to None. + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + + Notes + ----- + The function uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + return super().solve_power( + effect_size=effect_size, + nobs1=nobs1, + alpha=alpha, + power=power, + ratio=ratio, + alternative=alternative, + ) + + +class NormalIndPower(Power): + """ + Statistical Power calculations for z-test for two independent samples + + currently only uses pooled variance + + Parameters + ---------- + ddof : int, optional + Degrees of freedom correction for the standard deviation used in + computing the effective sample size. Used, e.g., for a correlation + coefficient where ddof=3. + **kwds + Additional keyword arguments passed to the ``Power`` base class. + + """ + + def __init__(self, ddof=0, **kwds): + self.ddof = ddof + super().__init__(**kwds) + + def power(self, effect_size, nobs1, alpha, ratio=1, alternative="two-sided"): + """ + Calculate the power of a z-test for two independent sample + + Parameters + ---------- + effect_size : float + standardized effect size, difference between the two means divided + by the standard deviation. effect size has to be positive. + nobs1 : int or float + number of observations of sample 1. The number of observations of + sample two is ratio times the size of sample 1, + i.e., ``nobs2 = nobs1 * ratio`` + ``ratio`` can be set to zero in order to get the power for a + one sample test. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + ratio : float, optional + ratio of the number of observations in sample 2 relative to + sample 1. see description of nobs1 + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + """ + + ddof = self.ddof # for correlation, ddof=3 + + # get effective nobs, factor for std of test statistic + if ratio > 0: + nobs2 = nobs1 * ratio + # equivalent to nobs = n1*n2/(n1+n2)=n1*ratio/(1+ratio) + nobs = 1.0 / (1.0 / (nobs1 - ddof) + 1.0 / (nobs2 - ddof)) + else: + nobs = nobs1 - ddof + return normal_power(effect_size, nobs, alpha, alternative=alternative) + + # method is only added to have explicit keywords and docstring + def solve_power( + self, + effect_size=None, + nobs1=None, + alpha=None, + power=None, + ratio=1.0, + alternative="two-sided", + ): + """ + Solve for any one parameter of the power of a two sample z-test + + for z-test the keywords are: + effect_size, nobs1, alpha, power, ratio + + exactly one needs to be ``None``, all others need numeric values + + Parameters + ---------- + effect_size : None or float + standardized effect size, difference between the two means divided + by the standard deviation. + If ratio=0, then this is the standardized mean in the one sample + test. + nobs1 : None or int or float + number of observations of sample 1. The number of observations of + sample two is ratio times the size of sample 1, + i.e., ``nobs2 = nobs1 * ratio`` + ``ratio`` can be set to zero in order to get the power for a + one sample test. + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + ratio : None or float, optional + ratio of the number of observations in sample 2 relative to + sample 1. see description of nobs1 + The default for ratio is 1; to solve for ratio given the other + arguments it has to be explicitly set to None. + alternative : {'two-sided', 'larger', 'smaller'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. The one-sided test can be + either 'larger', 'smaller'. + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + + Notes + ----- + The function uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + return super().solve_power( + effect_size=effect_size, + nobs1=nobs1, + alpha=alpha, + power=power, + ratio=ratio, + alternative=alternative, + ) + + +class FTestPower(Power): + """ + Statistical Power calculations for generic F-test of a constraint + + This class is not recommended, use `FTestPowerF2` with corrected interface. + + This is based on Cohen's f as effect size measure. + + Warning: Methods in this class have the names df_num and df_denom reversed. + + See Also + -------- + FTestPowerF2 : + Class with Cohen's f-squared as effect size, corrected keyword names. + + Examples + -------- + Sample size and power for multiple regression base on R-squared + + Compute effect size from R-squared + + >>> r2 = 0.1 + >>> f2 = r2 / (1 - r2) + >>> f = np.sqrt(f2) + >>> r2, f2, f + (0.1, 0.11111111111111112, 0.33333333333333337) + + Find sample size by solving for denominator df, wrongly named ``df_num`` + + >>> df1 = 1 # number of constraints in hypothesis test + >>> df2 = FTestPower().solve_power(effect_size=f, alpha=0.1, power=0.9, + ... df_denom=df1) + >>> ncc = 1 # default + >>> nobs = df2 + df1 + ncc + >>> df2, nobs + (76.46459758305376, 78.46459758305376) + + verify power at df2 + + >>> FTestPower().power(effect_size=f, alpha=0.1, df_denom=df1, df_num=df2) + 0.8999999972109698 + + """ + + def power(self, effect_size, df_num, df_denom, alpha, ncc=1): + """ + Calculate the power of a F-test + + The effect size is Cohen's ``f``, square root of ``f2``. + + The sample size is given by ``nobs = df_denom + df_num + ncc`` + + Warning: The meaning of df_num and df_denom is reversed. + + Parameters + ---------- + effect_size : float + Standardized effect size. The effect size is here Cohen's ``f``, + square root of ``f2``. + df_num : int or float + Warning incorrect name + denominator degrees of freedom, + This corresponds to the number of constraints in Wald tests. + df_denom : int or float + Warning incorrect name + numerator degrees of freedom. + This corresponds to the df_resid in Wald tests. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + ncc : int, optional + degrees of freedom correction for non-centrality parameter. + see Notes + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + Notes + ----- + + sample size is given implicitly by df_num + + set ncc=0 to match t-test, or f-test in LikelihoodModelResults. + ncc=1 matches the non-centrality parameter in R::pwr::pwr.f2.test + + ftest_power with ncc=0 should also be correct for f_test in regression + models, with df_num and d_denom as defined there. (not verified yet) + """ + + pow_ = ftest_power(effect_size, df_num, df_denom, alpha, ncc=ncc) + # print effect_size, df_num, df_denom, alpha, pow_ + return pow_ + + # method is only added to have explicit keywords and docstring + def solve_power( + self, + effect_size=None, + df_num=None, + df_denom=None, + alpha=None, + power=None, + ncc=1, + **kwargs, + ): + """ + Solve for any one parameter of the power of a F-test + + for the one sample F-test the keywords are: + effect_size, df_num, df_denom, alpha, power + + Exactly one needs to be ``None``, all others need numeric values. + + The effect size is Cohen's ``f``, square root of ``f2``. + + The sample size is given by ``nobs = df_denom + df_num + ncc``. + + Warning: The meaning of df_num and df_denom is reversed. + + Parameters + ---------- + effect_size : None or float + Standardized effect size. The effect size is here Cohen's ``f``, + square root of ``f2``. + df_num : None or int or float + Warning incorrect name + denominator degrees of freedom, + This corresponds to the number of constraints in Wald tests. + Sample size is given by ``nobs = df_denom + df_num + ncc`` + df_denom : None or int or float + Warning incorrect name + numerator degrees of freedom. + This corresponds to the df_resid in Wald tests. + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + ncc : int, optional + degrees of freedom correction for non-centrality parameter. + see Notes + **kwargs + ``kwargs`` are not used and included for backwards compatibility. + If ``nobs`` is used as keyword, then a warning is issued. All + other keywords in ``kwargs`` raise a ValueError. + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + + Notes + ----- + The method uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + if kwargs: + if "nobs" in kwargs: + warnings.warn("nobs is not used", stacklevel=2) + else: + raise ValueError(f"incorrect keyword(s) {kwargs}") + return super().solve_power( + effect_size=effect_size, + df_num=df_num, + df_denom=df_denom, + alpha=alpha, + power=power, + ncc=ncc, + ) + + +class FTestPowerF2(Power): + """ + Statistical Power calculations for generic F-test of a constraint + + This is based on Cohen's f^2 as effect size measure. + + Examples + -------- + Sample size and power for multiple regression base on R-squared + + Compute effect size from R-squared + + >>> r2 = 0.1 + >>> f2 = r2 / (1 - r2) + >>> f = np.sqrt(f2) + >>> r2, f2, f + (0.1, 0.11111111111111112, 0.33333333333333337) + + Find sample size by solving for denominator degrees of freedom. + + >>> df1 = 1 # number of constraints in hypothesis test + >>> df2 = FTestPowerF2().solve_power(effect_size=f2, alpha=0.1, power=0.9, + ... df_num=df1) + >>> ncc = 1 # default + >>> nobs = df2 + df1 + ncc + >>> df2, nobs + (76.46459758305376, 78.46459758305376) + + verify power at df2 + + >>> FTestPowerF2().power(effect_size=f, alpha=0.1, df_num=df1, df_denom=df2) + 0.8999999972109698 + + """ + + def power(self, effect_size, df_num, df_denom, alpha, ncc=1): + """ + Calculate the power of a F-test + + The effect size is Cohen's ``f^2``. + + The sample size is given by ``nobs = df_denom + df_num + ncc`` + + Parameters + ---------- + effect_size : float + The effect size is here Cohen's ``f2``. This is equal to + the noncentrality of an F-test divided by nobs. + df_num : int or float + Numerator degrees of freedom, + This corresponds to the number of constraints in Wald tests. + df_denom : int or float + Denominator degrees of freedom. + This corresponds to the df_resid in Wald tests. + alpha : float in interval (0,1) + Significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + ncc : int, optional + Degrees of freedom correction for non-centrality parameter. + see Notes + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + Notes + ----- + The sample size is given implicitly by df_denom + + set ncc=0 to match t-test, or f-test in LikelihoodModelResults. + ncc=1 matches the non-centrality parameter in R::pwr::pwr.f2.test + + ftest_power with ncc=0 should also be correct for f_test in regression + models, with df_num and d_denom as defined there. (not verified yet) + """ + + pow_ = ftest_power_f2(effect_size, df_num, df_denom, alpha, ncc=ncc) + return pow_ + + # method is only added to have explicit keywords and docstring + def solve_power( + self, + effect_size=None, + df_num=None, + df_denom=None, + alpha=None, + power=None, + ncc=1, + ): + """ + Solve for any one parameter of the power of a F-test + + for the one sample F-test the keywords are: + effect_size, df_num, df_denom, alpha, power + + Exactly one needs to be ``None``, all others need numeric values. + + The effect size is Cohen's ``f2``. + + The sample size is given by ``nobs = df_denom + df_num + ncc``, and + can be found by solving for df_denom. + + Parameters + ---------- + effect_size : None or float + The effect size is here Cohen's ``f2``. This is equal to + the noncentrality of an F-test divided by nobs. + df_num : None or int or float + Numerator degrees of freedom, + This corresponds to the number of constraints in Wald tests. + df_denom : None or int or float + Denominator degrees of freedom. + This corresponds to the df_resid in Wald tests. + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + ncc : int, optional + degrees of freedom correction for non-centrality parameter. + see Notes + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + + Notes + ----- + The function uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + + return super().solve_power( + effect_size=effect_size, + df_num=df_num, + df_denom=df_denom, + alpha=alpha, + power=power, + ncc=ncc, + ) + + +class FTestAnovaPower(Power): + """ + Statistical Power calculations F-test for one factor balanced ANOVA + + This is based on Cohen's f as effect size measure. + + See Also + -------- + statsmodels.stats.oneway.effectsize_oneway + + """ + + def power(self, effect_size, nobs, alpha, k_groups=2): + """ + Calculate the power of a F-test for one factor ANOVA + + Parameters + ---------- + effect_size : float + standardized effect size. The effect size is here Cohen's f, square + root of "f2". + nobs : int or float + sample size, number of observations. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + k_groups : int or float + number of groups in the ANOVA or k-sample comparison. Default is 2. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + """ + return ftest_anova_power(effect_size, nobs, alpha, k_groups=k_groups) + + # method is only added to have explicit keywords and docstring + def solve_power( + self, effect_size=None, nobs=None, alpha=None, power=None, k_groups=2 + ): + """ + Solve for any one parameter of the power of a F-test + + for the one sample F-test the keywords are: + effect_size, nobs, alpha, power + + Exactly one needs to be ``None``, all others need numeric values. + + + Parameters + ---------- + effect_size : None or float + standardized effect size, mean divided by the standard deviation. + effect size has to be positive. + nobs : None or int or float + sample size, number of observations. + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + k_groups : int or float, optional + number of groups in the ANOVA or k-sample comparison. Default is 2. + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + + Notes + ----- + The function uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + # update start values for root finding + if k_groups is not None: + self.start_ttp["nobs"] = k_groups * 10 + self.start_bqexp["nobs"] = {"low": k_groups * 2, "start_upp": k_groups * 10} + # first attempt at special casing + if effect_size is None: + return self._solve_effect_size( + effect_size=effect_size, + nobs=nobs, + alpha=alpha, + k_groups=k_groups, + power=power, + ) + + return super().solve_power( + effect_size=effect_size, + nobs=nobs, + alpha=alpha, + k_groups=k_groups, + power=power, + ) + + def _solve_effect_size( + self, effect_size=None, nobs=None, alpha=None, power=None, k_groups=2 + ): + """experimental, test failure in solve_power for effect_size""" + + def func(x): + effect_size = x + return self._power_identity( + effect_size=effect_size, + nobs=nobs, + alpha=alpha, + k_groups=k_groups, + power=power, + ) + + val, r = optimize.brentq(func, 1e-8, 1 - 1e-8, full_output=True) + if not r.converged: + print(r) + return val + + +class GofChisquarePower(Power): + """Statistical Power calculations for one sample chisquare test""" + + def power( + self, effect_size, nobs, alpha, n_bins, ddof=0 + ): # alternative='two-sided'): + """ + Calculate the power of a chisquare test for one sample + + Only two-sided alternative is implemented + + Parameters + ---------- + effect_size : float + standardized effect size, according to Cohen's definition. + see :func:`statsmodels.stats.gof.chisquare_effectsize` + nobs : int or float + sample size, number of observations. + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + n_bins : int + number of bins or cells in the distribution. + ddof : int, optional + Degrees of freedom correction for the chisquare distribution. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + """ + from statsmodels.stats.gof import chisquare_power + + return chisquare_power(effect_size, nobs, n_bins, alpha, ddof=ddof) + + # method is only added to have explicit keywords and docstring + def solve_power( + self, effect_size=None, nobs=None, alpha=None, power=None, n_bins=2 + ): + """ + Solve for any one parameter of the power of a one sample chisquare-test + + for the one sample chisquare-test the keywords are: + effect_size, nobs, alpha, power + + Exactly one needs to be ``None``, all others need numeric values. + + n_bins needs to be defined, a default=2 is used. + + + Parameters + ---------- + effect_size : None or float + standardized effect size, according to Cohen's definition. + see :func:`statsmodels.stats.gof.chisquare_effectsize` + nobs : None or int or float + sample size, number of observations. + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + n_bins : int, optional + number of bins or cells in the distribution + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + + Notes + ----- + The function uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + return super().solve_power( + effect_size=effect_size, nobs=nobs, n_bins=n_bins, alpha=alpha, power=power + ) + + +class _GofChisquareIndPower(Power): + """ + Statistical Power calculations for chisquare goodness-of-fit test + + TODO: this is not working yet + for 2sample case need two nobs in function + no one-sided chisquare test, is there one? use normal distribution? + -> drop one-sided options? + """ + + def power(self, effect_size, nobs1, alpha, ratio=1, alternative="two-sided"): + """ + Calculate the power of a chisquare for two independent sample + + Parameters + ---------- + effect_size : float + standardized effect size, difference between the two means divided + by the standard deviation. effect size has to be positive. + nobs1 : int or float + number of observations of sample 1. The number of observations of + sample two is ratio times the size of sample 1, + i.e., ``nobs2 = nobs1 * ratio`` + alpha : float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + ratio : float, optional + ratio of the number of observations in sample 2 relative to + sample 1. see description of nobs1 + alternative : {'two-sided', 'one-sided'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. + 'one-sided' assumes we are in the relevant tail. + + Returns + ------- + power : float + Power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + + """ + + from statsmodels.stats.gof import chisquare_power + + nobs2 = nobs1 * ratio + # equivalent to nobs = n1*n2/(n1+n2)=n1*ratio/(1+ratio) + nobs = 1.0 / (1.0 / nobs1 + 1.0 / nobs2) + return chisquare_power(effect_size, nobs, alpha) + + # method is only added to have explicit keywords and docstring + def solve_power( + self, + effect_size=None, + nobs1=None, + alpha=None, + power=None, + ratio=1.0, + alternative="two-sided", + ): + """ + Solve for any one parameter of the power of a two sample chisquare-test + + for the chisquare-test the keywords are: + effect_size, nobs1, alpha, power, ratio + + exactly one needs to be ``None``, all others need numeric values + + Parameters + ---------- + effect_size : None or float + standardized effect size, difference between the two means divided + by the standard deviation. + nobs1 : None or int or float + number of observations of sample 1. The number of observations of + sample two is ratio times the size of sample 1, + i.e., ``nobs2 = nobs1 * ratio`` + alpha : None or float in interval (0,1) + significance level, e.g., 0.05, is the probability of a type I + error, that is wrong rejections if the Null Hypothesis is true. + power : None or float in interval (0,1) + power of the test, e.g., 0.8, is one minus the probability of a + type II error. Power is the probability that the test correctly + rejects the Null Hypothesis if the Alternative Hypothesis is true. + ratio : None or float, optional + ratio of the number of observations in sample 2 relative to + sample 1. see description of nobs1 + The default for ratio is 1; to solve for ratio given the other + arguments it has to be explicitly set to None. + alternative : {'two-sided', 'one-sided'}, optional + extra argument to choose whether the power is calculated for a + two-sided (default) or one sided test. + 'one-sided' assumes we are in the relevant tail. + + Returns + ------- + value : float + The value of the parameter that was set to None in the call. The + value solves the power equation given the remaining parameters. + + + Notes + ----- + The function uses scipy.optimize for finding the value that satisfies + the power equation. It first uses ``brentq`` with a prior search for + bounds. If this fails to find a root, ``fsolve`` is used. If ``fsolve`` + also fails, then, for ``alpha``, ``power`` and ``effect_size``, + ``brentq`` with fixed bounds is used. However, there can still be cases + where this fails. + + """ + return super().solve_power( + effect_size=effect_size, + nobs1=nobs1, + alpha=alpha, + power=power, + ratio=ratio, + alternative=alternative, + ) + + +# shortcut functions +tt_solve_power = TTestPower().solve_power +tt_ind_solve_power = TTestIndPower().solve_power +zt_ind_solve_power = NormalIndPower().solve_power diff --git a/shared/package-files/41/41c6e13b296e71c76e86fa20b1e5a184c2a99c931e77f95fb3486f73a06f00d7/blob b/shared/package-files/41/41c6e13b296e71c76e86fa20b1e5a184c2a99c931e77f95fb3486f73a06f00d7/blob new file mode 100644 index 0000000000000000000000000000000000000000..a25aa4e42649eea6d8fbff1b4ea4b293539b9f08 --- /dev/null +++ b/shared/package-files/41/41c6e13b296e71c76e86fa20b1e5a184c2a99c931e77f95fb3486f73a06f00d7/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41c6e13b296e71c76e86fa20b1e5a184c2a99c931e77f95fb3486f73a06f00d7 +size 2701899968 diff --git a/shared/package-files/41/41c708c5adba6e097513ab8ccb9f1d7865a2fb469e22491a9e01dcc64da459fc/blob b/shared/package-files/41/41c708c5adba6e097513ab8ccb9f1d7865a2fb469e22491a9e01dcc64da459fc/blob new file mode 100644 index 0000000000000000000000000000000000000000..b1b94fd58e7e9ed0ef3449473bc48de68afcc3fe --- /dev/null +++ b/shared/package-files/41/41c708c5adba6e097513ab8ccb9f1d7865a2fb469e22491a9e01dcc64da459fc/blob @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.29.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/shared/package-files/41/41cac51c9f92ffe7a4bbf83041bf6f9317b714ece180b65187a5edb1884d1c29/blob b/shared/package-files/41/41cac51c9f92ffe7a4bbf83041bf6f9317b714ece180b65187a5edb1884d1c29/blob new file mode 100644 index 0000000000000000000000000000000000000000..873c5db6737330483a8b67f0dffed051baf14e14 --- /dev/null +++ b/shared/package-files/41/41cac51c9f92ffe7a4bbf83041bf6f9317b714ece180b65187a5edb1884d1c29/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41cac51c9f92ffe7a4bbf83041bf6f9317b714ece180b65187a5edb1884d1c29 +size 6981992 diff --git a/shared/package-files/41/41cb1a37427106bf40af0427ce198dd3a1bc74c4e9a88b886daa49bd65abf084/blob b/shared/package-files/41/41cb1a37427106bf40af0427ce198dd3a1bc74c4e9a88b886daa49bd65abf084/blob new file mode 100644 index 0000000000000000000000000000000000000000..24879612a769bed06e07ce438182b5127365eee9 --- /dev/null +++ b/shared/package-files/41/41cb1a37427106bf40af0427ce198dd3a1bc74c4e9a88b886daa49bd65abf084/blob @@ -0,0 +1 @@ +from _dummy_thread import * diff --git a/shared/package-files/41/41cb48d69deaa9089aa8ba4625d2f0bc8bc40910f3e6d697151d44945641d71d/blob b/shared/package-files/41/41cb48d69deaa9089aa8ba4625d2f0bc8bc40910f3e6d697151d44945641d71d/blob new file mode 100644 index 0000000000000000000000000000000000000000..a348e49abb116983480a987fd4d9bd3c88ef2bbc --- /dev/null +++ b/shared/package-files/41/41cb48d69deaa9089aa8ba4625d2f0bc8bc40910f3e6d697151d44945641d71d/blob @@ -0,0 +1,15 @@ +from collections import OrderedDict +from typing import Any, Dict, Iterator, List, Optional + +from django.core.serializers.base import DeserializedObject +from django.db.models.base import Model + +from django.core.serializers import base + +class Serializer(base.Serializer): + objects: List[Any] = ... + def get_dump_object(self, obj: Model) -> OrderedDict: ... + +def Deserializer( + object_list: List[Dict[str, Any]], *, using: Optional[str] = ..., ignorenonexistent: bool = ..., **options: Any +) -> Iterator[DeserializedObject]: ... diff --git a/shared/package-files/41/41cda824ec237bee2e7054f570046990150bbe4157308c8ec42b70382c68960c/blob b/shared/package-files/41/41cda824ec237bee2e7054f570046990150bbe4157308c8ec42b70382c68960c/blob new file mode 100644 index 0000000000000000000000000000000000000000..3d2d71920f46399a8775b28ea36b59c8eceb7c6e Binary files /dev/null and b/shared/package-files/41/41cda824ec237bee2e7054f570046990150bbe4157308c8ec42b70382c68960c/blob differ diff --git a/shared/package-files/41/41d26fc8ad8dd77f1b8833e18b1c7f67dc5b27b47e692c73e668524af87e1d18/blob b/shared/package-files/41/41d26fc8ad8dd77f1b8833e18b1c7f67dc5b27b47e692c73e668524af87e1d18/blob new file mode 100644 index 0000000000000000000000000000000000000000..fb593485d17a8155f784ef881b3868338348e1a8 --- /dev/null +++ b/shared/package-files/41/41d26fc8ad8dd77f1b8833e18b1c7f67dc5b27b47e692c73e668524af87e1d18/blob @@ -0,0 +1,101 @@ +import numpy as np +import pytest + +from sklearn.metrics import euclidean_distances +from sklearn.neighbors import KNeighborsTransformer, RadiusNeighborsTransformer +from sklearn.neighbors._base import _is_sorted_by_data +from sklearn.utils._testing import assert_array_equal + + +def test_transformer_result(): + # Test the number of neighbors returned + n_neighbors = 5 + n_samples_fit = 20 + n_queries = 18 + n_features = 10 + + rng = np.random.RandomState(42) + X = rng.randn(n_samples_fit, n_features) + X2 = rng.randn(n_queries, n_features) + radius = np.percentile(euclidean_distances(X), 10) + + # with n_neighbors + for mode in ["distance", "connectivity"]: + add_one = mode == "distance" + nnt = KNeighborsTransformer(n_neighbors=n_neighbors, mode=mode) + Xt = nnt.fit_transform(X) + assert Xt.shape == (n_samples_fit, n_samples_fit) + assert Xt.data.shape == (n_samples_fit * (n_neighbors + add_one),) + assert Xt.format == "csr" + assert _is_sorted_by_data(Xt) + + X2t = nnt.transform(X2) + assert X2t.shape == (n_queries, n_samples_fit) + assert X2t.data.shape == (n_queries * (n_neighbors + add_one),) + assert X2t.format == "csr" + assert _is_sorted_by_data(X2t) + + # with radius + for mode in ["distance", "connectivity"]: + add_one = mode == "distance" + nnt = RadiusNeighborsTransformer(radius=radius, mode=mode) + Xt = nnt.fit_transform(X) + assert Xt.shape == (n_samples_fit, n_samples_fit) + assert not Xt.data.shape == (n_samples_fit * (n_neighbors + add_one),) + assert Xt.format == "csr" + assert _is_sorted_by_data(Xt) + + X2t = nnt.transform(X2) + assert X2t.shape == (n_queries, n_samples_fit) + assert not X2t.data.shape == (n_queries * (n_neighbors + add_one),) + assert X2t.format == "csr" + assert _is_sorted_by_data(X2t) + + +def _has_explicit_diagonal(X): + """Return True if the diagonal is explicitly stored""" + X = X.tocoo() + explicit = X.row[X.row == X.col] + return len(explicit) == X.shape[0] + + +def test_explicit_diagonal(): + # Test that the diagonal is explicitly stored in the sparse graph + n_neighbors = 5 + n_samples_fit, n_samples_transform, n_features = 20, 18, 10 + rng = np.random.RandomState(42) + X = rng.randn(n_samples_fit, n_features) + X2 = rng.randn(n_samples_transform, n_features) + + nnt = KNeighborsTransformer(n_neighbors=n_neighbors) + Xt = nnt.fit_transform(X) + assert _has_explicit_diagonal(Xt) + assert np.all(Xt.data.reshape(n_samples_fit, n_neighbors + 1)[:, 0] == 0) + + Xt = nnt.transform(X) + assert _has_explicit_diagonal(Xt) + assert np.all(Xt.data.reshape(n_samples_fit, n_neighbors + 1)[:, 0] == 0) + + # Using transform on new data should not always have zero diagonal + X2t = nnt.transform(X2) + assert not _has_explicit_diagonal(X2t) + + +@pytest.mark.parametrize("Klass", [KNeighborsTransformer, RadiusNeighborsTransformer]) +def test_graph_feature_names_out(Klass): + """Check `get_feature_names_out` for transformers defined in `_graph.py`.""" + + n_samples_fit = 20 + n_features = 10 + rng = np.random.RandomState(42) + X = rng.randn(n_samples_fit, n_features) + + est = Klass().fit(X) + names_out = est.get_feature_names_out() + + class_name_lower = Klass.__name__.lower() + expected_names_out = np.array( + [f"{class_name_lower}{i}" for i in range(est.n_samples_fit_)], + dtype=object, + ) + assert_array_equal(names_out, expected_names_out) diff --git a/shared/package-files/41/41d4d08956f385ba5968965511255f4ba72050c2448ca6916896bddcde3dc346/blob b/shared/package-files/41/41d4d08956f385ba5968965511255f4ba72050c2448ca6916896bddcde3dc346/blob new file mode 100644 index 0000000000000000000000000000000000000000..d641b2180e4ba661c8cf79fe106bb65f1bde7766 --- /dev/null +++ b/shared/package-files/41/41d4d08956f385ba5968965511255f4ba72050c2448ca6916896bddcde3dc346/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41d4d08956f385ba5968965511255f4ba72050c2448ca6916896bddcde3dc346 +size 299736 diff --git a/shared/package-files/41/41d7179c2340c29b395554cda3a8ec766112e87e8aeb3aa9c9467121999f29ad/blob b/shared/package-files/41/41d7179c2340c29b395554cda3a8ec766112e87e8aeb3aa9c9467121999f29ad/blob new file mode 100644 index 0000000000000000000000000000000000000000..c4e8c1cc99b00d63672e12f2908a82c899076306 --- /dev/null +++ b/shared/package-files/41/41d7179c2340c29b395554cda3a8ec766112e87e8aeb3aa9c9467121999f29ad/blob @@ -0,0 +1,9 @@ +from importlib.util import find_spec + +import torch + +__all__ = ["amp_definitely_not_available"] + + +def amp_definitely_not_available(): + return not (torch.cuda.is_available() or find_spec("torch_xla")) diff --git a/shared/package-files/41/41d7748bb1f870d8400017c53993eea65862ffd482aae1693be84d93245c303f/blob b/shared/package-files/41/41d7748bb1f870d8400017c53993eea65862ffd482aae1693be84d93245c303f/blob new file mode 100644 index 0000000000000000000000000000000000000000..30537565fe8c47f74da0e63a39f4b46600f7768f --- /dev/null +++ b/shared/package-files/41/41d7748bb1f870d8400017c53993eea65862ffd482aae1693be84d93245c303f/blob @@ -0,0 +1,108 @@ +NIST/ITL StRD +Dataset Name: AtmWtAg (AtmWtAg.dat) + + +File Format: ASCII + Certified Values (lines 41 to 47) + Data (lines 61 to 108) + + +Procedure: Analysis of Variance + + +Reference: Powell, L.J., Murphy, T.J. and Gramlich, J.W. (1982). + "The Absolute Isotopic Abundance & Atomic Weight + of a Reference Sample of Silver". + NBS Journal of Research, 87, pp. 9-19. + + +Data: 1 Factor + 2 Treatments + 24 Replicates/Cell + 48 Observations + 7 Constant Leading Digits + Average Level of Difficulty + Observed Data + + +Model: 3 Parameters (mu, tau_1, tau_2) + y_{ij} = mu + tau_i + epsilon_{ij} + + + + + + +Certified Values: + +Source of Sums of Mean +Variation df Squares Squares F Statistic + + +Between Instrument 1 3.63834187500000E-09 3.63834187500000E-09 1.59467335677930E+01 +Within Instrument 46 1.04951729166667E-08 2.28155932971014E-10 + + Certified R-Squared 2.57426544538321E-01 + + Certified Residual + Standard Deviation 1.51048314446410E-05 + + + + + + + + + + + +Data: Instrument AgWt + 1 107.8681568 + 1 107.8681465 + 1 107.8681572 + 1 107.8681785 + 1 107.8681446 + 1 107.8681903 + 1 107.8681526 + 1 107.8681494 + 1 107.8681616 + 1 107.8681587 + 1 107.8681519 + 1 107.8681486 + 1 107.8681419 + 1 107.8681569 + 1 107.8681508 + 1 107.8681672 + 1 107.8681385 + 1 107.8681518 + 1 107.8681662 + 1 107.8681424 + 1 107.8681360 + 1 107.8681333 + 1 107.8681610 + 1 107.8681477 + 2 107.8681079 + 2 107.8681344 + 2 107.8681513 + 2 107.8681197 + 2 107.8681604 + 2 107.8681385 + 2 107.8681642 + 2 107.8681365 + 2 107.8681151 + 2 107.8681082 + 2 107.8681517 + 2 107.8681448 + 2 107.8681198 + 2 107.8681482 + 2 107.8681334 + 2 107.8681609 + 2 107.8681101 + 2 107.8681512 + 2 107.8681469 + 2 107.8681360 + 2 107.8681254 + 2 107.8681261 + 2 107.8681450 + 2 107.8681368 diff --git a/shared/package-files/41/41d7b70281a913330914c46e645ae09630e80da35258e8929e82e69ae2df7140/blob b/shared/package-files/41/41d7b70281a913330914c46e645ae09630e80da35258e8929e82e69ae2df7140/blob new file mode 100644 index 0000000000000000000000000000000000000000..513e73ef2efe42d8014cb0d712fd370b82ac8b76 --- /dev/null +++ b/shared/package-files/41/41d7b70281a913330914c46e645ae09630e80da35258e8929e82e69ae2df7140/blob @@ -0,0 +1,881 @@ +# mypy: ignore-errors + +import torch + +# These two dicts are autogenerated with autogen/gen_dtypes.py, +# using numpy version 1.23.5. + +_can_cast_dict = { + "no": { + torch.float16: { + torch.float16: True, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float32: { + torch.float16: False, + torch.float32: True, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float64: { + torch.float16: False, + torch.float32: False, + torch.float64: True, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex64: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: True, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex128: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.uint8: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: True, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.int8: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: True, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.int16: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: True, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.int32: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: True, + torch.int64: False, + torch.bool: False, + }, + torch.int64: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: True, + torch.bool: False, + }, + torch.bool: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: True, + }, + }, + "equiv": { + torch.float16: { + torch.float16: True, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float32: { + torch.float16: False, + torch.float32: True, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float64: { + torch.float16: False, + torch.float32: False, + torch.float64: True, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex64: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: True, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex128: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.uint8: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: True, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.int8: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: True, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.int16: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: True, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.int32: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: True, + torch.int64: False, + torch.bool: False, + }, + torch.int64: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: True, + torch.bool: False, + }, + torch.bool: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: False, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: True, + }, + }, + "safe": { + torch.float16: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float32: { + torch.float16: False, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float64: { + torch.float16: False, + torch.float32: False, + torch.float64: True, + torch.complex64: False, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex64: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex128: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: False, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.uint8: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: False, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int8: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int16: { + torch.float16: False, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int32: { + torch.float16: False, + torch.float32: False, + torch.float64: True, + torch.complex64: False, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int64: { + torch.float16: False, + torch.float32: False, + torch.float64: True, + torch.complex64: False, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: True, + torch.bool: False, + }, + torch.bool: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + }, + "same_kind": { + torch.float16: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float32: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.float64: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex64: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.complex128: { + torch.float16: False, + torch.float32: False, + torch.float64: False, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: False, + torch.int16: False, + torch.int32: False, + torch.int64: False, + torch.bool: False, + }, + torch.uint8: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int8: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int16: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int32: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.int64: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: False, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: False, + }, + torch.bool: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + }, + "unsafe": { + torch.float16: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.float32: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.float64: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.complex64: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.complex128: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.uint8: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.int8: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.int16: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.int32: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.int64: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + torch.bool: { + torch.float16: True, + torch.float32: True, + torch.float64: True, + torch.complex64: True, + torch.complex128: True, + torch.uint8: True, + torch.int8: True, + torch.int16: True, + torch.int32: True, + torch.int64: True, + torch.bool: True, + }, + }, +} + + +_result_type_dict = { + torch.float16: { + torch.float16: torch.float16, + torch.float32: torch.float32, + torch.float64: torch.float64, + torch.complex64: torch.complex64, + torch.complex128: torch.complex128, + torch.uint8: torch.float16, + torch.int8: torch.float16, + torch.int16: torch.float32, + torch.int32: torch.float64, + torch.int64: torch.float64, + torch.bool: torch.float16, + }, + torch.float32: { + torch.float16: torch.float32, + torch.float32: torch.float32, + torch.float64: torch.float64, + torch.complex64: torch.complex64, + torch.complex128: torch.complex128, + torch.uint8: torch.float32, + torch.int8: torch.float32, + torch.int16: torch.float32, + torch.int32: torch.float64, + torch.int64: torch.float64, + torch.bool: torch.float32, + }, + torch.float64: { + torch.float16: torch.float64, + torch.float32: torch.float64, + torch.float64: torch.float64, + torch.complex64: torch.complex128, + torch.complex128: torch.complex128, + torch.uint8: torch.float64, + torch.int8: torch.float64, + torch.int16: torch.float64, + torch.int32: torch.float64, + torch.int64: torch.float64, + torch.bool: torch.float64, + }, + torch.complex64: { + torch.float16: torch.complex64, + torch.float32: torch.complex64, + torch.float64: torch.complex128, + torch.complex64: torch.complex64, + torch.complex128: torch.complex128, + torch.uint8: torch.complex64, + torch.int8: torch.complex64, + torch.int16: torch.complex64, + torch.int32: torch.complex128, + torch.int64: torch.complex128, + torch.bool: torch.complex64, + }, + torch.complex128: { + torch.float16: torch.complex128, + torch.float32: torch.complex128, + torch.float64: torch.complex128, + torch.complex64: torch.complex128, + torch.complex128: torch.complex128, + torch.uint8: torch.complex128, + torch.int8: torch.complex128, + torch.int16: torch.complex128, + torch.int32: torch.complex128, + torch.int64: torch.complex128, + torch.bool: torch.complex128, + }, + torch.uint8: { + torch.float16: torch.float16, + torch.float32: torch.float32, + torch.float64: torch.float64, + torch.complex64: torch.complex64, + torch.complex128: torch.complex128, + torch.uint8: torch.uint8, + torch.int8: torch.int16, + torch.int16: torch.int16, + torch.int32: torch.int32, + torch.int64: torch.int64, + torch.bool: torch.uint8, + }, + torch.int8: { + torch.float16: torch.float16, + torch.float32: torch.float32, + torch.float64: torch.float64, + torch.complex64: torch.complex64, + torch.complex128: torch.complex128, + torch.uint8: torch.int16, + torch.int8: torch.int8, + torch.int16: torch.int16, + torch.int32: torch.int32, + torch.int64: torch.int64, + torch.bool: torch.int8, + }, + torch.int16: { + torch.float16: torch.float32, + torch.float32: torch.float32, + torch.float64: torch.float64, + torch.complex64: torch.complex64, + torch.complex128: torch.complex128, + torch.uint8: torch.int16, + torch.int8: torch.int16, + torch.int16: torch.int16, + torch.int32: torch.int32, + torch.int64: torch.int64, + torch.bool: torch.int16, + }, + torch.int32: { + torch.float16: torch.float64, + torch.float32: torch.float64, + torch.float64: torch.float64, + torch.complex64: torch.complex128, + torch.complex128: torch.complex128, + torch.uint8: torch.int32, + torch.int8: torch.int32, + torch.int16: torch.int32, + torch.int32: torch.int32, + torch.int64: torch.int64, + torch.bool: torch.int32, + }, + torch.int64: { + torch.float16: torch.float64, + torch.float32: torch.float64, + torch.float64: torch.float64, + torch.complex64: torch.complex128, + torch.complex128: torch.complex128, + torch.uint8: torch.int64, + torch.int8: torch.int64, + torch.int16: torch.int64, + torch.int32: torch.int64, + torch.int64: torch.int64, + torch.bool: torch.int64, + }, + torch.bool: { + torch.float16: torch.float16, + torch.float32: torch.float32, + torch.float64: torch.float64, + torch.complex64: torch.complex64, + torch.complex128: torch.complex128, + torch.uint8: torch.uint8, + torch.int8: torch.int8, + torch.int16: torch.int16, + torch.int32: torch.int32, + torch.int64: torch.int64, + torch.bool: torch.bool, + }, +} diff --git a/shared/package-files/41/41d7bbdf2f62da80eefc257751f2636c3d3eba990c25b9489ff46f708ce2f83e/blob b/shared/package-files/41/41d7bbdf2f62da80eefc257751f2636c3d3eba990c25b9489ff46f708ce2f83e/blob new file mode 100644 index 0000000000000000000000000000000000000000..081be6b67b7ed282606bbe56146dc56e0ea5a7ea --- /dev/null +++ b/shared/package-files/41/41d7bbdf2f62da80eefc257751f2636c3d3eba990c25b9489ff46f708ce2f83e/blob @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.38.4) +Root-Is-Purelib: false +Tag: cp310-cp310-linux_x86_64 + diff --git a/shared/package-files/41/41da0e7eaac03dd6f0b6d2ebcdf01ee7968423665cc787d0850a7a853fe57c5b/blob b/shared/package-files/41/41da0e7eaac03dd6f0b6d2ebcdf01ee7968423665cc787d0850a7a853fe57c5b/blob new file mode 100644 index 0000000000000000000000000000000000000000..445fc954f34842d25c11789d2f9e8537f46eaeb1 Binary files /dev/null and b/shared/package-files/41/41da0e7eaac03dd6f0b6d2ebcdf01ee7968423665cc787d0850a7a853fe57c5b/blob differ diff --git a/shared/package-files/41/41da76f5afb7ce062d248f762463a92f7ca47e4e0f905b224ba6afeef91ded0f/blob b/shared/package-files/41/41da76f5afb7ce062d248f762463a92f7ca47e4e0f905b224ba6afeef91ded0f/blob new file mode 100644 index 0000000000000000000000000000000000000000..d5e2d31c3c88e61f4c204cb6616887bba7e105dd --- /dev/null +++ b/shared/package-files/41/41da76f5afb7ce062d248f762463a92f7ca47e4e0f905b224ba6afeef91ded0f/blob @@ -0,0 +1,58 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://json-schema.org/draft/2020-12/schema", + "$vocabulary": { + "https://json-schema.org/draft/2020-12/vocab/core": true, + "https://json-schema.org/draft/2020-12/vocab/applicator": true, + "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, + "https://json-schema.org/draft/2020-12/vocab/validation": true, + "https://json-schema.org/draft/2020-12/vocab/meta-data": true, + "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, + "https://json-schema.org/draft/2020-12/vocab/content": true + }, + "$dynamicAnchor": "meta", + + "title": "Core and Validation specifications meta-schema", + "allOf": [ + {"$ref": "meta/core"}, + {"$ref": "meta/applicator"}, + {"$ref": "meta/unevaluated"}, + {"$ref": "meta/validation"}, + {"$ref": "meta/meta-data"}, + {"$ref": "meta/format-annotation"}, + {"$ref": "meta/content"} + ], + "type": ["object", "boolean"], + "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.", + "properties": { + "definitions": { + "$comment": "\"definitions\" has been replaced by \"$defs\".", + "type": "object", + "additionalProperties": { "$dynamicRef": "#meta" }, + "deprecated": true, + "default": {} + }, + "dependencies": { + "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.", + "type": "object", + "additionalProperties": { + "anyOf": [ + { "$dynamicRef": "#meta" }, + { "$ref": "meta/validation#/$defs/stringArray" } + ] + }, + "deprecated": true, + "default": {} + }, + "$recursiveAnchor": { + "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".", + "$ref": "meta/core#/$defs/anchorString", + "deprecated": true + }, + "$recursiveRef": { + "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".", + "$ref": "meta/core#/$defs/uriReferenceString", + "deprecated": true + } + } +} diff --git a/shared/package-files/41/41dc9d81c4a6464bff41eb29c21b84fefad74914be7e77d578a78876c6d392e6/blob b/shared/package-files/41/41dc9d81c4a6464bff41eb29c21b84fefad74914be7e77d578a78876c6d392e6/blob new file mode 100644 index 0000000000000000000000000000000000000000..a49cea555f322ad11dbe5ac72db7a173d446f07e --- /dev/null +++ b/shared/package-files/41/41dc9d81c4a6464bff41eb29c21b84fefad74914be7e77d578a78876c6d392e6/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor quantize_per_tensor(const at::Tensor & self, double scale, int64_t zero_point, at::ScalarType dtype); +TORCH_API at::Tensor quantize_per_tensor(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, at::ScalarType dtype); +TORCH_API ::std::vector quantize_per_tensor(at::TensorList tensors, const at::Tensor & scales, const at::Tensor & zero_points, at::ScalarType dtype); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/41/41df4cdb9a30165dd83ae009fcbafe8408759bb6d1c7314412c3960ece8aebc6/blob b/shared/package-files/41/41df4cdb9a30165dd83ae009fcbafe8408759bb6d1c7314412c3960ece8aebc6/blob new file mode 100644 index 0000000000000000000000000000000000000000..46532249550d214723291f7ca9874bb4a31380ac --- /dev/null +++ b/shared/package-files/41/41df4cdb9a30165dd83ae009fcbafe8408759bb6d1c7314412c3960ece8aebc6/blob @@ -0,0 +1,198 @@ +/* Translated into C++ by SciPy developers in 2024. + * Original header with Copyright information appears below. + */ + +/* j1.c + * + * Bessel function of order one + * + * + * + * SYNOPSIS: + * + * double x, y, j1(); + * + * y = j1( x ); + * + * + * + * DESCRIPTION: + * + * Returns Bessel function of order one of the argument. + * + * The domain is divided into the intervals [0, 8] and + * (8, infinity). In the first interval a 24 term Chebyshev + * expansion is used. In the second, the asymptotic + * trigonometric representation is employed using two + * rational functions of degree 5/5. + * + * + * + * ACCURACY: + * + * Absolute error: + * arithmetic domain # trials peak rms + * IEEE 0, 30 30000 2.6e-16 1.1e-16 + * + * + */ +/* y1.c + * + * Bessel function of second kind of order one + * + * + * + * SYNOPSIS: + * + * double x, y, y1(); + * + * y = y1( x ); + * + * + * + * DESCRIPTION: + * + * Returns Bessel function of the second kind of order one + * of the argument. + * + * The domain is divided into the intervals [0, 8] and + * (8, infinity). In the first interval a 25 term Chebyshev + * expansion is used, and a call to j1() is required. + * In the second, the asymptotic trigonometric representation + * is employed using two rational functions of degree 5/5. + * + * + * + * ACCURACY: + * + * Absolute error: + * arithmetic domain # trials peak rms + * IEEE 0, 30 30000 1.0e-15 1.3e-16 + * + * (error criterion relative when |y1| > 1). + * + */ + +/* + * Cephes Math Library Release 2.8: June, 2000 + * Copyright 1984, 1987, 1989, 2000 by Stephen L. Moshier + */ + +/* + * #define PIO4 .78539816339744830962 + * #define THPIO4 2.35619449019234492885 + * #define SQ2OPI .79788456080286535588 + */ +#pragma once + +#include "../config.h" +#include "../error.h" + +#include "const.h" +#include "polevl.h" + +namespace xsf { +namespace cephes { + + namespace detail { + constexpr double j1_RP[4] = { + -8.99971225705559398224E8, + 4.52228297998194034323E11, + -7.27494245221818276015E13, + 3.68295732863852883286E15, + }; + + constexpr double j1_RQ[8] = { + /* 1.00000000000000000000E0, */ + 6.20836478118054335476E2, 2.56987256757748830383E5, 8.35146791431949253037E7, 2.21511595479792499675E10, + 4.74914122079991414898E12, 7.84369607876235854894E14, 8.95222336184627338078E16, 5.32278620332680085395E18, + }; + + constexpr double j1_PP[7] = { + 7.62125616208173112003E-4, 7.31397056940917570436E-2, 1.12719608129684925192E0, 5.11207951146807644818E0, + 8.42404590141772420927E0, 5.21451598682361504063E0, 1.00000000000000000254E0, + }; + + constexpr double j1_PQ[7] = { + 5.71323128072548699714E-4, 6.88455908754495404082E-2, 1.10514232634061696926E0, 5.07386386128601488557E0, + 8.39985554327604159757E0, 5.20982848682361821619E0, 9.99999999999999997461E-1, + }; + + constexpr double j1_QP[8] = { + 5.10862594750176621635E-2, 4.98213872951233449420E0, 7.58238284132545283818E1, 3.66779609360150777800E2, + 7.10856304998926107277E2, 5.97489612400613639965E2, 2.11688757100572135698E2, 2.52070205858023719784E1, + }; + + constexpr double j1_QQ[7] = { + /* 1.00000000000000000000E0, */ + 7.42373277035675149943E1, 1.05644886038262816351E3, 4.98641058337653607651E3, 9.56231892404756170795E3, + 7.99704160447350683650E3, 2.82619278517639096600E3, 3.36093607810698293419E2, + }; + + constexpr double j1_YP[6] = { + 1.26320474790178026440E9, -6.47355876379160291031E11, 1.14509511541823727583E14, + -8.12770255501325109621E15, 2.02439475713594898196E17, -7.78877196265950026825E17, + }; + + constexpr double j1_YQ[8] = { + /* 1.00000000000000000000E0, */ + 5.94301592346128195359E2, 2.35564092943068577943E5, 7.34811944459721705660E7, 1.87601316108706159478E10, + 3.88231277496238566008E12, 6.20557727146953693363E14, 6.87141087355300489866E16, 3.97270608116560655612E18, + }; + + constexpr double j1_Z1 = 1.46819706421238932572E1; + constexpr double j1_Z2 = 4.92184563216946036703E1; + + } // namespace detail + + XSF_HOST_DEVICE inline double j1(double x) { + double w, z, p, q, xn; + + w = x; + if (x < 0) { + return -j1(-x); + } + + if (w <= 5.0) { + z = x * x; + w = polevl(z, detail::j1_RP, 3) / p1evl(z, detail::j1_RQ, 8); + w = w * x * (z - detail::j1_Z1) * (z - detail::j1_Z2); + return (w); + } + + w = 5.0 / x; + z = w * w; + p = polevl(z, detail::j1_PP, 6) / polevl(z, detail::j1_PQ, 6); + q = polevl(z, detail::j1_QP, 7) / p1evl(z, detail::j1_QQ, 7); + xn = x - detail::THPIO4; + p = p * std::cos(xn) - w * q * std::sin(xn); + return (p * detail::SQRT2OPI / std::sqrt(x)); + } + + XSF_HOST_DEVICE inline double y1(double x) { + double w, z, p, q, xn; + + if (x <= 5.0) { + if (x == 0.0) { + set_error("y1", SF_ERROR_SINGULAR, NULL); + return -std::numeric_limits::infinity(); + } else if (x <= 0.0) { + set_error("y1", SF_ERROR_DOMAIN, NULL); + return std::numeric_limits::quiet_NaN(); + } + z = x * x; + w = x * (polevl(z, detail::j1_YP, 5) / p1evl(z, detail::j1_YQ, 8)); + w += M_2_PI * (j1(x) * std::log(x) - 1.0 / x); + return (w); + } + + w = 5.0 / x; + z = w * w; + p = polevl(z, detail::j1_PP, 6) / polevl(z, detail::j1_PQ, 6); + q = polevl(z, detail::j1_QP, 7) / p1evl(z, detail::j1_QQ, 7); + xn = x - detail::THPIO4; + p = p * std::sin(xn) + w * q * std::cos(xn); + return (p * detail::SQRT2OPI / std::sqrt(x)); + } +} // namespace cephes +} // namespace xsf diff --git a/shared/package-files/41/41df97defedabb250b1589cebc2e20b405d409a95d561e4c42b33117d90305aa/blob b/shared/package-files/41/41df97defedabb250b1589cebc2e20b405d409a95d561e4c42b33117d90305aa/blob new file mode 100644 index 0000000000000000000000000000000000000000..93292be59d95dc70f3d4e7a2822da25c7e61b665 --- /dev/null +++ b/shared/package-files/41/41df97defedabb250b1589cebc2e20b405d409a95d561e4c42b33117d90305aa/blob @@ -0,0 +1,348 @@ +315.58 +316.39 +316.79 +317.82 +318.39 +318.22 +316.68 +315.01 +314.02 +313.55 +315.02 +315.75 +316.52 +317.1 +317.79 +319.22 +320.08 +319.7 +318.27 +315.99 +314.24 +314.05 +315.05 +316.23 +316.92 +317.76 +318.54 +319.49 +320.64 +319.85 +318.7 +316.96 +315.17 +315.47 +316.19 +317.17 +318.12 +318.72 +319.79 +320.68 +321.28 +320.89 +319.79 +317.56 +316.46 +315.59 +316.85 +317.87 +318.87 +319.25 +320.13 +321.49 +322.34 +321.62 +319.85 +317.87 +316.36 +316.24 +317.13 +318.46 +319.57 +320.23 +320.89 +321.54 +322.2 +321.9 +320.42 +318.6 +316.73 +317.15 +317.94 +318.91 +319.73 +320.78 +321.23 +322.49 +322.59 +322.35 +321.61 +319.24 +318.23 +317.76 +319.36 +319.5 +320.35 +321.4 +322.22 +323.45 +323.8 +323.5 +322.16 +320.09 +318.26 +317.66 +319.47 +320.7 +322.06 +322.23 +322.78 +324.1 +324.63 +323.79 +322.34 +320.73 +319 +318.99 +320.41 +321.68 +322.3 +322.89 +323.59 +324.65 +325.3 +325.15 +323.88 +321.8 +319.99 +319.86 +320.88 +322.36 +323.59 +324.23 +325.34 +326.33 +327.03 +326.24 +325.39 +323.16 +321.87 +321.31 +322.34 +323.74 +324.61 +325.58 +326.55 +327.81 +327.82 +327.53 +326.29 +324.66 +323.12 +323.09 +324.01 +325.1 +326.12 +326.62 +327.16 +327.94 +329.15 +328.79 +327.53 +325.65 +323.6 +323.78 +325.13 +326.26 +326.93 +327.84 +327.96 +329.93 +330.25 +329.24 +328.13 +326.42 +324.97 +325.29 +326.56 +327.73 +328.73 +329.7 +330.46 +331.7 +332.66 +332.22 +331.02 +329.39 +327.58 +327.27 +328.3 +328.81 +329.44 +330.89 +331.62 +332.85 +333.29 +332.44 +331.35 +329.58 +327.58 +327.55 +328.56 +329.73 +330.45 +330.98 +331.63 +332.88 +333.63 +333.53 +331.9 +330.08 +328.59 +328.31 +329.44 +330.64 +331.62 +332.45 +333.36 +334.46 +334.84 +334.29 +333.04 +330.88 +329.23 +328.83 +330.18 +331.5 +332.8 +333.22 +334.54 +335.82 +336.45 +335.97 +334.65 +332.4 +331.28 +330.73 +332.05 +333.54 +334.65 +335.06 +336.32 +337.39 +337.66 +337.56 +336.24 +334.39 +332.43 +332.22 +333.61 +334.78 +335.88 +336.43 +337.61 +338.53 +339.06 +338.92 +337.39 +335.72 +333.64 +333.65 +335.07 +336.53 +337.82 +338.19 +339.89 +340.56 +341.22 +340.92 +339.26 +337.27 +335.66 +335.54 +336.71 +337.79 +338.79 +340.06 +340.93 +342.02 +342.65 +341.8 +340.01 +337.94 +336.17 +336.28 +337.76 +339.05 +340.18 +341.04 +342.16 +343.01 +343.64 +342.91 +341.72 +339.52 +337.75 +337.68 +339.14 +340.37 +341.32 +342.45 +343.05 +344.91 +345.77 +345.3 +343.98 +342.41 +339.89 +340.03 +341.19 +342.87 +343.74 +344.55 +345.28 +347 +347.37 +346.74 +345.36 +343.19 +340.97 +341.2 +342.76 +343.96 +344.82 +345.82 +347.24 +348.09 +348.66 +347.9 +346.27 +344.21 +342.88 +342.58 +343.99 +345.31 +345.98 +346.72 +347.63 +349.24 +349.83 +349.1 +347.52 +345.43 +344.48 +343.89 +345.29 +346.54 +347.66 +348.07 +349.12 +350.55 +351.34 +350.8 +349.1 +347.54 +346.2 +346.2 +347.44 +348.67 diff --git a/shared/package-files/41/41e02cb261410cf082e5546839b029e1491e6f01133f7a92efe9dae1a72cb563/blob b/shared/package-files/41/41e02cb261410cf082e5546839b029e1491e6f01133f7a92efe9dae1a72cb563/blob new file mode 100644 index 0000000000000000000000000000000000000000..2261a5b6e750f40401ceb3aeb8f6649265bb8396 --- /dev/null +++ b/shared/package-files/41/41e02cb261410cf082e5546839b029e1491e6f01133f7a92efe9dae1a72cb563/blob @@ -0,0 +1,33 @@ +from __future__ import annotations + +from .base import ProgressBar, ProgressBarCounter +from .formatters import ( + Bar, + Formatter, + IterationsPerSecond, + Label, + Percentage, + Progress, + Rainbow, + SpinningWheel, + Text, + TimeElapsed, + TimeLeft, +) + +__all__ = [ + "ProgressBar", + "ProgressBarCounter", + # Formatters. + "Formatter", + "Text", + "Label", + "Percentage", + "Bar", + "Progress", + "TimeElapsed", + "TimeLeft", + "IterationsPerSecond", + "SpinningWheel", + "Rainbow", +] diff --git a/shared/package-files/41/41e0e8878e2d4bfff2f4b2bb2f050101cf920f9452fa984f03879858f979c888/blob b/shared/package-files/41/41e0e8878e2d4bfff2f4b2bb2f050101cf920f9452fa984f03879858f979c888/blob new file mode 100644 index 0000000000000000000000000000000000000000..e7901ed36310668dc21b96d44fed0686de368b1f --- /dev/null +++ b/shared/package-files/41/41e0e8878e2d4bfff2f4b2bb2f050101cf920f9452fa984f03879858f979c888/blob @@ -0,0 +1,64 @@ +import numpy as np +import pytest + +import pandas.util._test_decorators as td + +from pandas import DataFrame +import pandas._testing as tm + + +class TestCopy: + @pytest.mark.parametrize("attr", ["index", "columns"]) + def test_copy_index_name_checking(self, float_frame, attr): + # don't want to be able to modify the index stored elsewhere after + # making a copy + ind = getattr(float_frame, attr) + ind.name = None + cp = float_frame.copy() + getattr(cp, attr).name = "foo" + assert getattr(float_frame, attr).name is None + + @td.skip_copy_on_write_invalid_test + def test_copy_cache(self): + # GH#31784 _item_cache not cleared on copy causes incorrect reads after updates + df = DataFrame({"a": [1]}) + + df["x"] = [0] + df["a"] + + df.copy() + + df["a"].values[0] = -1 + + tm.assert_frame_equal(df, DataFrame({"a": [-1], "x": [0]})) + + df["y"] = [0] + + assert df["a"].values[0] == -1 + tm.assert_frame_equal(df, DataFrame({"a": [-1], "x": [0], "y": [0]})) + + def test_copy(self, float_frame, float_string_frame): + cop = float_frame.copy() + cop["E"] = cop["A"] + assert "E" not in float_frame + + # copy objects + copy = float_string_frame.copy() + assert copy._mgr is not float_string_frame._mgr + + @td.skip_array_manager_invalid_test + def test_copy_consolidates(self): + # GH#42477 + df = DataFrame( + { + "a": np.random.default_rng(2).integers(0, 100, size=55), + "b": np.random.default_rng(2).integers(0, 100, size=55), + } + ) + + for i in range(10): + df.loc[:, f"n_{i}"] = np.random.default_rng(2).integers(0, 100, size=55) + + assert len(df._mgr.blocks) == 11 + result = df.copy() + assert len(result._mgr.blocks) == 1 diff --git a/shared/package-files/41/41e2ffde1a6743801c20aeb7422a454429dd72113c64a1aa8d0afc43d9d1c019/blob b/shared/package-files/41/41e2ffde1a6743801c20aeb7422a454429dd72113c64a1aa8d0afc43d9d1c019/blob new file mode 100644 index 0000000000000000000000000000000000000000..ed7e1a287684b7813592b19060e962511e76ee5d --- /dev/null +++ b/shared/package-files/41/41e2ffde1a6743801c20aeb7422a454429dd72113c64a1aa8d0afc43d9d1c019/blob @@ -0,0 +1,33 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +namespace py = pybind11; + +namespace torch::autograd { + +struct PySavedVariableHooks : public SavedVariableHooks { + PySavedVariableHooks(py::function& pack_hook, py::function& unpack_hook); + void call_pack_hook(const at::Tensor& tensor) override; + at::Tensor call_unpack_hook() override; + ~PySavedVariableHooks() override; + + private: + PyObject* pack_hook_; + PyObject* unpack_hook_; + PyObject* data_ = nullptr; +}; + +struct PyDefaultSavedVariableHooks { + static void push_hooks(py::function& pack_hook, py::function& unpack_hook); + static void pop_hooks(); + static std::unique_ptr get_hooks(); +}; + +} // namespace torch::autograd diff --git a/shared/package-files/41/41e3234dcdb4fc865e552865c4465042cbf6b2e1403eaa6f0fce93047112ca4b/blob b/shared/package-files/41/41e3234dcdb4fc865e552865c4465042cbf6b2e1403eaa6f0fce93047112ca4b/blob new file mode 100644 index 0000000000000000000000000000000000000000..eb3bfca7c293885ad79e052272f0000a8c89c528 --- /dev/null +++ b/shared/package-files/41/41e3234dcdb4fc865e552865c4465042cbf6b2e1403eaa6f0fce93047112ca4b/blob @@ -0,0 +1,1486 @@ +import collections +import io +import itertools +import platform +import time +from unittest import mock +import warnings + +import numpy as np +from numpy.testing import assert_allclose +import pytest + +from matplotlib.testing.decorators import check_figures_equal, image_comparison +from matplotlib.testing._markers import needs_usetex +import matplotlib.pyplot as plt +import matplotlib as mpl +import matplotlib.patches as mpatches +import matplotlib.transforms as mtransforms +import matplotlib.collections as mcollections +import matplotlib.lines as mlines +from matplotlib.legend_handler import HandlerTuple +import matplotlib.legend as mlegend +from matplotlib import rc_context +from matplotlib.font_manager import FontProperties + + +def test_legend_ordereddict(): + # smoketest that ordereddict inputs work... + + X = np.random.randn(10) + Y = np.random.randn(10) + labels = ['a'] * 5 + ['b'] * 5 + colors = ['r'] * 5 + ['g'] * 5 + + fig, ax = plt.subplots() + for x, y, label, color in zip(X, Y, labels, colors): + ax.scatter(x, y, label=label, c=color) + + handles, labels = ax.get_legend_handles_labels() + legend = collections.OrderedDict(zip(labels, handles)) + ax.legend(legend.values(), legend.keys(), + loc='center left', bbox_to_anchor=(1, .5)) + + +def test_legend_generator(): + # smoketest that generator inputs work + fig, ax = plt.subplots() + ax.plot([0, 1]) + ax.plot([0, 2]) + + handles = (line for line in ax.get_lines()) + labels = (label for label in ['spam', 'eggs']) + + ax.legend(handles, labels, loc='upper left') + + +@image_comparison(['legend_auto1.png'], remove_text=True) +def test_legend_auto1(): + """Test automatic legend placement""" + fig, ax = plt.subplots() + x = np.arange(100) + ax.plot(x, 50 - x, 'o', label='y=1') + ax.plot(x, x - 50, 'o', label='y=-1') + ax.legend(loc='best') + + +@image_comparison(['legend_auto2.png'], remove_text=True) +def test_legend_auto2(): + """Test automatic legend placement""" + fig, ax = plt.subplots() + x = np.arange(100) + b1 = ax.bar(x, x, align='edge', color='m') + b2 = ax.bar(x, x[::-1], align='edge', color='g') + ax.legend([b1[0], b2[0]], ['up', 'down'], loc='best') + + +@image_comparison(['legend_auto3.png']) +def test_legend_auto3(): + """Test automatic legend placement""" + fig, ax = plt.subplots() + x = [0.9, 0.1, 0.1, 0.9, 0.9, 0.5] + y = [0.95, 0.95, 0.05, 0.05, 0.5, 0.5] + ax.plot(x, y, 'o-', label='line') + ax.set_xlim(0.0, 1.0) + ax.set_ylim(0.0, 1.0) + ax.legend(loc='best') + + +def test_legend_auto4(): + """ + Check that the legend location with automatic placement is the same, + whatever the histogram type is. Related to issue #9580. + """ + # NB: barstacked is pointless with a single dataset. + fig, axs = plt.subplots(ncols=3, figsize=(6.4, 2.4)) + leg_bboxes = [] + for ax, ht in zip(axs.flat, ('bar', 'step', 'stepfilled')): + ax.set_title(ht) + # A high bar on the left but an even higher one on the right. + ax.hist([0] + 5*[9], bins=range(10), label="Legend", histtype=ht) + leg = ax.legend(loc="best") + fig.canvas.draw() + leg_bboxes.append( + leg.get_window_extent().transformed(ax.transAxes.inverted())) + + # The histogram type "bar" is assumed to be the correct reference. + assert_allclose(leg_bboxes[1].bounds, leg_bboxes[0].bounds) + assert_allclose(leg_bboxes[2].bounds, leg_bboxes[0].bounds) + + +def test_legend_auto5(): + """ + Check that the automatic placement handle a rather complex + case with non rectangular patch. Related to issue #9580. + """ + fig, axs = plt.subplots(ncols=2, figsize=(9.6, 4.8)) + + leg_bboxes = [] + for ax, loc in zip(axs.flat, ("center", "best")): + # An Ellipse patch at the top, a U-shaped Polygon patch at the + # bottom and a ring-like Wedge patch: the correct placement of + # the legend should be in the center. + for _patch in [ + mpatches.Ellipse( + xy=(0.5, 0.9), width=0.8, height=0.2, fc="C1"), + mpatches.Polygon(np.array([ + [0, 1], [0, 0], [1, 0], [1, 1], [0.9, 1.0], [0.9, 0.1], + [0.1, 0.1], [0.1, 1.0], [0.1, 1.0]]), fc="C1"), + mpatches.Wedge((0.5, 0.5), 0.5, 0, 360, width=0.05, fc="C0") + ]: + ax.add_patch(_patch) + + ax.plot([0.1, 0.9], [0.9, 0.9], label="A segment") # sthg to label + + leg = ax.legend(loc=loc) + fig.canvas.draw() + leg_bboxes.append( + leg.get_window_extent().transformed(ax.transAxes.inverted())) + + assert_allclose(leg_bboxes[1].bounds, leg_bboxes[0].bounds) + + +@image_comparison(['legend_various_labels.png'], remove_text=True) +def test_various_labels(): + # tests all sorts of label types + fig = plt.figure() + ax = fig.add_subplot(121) + ax.plot(np.arange(4), 'o', label=1) + ax.plot(np.linspace(4, 4.1), 'o', label='Développés') + ax.plot(np.arange(4, 1, -1), 'o', label='__nolegend__') + ax.legend(numpoints=1, loc='best') + + +@image_comparison(['legend_labels_first.png'], remove_text=True, + tol=0 if platform.machine() == 'x86_64' else 0.013) +def test_labels_first(): + # test labels to left of markers + fig, ax = plt.subplots() + ax.plot(np.arange(10), '-o', label=1) + ax.plot(np.ones(10)*5, ':x', label="x") + ax.plot(np.arange(20, 10, -1), 'd', label="diamond") + ax.legend(loc='best', markerfirst=False) + + +@image_comparison(['legend_multiple_keys.png'], remove_text=True, + tol=0 if platform.machine() == 'x86_64' else 0.013) +def test_multiple_keys(): + # test legend entries with multiple keys + fig, ax = plt.subplots() + p1, = ax.plot([1, 2, 3], '-o') + p2, = ax.plot([2, 3, 4], '-x') + p3, = ax.plot([3, 4, 5], '-d') + ax.legend([(p1, p2), (p2, p1), p3], ['two keys', 'pad=0', 'one key'], + numpoints=1, + handler_map={(p1, p2): HandlerTuple(ndivide=None), + (p2, p1): HandlerTuple(ndivide=None, pad=0)}) + + +@image_comparison(['rgba_alpha.png'], remove_text=True, + tol=0 if platform.machine() == 'x86_64' else 0.03) +def test_alpha_rgba(): + fig, ax = plt.subplots() + ax.plot(range(10), lw=5) + leg = plt.legend(['Longlabel that will go away'], loc='center') + leg.legendPatch.set_facecolor([1, 0, 0, 0.5]) + + +@image_comparison(['rcparam_alpha.png'], remove_text=True, + tol=0 if platform.machine() == 'x86_64' else 0.03) +def test_alpha_rcparam(): + fig, ax = plt.subplots() + ax.plot(range(10), lw=5) + with mpl.rc_context(rc={'legend.framealpha': .75}): + leg = plt.legend(['Longlabel that will go away'], loc='center') + # this alpha is going to be over-ridden by the rcparam with + # sets the alpha of the patch to be non-None which causes the alpha + # value of the face color to be discarded. This behavior may not be + # ideal, but it is what it is and we should keep track of it changing + leg.legendPatch.set_facecolor([1, 0, 0, 0.5]) + + +@image_comparison(['fancy.png'], remove_text=True, tol=0.05) +def test_fancy(): + # Tolerance caused by changing default shadow "shade" from 0.3 to 1 - 0.7 = + # 0.30000000000000004 + # using subplot triggers some offsetbox functionality untested elsewhere + plt.subplot(121) + plt.plot([5] * 10, 'o--', label='XX') + plt.scatter(np.arange(10), np.arange(10, 0, -1), label='XX\nXX') + plt.errorbar(np.arange(10), np.arange(10), xerr=0.5, + yerr=0.5, label='XX') + plt.legend(loc="center left", bbox_to_anchor=[1.0, 0.5], + ncols=2, shadow=True, title="My legend", numpoints=1) + + +@image_comparison(['framealpha'], remove_text=True, + tol=0 if platform.machine() == 'x86_64' else 0.024) +def test_framealpha(): + x = np.linspace(1, 100, 100) + y = x + plt.plot(x, y, label='mylabel', lw=10) + plt.legend(framealpha=0.5) + + +@image_comparison(['scatter_rc3.png', 'scatter_rc1.png'], remove_text=True) +def test_rc(): + # using subplot triggers some offsetbox functionality untested elsewhere + plt.figure() + ax = plt.subplot(121) + ax.scatter(np.arange(10), np.arange(10, 0, -1), label='three') + ax.legend(loc="center left", bbox_to_anchor=[1.0, 0.5], + title="My legend") + + mpl.rcParams['legend.scatterpoints'] = 1 + plt.figure() + ax = plt.subplot(121) + ax.scatter(np.arange(10), np.arange(10, 0, -1), label='one') + ax.legend(loc="center left", bbox_to_anchor=[1.0, 0.5], + title="My legend") + + +@image_comparison(['legend_expand.png'], remove_text=True) +def test_legend_expand(): + """Test expand mode""" + legend_modes = [None, "expand"] + fig, axs = plt.subplots(len(legend_modes), 1) + x = np.arange(100) + for ax, mode in zip(axs, legend_modes): + ax.plot(x, 50 - x, 'o', label='y=1') + l1 = ax.legend(loc='upper left', mode=mode) + ax.add_artist(l1) + ax.plot(x, x - 50, 'o', label='y=-1') + l2 = ax.legend(loc='right', mode=mode) + ax.add_artist(l2) + ax.legend(loc='lower left', mode=mode, ncols=2) + + +@image_comparison(['hatching'], remove_text=True, style='default') +def test_hatching(): + # Remove legend texts when this image is regenerated. + # Remove this line when this test image is regenerated. + plt.rcParams['text.kerning_factor'] = 6 + + fig, ax = plt.subplots() + + # Patches + patch = plt.Rectangle((0, 0), 0.3, 0.3, hatch='xx', + label='Patch\ndefault color\nfilled') + ax.add_patch(patch) + patch = plt.Rectangle((0.33, 0), 0.3, 0.3, hatch='||', edgecolor='C1', + label='Patch\nexplicit color\nfilled') + ax.add_patch(patch) + patch = plt.Rectangle((0, 0.4), 0.3, 0.3, hatch='xx', fill=False, + label='Patch\ndefault color\nunfilled') + ax.add_patch(patch) + patch = plt.Rectangle((0.33, 0.4), 0.3, 0.3, hatch='||', fill=False, + edgecolor='C1', + label='Patch\nexplicit color\nunfilled') + ax.add_patch(patch) + + # Paths + ax.fill_between([0, .15, .3], [.8, .8, .8], [.9, 1.0, .9], + hatch='+', label='Path\ndefault color') + ax.fill_between([.33, .48, .63], [.8, .8, .8], [.9, 1.0, .9], + hatch='+', edgecolor='C2', label='Path\nexplicit color') + + ax.set_xlim(-0.01, 1.1) + ax.set_ylim(-0.01, 1.1) + ax.legend(handlelength=4, handleheight=4) + + +def test_legend_remove(): + fig, ax = plt.subplots() + lines = ax.plot(range(10)) + leg = fig.legend(lines, "test") + leg.remove() + assert fig.legends == [] + leg = ax.legend("test") + leg.remove() + assert ax.get_legend() is None + + +def test_reverse_legend_handles_and_labels(): + """Check that the legend handles and labels are reversed.""" + fig, ax = plt.subplots() + x = 1 + y = 1 + labels = ["First label", "Second label", "Third label"] + markers = ['.', ',', 'o'] + + ax.plot(x, y, markers[0], label=labels[0]) + ax.plot(x, y, markers[1], label=labels[1]) + ax.plot(x, y, markers[2], label=labels[2]) + leg = ax.legend(reverse=True) + actual_labels = [t.get_text() for t in leg.get_texts()] + actual_markers = [h.get_marker() for h in leg.legend_handles] + assert actual_labels == list(reversed(labels)) + assert actual_markers == list(reversed(markers)) + + +@check_figures_equal(extensions=["png"]) +def test_reverse_legend_display(fig_test, fig_ref): + """Check that the rendered legend entries are reversed""" + ax = fig_test.subplots() + ax.plot([1], 'ro', label="first") + ax.plot([2], 'bx', label="second") + ax.legend(reverse=True) + + ax = fig_ref.subplots() + ax.plot([2], 'bx', label="second") + ax.plot([1], 'ro', label="first") + ax.legend() + + +class TestLegendFunction: + # Tests the legend function on the Axes and pyplot. + def test_legend_no_args(self): + lines = plt.plot(range(10), label='hello world') + with mock.patch('matplotlib.legend.Legend') as Legend: + plt.legend() + Legend.assert_called_with(plt.gca(), lines, ['hello world']) + + def test_legend_positional_handles_labels(self): + lines = plt.plot(range(10)) + with mock.patch('matplotlib.legend.Legend') as Legend: + plt.legend(lines, ['hello world']) + Legend.assert_called_with(plt.gca(), lines, ['hello world']) + + def test_legend_positional_handles_only(self): + lines = plt.plot(range(10)) + with pytest.raises(TypeError, match='but found an Artist'): + # a single arg is interpreted as labels + # it's a common error to just pass handles + plt.legend(lines) + + def test_legend_positional_labels_only(self): + lines = plt.plot(range(10), label='hello world') + with mock.patch('matplotlib.legend.Legend') as Legend: + plt.legend(['foobar']) + Legend.assert_called_with(plt.gca(), lines, ['foobar']) + + def test_legend_three_args(self): + lines = plt.plot(range(10), label='hello world') + with mock.patch('matplotlib.legend.Legend') as Legend: + plt.legend(lines, ['foobar'], loc='right') + Legend.assert_called_with(plt.gca(), lines, ['foobar'], loc='right') + + def test_legend_handler_map(self): + lines = plt.plot(range(10), label='hello world') + with mock.patch('matplotlib.legend.' + '_get_legend_handles_labels') as handles_labels: + handles_labels.return_value = lines, ['hello world'] + plt.legend(handler_map={'1': 2}) + handles_labels.assert_called_with([plt.gca()], {'1': 2}) + + def test_legend_kwargs_handles_only(self): + fig, ax = plt.subplots() + x = np.linspace(0, 1, 11) + ln1, = ax.plot(x, x, label='x') + ln2, = ax.plot(x, 2*x, label='2x') + ln3, = ax.plot(x, 3*x, label='3x') + with mock.patch('matplotlib.legend.Legend') as Legend: + ax.legend(handles=[ln3, ln2]) # reversed and not ln1 + Legend.assert_called_with(ax, [ln3, ln2], ['3x', '2x']) + + def test_legend_kwargs_labels_only(self): + fig, ax = plt.subplots() + x = np.linspace(0, 1, 11) + ln1, = ax.plot(x, x) + ln2, = ax.plot(x, 2*x) + with mock.patch('matplotlib.legend.Legend') as Legend: + ax.legend(labels=['x', '2x']) + Legend.assert_called_with(ax, [ln1, ln2], ['x', '2x']) + + def test_legend_kwargs_handles_labels(self): + fig, ax = plt.subplots() + th = np.linspace(0, 2*np.pi, 1024) + lns, = ax.plot(th, np.sin(th), label='sin') + lnc, = ax.plot(th, np.cos(th), label='cos') + with mock.patch('matplotlib.legend.Legend') as Legend: + # labels of lns, lnc are overwritten with explicit ('a', 'b') + ax.legend(labels=('a', 'b'), handles=(lnc, lns)) + Legend.assert_called_with(ax, (lnc, lns), ('a', 'b')) + + def test_warn_mixed_args_and_kwargs(self): + fig, ax = plt.subplots() + th = np.linspace(0, 2*np.pi, 1024) + lns, = ax.plot(th, np.sin(th), label='sin') + lnc, = ax.plot(th, np.cos(th), label='cos') + with pytest.warns(DeprecationWarning) as record: + ax.legend((lnc, lns), labels=('a', 'b')) + assert len(record) == 1 + assert str(record[0].message).startswith( + "You have mixed positional and keyword arguments, some input may " + "be discarded.") + + def test_parasite(self): + from mpl_toolkits.axes_grid1 import host_subplot # type: ignore[import] + + host = host_subplot(111) + par = host.twinx() + + p1, = host.plot([0, 1, 2], [0, 1, 2], label="Density") + p2, = par.plot([0, 1, 2], [0, 3, 2], label="Temperature") + + with mock.patch('matplotlib.legend.Legend') as Legend: + plt.legend() + Legend.assert_called_with(host, [p1, p2], ['Density', 'Temperature']) + + +class TestLegendFigureFunction: + # Tests the legend function for figure + def test_legend_handle_label(self): + fig, ax = plt.subplots() + lines = ax.plot(range(10)) + with mock.patch('matplotlib.legend.Legend') as Legend: + fig.legend(lines, ['hello world']) + Legend.assert_called_with(fig, lines, ['hello world'], + bbox_transform=fig.transFigure) + + def test_legend_no_args(self): + fig, ax = plt.subplots() + lines = ax.plot(range(10), label='hello world') + with mock.patch('matplotlib.legend.Legend') as Legend: + fig.legend() + Legend.assert_called_with(fig, lines, ['hello world'], + bbox_transform=fig.transFigure) + + def test_legend_label_arg(self): + fig, ax = plt.subplots() + lines = ax.plot(range(10)) + with mock.patch('matplotlib.legend.Legend') as Legend: + fig.legend(['foobar']) + Legend.assert_called_with(fig, lines, ['foobar'], + bbox_transform=fig.transFigure) + + def test_legend_label_three_args(self): + fig, ax = plt.subplots() + lines = ax.plot(range(10)) + with pytest.raises(TypeError, match="0-2"): + fig.legend(lines, ['foobar'], 'right') + with pytest.raises(TypeError, match="0-2"): + fig.legend(lines, ['foobar'], 'right', loc='left') + + def test_legend_kw_args(self): + fig, axs = plt.subplots(1, 2) + lines = axs[0].plot(range(10)) + lines2 = axs[1].plot(np.arange(10) * 2.) + with mock.patch('matplotlib.legend.Legend') as Legend: + fig.legend(loc='right', labels=('a', 'b'), handles=(lines, lines2)) + Legend.assert_called_with( + fig, (lines, lines2), ('a', 'b'), loc='right', + bbox_transform=fig.transFigure) + + def test_warn_args_kwargs(self): + fig, axs = plt.subplots(1, 2) + lines = axs[0].plot(range(10)) + lines2 = axs[1].plot(np.arange(10) * 2.) + with pytest.warns(DeprecationWarning) as record: + fig.legend((lines, lines2), labels=('a', 'b')) + assert len(record) == 1 + assert str(record[0].message).startswith( + "You have mixed positional and keyword arguments, some input may " + "be discarded.") + + +def test_figure_legend_outside(): + todos = ['upper ' + pos for pos in ['left', 'center', 'right']] + todos += ['lower ' + pos for pos in ['left', 'center', 'right']] + todos += ['left ' + pos for pos in ['lower', 'center', 'upper']] + todos += ['right ' + pos for pos in ['lower', 'center', 'upper']] + + upperext = [20.347556, 27.722556, 790.583, 545.499] + lowerext = [20.347556, 71.056556, 790.583, 588.833] + leftext = [151.681556, 27.722556, 790.583, 588.833] + rightext = [20.347556, 27.722556, 659.249, 588.833] + axbb = [upperext, upperext, upperext, + lowerext, lowerext, lowerext, + leftext, leftext, leftext, + rightext, rightext, rightext] + + legbb = [[10., 555., 133., 590.], # upper left + [338.5, 555., 461.5, 590.], # upper center + [667, 555., 790., 590.], # upper right + [10., 10., 133., 45.], # lower left + [338.5, 10., 461.5, 45.], # lower center + [667., 10., 790., 45.], # lower right + [10., 10., 133., 45.], # left lower + [10., 282.5, 133., 317.5], # left center + [10., 555., 133., 590.], # left upper + [667, 10., 790., 45.], # right lower + [667., 282.5, 790., 317.5], # right center + [667., 555., 790., 590.]] # right upper + + for nn, todo in enumerate(todos): + print(todo) + fig, axs = plt.subplots(constrained_layout=True, dpi=100) + axs.plot(range(10), label='Boo1') + leg = fig.legend(loc='outside ' + todo) + fig.draw_without_rendering() + + assert_allclose(axs.get_window_extent().extents, + axbb[nn]) + assert_allclose(leg.get_window_extent().extents, + legbb[nn]) + + +@image_comparison(['legend_stackplot.png'], + tol=0 if platform.machine() == 'x86_64' else 0.031) +def test_legend_stackplot(): + """Test legend for PolyCollection using stackplot.""" + # related to #1341, #1943, and PR #3303 + fig, ax = plt.subplots() + x = np.linspace(0, 10, 10) + y1 = 1.0 * x + y2 = 2.0 * x + 1 + y3 = 3.0 * x + 2 + ax.stackplot(x, y1, y2, y3, labels=['y1', 'y2', 'y3']) + ax.set_xlim((0, 10)) + ax.set_ylim((0, 70)) + ax.legend(loc='best') + + +def test_cross_figure_patch_legend(): + fig, ax = plt.subplots() + fig2, ax2 = plt.subplots() + + brs = ax.bar(range(3), range(3)) + fig2.legend(brs, 'foo') + + +def test_nanscatter(): + fig, ax = plt.subplots() + + h = ax.scatter([np.nan], [np.nan], marker="o", + facecolor="r", edgecolor="r", s=3) + + ax.legend([h], ["scatter"]) + + fig, ax = plt.subplots() + for color in ['red', 'green', 'blue']: + n = 750 + x, y = np.random.rand(2, n) + scale = 200.0 * np.random.rand(n) + ax.scatter(x, y, c=color, s=scale, label=color, + alpha=0.3, edgecolors='none') + + ax.legend() + ax.grid(True) + + +def test_legend_repeatcheckok(): + fig, ax = plt.subplots() + ax.scatter(0.0, 1.0, color='k', marker='o', label='test') + ax.scatter(0.5, 0.0, color='r', marker='v', label='test') + ax.legend() + hand, lab = mlegend._get_legend_handles_labels([ax]) + assert len(lab) == 2 + fig, ax = plt.subplots() + ax.scatter(0.0, 1.0, color='k', marker='o', label='test') + ax.scatter(0.5, 0.0, color='k', marker='v', label='test') + ax.legend() + hand, lab = mlegend._get_legend_handles_labels([ax]) + assert len(lab) == 2 + + +@image_comparison(['not_covering_scatter.png']) +def test_not_covering_scatter(): + colors = ['b', 'g', 'r'] + + for n in range(3): + plt.scatter([n], [n], color=colors[n]) + + plt.legend(['foo', 'foo', 'foo'], loc='best') + plt.gca().set_xlim(-0.5, 2.2) + plt.gca().set_ylim(-0.5, 2.2) + + +@image_comparison(['not_covering_scatter_transform.png']) +def test_not_covering_scatter_transform(): + # Offsets point to top left, the default auto position + offset = mtransforms.Affine2D().translate(-20, 20) + x = np.linspace(0, 30, 1000) + plt.plot(x, x) + + plt.scatter([20], [10], transform=offset + plt.gca().transData) + + plt.legend(['foo', 'bar'], loc='best') + + +def test_linecollection_scaled_dashes(): + lines1 = [[(0, .5), (.5, 1)], [(.3, .6), (.2, .2)]] + lines2 = [[[0.7, .2], [.8, .4]], [[.5, .7], [.6, .1]]] + lines3 = [[[0.6, .2], [.8, .4]], [[.5, .7], [.1, .1]]] + lc1 = mcollections.LineCollection(lines1, linestyles="--", lw=3) + lc2 = mcollections.LineCollection(lines2, linestyles="-.") + lc3 = mcollections.LineCollection(lines3, linestyles=":", lw=.5) + + fig, ax = plt.subplots() + ax.add_collection(lc1) + ax.add_collection(lc2) + ax.add_collection(lc3) + + leg = ax.legend([lc1, lc2, lc3], ["line1", "line2", 'line 3']) + h1, h2, h3 = leg.legend_handles + + for oh, lh in zip((lc1, lc2, lc3), (h1, h2, h3)): + assert oh.get_linestyles()[0] == lh._dash_pattern + + +def test_handler_numpoints(): + """Test legend handler with numpoints <= 1.""" + # related to #6921 and PR #8478 + fig, ax = plt.subplots() + ax.plot(range(5), label='test') + ax.legend(numpoints=0.5) + + +def test_text_nohandler_warning(): + """Test that Text artists with labels raise a warning""" + fig, ax = plt.subplots() + ax.plot([0], label="mock data") + ax.text(x=0, y=0, s="text", label="label") + with pytest.warns(UserWarning) as record: + ax.legend() + assert len(record) == 1 + + # this should _not_ warn: + f, ax = plt.subplots() + ax.pcolormesh(np.random.uniform(0, 1, (10, 10))) + with warnings.catch_warnings(): + warnings.simplefilter("error") + ax.get_legend_handles_labels() + + +def test_empty_bar_chart_with_legend(): + """Test legend when bar chart is empty with a label.""" + # related to issue #13003. Calling plt.legend() should not + # raise an IndexError. + plt.bar([], [], label='test') + plt.legend() + + +@image_comparison(['shadow_argument_types.png'], remove_text=True, style='mpl20', + tol=0 if platform.machine() == 'x86_64' else 0.028) +def test_shadow_argument_types(): + # Test that different arguments for shadow work as expected + fig, ax = plt.subplots() + ax.plot([1, 2, 3], label='test') + + # Test various shadow configurations + # as well as different ways of specifying colors + legs = (ax.legend(loc='upper left', shadow=True), # True + ax.legend(loc='upper right', shadow=False), # False + ax.legend(loc='center left', # string + shadow={'color': 'red', 'alpha': 0.1}), + ax.legend(loc='center right', # tuple + shadow={'color': (0.1, 0.2, 0.5), 'oy': -5}), + ax.legend(loc='lower left', # tab + shadow={'color': 'tab:cyan', 'ox': 10}) + ) + for l in legs: + ax.add_artist(l) + ax.legend(loc='lower right') # default + + +def test_shadow_invalid_argument(): + # Test if invalid argument to legend shadow + # (i.e. not [color|bool]) raises ValueError + fig, ax = plt.subplots() + ax.plot([1, 2, 3], label='test') + with pytest.raises(ValueError, match="dict or bool"): + ax.legend(loc="upper left", shadow="aardvark") # Bad argument + + +def test_shadow_framealpha(): + # Test if framealpha is activated when shadow is True + # and framealpha is not explicitly passed''' + fig, ax = plt.subplots() + ax.plot(range(100), label="test") + leg = ax.legend(shadow=True, facecolor='w') + assert leg.get_frame().get_alpha() == 1 + + +def test_legend_title_empty(): + # test that if we don't set the legend title, that + # it comes back as an empty string, and that it is not + # visible: + fig, ax = plt.subplots() + ax.plot(range(10), label="mock data") + leg = ax.legend() + assert leg.get_title().get_text() == "" + assert not leg.get_title().get_visible() + + +def test_legend_proper_window_extent(): + # test that legend returns the expected extent under various dpi... + fig, ax = plt.subplots(dpi=100) + ax.plot(range(10), label='Aardvark') + leg = ax.legend() + x01 = leg.get_window_extent(fig.canvas.get_renderer()).x0 + + fig, ax = plt.subplots(dpi=200) + ax.plot(range(10), label='Aardvark') + leg = ax.legend() + x02 = leg.get_window_extent(fig.canvas.get_renderer()).x0 + assert pytest.approx(x01*2, 0.1) == x02 + + +def test_window_extent_cached_renderer(): + fig, ax = plt.subplots(dpi=100) + ax.plot(range(10), label='Aardvark') + leg = ax.legend() + leg2 = fig.legend() + fig.canvas.draw() + # check that get_window_extent will use the cached renderer + leg.get_window_extent() + leg2.get_window_extent() + + +def test_legend_title_fontprop_fontsize(): + # test the title_fontsize kwarg + plt.plot(range(10), label="mock data") + with pytest.raises(ValueError): + plt.legend(title='Aardvark', title_fontsize=22, + title_fontproperties={'family': 'serif', 'size': 22}) + + leg = plt.legend(title='Aardvark', title_fontproperties=FontProperties( + family='serif', size=22)) + assert leg.get_title().get_size() == 22 + + fig, axes = plt.subplots(2, 3, figsize=(10, 6)) + axes = axes.flat + axes[0].plot(range(10), label="mock data") + leg0 = axes[0].legend(title='Aardvark', title_fontsize=22) + assert leg0.get_title().get_fontsize() == 22 + axes[1].plot(range(10), label="mock data") + leg1 = axes[1].legend(title='Aardvark', + title_fontproperties={'family': 'serif', 'size': 22}) + assert leg1.get_title().get_fontsize() == 22 + axes[2].plot(range(10), label="mock data") + mpl.rcParams['legend.title_fontsize'] = None + leg2 = axes[2].legend(title='Aardvark', + title_fontproperties={'family': 'serif'}) + assert leg2.get_title().get_fontsize() == mpl.rcParams['font.size'] + axes[3].plot(range(10), label="mock data") + leg3 = axes[3].legend(title='Aardvark') + assert leg3.get_title().get_fontsize() == mpl.rcParams['font.size'] + axes[4].plot(range(10), label="mock data") + mpl.rcParams['legend.title_fontsize'] = 20 + leg4 = axes[4].legend(title='Aardvark', + title_fontproperties={'family': 'serif'}) + assert leg4.get_title().get_fontsize() == 20 + axes[5].plot(range(10), label="mock data") + leg5 = axes[5].legend(title='Aardvark') + assert leg5.get_title().get_fontsize() == 20 + + +@pytest.mark.parametrize('alignment', ('center', 'left', 'right')) +def test_legend_alignment(alignment): + fig, ax = plt.subplots() + ax.plot(range(10), label='test') + leg = ax.legend(title="Aardvark", alignment=alignment) + assert leg.get_children()[0].align == alignment + assert leg.get_alignment() == alignment + + +@pytest.mark.parametrize('loc', ('center', 'best',)) +def test_ax_legend_set_loc(loc): + fig, ax = plt.subplots() + ax.plot(range(10), label='test') + leg = ax.legend() + leg.set_loc(loc) + assert leg._get_loc() == mlegend.Legend.codes[loc] + + +@pytest.mark.parametrize('loc', ('outside right', 'right',)) +def test_fig_legend_set_loc(loc): + fig, ax = plt.subplots() + ax.plot(range(10), label='test') + leg = fig.legend() + leg.set_loc(loc) + + loc = loc.split()[1] if loc.startswith("outside") else loc + assert leg._get_loc() == mlegend.Legend.codes[loc] + + +@pytest.mark.parametrize('alignment', ('center', 'left', 'right')) +def test_legend_set_alignment(alignment): + fig, ax = plt.subplots() + ax.plot(range(10), label='test') + leg = ax.legend() + leg.set_alignment(alignment) + assert leg.get_children()[0].align == alignment + assert leg.get_alignment() == alignment + + +@pytest.mark.parametrize('color', ('red', 'none', (.5, .5, .5))) +def test_legend_labelcolor_single(color): + # test labelcolor for a single color + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1') + ax.plot(np.arange(10), np.arange(10)*2, label='#2') + ax.plot(np.arange(10), np.arange(10)*3, label='#3') + + leg = ax.legend(labelcolor=color) + for text in leg.get_texts(): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_list(): + # test labelcolor for a list of colors + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1') + ax.plot(np.arange(10), np.arange(10)*2, label='#2') + ax.plot(np.arange(10), np.arange(10)*3, label='#3') + + leg = ax.legend(labelcolor=['r', 'g', 'b']) + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_linecolor(): + # test the labelcolor for labelcolor='linecolor' + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', color='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', color='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', color='b') + + leg = ax.legend(labelcolor='linecolor') + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_linecolor(): + # test the labelcolor for labelcolor='linecolor' on PathCollection + fig, ax = plt.subplots() + ax.scatter(np.arange(10), np.arange(10)*1, label='#1', c='r') + ax.scatter(np.arange(10), np.arange(10)*2, label='#2', c='g') + ax.scatter(np.arange(10), np.arange(10)*3, label='#3', c='b') + + leg = ax.legend(labelcolor='linecolor') + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_linecolor_iterable(): + # test the labelcolor for labelcolor='linecolor' on PathCollection + # with iterable colors + fig, ax = plt.subplots() + colors = np.array(['r', 'g', 'b', 'c', 'm'] * 2) + ax.scatter(np.arange(10), np.arange(10), label='#1', c=colors) + + leg = ax.legend(labelcolor='linecolor') + text, = leg.get_texts() + assert mpl.colors.same_color(text.get_color(), 'black') + + +def test_legend_pathcollection_labelcolor_linecolor_cmap(): + # test the labelcolor for labelcolor='linecolor' on PathCollection + # with a colormap + fig, ax = plt.subplots() + ax.scatter(np.arange(10), np.arange(10), c=np.arange(10), label='#1') + + leg = ax.legend(labelcolor='linecolor') + text, = leg.get_texts() + assert mpl.colors.same_color(text.get_color(), 'black') + + +def test_legend_labelcolor_markeredgecolor(): + # test the labelcolor for labelcolor='markeredgecolor' + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', markeredgecolor='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', markeredgecolor='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', markeredgecolor='b') + + leg = ax.legend(labelcolor='markeredgecolor') + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_markeredgecolor(): + # test the labelcolor for labelcolor='markeredgecolor' on PathCollection + fig, ax = plt.subplots() + ax.scatter(np.arange(10), np.arange(10)*1, label='#1', edgecolor='r') + ax.scatter(np.arange(10), np.arange(10)*2, label='#2', edgecolor='g') + ax.scatter(np.arange(10), np.arange(10)*3, label='#3', edgecolor='b') + + leg = ax.legend(labelcolor='markeredgecolor') + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_markeredgecolor_iterable(): + # test the labelcolor for labelcolor='markeredgecolor' on PathCollection + # with iterable colors + fig, ax = plt.subplots() + colors = np.array(['r', 'g', 'b', 'c', 'm'] * 2) + ax.scatter(np.arange(10), np.arange(10), label='#1', edgecolor=colors) + + leg = ax.legend(labelcolor='markeredgecolor') + for text, color in zip(leg.get_texts(), ['k']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_markeredgecolor_cmap(): + # test the labelcolor for labelcolor='markeredgecolor' on PathCollection + # with a colormap + fig, ax = plt.subplots() + edgecolors = mpl.cm.viridis(np.random.rand(10)) + ax.scatter( + np.arange(10), + np.arange(10), + label='#1', + c=np.arange(10), + edgecolor=edgecolors, + cmap="Reds" + ) + + leg = ax.legend(labelcolor='markeredgecolor') + for text, color in zip(leg.get_texts(), ['k']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_markerfacecolor(): + # test the labelcolor for labelcolor='markerfacecolor' + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', markerfacecolor='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', markerfacecolor='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', markerfacecolor='b') + + leg = ax.legend(labelcolor='markerfacecolor') + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_markerfacecolor(): + # test the labelcolor for labelcolor='markerfacecolor' on PathCollection + fig, ax = plt.subplots() + ax.scatter(np.arange(10), np.arange(10)*1, label='#1', facecolor='r') + ax.scatter(np.arange(10), np.arange(10)*2, label='#2', facecolor='g') + ax.scatter(np.arange(10), np.arange(10)*3, label='#3', facecolor='b') + + leg = ax.legend(labelcolor='markerfacecolor') + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_markerfacecolor_iterable(): + # test the labelcolor for labelcolor='markerfacecolor' on PathCollection + # with iterable colors + fig, ax = plt.subplots() + colors = np.array(['r', 'g', 'b', 'c', 'm'] * 2) + ax.scatter(np.arange(10), np.arange(10), label='#1', facecolor=colors) + + leg = ax.legend(labelcolor='markerfacecolor') + for text, color in zip(leg.get_texts(), ['k']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_pathcollection_labelcolor_markfacecolor_cmap(): + # test the labelcolor for labelcolor='markerfacecolor' on PathCollection + # with colormaps + fig, ax = plt.subplots() + colors = mpl.cm.viridis(np.random.rand(10)) + ax.scatter( + np.arange(10), + np.arange(10), + label='#1', + c=colors + ) + + leg = ax.legend(labelcolor='markerfacecolor') + for text, color in zip(leg.get_texts(), ['k']): + assert mpl.colors.same_color(text.get_color(), color) + + +@pytest.mark.parametrize('color', ('red', 'none', (.5, .5, .5))) +def test_legend_labelcolor_rcparam_single(color): + # test the rcParams legend.labelcolor for a single color + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1') + ax.plot(np.arange(10), np.arange(10)*2, label='#2') + ax.plot(np.arange(10), np.arange(10)*3, label='#3') + + mpl.rcParams['legend.labelcolor'] = color + leg = ax.legend() + for text in leg.get_texts(): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_rcparam_linecolor(): + # test the rcParams legend.labelcolor for a linecolor + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', color='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', color='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', color='b') + + mpl.rcParams['legend.labelcolor'] = 'linecolor' + leg = ax.legend() + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_rcparam_markeredgecolor(): + # test the labelcolor for labelcolor='markeredgecolor' + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', markeredgecolor='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', markeredgecolor='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', markeredgecolor='b') + + mpl.rcParams['legend.labelcolor'] = 'markeredgecolor' + leg = ax.legend() + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_rcparam_markeredgecolor_short(): + # test the labelcolor for labelcolor='markeredgecolor' + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', markeredgecolor='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', markeredgecolor='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', markeredgecolor='b') + + mpl.rcParams['legend.labelcolor'] = 'mec' + leg = ax.legend() + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_rcparam_markerfacecolor(): + # test the labelcolor for labelcolor='markeredgecolor' + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', markerfacecolor='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', markerfacecolor='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', markerfacecolor='b') + + mpl.rcParams['legend.labelcolor'] = 'markerfacecolor' + leg = ax.legend() + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +def test_legend_labelcolor_rcparam_markerfacecolor_short(): + # test the labelcolor for labelcolor='markeredgecolor' + fig, ax = plt.subplots() + ax.plot(np.arange(10), np.arange(10)*1, label='#1', markerfacecolor='r') + ax.plot(np.arange(10), np.arange(10)*2, label='#2', markerfacecolor='g') + ax.plot(np.arange(10), np.arange(10)*3, label='#3', markerfacecolor='b') + + mpl.rcParams['legend.labelcolor'] = 'mfc' + leg = ax.legend() + for text, color in zip(leg.get_texts(), ['r', 'g', 'b']): + assert mpl.colors.same_color(text.get_color(), color) + + +@pytest.mark.filterwarnings("ignore:No artists with labels found to put in legend") +def test_get_set_draggable(): + legend = plt.legend() + assert not legend.get_draggable() + legend.set_draggable(True) + assert legend.get_draggable() + legend.set_draggable(False) + assert not legend.get_draggable() + + +@pytest.mark.parametrize('draggable', (True, False)) +def test_legend_draggable(draggable): + fig, ax = plt.subplots() + ax.plot(range(10), label='shabnams') + leg = ax.legend(draggable=draggable) + assert leg.get_draggable() is draggable + + +def test_alpha_handles(): + x, n, hh = plt.hist([1, 2, 3], alpha=0.25, label='data', color='red') + legend = plt.legend() + for lh in legend.legend_handles: + lh.set_alpha(1.0) + assert lh.get_facecolor()[:-1] == hh[1].get_facecolor()[:-1] + assert lh.get_edgecolor()[:-1] == hh[1].get_edgecolor()[:-1] + + +@needs_usetex +def test_usetex_no_warn(caplog): + mpl.rcParams['font.family'] = 'serif' + mpl.rcParams['font.serif'] = 'Computer Modern' + mpl.rcParams['text.usetex'] = True + + fig, ax = plt.subplots() + ax.plot(0, 0, label='input') + ax.legend(title="My legend") + + fig.canvas.draw() + assert "Font family ['serif'] not found." not in caplog.text + + +def test_warn_big_data_best_loc(monkeypatch): + # Force _find_best_position to think it took a long time. + counter = itertools.count(0, step=1.5) + monkeypatch.setattr(time, 'perf_counter', lambda: next(counter)) + + fig, ax = plt.subplots() + fig.canvas.draw() # So that we can call draw_artist later. + + # Place line across all possible legend locations. + x = [0.9, 0.1, 0.1, 0.9, 0.9, 0.5] + y = [0.95, 0.95, 0.05, 0.05, 0.5, 0.5] + ax.plot(x, y, 'o-', label='line') + + with rc_context({'legend.loc': 'best'}): + legend = ax.legend() + with pytest.warns(UserWarning, + match='Creating legend with loc="best" can be slow with large ' + 'amounts of data.') as records: + fig.draw_artist(legend) # Don't bother drawing the lines -- it's slow. + # The _find_best_position method of Legend is called twice, duplicating + # the warning message. + assert len(records) == 2 + + +def test_no_warn_big_data_when_loc_specified(monkeypatch): + # Force _find_best_position to think it took a long time. + counter = itertools.count(0, step=1.5) + monkeypatch.setattr(time, 'perf_counter', lambda: next(counter)) + + fig, ax = plt.subplots() + fig.canvas.draw() + + # Place line across all possible legend locations. + x = [0.9, 0.1, 0.1, 0.9, 0.9, 0.5] + y = [0.95, 0.95, 0.05, 0.05, 0.5, 0.5] + ax.plot(x, y, 'o-', label='line') + + legend = ax.legend('best') + fig.draw_artist(legend) # Check that no warning is emitted. + + +@pytest.mark.parametrize('label_array', [['low', 'high'], + ('low', 'high'), + np.array(['low', 'high'])]) +def test_plot_multiple_input_multiple_label(label_array): + # test ax.plot() with multidimensional input + # and multiple labels + x = [1, 2, 3] + y = [[1, 2], + [2, 5], + [4, 9]] + + fig, ax = plt.subplots() + ax.plot(x, y, label=label_array) + leg = ax.legend() + legend_texts = [entry.get_text() for entry in leg.get_texts()] + assert legend_texts == ['low', 'high'] + + +@pytest.mark.parametrize('label', ['one', 1, int]) +def test_plot_multiple_input_single_label(label): + # test ax.plot() with multidimensional input + # and single label + x = [1, 2, 3] + y = [[1, 2], + [2, 5], + [4, 9]] + + fig, ax = plt.subplots() + ax.plot(x, y, label=label) + leg = ax.legend() + legend_texts = [entry.get_text() for entry in leg.get_texts()] + assert legend_texts == [str(label)] * 2 + + +@pytest.mark.parametrize('label_array', [['low', 'high'], + ('low', 'high'), + np.array(['low', 'high'])]) +def test_plot_single_input_multiple_label(label_array): + # test ax.plot() with 1D array like input + # and iterable label + x = [1, 2, 3] + y = [2, 5, 6] + fig, ax = plt.subplots() + with pytest.warns(mpl.MatplotlibDeprecationWarning, + match='Passing label as a length 2 sequence'): + ax.plot(x, y, label=label_array) + leg = ax.legend() + assert len(leg.get_texts()) == 1 + assert leg.get_texts()[0].get_text() == str(label_array) + + +def test_plot_single_input_list_label(): + fig, ax = plt.subplots() + line, = ax.plot([[0], [1]], label=['A']) + assert line.get_label() == 'A' + + +def test_plot_multiple_label_incorrect_length_exception(): + # check that exception is raised if multiple labels + # are given, but number of on labels != number of lines + with pytest.raises(ValueError): + x = [1, 2, 3] + y = [[1, 2], + [2, 5], + [4, 9]] + label = ['high', 'low', 'medium'] + fig, ax = plt.subplots() + ax.plot(x, y, label=label) + + +def test_legend_face_edgecolor(): + # Smoke test for PolyCollection legend handler with 'face' edgecolor. + fig, ax = plt.subplots() + ax.fill_between([0, 1, 2], [1, 2, 3], [2, 3, 4], + facecolor='r', edgecolor='face', label='Fill') + ax.legend() + + +def test_legend_text_axes(): + fig, ax = plt.subplots() + ax.plot([1, 2], [3, 4], label='line') + leg = ax.legend() + + assert leg.axes is ax + assert leg.get_texts()[0].axes is ax + + +def test_handlerline2d(): + # Test marker consistency for monolithic Line2D legend handler (#11357). + fig, ax = plt.subplots() + ax.scatter([0, 1], [0, 1], marker="v") + handles = [mlines.Line2D([0], [0], marker="v")] + leg = ax.legend(handles, ["Aardvark"], numpoints=1) + assert handles[0].get_marker() == leg.legend_handles[0].get_marker() + + +def test_subfigure_legend(): + # Test that legend can be added to subfigure (#20723) + subfig = plt.figure().subfigures() + ax = subfig.subplots() + ax.plot([0, 1], [0, 1], label="line") + leg = subfig.legend() + assert leg.get_figure(root=False) is subfig + + +def test_setting_alpha_keeps_polycollection_color(): + pc = plt.fill_between([0, 1], [2, 3], color='#123456', label='label') + patch = plt.legend().get_patches()[0] + patch.set_alpha(0.5) + assert patch.get_facecolor()[:3] == tuple(pc.get_facecolor()[0][:3]) + assert patch.get_edgecolor()[:3] == tuple(pc.get_edgecolor()[0][:3]) + + +def test_legend_markers_from_line2d(): + # Test that markers can be copied for legend lines (#17960) + _markers = ['.', '*', 'v'] + fig, ax = plt.subplots() + lines = [mlines.Line2D([0], [0], ls='None', marker=mark) + for mark in _markers] + labels = ["foo", "bar", "xyzzy"] + markers = [line.get_marker() for line in lines] + legend = ax.legend(lines, labels) + + new_markers = [line.get_marker() for line in legend.get_lines()] + new_labels = [text.get_text() for text in legend.get_texts()] + + assert markers == new_markers == _markers + assert labels == new_labels + + +@check_figures_equal(extensions=['png']) +def test_ncol_ncols(fig_test, fig_ref): + # Test that both ncol and ncols work + strings = ["a", "b", "c", "d", "e", "f"] + ncols = 3 + fig_test.legend(strings, ncol=ncols) + fig_ref.legend(strings, ncols=ncols) + + +def test_loc_invalid_tuple_exception(): + # check that exception is raised if the loc arg + # of legend is not a 2-tuple of numbers + fig, ax = plt.subplots() + with pytest.raises(ValueError, match=('loc must be string, coordinate ' + 'tuple, or an integer 0-10, not \\(1.1,\\)')): + ax.legend(loc=(1.1, ), labels=["mock data"]) + + with pytest.raises(ValueError, match=('loc must be string, coordinate ' + 'tuple, or an integer 0-10, not \\(0.481, 0.4227, 0.4523\\)')): + ax.legend(loc=(0.481, 0.4227, 0.4523), labels=["mock data"]) + + with pytest.raises(ValueError, match=('loc must be string, coordinate ' + 'tuple, or an integer 0-10, not \\(0.481, \'go blue\'\\)')): + ax.legend(loc=(0.481, "go blue"), labels=["mock data"]) + + +def test_loc_valid_tuple(): + fig, ax = plt.subplots() + ax.legend(loc=(0.481, 0.442), labels=["mock data"]) + ax.legend(loc=(1, 2), labels=["mock data"]) + + +def test_loc_valid_list(): + fig, ax = plt.subplots() + ax.legend(loc=[0.481, 0.442], labels=["mock data"]) + ax.legend(loc=[1, 2], labels=["mock data"]) + + +def test_loc_invalid_list_exception(): + fig, ax = plt.subplots() + with pytest.raises(ValueError, match=('loc must be string, coordinate ' + 'tuple, or an integer 0-10, not \\[1.1, 2.2, 3.3\\]')): + ax.legend(loc=[1.1, 2.2, 3.3], labels=["mock data"]) + + +def test_loc_invalid_type(): + fig, ax = plt.subplots() + with pytest.raises(ValueError, match=("loc must be string, coordinate " + "tuple, or an integer 0-10, not {'not': True}")): + ax.legend(loc={'not': True}, labels=["mock data"]) + + +def test_loc_validation_numeric_value(): + fig, ax = plt.subplots() + ax.legend(loc=0, labels=["mock data"]) + ax.legend(loc=1, labels=["mock data"]) + ax.legend(loc=5, labels=["mock data"]) + ax.legend(loc=10, labels=["mock data"]) + with pytest.raises(ValueError, match=('loc must be string, coordinate ' + 'tuple, or an integer 0-10, not 11')): + ax.legend(loc=11, labels=["mock data"]) + + with pytest.raises(ValueError, match=('loc must be string, coordinate ' + 'tuple, or an integer 0-10, not -1')): + ax.legend(loc=-1, labels=["mock data"]) + + +def test_loc_validation_string_value(): + fig, ax = plt.subplots() + labels = ["mock data"] + ax.legend(loc='best', labels=labels) + ax.legend(loc='upper right', labels=labels) + ax.legend(loc='best', labels=labels) + ax.legend(loc='upper right', labels=labels) + ax.legend(loc='upper left', labels=labels) + ax.legend(loc='lower left', labels=labels) + ax.legend(loc='lower right', labels=labels) + ax.legend(loc='right', labels=labels) + ax.legend(loc='center left', labels=labels) + ax.legend(loc='center right', labels=labels) + ax.legend(loc='lower center', labels=labels) + ax.legend(loc='upper center', labels=labels) + with pytest.raises(ValueError, match="'wrong' is not a valid value for"): + ax.legend(loc='wrong', labels=labels) + + +def test_legend_handle_label_mismatch(): + pl1, = plt.plot(range(10)) + pl2, = plt.plot(range(10)) + with pytest.warns(UserWarning, match="number of handles and labels"): + legend = plt.legend(handles=[pl1, pl2], labels=["pl1", "pl2", "pl3"]) + assert len(legend.legend_handles) == 2 + assert len(legend.get_texts()) == 2 + + +def test_legend_handle_label_mismatch_no_len(): + pl1, = plt.plot(range(10)) + pl2, = plt.plot(range(10)) + legend = plt.legend(handles=iter([pl1, pl2]), + labels=iter(["pl1", "pl2", "pl3"])) + assert len(legend.legend_handles) == 2 + assert len(legend.get_texts()) == 2 + + +def test_legend_nolabels_warning(): + plt.plot([1, 2, 3]) + with pytest.raises(UserWarning, match="No artists with labels found"): + plt.legend() + + +@pytest.mark.filterwarnings("ignore:No artists with labels found to put in legend") +def test_legend_nolabels_draw(): + plt.plot([1, 2, 3]) + plt.legend() + assert plt.gca().get_legend() is not None + + +def test_legend_loc_polycollection(): + # Test that the legend is placed in the correct + # position for 'best' for polycollection + x = [3, 4, 5] + y1 = [1, 1, 1] + y2 = [5, 5, 5] + leg_bboxes = [] + fig, axs = plt.subplots(ncols=2, figsize=(10, 5)) + for ax, loc in zip(axs.flat, ('best', 'lower left')): + ax.fill_between(x, y1, y2, color='gray', alpha=0.5, label='Shaded Area') + ax.set_xlim(0, 6) + ax.set_ylim(-1, 5) + leg = ax.legend(loc=loc) + fig.canvas.draw() + leg_bboxes.append( + leg.get_window_extent().transformed(ax.transAxes.inverted())) + assert_allclose(leg_bboxes[1].bounds, leg_bboxes[0].bounds) + + +def test_legend_text(): + # Test that legend is place in the correct + # position for 'best' when there is text in figure + fig, axs = plt.subplots(ncols=2, figsize=(10, 5)) + leg_bboxes = [] + for ax, loc in zip(axs.flat, ('best', 'lower left')): + x = [1, 2] + y = [2, 1] + ax.plot(x, y, label='plot name') + ax.text(1.5, 2, 'some text blahblah', verticalalignment='top') + leg = ax.legend(loc=loc) + fig.canvas.draw() + leg_bboxes.append( + leg.get_window_extent().transformed(ax.transAxes.inverted())) + assert_allclose(leg_bboxes[1].bounds, leg_bboxes[0].bounds) + + +def test_legend_annotate(): + fig, ax = plt.subplots() + + ax.plot([1, 2, 3], label="Line") + ax.annotate("a", xy=(1, 1)) + ax.legend(loc=0) + + with mock.patch.object( + fig, '_get_renderer', wraps=fig._get_renderer) as mocked_get_renderer: + fig.savefig(io.BytesIO()) + + # Finding the legend position should not require _get_renderer to be called + mocked_get_renderer.assert_not_called() + + +def test_boxplot_legend_labels(): + # Test that legend entries are generated when passing `label`. + np.random.seed(19680801) + data = np.random.random((10, 4)) + fig, axs = plt.subplots(nrows=1, ncols=4) + legend_labels = ['box A', 'box B', 'box C', 'box D'] + + # Testing legend labels and patch passed to legend. + bp1 = axs[0].boxplot(data, patch_artist=True, label=legend_labels) + assert [v.get_label() for v in bp1['boxes']] == legend_labels + handles, labels = axs[0].get_legend_handles_labels() + assert labels == legend_labels + assert all(isinstance(h, mpl.patches.PathPatch) for h in handles) + + # Testing legend without `box`. + bp2 = axs[1].boxplot(data, label=legend_labels, showbox=False) + # Without a box, The legend entries should be passed from the medians. + assert [v.get_label() for v in bp2['medians']] == legend_labels + handles, labels = axs[1].get_legend_handles_labels() + assert labels == legend_labels + assert all(isinstance(h, mpl.lines.Line2D) for h in handles) + + # Testing legend with number of labels different from number of boxes. + with pytest.raises(ValueError, match='values must have same the length'): + bp3 = axs[2].boxplot(data, label=legend_labels[:-1]) + + # Test that for a string label, only the first box gets a label. + bp4 = axs[3].boxplot(data, label='box A') + assert bp4['medians'][0].get_label() == 'box A' + assert all(x.get_label().startswith("_") for x in bp4['medians'][1:]) diff --git a/shared/package-files/41/41e42466b686bd3739838b6fd503ec1d514c93bbcdef23b6b1b4e869fe86369e/blob b/shared/package-files/41/41e42466b686bd3739838b6fd503ec1d514c93bbcdef23b6b1b4e869fe86369e/blob new file mode 100644 index 0000000000000000000000000000000000000000..786b0e98e21bedeba4eaed34888c4854e6f11f0f --- /dev/null +++ b/shared/package-files/41/41e42466b686bd3739838b6fd503ec1d514c93bbcdef23b6b1b4e869fe86369e/blob @@ -0,0 +1,47 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::conv_transpose1d(Tensor input, Tensor weight, Tensor? bias=None, SymInt[1] stride=1, SymInt[1] padding=0, SymInt[1] output_padding=0, SymInt groups=1, SymInt[1] dilation=1) -> Tensor +inline at::Tensor conv_transpose1d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, int64_t groups=1, at::IntArrayRef dilation=1) { + return at::_ops::conv_transpose1d::call(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), groups, c10::fromIntArrayRefSlow(dilation)); +} +namespace symint { + template ::value>> + at::Tensor conv_transpose1d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, int64_t groups=1, at::IntArrayRef dilation=1) { + return at::_ops::conv_transpose1d::call(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), groups, c10::fromIntArrayRefSlow(dilation)); + } +} + +// aten::conv_transpose1d(Tensor input, Tensor weight, Tensor? bias=None, SymInt[1] stride=1, SymInt[1] padding=0, SymInt[1] output_padding=0, SymInt groups=1, SymInt[1] dilation=1) -> Tensor +inline at::Tensor conv_transpose1d_symint(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymInt groups=1, c10::SymIntArrayRef dilation=c10::SymInt(1)) { + return at::_ops::conv_transpose1d::call(input, weight, bias, stride, padding, output_padding, groups, dilation); +} +namespace symint { + template ::value>> + at::Tensor conv_transpose1d(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymInt groups=1, c10::SymIntArrayRef dilation=c10::SymInt(1)) { + return at::_ops::conv_transpose1d::call(input, weight, bias, stride, padding, output_padding, groups, dilation); + } +} + +} diff --git a/shared/package-files/41/41e51412e3668739e9b8a34f2fe0742153a431d302bbca095fad8e0b4569cee8/blob b/shared/package-files/41/41e51412e3668739e9b8a34f2fe0742153a431d302bbca095fad8e0b4569cee8/blob new file mode 100644 index 0000000000000000000000000000000000000000..5c7da73f4e0e57cfe9074c50c2628300130fc94d --- /dev/null +++ b/shared/package-files/41/41e51412e3668739e9b8a34f2fe0742153a431d302bbca095fad8e0b4569cee8/blob @@ -0,0 +1,137 @@ +from __future__ import annotations + +import socket +import typing + +from ..exceptions import LocationParseError +from .timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT + +_TYPE_SOCKET_OPTIONS = typing.Sequence[typing.Tuple[int, int, typing.Union[int, bytes]]] + +if typing.TYPE_CHECKING: + from .._base_connection import BaseHTTPConnection + + +def is_connection_dropped(conn: BaseHTTPConnection) -> bool: # Platform-specific + """ + Returns True if the connection is dropped and should be closed. + :param conn: :class:`urllib3.connection.HTTPConnection` object. + """ + return not conn.is_connected + + +# This function is copied from socket.py in the Python 2.7 standard +# library test suite. Added to its signature is only `socket_options`. +# One additional modification is that we avoid binding to IPv6 servers +# discovered in DNS if the system doesn't have IPv6 functionality. +def create_connection( + address: tuple[str, int], + timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + source_address: tuple[str, int] | None = None, + socket_options: _TYPE_SOCKET_OPTIONS | None = None, +) -> socket.socket: + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`socket.getdefaulttimeout` + is used. If *source_address* is set it must be a tuple of (host, port) + for the socket to bind as a source address before making the connection. + An host of '' or port 0 tells the OS to use the default. + """ + + host, port = address + if host.startswith("["): + host = host.strip("[]") + err = None + + # Using the value from allowed_gai_family() in the context of getaddrinfo lets + # us select whether to work with IPv4 DNS records, IPv6 records, or both. + # The original create_connection function always returns all records. + family = allowed_gai_family() + + try: + host.encode("idna") + except UnicodeError: + raise LocationParseError(f"'{host}', label empty or too long") from None + + for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM): + af, socktype, proto, canonname, sa = res + sock = None + try: + sock = socket.socket(af, socktype, proto) + + # If provided, set socket level options before connecting. + _set_socket_options(sock, socket_options) + + if timeout is not _DEFAULT_TIMEOUT: + sock.settimeout(timeout) + if source_address: + sock.bind(source_address) + sock.connect(sa) + # Break explicitly a reference cycle + err = None + return sock + + except OSError as _: + err = _ + if sock is not None: + sock.close() + + if err is not None: + try: + raise err + finally: + # Break explicitly a reference cycle + err = None + else: + raise OSError("getaddrinfo returns an empty list") + + +def _set_socket_options( + sock: socket.socket, options: _TYPE_SOCKET_OPTIONS | None +) -> None: + if options is None: + return + + for opt in options: + sock.setsockopt(*opt) + + +def allowed_gai_family() -> socket.AddressFamily: + """This function is designed to work in the context of + getaddrinfo, where family=socket.AF_UNSPEC is the default and + will perform a DNS search for both IPv6 and IPv4 records.""" + + family = socket.AF_INET + if HAS_IPV6: + family = socket.AF_UNSPEC + return family + + +def _has_ipv6(host: str) -> bool: + """Returns True if the system can bind an IPv6 address.""" + sock = None + has_ipv6 = False + + if socket.has_ipv6: + # has_ipv6 returns true if cPython was compiled with IPv6 support. + # It does not tell us if the system has IPv6 support enabled. To + # determine that we must bind to an IPv6 address. + # https://github.com/urllib3/urllib3/pull/611 + # https://bugs.python.org/issue658327 + try: + sock = socket.socket(socket.AF_INET6) + sock.bind((host, 0)) + has_ipv6 = True + except Exception: + pass + + if sock: + sock.close() + return has_ipv6 + + +HAS_IPV6 = _has_ipv6("::1") diff --git a/shared/package-files/41/41e80dd275b5a4e2c432a9991e82a1bb3ca028535ae5d187bb51dc36c0d0e660/blob b/shared/package-files/41/41e80dd275b5a4e2c432a9991e82a1bb3ca028535ae5d187bb51dc36c0d0e660/blob new file mode 100644 index 0000000000000000000000000000000000000000..a529a037b11a7dca152b773ac3b414ad121509d0 --- /dev/null +++ b/shared/package-files/41/41e80dd275b5a4e2c432a9991e82a1bb3ca028535ae5d187bb51dc36c0d0e660/blob @@ -0,0 +1,155 @@ +# style.tcl -- +# +# This demonstration script creates a text widget that illustrates the +# various display styles that may be set for tags. + +if {![info exists widgetDemo]} { + error "This script should be run from the \"widget\" demo." +} + +package require Tk + +set w .style +catch {destroy $w} +toplevel $w +wm title $w "Text Demonstration - Display Styles" +wm iconname $w "style" +positionWindow $w + +## See Code / Dismiss buttons +set btns [addSeeDismiss $w.buttons $w] +pack $btns -side bottom -fill x + +# Only set the font family in one place for simplicity and consistency + +set family Courier + +text $w.text -yscrollcommand "$w.scroll set" -setgrid true \ + -width 70 -height 32 -wrap word -font "$family 12" +ttk::scrollbar $w.scroll -command "$w.text yview" +pack $w.scroll -side right -fill y +pack $w.text -expand yes -fill both + +# Set up display styles + +$w.text tag configure bold -font "$family 12 bold italic" +$w.text tag configure big -font "$family 14 bold" +$w.text tag configure verybig -font "Helvetica 24 bold" +$w.text tag configure tiny -font "Times 8 bold" +if {[winfo depth $w] > 1} { + $w.text tag configure color1 -background #a0b7ce + $w.text tag configure color2 -foreground red + $w.text tag configure raised -relief raised -borderwidth 1 + $w.text tag configure sunken -relief sunken -borderwidth 1 +} else { + $w.text tag configure color1 -background black -foreground white + $w.text tag configure color2 -background black -foreground white + $w.text tag configure raised -background white -relief raised \ + -borderwidth 1 + $w.text tag configure sunken -background white -relief sunken \ + -borderwidth 1 +} +$w.text tag configure bgstipple -background black -borderwidth 0 \ + -bgstipple gray12 +$w.text tag configure fgstipple -fgstipple gray50 +$w.text tag configure underline -underline on +$w.text tag configure overstrike -overstrike on +$w.text tag configure right -justify right +$w.text tag configure center -justify center +$w.text tag configure super -offset 4p -font "$family 10" +$w.text tag configure sub -offset -2p -font "$family 10" +$w.text tag configure margins -lmargin1 12m -lmargin2 6m -rmargin 10m +$w.text tag configure spacing -spacing1 10p -spacing2 2p \ + -lmargin1 12m -lmargin2 6m -rmargin 10m + +$w.text insert end {Text widgets like this one allow you to display information in a +variety of styles. Display styles are controlled using a mechanism +called } +$w.text insert end tags bold +$w.text insert end {. Tags are just textual names that you can apply to one +or more ranges of characters within a text widget. You can configure +tags with various display styles. If you do this, then the tagged +characters will be displayed with the styles you chose. The +available display styles are: +} +$w.text insert end "\n1. Font." big +$w.text insert end " You can choose any system font, " +$w.text insert end large verybig +$w.text insert end " or " +$w.text insert end "small" tiny ".\n" +$w.text insert end "\n2. Color." big +$w.text insert end " You can change either the " +$w.text insert end background color1 +$w.text insert end " or " +$w.text insert end foreground color2 +$w.text insert end "\ncolor, or " +$w.text insert end both {color1 color2} +$w.text insert end ".\n" +$w.text insert end "\n3. Stippling." big +$w.text insert end " You can cause either the " +$w.text insert end background bgstipple +$w.text insert end " or " +$w.text insert end foreground fgstipple +$w.text insert end { +information to be drawn with a stipple fill instead of a solid fill. +} +$w.text insert end "\n4. Underlining." big +$w.text insert end " You can " +$w.text insert end underline underline +$w.text insert end " ranges of text.\n" +$w.text insert end "\n5. Overstrikes." big +$w.text insert end " You can " +$w.text insert end "draw lines through" overstrike +$w.text insert end " ranges of text.\n" +$w.text insert end "\n6. 3-D effects." big +$w.text insert end { You can arrange for the background to be drawn +with a border that makes characters appear either } +$w.text insert end raised raised +$w.text insert end " or " +$w.text insert end sunken sunken +$w.text insert end ".\n" +$w.text insert end "\n7. Justification." big +$w.text insert end " You can arrange for lines to be displayed\n" +$w.text insert end "left-justified,\n" +$w.text insert end "right-justified, or\n" right +$w.text insert end "centered.\n" center +$w.text insert end "\n8. Superscripts and subscripts." big +$w.text insert end " You can control the vertical\n" +$w.text insert end "position of text to generate superscript effects like 10" +$w.text insert end "n" super +$w.text insert end " or\nsubscript effects like X" +$w.text insert end "i" sub +$w.text insert end ".\n" +$w.text insert end "\n9. Margins." big +$w.text insert end " You can control the amount of extra space left" +$w.text insert end " on\neach side of the text:\n" +$w.text insert end "This paragraph is an example of the use of " margins +$w.text insert end "margins. It consists of a single line of text " margins +$w.text insert end "that wraps around on the screen. There are two " margins +$w.text insert end "separate left margin values, one for the first " margins +$w.text insert end "display line associated with the text line, " margins +$w.text insert end "and one for the subsequent display lines, which " margins +$w.text insert end "occur because of wrapping. There is also a " margins +$w.text insert end "separate specification for the right margin, " margins +$w.text insert end "which is used to choose wrap points for lines.\n" margins +$w.text insert end "\n10. Spacing." big +$w.text insert end " You can control the spacing of lines with three\n" +$w.text insert end "separate parameters. \"Spacing1\" tells how much " +$w.text insert end "extra space to leave\nabove a line, \"spacing3\" " +$w.text insert end "tells how much space to leave below a line,\nand " +$w.text insert end "if a text line wraps, \"spacing2\" tells how much " +$w.text insert end "space to leave\nbetween the display lines that " +$w.text insert end "make up the text line.\n" +$w.text insert end "These indented paragraphs illustrate how spacing " spacing +$w.text insert end "can be used. Each paragraph is actually a " spacing +$w.text insert end "single line in the text widget, which is " spacing +$w.text insert end "word-wrapped by the widget.\n" spacing +$w.text insert end "Spacing1 is set to 10 points for this text, " spacing +$w.text insert end "which results in relatively large gaps between " spacing +$w.text insert end "the paragraphs. Spacing2 is set to 2 points, " spacing +$w.text insert end "which results in just a bit of extra space " spacing +$w.text insert end "within a pararaph. Spacing3 isn't used " spacing +$w.text insert end "in this example.\n" spacing +$w.text insert end "To see where the space is, select ranges of " spacing +$w.text insert end "text within these paragraphs. The selection " spacing +$w.text insert end "highlight will cover the extra space." spacing diff --git a/shared/package-files/41/41eb014e1136d816b5ede51d1b6d6558da8f46f061caea4b9cfb17b9e2dacc7c/blob b/shared/package-files/41/41eb014e1136d816b5ede51d1b6d6558da8f46f061caea4b9cfb17b9e2dacc7c/blob new file mode 100644 index 0000000000000000000000000000000000000000..befe709728bdd4e9fac3c626f4e33986d671c86d --- /dev/null +++ b/shared/package-files/41/41eb014e1136d816b5ede51d1b6d6558da8f46f061caea4b9cfb17b9e2dacc7c/blob @@ -0,0 +1,11 @@ +from pandas import timedelta_range +import pandas._testing as tm + + +class TestPickle: + def test_pickle_after_set_freq(self): + tdi = timedelta_range("1 day", periods=4, freq="s") + tdi = tdi._with_freq(None) + + res = tm.round_trip_pickle(tdi) + tm.assert_index_equal(res, tdi) diff --git a/shared/package-files/41/41ec04f5a5a1b98ec51fbab9a72051194552aab6396188ab188a5740a791630b/blob b/shared/package-files/41/41ec04f5a5a1b98ec51fbab9a72051194552aab6396188ab188a5740a791630b/blob new file mode 100644 index 0000000000000000000000000000000000000000..c5fa62c19f4ccb4af811639cce19bdfad1b5ee61 --- /dev/null +++ b/shared/package-files/41/41ec04f5a5a1b98ec51fbab9a72051194552aab6396188ab188a5740a791630b/blob @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor _embedding_bag_backward_symint(const at::Tensor & grad, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, const at::Tensor & bag_size, const at::Tensor & maximum_indices, c10::SymInt num_weights, bool scale_grad_by_freq, int64_t mode, bool sparse, const c10::optional & per_sample_weights, int64_t padding_idx=-1); +} // namespace native +} // namespace at diff --git a/shared/package-files/41/41ee0a110d3f5eca6ac054c050864febdd930ac6112750f7189cded34bf19256/blob b/shared/package-files/41/41ee0a110d3f5eca6ac054c050864febdd930ac6112750f7189cded34bf19256/blob new file mode 100644 index 0000000000000000000000000000000000000000..d4bb2d592ddd5418b482cf70100946a3d89488af --- /dev/null +++ b/shared/package-files/41/41ee0a110d3f5eca6ac054c050864febdd930ac6112750f7189cded34bf19256/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor empty(at::IntArrayRef size, c10::optional names, at::TensorOptions options={}, c10::optional memory_format=c10::nullopt); +TORCH_API at::Tensor empty(at::IntArrayRef size, c10::optional names, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory, c10::optional memory_format); +TORCH_API at::Tensor & empty_out(at::Tensor & out, at::IntArrayRef size, c10::optional names, c10::optional memory_format=c10::nullopt); +TORCH_API at::Tensor & empty_outf(at::IntArrayRef size, c10::optional names, c10::optional memory_format, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/41/41ee96f160ccca37ebf3ed10fa95b98e0803be54b448083ef92c6ac8cf6f6312/blob b/shared/package-files/41/41ee96f160ccca37ebf3ed10fa95b98e0803be54b448083ef92c6ac8cf6f6312/blob new file mode 100644 index 0000000000000000000000000000000000000000..503e5869d7f226f25c4a3047b1b1c8c57b27de29 --- /dev/null +++ b/shared/package-files/41/41ee96f160ccca37ebf3ed10fa95b98e0803be54b448083ef92c6ac8cf6f6312/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41ee96f160ccca37ebf3ed10fa95b98e0803be54b448083ef92c6ac8cf6f6312 +size 1041704 diff --git a/shared/package-files/41/41f089ebe7eaba30a1d7ad9a45bf40fea356942d24fbae6b57834033470517da/blob b/shared/package-files/41/41f089ebe7eaba30a1d7ad9a45bf40fea356942d24fbae6b57834033470517da/blob new file mode 100644 index 0000000000000000000000000000000000000000..72d90f567d91d35d781b91035e33b380988301c2 --- /dev/null +++ b/shared/package-files/41/41f089ebe7eaba30a1d7ad9a45bf40fea356942d24fbae6b57834033470517da/blob @@ -0,0 +1,563 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates +import logging +import math +from typing import Dict, List, Optional, Tuple, TYPE_CHECKING, Union + +import torch + +from torch.distributed import is_available + +from ..utils._typing_utils import not_none + +__all__ = ["init_device_mesh", "DeviceMesh"] + + +if not is_available(): + import sys + + # We need to create the stubs when distributed is not available. + # Otherwise, we would fail the doc tests (```./.ci/pytorch/docs-test.sh```), + # since it would try to import ``torch.distributed.device_mesh`` or + # ``torch.distributed.init_device_mesh`` but cannot find them. + + class _DeviceMeshStub: + pass + + def _init_device_mesh_stub(): + pass + + sys.modules["torch.distributed.device_mesh"].DeviceMesh = _DeviceMeshStub # type: ignore[attr-defined] + sys.modules[ + "torch.distributed.device_mesh" + ].init_device_mesh = _init_device_mesh_stub # type: ignore[attr-defined] + + +else: + from torch.distributed.distributed_c10d import ( + _find_pg_by_ranks_and_tag, + _get_default_group, + _get_group_tag, + get_rank, + get_world_size, + init_process_group, + is_initialized, + new_group, + ProcessGroup, + ) + + logger = logging.getLogger(__name__) + + # only import numpy typing when type checking + if TYPE_CHECKING: + try: + from numpy.typing import ArrayLike + except ImportError: + logger.warning( + "DeviceMesh requires numpy >= 1.21 to be installed for type checking" + ) + + class _MeshEnv: + def __init__(self) -> None: + self.mesh_stack: List[DeviceMesh] = [] + self.child_to_parent_mapping: Dict[DeviceMesh, DeviceMesh] = {} + self.parent_to_child_mapping: Dict[DeviceMesh, Dict[str, DeviceMesh]] = {} + + def get_current_mesh(self) -> "DeviceMesh": + if len(self.mesh_stack) == 0: + raise RuntimeError("No device mesh is currently active!") + return self.mesh_stack[-1] + + def create_child_mesh( + self, device_mesh: "DeviceMesh", mesh_dim: int, mesh_dim_name: str + ) -> "DeviceMesh": + # Directly return the child mesh if it is already created. + child_mesh_mappings = self.parent_to_child_mapping.get(device_mesh) + if child_mesh_mappings: + sub_mesh = child_mesh_mappings.get(mesh_dim_name) + if sub_mesh: + return sub_mesh + + # swap the current dim to the last dim then reshape to flatten out other + # dims, so we can just extract the list of ranks which contains cur_rank. + cur_rank = device_mesh.get_rank() + pg_ranks_by_dim = device_mesh.mesh.swapdims(-1, mesh_dim).reshape( + -1, device_mesh.mesh.size(mesh_dim) + ) + + for mesh_1d in pg_ranks_by_dim: + sub_mesh = DeviceMesh( + device_mesh.device_type, + mesh_1d, + mesh_dim_names=(mesh_dim_name,), + ) + if cur_rank in mesh_1d: + res_sub_mesh = sub_mesh + + res_sub_mesh._dim_group_infos = [device_mesh._dim_group_infos[mesh_dim]] # type: ignore[possibly-undefined] + # Assign the current DeviceMesh as the parent of the child DeviceMesh. + self.child_to_parent_mapping[res_sub_mesh] = device_mesh + self.parent_to_child_mapping.setdefault(device_mesh, {})[ + mesh_dim_name + ] = res_sub_mesh + return res_sub_mesh + + def get_parent_mesh(self, device_mesh: "DeviceMesh") -> Optional["DeviceMesh"]: + return self.child_to_parent_mapping.get(device_mesh, None) + + def get_parent_mesh_dim(self, device_mesh: "DeviceMesh") -> Optional[int]: + """ + Return the index of the mesh dim in the parent mesh. + The device_mesh passed in needs to be sliced out from a parent mesh. + """ + parent_mesh = self.get_parent_mesh(device_mesh) + child_mesh_dim_names = device_mesh.mesh_dim_names + if parent_mesh and child_mesh_dim_names: + assert ( + len(child_mesh_dim_names) == 1 + ), "The child mesh can only be a 1D mesh." + child_mesh_dim_name = child_mesh_dim_names[0] + return self.get_mesh_dim_by_name(parent_mesh, child_mesh_dim_name) + return None + + @staticmethod + def num_devices_per_host(device_type: str) -> int: + return _get_device_handle(device_type).device_count() + + @staticmethod + def num_hosts(device_type: str) -> int: + # ProcessGroup can't tell us this info so we have to infer it, assume + # homogeneous hardware for now + return get_world_size() // _MeshEnv.num_devices_per_host(device_type) + + def get_mesh_dim_by_name( + self, device_mesh: "DeviceMesh", mesh_dim_name: str + ) -> int: + if ( + device_mesh.mesh_dim_names is None + or len(device_mesh.mesh_dim_names) == 0 + ): + raise KeyError( + "No `mesh_dim_names` found.", + ) + if mesh_dim_name not in device_mesh.mesh_dim_names: + raise KeyError( + f"Mesh dimension '{mesh_dim_name}' does not exist.", + f"Available mesh dimensions are: mesh_dim_names={device_mesh.mesh_dim_names}", + ) + return not_none(device_mesh.mesh_dim_names.index(mesh_dim_name)) + + _mesh_resources: _MeshEnv = _MeshEnv() + + def _get_device_handle(device_type: str = "cuda"): + """ + Get the module corresponding to the device_type which is cuda or cuda-like device. + For example, when the device_type is cuda, the module `torch.cuda` is returned. + Return None when there is no corresponding module for device_type, otherwise + return the corresponding module. + """ + return getattr(torch, device_type, None) + + class DeviceMesh: + """ + DeviceMesh represents a mesh of devices, where layout of devices could be + represented as a n-d dimension array, and each value of the n-d dimensional + array is the global id of the default process group ranks. + + DeviceMesh could be used to describe the layout of devices across the cluster, + and serves as a proxy for communication among the device lists within the cluster. + + DeviceMesh can be used as a context manager. + + .. note:: + DeviceMesh follows SPMD programming model, which means the same PyTorch Python program + is running on all processes/ranks in the cluster. Therefore, users need to make sure the + `mesh` array (which describes the layout of devices) should be identical across all ranks. + Inconsistent `mesh` will lead to silent hang. + + Args: + device_type (str): The device type of the mesh. Currently supports: "cpu", "cuda/cuda-like". + mesh (ndarray): A multi-dimensional array or an integer tensor describing the layout + of devices, where the IDs are global IDs of the default process group. + + Returns: + DeviceMesh: A :class:`DeviceMesh` object representing the device layout. + + The following program runs on each process/rank in an SPMD manner. In this example, we have 2 + hosts with 4 GPUs each. + A reduction over the first dimension of mesh will reduce across + columns (0, 4), .. and (3, 7), a reduction over the second dimension + of mesh reduces across rows (0, 1, 2, 3) and (4, 5, 6, 7). + + Example:: + >>> # xdoctest: +SKIP("no rank") + >>> from torch.distributed.device_mesh import DeviceMesh + >>> + >>> # Initialize device mesh as (2, 4) to represent the topology + >>> # of cross-host(dim 0), and within-host (dim 1). + >>> mesh = DeviceMesh(device_type="cuda", mesh=[[0, 1, 2, 3],[4, 5, 6, 7]]) + """ + + device_type: str + mesh: torch.Tensor + mesh_dim_names: Optional[Tuple[str, ...]] + + def __init__( + self, + device_type: str, + mesh: Union[torch.Tensor, "ArrayLike"], + *, + mesh_dim_names: Optional[Tuple[str, ...]] = None, + ) -> None: + self.device_type = device_type + if isinstance(mesh, torch.Tensor) and mesh.device.type != "cpu": + raise ValueError(f"`mesh` must be a CPU tensor, got {mesh}") + self.mesh = ( + mesh.detach().cpu() + if isinstance(mesh, torch.Tensor) + else torch.tensor(mesh, dtype=torch.int) + ) + self.mesh_dim_names = mesh_dim_names + + # private field to pre-generate DeviceMesh's hash + self._flatten_mesh_list = tuple(self.mesh.flatten().tolist()) + self._hash = hash((self._flatten_mesh_list, self.mesh.shape, id(self))) + + # Skip process group initialization if xla device. + # TODO(yeounoh) implement DeviceMesh backend and register XLA backend. + if device_type != "xla": + # always try to create default (world) pg, even if it is not initialized + # already. The world pg is used for device mesh identity (rank) on each + # process (we need to know if the current global rank is in the mesh or not). + self._get_or_create_default_group() + self._init_process_groups() + + def _get_or_create_default_group(self): + default_initialized = is_initialized() + if not default_initialized: + init_process_group() + + world_size = get_world_size() + if self.mesh.numel() > world_size: + raise RuntimeError( + f"Mesh should not be bigger than default world size, but found {self.mesh.numel()} ranks!" + ) + + device_handle = _get_device_handle(self.device_type) + # TODO: if user want to pass pg_options, offer a way to do it + if not default_initialized and device_handle: + # automatically set the current cuda/cuda-like device base on num of gpu devices available in each host + # NOTE: This device selection would only work for homogeneous hardware. + num_devices_per_host = device_handle.device_count() + if ( + world_size > num_devices_per_host + and world_size % num_devices_per_host != 0 + ): + raise RuntimeError( + f"DeviceMesh only support homogeneous hardware, but found " + f"{world_size} ranks and {num_devices_per_host} {self.device_type} devices!" + ) + device_handle.set_device(get_rank() % num_devices_per_host) + + # calculate the coordinates of the current global rank on the mesh + rank_coords = (self.mesh == get_rank()).nonzero() + assert rank_coords.size(0) in (0, 1) + self._coordinate_on_dim: Optional[List[int]] = ( + rank_coords[0].tolist() if rank_coords.size(0) > 0 else None + ) + return _get_default_group() + + def _init_process_groups(self): + # tag/ranks/group_name associated with each mesh dimension, each + # mesh dimension should have one sub-group per rank + # + # TODO(yifu): remove tag and ranks once we fully migrate to native + # functional collectives. See details in: + # https://github.com/pytorch/pytorch/issues/93173#issuecomment-1907095208 + dim_group_infos: List[Tuple[str, List[int], str]] = [] + + if self.mesh.ndim == 1 and self.mesh.numel() == get_world_size(): + # if the mesh is the same as world_pg, we just append the default + # pg to the first dim groups, as new_group cannot have the exact + # same ranks as world + dim_group_infos.append( + ( + _get_group_tag(_get_default_group()), + list(range(get_world_size())), + _get_default_group().group_name, + ) + ) + else: + # create sub pgs base on the mesh argument specified + for dim in range(self.mesh.ndim): + # swap the current dim to the last dim + # then reshape to flatten out other dims + pg_ranks_by_dim = self.mesh.swapdims(-1, dim).reshape( + -1, self.mesh.size(dim) + ) + # multi-dim mesh, create subgroups by looping over the pg_ranks + # for each dim and append the groups + for dim_mesh in pg_ranks_by_dim: + subgroup_ranks = dim_mesh.tolist() + + # We temporarily revert the re-use subgroup, since it breaks two internal tests. + # Temporarily reverting to resolve test timeout while root-causing. + # TODO: Add two tests to cover internal tests scenarios and re-enable reuse subgroup if exists. + dim_group = new_group(ranks=subgroup_ranks) + + # only add to dim_groups if the current rank in the subgroup + if self.get_rank() in subgroup_ranks: + if len(dim_group_infos) > dim: + raise RuntimeError( + f"Each device mesh dimension should get only one process group, but got {self.get_rank} " + f"in {subgroup_ranks}!" + ) + dim_group_infos.append( + ( + _get_group_tag(not_none(dim_group)), + subgroup_ranks, + dim_group.group_name, + ) + ) + self._dim_group_infos = dim_group_infos + + def __enter__(self) -> "DeviceMesh": + # set this mesh as the current mesh in mesh env + _mesh_resources.mesh_stack.append(self) + return self + + # pyre-fixme[2]: Parameter must be annotated. + def __exit__(self, exc_type, exc_value, exc_traceback) -> None: + # pop this mesh from mesh env + _mesh_resources.mesh_stack.pop() + + def __repr__(self) -> str: + device_mesh_repr = ( + f"DeviceMesh({self.mesh.tolist()})" + if not self.mesh_dim_names + else f"DeviceMesh({self.mesh.tolist()}, mesh_dim_names={self.mesh_dim_names})" + ) + return device_mesh_repr + + def __hash__(self): + return self._hash + + def __eq__(self, other: object) -> bool: + if not isinstance(other, DeviceMesh): + return False + if id(self.mesh) == id(other.mesh): + return True + return ( + self.mesh.shape == other.mesh.shape + and self._flatten_mesh_list == other._flatten_mesh_list + ) + + def __getitem__(self, mesh_dim_name: str) -> "DeviceMesh": + """ + Slice the current DeviceMesh based on the mesh_dim_name given to create a child + DeviceMesh. + + Args: + mesh_dim_name (str): the name of the mesh dimension of the parent DeviceMesh + to create a child DeviceMesh for. + Returns: + A :class:`DeviceMesh` object + + The following program runs on each process/rank in an SPMD manner. In this example, we have 2 + hosts with 4 GPUs each. + Calling mesh["tp"] on rank 0, 1, 2, 3 would return a 1D child DeviceMesh:([0, 1, 2, 3]). + Calling mesh["tp"] on rank 4, 5, 6, 7 would return a 1D child DeviceMesh:([4, 5, 6, 7]). + Calling mesh["dp"] on rank 0, 4 would return a 1D child DeviceMesh:([0, 4]). + Calling mesh["dp"] on rank 1, 5 would return a 1D child DeviceMesh:([1, 5]). + Calling mesh["dp"] on rank 2, 6 would return a 1D child DeviceMesh:([2, 6]). + Calling mesh["dp"] on rank 3, 7 would return a 1D child DeviceMesh:([3, 7]). + + Example:: + >>> # xdoctest: +SKIP("no rank") + >>> from torch.distributed.device_mesh import DeviceMesh + >>> + >>> # Initialize device mesh as (2, 4) to represent the topology + >>> # of cross-host(dim 0), and within-host (dim 1). + >>> mesh = DeviceMesh(device_type="cuda", mesh=[[0, 1, 2, 3],[4, 5, 6, 7]]) + """ + if self.mesh.ndim == 1: + if self.mesh_dim_names and mesh_dim_name == self.mesh_dim_names[0]: + return self + else: + raise RuntimeError( + f"Invalid mesh_dim_name {mesh_dim_name} specified." + ) + + mesh_dim = _mesh_resources.get_mesh_dim_by_name(self, mesh_dim_name) + submesh = _mesh_resources.create_child_mesh(self, mesh_dim, mesh_dim_name) + return submesh + + def get_group( + self, mesh_dim: Optional[Union[int, str]] = None + ) -> Union[ProcessGroup, List[ProcessGroup]]: + """ + Returns a list of ProcessGroups corresponding to the mesh dimensions, or + returns a single ProcessGroup if mesh_dim is specified or the given mesh has + only one mesh dimension. + + Args: + mesh_dim (str/int, optional): it can be the name of the mesh dimension or the index + of the mesh dimension. Default is None. + + Returns: + A list of :class:`ProcessGroup` object when `mesh_dim` is not specified for + a DeviceMesh with more than 1 dimension; otherwise, returns a single + :class:`ProcessGroup` object. + """ + if not hasattr(self, "_dim_group_infos"): + raise RuntimeError("DeviceMesh process groups not initialized!") + + if self.mesh.ndim == 1: + return not_none( + _find_pg_by_ranks_and_tag(*self._dim_group_infos[0][:2]) + ) + + if mesh_dim is not None: + if isinstance(mesh_dim, str): + mesh_dim = _mesh_resources.get_mesh_dim_by_name(self, mesh_dim) + return not_none( + _find_pg_by_ranks_and_tag(*self._dim_group_infos[mesh_dim][:2]) + ) + else: + dim_groups = [] + for ith_dim in range(self.mesh.ndim): + dim_groups.append( + not_none( + _find_pg_by_ranks_and_tag( + *self._dim_group_infos[ith_dim][:2] + ) + ) + ) + return dim_groups + + def size(self, mesh_dim: Optional[int] = None) -> int: + return self.mesh.numel() if mesh_dim is None else self.mesh.size(mesh_dim) + + @property + def ndim(self) -> int: + return self.mesh.ndim + + @property + def shape(self) -> Tuple[int, ...]: + return tuple(self.mesh.shape) + + def get_rank(self) -> int: + """ + Returns the current global rank. + """ + return get_rank() + + def get_local_rank(self, mesh_dim: Optional[Union[int, str]] = None) -> int: + """ + Returns the local rank of the given mesh_dim of the DeviceMesh. + + Args: + mesh_dim (str/int, optional): it can be the name of the mesh dimension or the index + of the mesh dimension. Default is None. + + Returns: + An integer denotes the local rank. + + The following program runs on each process/rank in an SPMD manner. In this example, we have 2 + hosts with 4 GPUs each. + Calling mesh_2d.get_local_rank(mesh_dim=0) on rank 0, 1, 2, 3 would return 0. + Calling mesh_2d.get_local_rank(mesh_dim=0) on rank 4, 5, 6, 7 would return 1. + Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 0, 4 would return 0. + Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 1, 5 would return 1. + Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 2, 6 would return 2. + Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 3, 7 would return 3. + + Example:: + >>> # xdoctest: +SKIP("no rank") + >>> from torch.distributed.device_mesh import DeviceMesh + >>> + >>> # Initialize device mesh as (2, 4) to represent the topology + >>> # of cross-host(dim 0), and within-host (dim 1). + >>> mesh = DeviceMesh(device_type="cuda", mesh=[[0, 1, 2, 3],[4, 5, 6, 7]]) + """ + if self.ndim > 1 and mesh_dim is None: + raise RuntimeError( + f"Found the DeviceMesh have {self.mesh.ndim} dimensions", + "Optional kwarg `mesh_dim` needs to be specified when device_mesh.ndim > 1.", + ) + elif mesh_dim is None: + mesh_dim = 0 + + mesh_dim_group = not_none(self.get_group(mesh_dim)) + assert isinstance( + mesh_dim_group, ProcessGroup + ), "We expect ProcessGroup before calling `get_rank`!" + return not_none(get_rank(mesh_dim_group)) + + def get_coordinate(self) -> Optional[List[int]]: + """ + Return the relative indices of this rank relative to all + dimensions of the mesh. If this rank is not part of the mesh, return None. + """ + return self._coordinate_on_dim if self._coordinate_on_dim else None + + def init_device_mesh( + device_type: str, + mesh_shape: Tuple[int, ...], + *, + mesh_dim_names: Optional[Tuple[str, ...]] = None, + ) -> DeviceMesh: + """ + Initializes a `DeviceMesh` based on `device_type`, `mesh_shape`, and `mesh_dim_names` parameters. + + This creates a DeviceMesh with an n-dimensional array layout, where `n` is the length of `mesh_shape`. + If `mesh_dim_names` is provided, each dimension is labeled as `mesh_dim_names[i]`. + + .. note:: + `init_device_mesh` follows SPMD programming model, meaning the same PyTorch Python program + runs on all processes/ranks in the cluster. Ensure `mesh_shape` (the dimensions of the nD array + describing device layout) is identical across all ranks. Inconsistent `mesh_shape` may lead to hanging. + + .. note:: + If no process group is found, init_device_mesh will initialize distributed process group/groups + required for distributed communications behind the scene. + + Args: + device_type (str): The device type of the mesh. Currently supports: "cpu", "cuda/cuda-like". + mesh_shape (Tuple[int]): A tuple defining the dimensions of the multi-dimensional array + describing the layout of devices. + mesh_dim_names (Tuple[str], optional): A tuple of mesh dimension names to assign to each dimension + of the multi-dimensional array describing the layout of devices. Its length must match the length + of `mesh_shape`. Each string in `mesh_dim_names` must be unique. + + Returns: + DeviceMesh: A :class:`DeviceMesh` object representing the device layout. + + Example:: + >>> # xdoctest: +SKIP("no rank") + >>> from torch.distributed.device_mesh import init_device_mesh + >>> + >>> mesh_1d = init_device_mesh("cuda", mesh_shape=(8,)) + >>> mesh_2d = init_device_mesh("cuda", mesh_shape=(2, 8), mesh_dim_names=("dp", "tp")) + + """ + if mesh_dim_names is not None: + if len(set(mesh_dim_names)) != len(mesh_dim_names): + raise RuntimeError( + "Each mesh_dim_name must be unique.", + f"Found repeated mesh_dim_name in mesh_dim_names {mesh_dim_names}", + ) + + if len(mesh_shape) != len(mesh_dim_names): + raise RuntimeError( + "mesh_shape and mesh_dim_names should have same length!", + f"Found len(mesh_dim_names): {len(mesh_dim_names)} and len(mesh_shape):{len(mesh_shape)}.", + ) + + mesh = torch.arange(math.prod(mesh_shape)).view(mesh_shape) + device_mesh = DeviceMesh( + device_type=device_type, + mesh=mesh, + mesh_dim_names=mesh_dim_names, + ) + + return device_mesh diff --git a/shared/package-files/41/41f0e2a823a0cd2c8273e38146fd1ddfcdccc8b5b5c4a4575ef365256681017a/blob b/shared/package-files/41/41f0e2a823a0cd2c8273e38146fd1ddfcdccc8b5b5c4a4575ef365256681017a/blob new file mode 100644 index 0000000000000000000000000000000000000000..0ae7c772afd975d6388e43a916144331a57294bd Binary files /dev/null and b/shared/package-files/41/41f0e2a823a0cd2c8273e38146fd1ddfcdccc8b5b5c4a4575ef365256681017a/blob differ diff --git a/shared/package-files/41/41f62f4991e9fa89ec25bc78a82a65e4f6773e67ba8b900be61d360035c38188/blob b/shared/package-files/41/41f62f4991e9fa89ec25bc78a82a65e4f6773e67ba8b900be61d360035c38188/blob new file mode 100644 index 0000000000000000000000000000000000000000..05f8e3fb21f21825abad1674ea2aebef79db4c43 --- /dev/null +++ b/shared/package-files/41/41f62f4991e9fa89ec25bc78a82a65e4f6773e67ba8b900be61d360035c38188/blob @@ -0,0 +1,61 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API bartlett_window { + using schema = at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bartlett_window") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bartlett_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor") + static at::Tensor call(int64_t window_length, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +}; + +struct TORCH_API bartlett_window_periodic { + using schema = at::Tensor (int64_t, bool, c10::optional, c10::optional, c10::optional, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bartlett_window") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "periodic") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bartlett_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor") + static at::Tensor call(int64_t window_length, bool periodic, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, bool periodic, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +}; + +struct TORCH_API bartlett_window_out { + using schema = at::Tensor & (int64_t, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bartlett_window") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bartlett_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(int64_t window_length, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, at::Tensor & out); +}; + +struct TORCH_API bartlett_window_periodic_out { + using schema = at::Tensor & (int64_t, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bartlett_window") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "periodic_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bartlett_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(int64_t window_length, bool periodic, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, int64_t window_length, bool periodic, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/41/41f694531f93d0588a0490416f76c3965b7c3bc79313b3298a0abbc2f0dea517/blob b/shared/package-files/41/41f694531f93d0588a0490416f76c3965b7c3bc79313b3298a0abbc2f0dea517/blob new file mode 100644 index 0000000000000000000000000000000000000000..08c826ff6d43a7e34be0adfd28f7f542ec3c21f2 --- /dev/null +++ b/shared/package-files/41/41f694531f93d0588a0490416f76c3965b7c3bc79313b3298a0abbc2f0dea517/blob @@ -0,0 +1,955 @@ +# mypy: allow-untyped-defs +"""Access and control log capturing.""" + +from __future__ import annotations + +from contextlib import contextmanager +from contextlib import nullcontext +from datetime import datetime +from datetime import timedelta +from datetime import timezone +import io +from io import StringIO +import logging +from logging import LogRecord +import os +from pathlib import Path +import re +from types import TracebackType +from typing import AbstractSet +from typing import Dict +from typing import final +from typing import Generator +from typing import Generic +from typing import List +from typing import Literal +from typing import Mapping +from typing import TYPE_CHECKING +from typing import TypeVar + +from _pytest import nodes +from _pytest._io import TerminalWriter +from _pytest.capture import CaptureManager +from _pytest.config import _strtobool +from _pytest.config import Config +from _pytest.config import create_terminal_writer +from _pytest.config import hookimpl +from _pytest.config import UsageError +from _pytest.config.argparsing import Parser +from _pytest.deprecated import check_ispytest +from _pytest.fixtures import fixture +from _pytest.fixtures import FixtureRequest +from _pytest.main import Session +from _pytest.stash import StashKey +from _pytest.terminal import TerminalReporter + + +if TYPE_CHECKING: + logging_StreamHandler = logging.StreamHandler[StringIO] +else: + logging_StreamHandler = logging.StreamHandler + +DEFAULT_LOG_FORMAT = "%(levelname)-8s %(name)s:%(filename)s:%(lineno)d %(message)s" +DEFAULT_LOG_DATE_FORMAT = "%H:%M:%S" +_ANSI_ESCAPE_SEQ = re.compile(r"\x1b\[[\d;]+m") +caplog_handler_key = StashKey["LogCaptureHandler"]() +caplog_records_key = StashKey[Dict[str, List[logging.LogRecord]]]() + + +def _remove_ansi_escape_sequences(text: str) -> str: + return _ANSI_ESCAPE_SEQ.sub("", text) + + +class DatetimeFormatter(logging.Formatter): + """A logging formatter which formats record with + :func:`datetime.datetime.strftime` formatter instead of + :func:`time.strftime` in case of microseconds in format string. + """ + + def formatTime(self, record: LogRecord, datefmt: str | None = None) -> str: + if datefmt and "%f" in datefmt: + ct = self.converter(record.created) + tz = timezone(timedelta(seconds=ct.tm_gmtoff), ct.tm_zone) + # Construct `datetime.datetime` object from `struct_time` + # and msecs information from `record` + # Using int() instead of round() to avoid it exceeding 1_000_000 and causing a ValueError (#11861). + dt = datetime(*ct[0:6], microsecond=int(record.msecs * 1000), tzinfo=tz) + return dt.strftime(datefmt) + # Use `logging.Formatter` for non-microsecond formats + return super().formatTime(record, datefmt) + + +class ColoredLevelFormatter(DatetimeFormatter): + """A logging formatter which colorizes the %(levelname)..s part of the + log format passed to __init__.""" + + LOGLEVEL_COLOROPTS: Mapping[int, AbstractSet[str]] = { + logging.CRITICAL: {"red"}, + logging.ERROR: {"red", "bold"}, + logging.WARNING: {"yellow"}, + logging.WARN: {"yellow"}, + logging.INFO: {"green"}, + logging.DEBUG: {"purple"}, + logging.NOTSET: set(), + } + LEVELNAME_FMT_REGEX = re.compile(r"%\(levelname\)([+-.]?\d*(?:\.\d+)?s)") + + def __init__(self, terminalwriter: TerminalWriter, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + self._terminalwriter = terminalwriter + self._original_fmt = self._style._fmt + self._level_to_fmt_mapping: dict[int, str] = {} + + for level, color_opts in self.LOGLEVEL_COLOROPTS.items(): + self.add_color_level(level, *color_opts) + + def add_color_level(self, level: int, *color_opts: str) -> None: + """Add or update color opts for a log level. + + :param level: + Log level to apply a style to, e.g. ``logging.INFO``. + :param color_opts: + ANSI escape sequence color options. Capitalized colors indicates + background color, i.e. ``'green', 'Yellow', 'bold'`` will give bold + green text on yellow background. + + .. warning:: + This is an experimental API. + """ + assert self._fmt is not None + levelname_fmt_match = self.LEVELNAME_FMT_REGEX.search(self._fmt) + if not levelname_fmt_match: + return + levelname_fmt = levelname_fmt_match.group() + + formatted_levelname = levelname_fmt % {"levelname": logging.getLevelName(level)} + + # add ANSI escape sequences around the formatted levelname + color_kwargs = {name: True for name in color_opts} + colorized_formatted_levelname = self._terminalwriter.markup( + formatted_levelname, **color_kwargs + ) + self._level_to_fmt_mapping[level] = self.LEVELNAME_FMT_REGEX.sub( + colorized_formatted_levelname, self._fmt + ) + + def format(self, record: logging.LogRecord) -> str: + fmt = self._level_to_fmt_mapping.get(record.levelno, self._original_fmt) + self._style._fmt = fmt + return super().format(record) + + +class PercentStyleMultiline(logging.PercentStyle): + """A logging style with special support for multiline messages. + + If the message of a record consists of multiple lines, this style + formats the message as if each line were logged separately. + """ + + def __init__(self, fmt: str, auto_indent: int | str | bool | None) -> None: + super().__init__(fmt) + self._auto_indent = self._get_auto_indent(auto_indent) + + @staticmethod + def _get_auto_indent(auto_indent_option: int | str | bool | None) -> int: + """Determine the current auto indentation setting. + + Specify auto indent behavior (on/off/fixed) by passing in + extra={"auto_indent": [value]} to the call to logging.log() or + using a --log-auto-indent [value] command line or the + log_auto_indent [value] config option. + + Default behavior is auto-indent off. + + Using the string "True" or "on" or the boolean True as the value + turns auto indent on, using the string "False" or "off" or the + boolean False or the int 0 turns it off, and specifying a + positive integer fixes the indentation position to the value + specified. + + Any other values for the option are invalid, and will silently be + converted to the default. + + :param None|bool|int|str auto_indent_option: + User specified option for indentation from command line, config + or extra kwarg. Accepts int, bool or str. str option accepts the + same range of values as boolean config options, as well as + positive integers represented in str form. + + :returns: + Indentation value, which can be + -1 (automatically determine indentation) or + 0 (auto-indent turned off) or + >0 (explicitly set indentation position). + """ + if auto_indent_option is None: + return 0 + elif isinstance(auto_indent_option, bool): + if auto_indent_option: + return -1 + else: + return 0 + elif isinstance(auto_indent_option, int): + return int(auto_indent_option) + elif isinstance(auto_indent_option, str): + try: + return int(auto_indent_option) + except ValueError: + pass + try: + if _strtobool(auto_indent_option): + return -1 + except ValueError: + return 0 + + return 0 + + def format(self, record: logging.LogRecord) -> str: + if "\n" in record.message: + if hasattr(record, "auto_indent"): + # Passed in from the "extra={}" kwarg on the call to logging.log(). + auto_indent = self._get_auto_indent(record.auto_indent) + else: + auto_indent = self._auto_indent + + if auto_indent: + lines = record.message.splitlines() + formatted = self._fmt % {**record.__dict__, "message": lines[0]} + + if auto_indent < 0: + indentation = _remove_ansi_escape_sequences(formatted).find( + lines[0] + ) + else: + # Optimizes logging by allowing a fixed indentation. + indentation = auto_indent + lines[0] = formatted + return ("\n" + " " * indentation).join(lines) + return self._fmt % record.__dict__ + + +def get_option_ini(config: Config, *names: str): + for name in names: + ret = config.getoption(name) # 'default' arg won't work as expected + if ret is None: + ret = config.getini(name) + if ret: + return ret + + +def pytest_addoption(parser: Parser) -> None: + """Add options to control log capturing.""" + group = parser.getgroup("logging") + + def add_option_ini(option, dest, default=None, type=None, **kwargs): + parser.addini( + dest, default=default, type=type, help="Default value for " + option + ) + group.addoption(option, dest=dest, **kwargs) + + add_option_ini( + "--log-level", + dest="log_level", + default=None, + metavar="LEVEL", + help=( + "Level of messages to catch/display." + " Not set by default, so it depends on the root/parent log handler's" + ' effective level, where it is "WARNING" by default.' + ), + ) + add_option_ini( + "--log-format", + dest="log_format", + default=DEFAULT_LOG_FORMAT, + help="Log format used by the logging module", + ) + add_option_ini( + "--log-date-format", + dest="log_date_format", + default=DEFAULT_LOG_DATE_FORMAT, + help="Log date format used by the logging module", + ) + parser.addini( + "log_cli", + default=False, + type="bool", + help='Enable log display during test run (also known as "live logging")', + ) + add_option_ini( + "--log-cli-level", dest="log_cli_level", default=None, help="CLI logging level" + ) + add_option_ini( + "--log-cli-format", + dest="log_cli_format", + default=None, + help="Log format used by the logging module", + ) + add_option_ini( + "--log-cli-date-format", + dest="log_cli_date_format", + default=None, + help="Log date format used by the logging module", + ) + add_option_ini( + "--log-file", + dest="log_file", + default=None, + help="Path to a file when logging will be written to", + ) + add_option_ini( + "--log-file-mode", + dest="log_file_mode", + default="w", + choices=["w", "a"], + help="Log file open mode", + ) + add_option_ini( + "--log-file-level", + dest="log_file_level", + default=None, + help="Log file logging level", + ) + add_option_ini( + "--log-file-format", + dest="log_file_format", + default=None, + help="Log format used by the logging module", + ) + add_option_ini( + "--log-file-date-format", + dest="log_file_date_format", + default=None, + help="Log date format used by the logging module", + ) + add_option_ini( + "--log-auto-indent", + dest="log_auto_indent", + default=None, + help="Auto-indent multiline messages passed to the logging module. Accepts true|on, false|off or an integer.", + ) + group.addoption( + "--log-disable", + action="append", + default=[], + dest="logger_disable", + help="Disable a logger by name. Can be passed multiple times.", + ) + + +_HandlerType = TypeVar("_HandlerType", bound=logging.Handler) + + +# Not using @contextmanager for performance reasons. +class catching_logs(Generic[_HandlerType]): + """Context manager that prepares the whole logging machinery properly.""" + + __slots__ = ("handler", "level", "orig_level") + + def __init__(self, handler: _HandlerType, level: int | None = None) -> None: + self.handler = handler + self.level = level + + def __enter__(self) -> _HandlerType: + root_logger = logging.getLogger() + if self.level is not None: + self.handler.setLevel(self.level) + root_logger.addHandler(self.handler) + if self.level is not None: + self.orig_level = root_logger.level + root_logger.setLevel(min(self.orig_level, self.level)) + return self.handler + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + root_logger = logging.getLogger() + if self.level is not None: + root_logger.setLevel(self.orig_level) + root_logger.removeHandler(self.handler) + + +class LogCaptureHandler(logging_StreamHandler): + """A logging handler that stores log records and the log text.""" + + def __init__(self) -> None: + """Create a new log handler.""" + super().__init__(StringIO()) + self.records: list[logging.LogRecord] = [] + + def emit(self, record: logging.LogRecord) -> None: + """Keep the log records in a list in addition to the log text.""" + self.records.append(record) + super().emit(record) + + def reset(self) -> None: + self.records = [] + self.stream = StringIO() + + def clear(self) -> None: + self.records.clear() + self.stream = StringIO() + + def handleError(self, record: logging.LogRecord) -> None: + if logging.raiseExceptions: + # Fail the test if the log message is bad (emit failed). + # The default behavior of logging is to print "Logging error" + # to stderr with the call stack and some extra details. + # pytest wants to make such mistakes visible during testing. + raise # noqa: PLE0704 + + +@final +class LogCaptureFixture: + """Provides access and control of log capturing.""" + + def __init__(self, item: nodes.Node, *, _ispytest: bool = False) -> None: + check_ispytest(_ispytest) + self._item = item + self._initial_handler_level: int | None = None + # Dict of log name -> log level. + self._initial_logger_levels: dict[str | None, int] = {} + self._initial_disabled_logging_level: int | None = None + + def _finalize(self) -> None: + """Finalize the fixture. + + This restores the log levels and the disabled logging levels changed by :meth:`set_level`. + """ + # Restore log levels. + if self._initial_handler_level is not None: + self.handler.setLevel(self._initial_handler_level) + for logger_name, level in self._initial_logger_levels.items(): + logger = logging.getLogger(logger_name) + logger.setLevel(level) + # Disable logging at the original disabled logging level. + if self._initial_disabled_logging_level is not None: + logging.disable(self._initial_disabled_logging_level) + self._initial_disabled_logging_level = None + + @property + def handler(self) -> LogCaptureHandler: + """Get the logging handler used by the fixture.""" + return self._item.stash[caplog_handler_key] + + def get_records( + self, when: Literal["setup", "call", "teardown"] + ) -> list[logging.LogRecord]: + """Get the logging records for one of the possible test phases. + + :param when: + Which test phase to obtain the records from. + Valid values are: "setup", "call" and "teardown". + + :returns: The list of captured records at the given stage. + + .. versionadded:: 3.4 + """ + return self._item.stash[caplog_records_key].get(when, []) + + @property + def text(self) -> str: + """The formatted log text.""" + return _remove_ansi_escape_sequences(self.handler.stream.getvalue()) + + @property + def records(self) -> list[logging.LogRecord]: + """The list of log records.""" + return self.handler.records + + @property + def record_tuples(self) -> list[tuple[str, int, str]]: + """A list of a stripped down version of log records intended + for use in assertion comparison. + + The format of the tuple is: + + (logger_name, log_level, message) + """ + return [(r.name, r.levelno, r.getMessage()) for r in self.records] + + @property + def messages(self) -> list[str]: + """A list of format-interpolated log messages. + + Unlike 'records', which contains the format string and parameters for + interpolation, log messages in this list are all interpolated. + + Unlike 'text', which contains the output from the handler, log + messages in this list are unadorned with levels, timestamps, etc, + making exact comparisons more reliable. + + Note that traceback or stack info (from :func:`logging.exception` or + the `exc_info` or `stack_info` arguments to the logging functions) is + not included, as this is added by the formatter in the handler. + + .. versionadded:: 3.7 + """ + return [r.getMessage() for r in self.records] + + def clear(self) -> None: + """Reset the list of log records and the captured log text.""" + self.handler.clear() + + def _force_enable_logging( + self, level: int | str, logger_obj: logging.Logger + ) -> int: + """Enable the desired logging level if the global level was disabled via ``logging.disabled``. + + Only enables logging levels greater than or equal to the requested ``level``. + + Does nothing if the desired ``level`` wasn't disabled. + + :param level: + The logger level caplog should capture. + All logging is enabled if a non-standard logging level string is supplied. + Valid level strings are in :data:`logging._nameToLevel`. + :param logger_obj: The logger object to check. + + :return: The original disabled logging level. + """ + original_disable_level: int = logger_obj.manager.disable + + if isinstance(level, str): + # Try to translate the level string to an int for `logging.disable()` + level = logging.getLevelName(level) + + if not isinstance(level, int): + # The level provided was not valid, so just un-disable all logging. + logging.disable(logging.NOTSET) + elif not logger_obj.isEnabledFor(level): + # Each level is `10` away from other levels. + # https://docs.python.org/3/library/logging.html#logging-levels + disable_level = max(level - 10, logging.NOTSET) + logging.disable(disable_level) + + return original_disable_level + + def set_level(self, level: int | str, logger: str | None = None) -> None: + """Set the threshold level of a logger for the duration of a test. + + Logging messages which are less severe than this level will not be captured. + + .. versionchanged:: 3.4 + The levels of the loggers changed by this function will be + restored to their initial values at the end of the test. + + Will enable the requested logging level if it was disabled via :func:`logging.disable`. + + :param level: The level. + :param logger: The logger to update. If not given, the root logger. + """ + logger_obj = logging.getLogger(logger) + # Save the original log-level to restore it during teardown. + self._initial_logger_levels.setdefault(logger, logger_obj.level) + logger_obj.setLevel(level) + if self._initial_handler_level is None: + self._initial_handler_level = self.handler.level + self.handler.setLevel(level) + initial_disabled_logging_level = self._force_enable_logging(level, logger_obj) + if self._initial_disabled_logging_level is None: + self._initial_disabled_logging_level = initial_disabled_logging_level + + @contextmanager + def at_level(self, level: int | str, logger: str | None = None) -> Generator[None]: + """Context manager that sets the level for capturing of logs. After + the end of the 'with' statement the level is restored to its original + value. + + Will enable the requested logging level if it was disabled via :func:`logging.disable`. + + :param level: The level. + :param logger: The logger to update. If not given, the root logger. + """ + logger_obj = logging.getLogger(logger) + orig_level = logger_obj.level + logger_obj.setLevel(level) + handler_orig_level = self.handler.level + self.handler.setLevel(level) + original_disable_level = self._force_enable_logging(level, logger_obj) + try: + yield + finally: + logger_obj.setLevel(orig_level) + self.handler.setLevel(handler_orig_level) + logging.disable(original_disable_level) + + @contextmanager + def filtering(self, filter_: logging.Filter) -> Generator[None]: + """Context manager that temporarily adds the given filter to the caplog's + :meth:`handler` for the 'with' statement block, and removes that filter at the + end of the block. + + :param filter_: A custom :class:`logging.Filter` object. + + .. versionadded:: 7.5 + """ + self.handler.addFilter(filter_) + try: + yield + finally: + self.handler.removeFilter(filter_) + + +@fixture +def caplog(request: FixtureRequest) -> Generator[LogCaptureFixture]: + """Access and control log capturing. + + Captured logs are available through the following properties/methods:: + + * caplog.messages -> list of format-interpolated log messages + * caplog.text -> string containing formatted log output + * caplog.records -> list of logging.LogRecord instances + * caplog.record_tuples -> list of (logger_name, level, message) tuples + * caplog.clear() -> clear captured records and formatted log output string + """ + result = LogCaptureFixture(request.node, _ispytest=True) + yield result + result._finalize() + + +def get_log_level_for_setting(config: Config, *setting_names: str) -> int | None: + for setting_name in setting_names: + log_level = config.getoption(setting_name) + if log_level is None: + log_level = config.getini(setting_name) + if log_level: + break + else: + return None + + if isinstance(log_level, str): + log_level = log_level.upper() + try: + return int(getattr(logging, log_level, log_level)) + except ValueError as e: + # Python logging does not recognise this as a logging level + raise UsageError( + f"'{log_level}' is not recognized as a logging level name for " + f"'{setting_name}'. Please consider passing the " + "logging level num instead." + ) from e + + +# run after terminalreporter/capturemanager are configured +@hookimpl(trylast=True) +def pytest_configure(config: Config) -> None: + config.pluginmanager.register(LoggingPlugin(config), "logging-plugin") + + +class LoggingPlugin: + """Attaches to the logging module and captures log messages for each test.""" + + def __init__(self, config: Config) -> None: + """Create a new plugin to capture log messages. + + The formatter can be safely shared across all handlers so + create a single one for the entire test session here. + """ + self._config = config + + # Report logging. + self.formatter = self._create_formatter( + get_option_ini(config, "log_format"), + get_option_ini(config, "log_date_format"), + get_option_ini(config, "log_auto_indent"), + ) + self.log_level = get_log_level_for_setting(config, "log_level") + self.caplog_handler = LogCaptureHandler() + self.caplog_handler.setFormatter(self.formatter) + self.report_handler = LogCaptureHandler() + self.report_handler.setFormatter(self.formatter) + + # File logging. + self.log_file_level = get_log_level_for_setting( + config, "log_file_level", "log_level" + ) + log_file = get_option_ini(config, "log_file") or os.devnull + if log_file != os.devnull: + directory = os.path.dirname(os.path.abspath(log_file)) + if not os.path.isdir(directory): + os.makedirs(directory) + + self.log_file_mode = get_option_ini(config, "log_file_mode") or "w" + self.log_file_handler = _FileHandler( + log_file, mode=self.log_file_mode, encoding="UTF-8" + ) + log_file_format = get_option_ini(config, "log_file_format", "log_format") + log_file_date_format = get_option_ini( + config, "log_file_date_format", "log_date_format" + ) + + log_file_formatter = DatetimeFormatter( + log_file_format, datefmt=log_file_date_format + ) + self.log_file_handler.setFormatter(log_file_formatter) + + # CLI/live logging. + self.log_cli_level = get_log_level_for_setting( + config, "log_cli_level", "log_level" + ) + if self._log_cli_enabled(): + terminal_reporter = config.pluginmanager.get_plugin("terminalreporter") + # Guaranteed by `_log_cli_enabled()`. + assert terminal_reporter is not None + capture_manager = config.pluginmanager.get_plugin("capturemanager") + # if capturemanager plugin is disabled, live logging still works. + self.log_cli_handler: ( + _LiveLoggingStreamHandler | _LiveLoggingNullHandler + ) = _LiveLoggingStreamHandler(terminal_reporter, capture_manager) + else: + self.log_cli_handler = _LiveLoggingNullHandler() + log_cli_formatter = self._create_formatter( + get_option_ini(config, "log_cli_format", "log_format"), + get_option_ini(config, "log_cli_date_format", "log_date_format"), + get_option_ini(config, "log_auto_indent"), + ) + self.log_cli_handler.setFormatter(log_cli_formatter) + self._disable_loggers(loggers_to_disable=config.option.logger_disable) + + def _disable_loggers(self, loggers_to_disable: list[str]) -> None: + if not loggers_to_disable: + return + + for name in loggers_to_disable: + logger = logging.getLogger(name) + logger.disabled = True + + def _create_formatter(self, log_format, log_date_format, auto_indent): + # Color option doesn't exist if terminal plugin is disabled. + color = getattr(self._config.option, "color", "no") + if color != "no" and ColoredLevelFormatter.LEVELNAME_FMT_REGEX.search( + log_format + ): + formatter: logging.Formatter = ColoredLevelFormatter( + create_terminal_writer(self._config), log_format, log_date_format + ) + else: + formatter = DatetimeFormatter(log_format, log_date_format) + + formatter._style = PercentStyleMultiline( + formatter._style._fmt, auto_indent=auto_indent + ) + + return formatter + + def set_log_path(self, fname: str) -> None: + """Set the filename parameter for Logging.FileHandler(). + + Creates parent directory if it does not exist. + + .. warning:: + This is an experimental API. + """ + fpath = Path(fname) + + if not fpath.is_absolute(): + fpath = self._config.rootpath / fpath + + if not fpath.parent.exists(): + fpath.parent.mkdir(exist_ok=True, parents=True) + + # https://github.com/python/mypy/issues/11193 + stream: io.TextIOWrapper = fpath.open(mode=self.log_file_mode, encoding="UTF-8") # type: ignore[assignment] + old_stream = self.log_file_handler.setStream(stream) + if old_stream: + old_stream.close() + + def _log_cli_enabled(self) -> bool: + """Return whether live logging is enabled.""" + enabled = self._config.getoption( + "--log-cli-level" + ) is not None or self._config.getini("log_cli") + if not enabled: + return False + + terminal_reporter = self._config.pluginmanager.get_plugin("terminalreporter") + if terminal_reporter is None: + # terminal reporter is disabled e.g. by pytest-xdist. + return False + + return True + + @hookimpl(wrapper=True, tryfirst=True) + def pytest_sessionstart(self) -> Generator[None]: + self.log_cli_handler.set_when("sessionstart") + + with catching_logs(self.log_cli_handler, level=self.log_cli_level): + with catching_logs(self.log_file_handler, level=self.log_file_level): + return (yield) + + @hookimpl(wrapper=True, tryfirst=True) + def pytest_collection(self) -> Generator[None]: + self.log_cli_handler.set_when("collection") + + with catching_logs(self.log_cli_handler, level=self.log_cli_level): + with catching_logs(self.log_file_handler, level=self.log_file_level): + return (yield) + + @hookimpl(wrapper=True) + def pytest_runtestloop(self, session: Session) -> Generator[None, object, object]: + if session.config.option.collectonly: + return (yield) + + if self._log_cli_enabled() and self._config.get_verbosity() < 1: + # The verbose flag is needed to avoid messy test progress output. + self._config.option.verbose = 1 + + with catching_logs(self.log_cli_handler, level=self.log_cli_level): + with catching_logs(self.log_file_handler, level=self.log_file_level): + return (yield) # Run all the tests. + + @hookimpl + def pytest_runtest_logstart(self) -> None: + self.log_cli_handler.reset() + self.log_cli_handler.set_when("start") + + @hookimpl + def pytest_runtest_logreport(self) -> None: + self.log_cli_handler.set_when("logreport") + + def _runtest_for(self, item: nodes.Item, when: str) -> Generator[None]: + """Implement the internals of the pytest_runtest_xxx() hooks.""" + with catching_logs( + self.caplog_handler, + level=self.log_level, + ) as caplog_handler, catching_logs( + self.report_handler, + level=self.log_level, + ) as report_handler: + caplog_handler.reset() + report_handler.reset() + item.stash[caplog_records_key][when] = caplog_handler.records + item.stash[caplog_handler_key] = caplog_handler + + try: + yield + finally: + log = report_handler.stream.getvalue().strip() + item.add_report_section(when, "log", log) + + @hookimpl(wrapper=True) + def pytest_runtest_setup(self, item: nodes.Item) -> Generator[None]: + self.log_cli_handler.set_when("setup") + + empty: dict[str, list[logging.LogRecord]] = {} + item.stash[caplog_records_key] = empty + yield from self._runtest_for(item, "setup") + + @hookimpl(wrapper=True) + def pytest_runtest_call(self, item: nodes.Item) -> Generator[None]: + self.log_cli_handler.set_when("call") + + yield from self._runtest_for(item, "call") + + @hookimpl(wrapper=True) + def pytest_runtest_teardown(self, item: nodes.Item) -> Generator[None]: + self.log_cli_handler.set_when("teardown") + + try: + yield from self._runtest_for(item, "teardown") + finally: + del item.stash[caplog_records_key] + del item.stash[caplog_handler_key] + + @hookimpl + def pytest_runtest_logfinish(self) -> None: + self.log_cli_handler.set_when("finish") + + @hookimpl(wrapper=True, tryfirst=True) + def pytest_sessionfinish(self) -> Generator[None]: + self.log_cli_handler.set_when("sessionfinish") + + with catching_logs(self.log_cli_handler, level=self.log_cli_level): + with catching_logs(self.log_file_handler, level=self.log_file_level): + return (yield) + + @hookimpl + def pytest_unconfigure(self) -> None: + # Close the FileHandler explicitly. + # (logging.shutdown might have lost the weakref?!) + self.log_file_handler.close() + + +class _FileHandler(logging.FileHandler): + """A logging FileHandler with pytest tweaks.""" + + def handleError(self, record: logging.LogRecord) -> None: + # Handled by LogCaptureHandler. + pass + + +class _LiveLoggingStreamHandler(logging_StreamHandler): + """A logging StreamHandler used by the live logging feature: it will + write a newline before the first log message in each test. + + During live logging we must also explicitly disable stdout/stderr + capturing otherwise it will get captured and won't appear in the + terminal. + """ + + # Officially stream needs to be a IO[str], but TerminalReporter + # isn't. So force it. + stream: TerminalReporter = None # type: ignore + + def __init__( + self, + terminal_reporter: TerminalReporter, + capture_manager: CaptureManager | None, + ) -> None: + super().__init__(stream=terminal_reporter) # type: ignore[arg-type] + self.capture_manager = capture_manager + self.reset() + self.set_when(None) + self._test_outcome_written = False + + def reset(self) -> None: + """Reset the handler; should be called before the start of each test.""" + self._first_record_emitted = False + + def set_when(self, when: str | None) -> None: + """Prepare for the given test phase (setup/call/teardown).""" + self._when = when + self._section_name_shown = False + if when == "start": + self._test_outcome_written = False + + def emit(self, record: logging.LogRecord) -> None: + ctx_manager = ( + self.capture_manager.global_and_fixture_disabled() + if self.capture_manager + else nullcontext() + ) + with ctx_manager: + if not self._first_record_emitted: + self.stream.write("\n") + self._first_record_emitted = True + elif self._when in ("teardown", "finish"): + if not self._test_outcome_written: + self._test_outcome_written = True + self.stream.write("\n") + if not self._section_name_shown and self._when: + self.stream.section("live log " + self._when, sep="-", bold=True) + self._section_name_shown = True + super().emit(record) + + def handleError(self, record: logging.LogRecord) -> None: + # Handled by LogCaptureHandler. + pass + + +class _LiveLoggingNullHandler(logging.NullHandler): + """A logging handler used when live logging is disabled.""" + + def reset(self) -> None: + pass + + def set_when(self, when: str) -> None: + pass + + def handleError(self, record: logging.LogRecord) -> None: + # Handled by LogCaptureHandler. + pass diff --git a/shared/package-files/41/41f87914952ff5959dfcfe73c64bd860892faac3e9b60683b8a91e5ff17cbf20/blob b/shared/package-files/41/41f87914952ff5959dfcfe73c64bd860892faac3e9b60683b8a91e5ff17cbf20/blob new file mode 100644 index 0000000000000000000000000000000000000000..5e29c79e34a73bdfbbcc2571333bfdd28007e07f --- /dev/null +++ b/shared/package-files/41/41f87914952ff5959dfcfe73c64bd860892faac3e9b60683b8a91e5ff17cbf20/blob @@ -0,0 +1,20 @@ +#if defined(DETECT_FEATURES) && defined(__INTEL_COMPILER) + /* + * Unlike GCC and CLANG, Intel Compiler exposes all supported intrinsics, + * whether or not the build options for those features are specified. + * Therefore, we must test #definitions of CPU features when option native/host + * is enabled via `--cpu-baseline` or through env var `CFLAGS` otherwise + * the test will be broken and leads to enable all possible features. + */ + #ifndef __AVX512CD__ + #error "HOST/ARCH doesn't support AVX512CD" + #endif +#endif + +#include + +int main(int argc, char **argv) +{ + __m512i a = _mm512_lzcnt_epi32(_mm512_loadu_si512((const __m512i*)argv[argc-1])); + return _mm_cvtsi128_si32(_mm512_castsi512_si128(a)); +} diff --git a/shared/package-files/41/41f9e80776a2884bd4ce7f15057874d73a651d08246dd33cb70e9dcb4c7aec17/blob b/shared/package-files/41/41f9e80776a2884bd4ce7f15057874d73a651d08246dd33cb70e9dcb4c7aec17/blob new file mode 100644 index 0000000000000000000000000000000000000000..d89b121b2dd5894eabdd25ace948dd4157a97fb8 --- /dev/null +++ b/shared/package-files/41/41f9e80776a2884bd4ce7f15057874d73a651d08246dd33cb70e9dcb4c7aec17/blob @@ -0,0 +1,490 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +class Tensor; +} +namespace c10 { +struct IValue; +template class List; +struct Type; + +namespace detail { + +struct ListImpl final : public c10::intrusive_ptr_target { + using list_type = std::vector; + + explicit TORCH_API ListImpl(list_type list_, TypePtr elementType_); + + list_type list; + + TypePtr elementType; + + intrusive_ptr copy() const { + return make_intrusive(list, elementType); + } + friend TORCH_API bool operator==(const ListImpl& lhs, const ListImpl& rhs); +}; +} + +namespace impl { + +template class ListIterator; + +template class ListElementReference; + +template +void swap(ListElementReference&& lhs, ListElementReference&& rhs); + +template +bool operator==(const ListElementReference& lhs, const T& rhs); + +template +bool operator==(const T& lhs, const ListElementReference& rhs); + +template +struct ListElementConstReferenceTraits { + // In the general case, we use IValue::to(). + using const_reference = typename c10::detail::ivalue_to_const_ref_overload_return::type; +}; + +// There is no to() overload for c10::optional. +template<> +struct ListElementConstReferenceTraits> { + using const_reference = c10::optional>; +}; + +template +class ListElementReference final { +public: + operator std::conditional_t< + std::is_reference::type>::value, + const T&, + T>() const; + + ListElementReference& operator=(T&& new_value) &&; + + ListElementReference& operator=(const T& new_value) &&; + + // assigning another ref to this assigns the underlying value + ListElementReference& operator=(ListElementReference&& rhs) && noexcept; + + const IValue& get() const& { + return *iterator_; + } + + friend void swap(ListElementReference&& lhs, ListElementReference&& rhs); + + ListElementReference(const ListElementReference&) = delete; + ListElementReference& operator=(const ListElementReference&) = delete; + +private: + ListElementReference(Iterator iter) + : iterator_(iter) {} + + // allow moving, but only our friends (i.e. the List class) can move us + ListElementReference(ListElementReference&&) noexcept = default; + ListElementReference& operator=(ListElementReference&& rhs) & noexcept { + iterator_ = std::move(rhs.iterator_); + return *this; + } + + friend class List; + friend class ListIterator; + + Iterator iterator_; +}; + +// this wraps vector::iterator to make sure user code can't rely +// on it being the type of the underlying vector. +template +class ListIterator final { + public: + // C++17 friendly std::iterator implementation + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = std::ptrdiff_t; + using pointer = T*; + using reference = ListElementReference; + + explicit ListIterator() = default; + ~ListIterator() = default; + + ListIterator(const ListIterator&) = default; + ListIterator(ListIterator&&) noexcept = default; + ListIterator& operator=(const ListIterator&) = default; + ListIterator& operator=(ListIterator&&) noexcept = default; + + ListIterator& operator++() { + ++iterator_; + return *this; + } + + ListIterator operator++(int) { + ListIterator copy(*this); + ++*this; + return copy; + } + + ListIterator& operator--() { + --iterator_; + return *this; + } + + ListIterator operator--(int) { + ListIterator copy(*this); + --*this; + return copy; + } + + ListIterator& operator+=(typename List::size_type offset) { + iterator_ += offset; + return *this; + } + + ListIterator& operator-=(typename List::size_type offset) { + iterator_ -= offset; + return *this; + } + + ListIterator operator+(typename List::size_type offset) const { + return ListIterator{iterator_ + offset}; + } + + ListIterator operator-(typename List::size_type offset) const { + return ListIterator{iterator_ - offset}; + } + + friend difference_type operator-(const ListIterator& lhs, const ListIterator& rhs) { + return lhs.iterator_ - rhs.iterator_; + } + + ListElementReference operator*() const { + return {iterator_}; + } + + ListElementReference operator[](typename List::size_type offset) const { + return {iterator_ + offset}; + } + +private: + explicit ListIterator(Iterator iterator): iterator_(std::move(iterator)) {} + + Iterator iterator_; + + friend bool operator==(const ListIterator& lhs, const ListIterator& rhs) { + return lhs.iterator_ == rhs.iterator_; + } + + friend bool operator!=(const ListIterator& lhs, const ListIterator& rhs) { + return !(lhs == rhs); + } + + friend bool operator<(const ListIterator& lhs, const ListIterator& rhs) { + return lhs.iterator_ < rhs.iterator_; + } + + friend bool operator<=(const ListIterator& lhs, const ListIterator& rhs) { + return lhs.iterator_ <= rhs.iterator_; + } + + friend bool operator>(const ListIterator& lhs, const ListIterator& rhs) { + return lhs.iterator_ > rhs.iterator_; + } + + friend bool operator>=(const ListIterator& lhs, const ListIterator& rhs) { + return lhs.iterator_ >= rhs.iterator_; + } + + friend class ListIterator; + friend class List; +}; + +template List toTypedList(List list); +template List toList(List&& list); +template List toList(const List& list); +const IValue* ptr_to_first_element(const List& list); +} + +/** + * An object of this class stores a list of values of type T. + * + * This is a pointer type. After a copy, both Lists + * will share the same storage: + * + * > List a; + * > List b = a; + * > b.push_back("three"); + * > ASSERT("three" == a.get(0)); + * + * We use this class in the PyTorch kernel API instead of + * std::vector, because that allows us to do optimizations + * and switch out the underlying list implementation without + * breaking backwards compatibility for the kernel API. + */ +template +class List final { +private: + // This is an intrusive_ptr because List is a pointer type. + // Invariant: This will never be a nullptr, there will always be a valid + // ListImpl. + c10::intrusive_ptr impl_; + + using internal_reference_type = impl::ListElementReference; + using internal_const_reference_type = typename impl::ListElementConstReferenceTraits::const_reference; + +public: + using value_type = T; + using size_type = typename c10::detail::ListImpl::list_type::size_type; + using iterator = impl::ListIterator; + using const_iterator = impl::ListIterator; + using reverse_iterator = impl::ListIterator; + + /** + * Constructs an empty list. + */ + explicit List(); + + /** + * Constructs a list with some initial values. + * Example: + * List a({2, 3, 4}); + */ + List(std::initializer_list initial_values); + explicit List(ArrayRef initial_values); + + /** + * Create a generic list with runtime type information. + * This only works for c10::impl::GenericList and is not part of the public API + * but only supposed to be used internally by PyTorch. + */ + explicit List(TypePtr elementType); + + List(const List&) = default; + List& operator=(const List&) = default; + + /** + * Create a new List pointing to a deep copy of the same data. + * The List returned is a new list with separate storage. + * Changes in it are not reflected in the original list or vice versa. + */ + List copy() const; + + /** + * Returns the element at specified location pos, with bounds checking. + * If pos is not within the range of the container, an exception of type std::out_of_range is thrown. + */ + internal_const_reference_type get(size_type pos) const; + + /** + * Moves out the element at the specified location pos and returns it, with bounds checking. + * If pos is not within the range of the container, an exception of type std::out_of_range is thrown. + * The list contains an invalid element at position pos afterwards. Any operations + * on it before re-setting it are invalid. + */ + value_type extract(size_type pos) const; + + /** + * Returns a reference to the element at specified location pos, with bounds checking. + * If pos is not within the range of the container, an exception of type std::out_of_range is thrown. + * + * You cannot store the reference, but you can read it and assign new values to it: + * + * List list = ...; + * list[2] = 5; + * int64_t v = list[1]; + */ + internal_const_reference_type operator[](size_type pos) const; + + internal_reference_type operator[](size_type pos); + + /** + * Assigns a new value to the element at location pos. + */ + void set(size_type pos, const value_type& value) const; + + /** + * Assigns a new value to the element at location pos. + */ + void set(size_type pos, value_type&& value) const; + + /** + * Returns an iterator to the first element of the container. + * If the container is empty, the returned iterator will be equal to end(). + */ + iterator begin() const; + + /** + * Returns an iterator to the element following the last element of the container. + * This element acts as a placeholder; attempting to access it results in undefined behavior. + */ + iterator end() const; + + /** + * Checks if the container has no elements. + */ + bool empty() const; + + /** + * Returns the number of elements in the container + */ + size_type size() const; + + /** + * Increase the capacity of the vector to a value that's greater or equal to new_cap. + */ + void reserve(size_type new_cap) const; + + /** + * Erases all elements from the container. After this call, size() returns zero. + * Invalidates any references, pointers, or iterators referring to contained elements. Any past-the-end iterators are also invalidated. + */ + void clear() const; + + /** + * Inserts value before pos. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + iterator insert(iterator pos, const T& value) const; + + /** + * Inserts value before pos. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + iterator insert(iterator pos, T&& value) const; + + /** + * Inserts a new element into the container directly before pos. + * The new element is constructed with the given arguments. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + template + iterator emplace(iterator pos, Args&&... value) const; + + /** + * Appends the given element value to the end of the container. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + void push_back(const T& value) const; + + /** + * Appends the given element value to the end of the container. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + void push_back(T&& value) const; + + /** + * Appends the given list to the end of the container. Uses at most one memory allocation. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + void append(List lst) const; + + /** + * Appends the given element value to the end of the container. + * The new element is constructed with the given arguments. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + template + void emplace_back(Args&&... args) const; + + /** + * Removes the element at pos. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + iterator erase(iterator pos) const; + + /** + * Removes the elements in the range [first, last). + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + iterator erase(iterator first, iterator last) const; + + /** + * Removes the last element of the container. + * Calling pop_back on an empty container is undefined. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + void pop_back() const; + + /** + * Resizes the container to contain count elements. + * If the current size is less than count, additional default-inserted elements are appended. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + void resize(size_type count) const; + + /** + * Resizes the container to contain count elements. + * If the current size is less than count, additional copies of value are appended. + * May invalidate any references, pointers, or iterators referring to contained elements. Any past-the-end iterators may also be invalidated. + */ + void resize(size_type count, const T& value) const; + + /** + * Value equality comparison. This function implements Python-like semantics for + * equality: two lists with the same identity (e.g. same pointer) trivially + * compare equal, otherwise each element is compared for equality. + */ + template + friend bool operator==(const List& lhs, const List& rhs); + + template + friend bool operator!=(const List& lhs, const List& rhs); + + /** + * Identity comparison. Returns true if and only if `rhs` represents the same + * List object as `this`. + */ + bool is(const List& rhs) const; + + std::vector vec() const; + + /** + * Returns the number of Lists currently pointing to this same list. + * If this is the only instance pointing to this list, returns 1. + */ + // TODO Test use_count + size_t use_count() const; + + TypePtr elementType() const; + + // See [unsafe set type] for why this exists. + void unsafeSetElementType(TypePtr t); + +private: + explicit List(c10::intrusive_ptr&& elements); + explicit List(const c10::intrusive_ptr& elements); + friend struct IValue; + template friend List impl::toTypedList(List); + template friend List impl::toList(List&&); + template friend List impl::toList(const List&); + friend const IValue* impl::ptr_to_first_element(const List& list); +}; + +namespace impl { +// GenericList is how IValue stores lists. It is, however, not part of the +// public API. Kernels should use Lists with concrete types instead +// (maybe except for some internal prim ops). +using GenericList = List; + +const IValue* ptr_to_first_element(const GenericList& list); + +} +} + +namespace torch { + template using List = c10::List; +} + +#include // IWYU pragma: keep diff --git a/shared/package-files/41/41fb194beb1554d13af237fbe930c0a82455b9f315f08c1a049622f4533beb55/blob b/shared/package-files/41/41fb194beb1554d13af237fbe930c0a82455b9f315f08c1a049622f4533beb55/blob new file mode 100644 index 0000000000000000000000000000000000000000..a00b4ab65049538e8ac606a712e4557afd2b2d53 --- /dev/null +++ b/shared/package-files/41/41fb194beb1554d13af237fbe930c0a82455b9f315f08c1a049622f4533beb55/blob @@ -0,0 +1,258 @@ +from fontTools.misc import sstruct +from fontTools.misc.fixedTools import ( + fixedToFloat as fi2fl, + floatToFixed as fl2fi, + floatToFixedToStr as fl2str, + strToFixedToFloat as str2fl, +) +from fontTools.misc.textTools import Tag, bytesjoin, safeEval +from fontTools.ttLib import TTLibError +from . import DefaultTable +import struct + +# Apple's documentation of 'fvar': +# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6fvar.html + +FVAR_HEADER_FORMAT = """ + > # big endian + version: L + offsetToData: H + countSizePairs: H + axisCount: H + axisSize: H + instanceCount: H + instanceSize: H +""" + +FVAR_AXIS_FORMAT = """ + > # big endian + axisTag: 4s + minValue: 16.16F + defaultValue: 16.16F + maxValue: 16.16F + flags: H + axisNameID: H +""" + +FVAR_INSTANCE_FORMAT = """ + > # big endian + subfamilyNameID: H + flags: H +""" + + +class table__f_v_a_r(DefaultTable.DefaultTable): + """FonT Variations table + + The ``fvar`` table contains records of the variation axes and of the + named instances in a variable font. + + See also https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6fvar.html + """ + + def __init__(self, tag=None): + DefaultTable.DefaultTable.__init__(self, tag) + self.axes = [] + self.instances = [] + + def compile(self, ttFont): + instanceSize = sstruct.calcsize(FVAR_INSTANCE_FORMAT) + (len(self.axes) * 4) + includePostScriptNames = any( + instance.postscriptNameID != 0xFFFF for instance in self.instances + ) + if includePostScriptNames: + instanceSize += 2 + header = { + "version": 0x00010000, + "offsetToData": sstruct.calcsize(FVAR_HEADER_FORMAT), + "countSizePairs": 2, + "axisCount": len(self.axes), + "axisSize": sstruct.calcsize(FVAR_AXIS_FORMAT), + "instanceCount": len(self.instances), + "instanceSize": instanceSize, + } + result = [sstruct.pack(FVAR_HEADER_FORMAT, header)] + result.extend([axis.compile() for axis in self.axes]) + axisTags = [axis.axisTag for axis in self.axes] + for instance in self.instances: + result.append(instance.compile(axisTags, includePostScriptNames)) + return bytesjoin(result) + + def decompile(self, data, ttFont): + header = {} + headerSize = sstruct.calcsize(FVAR_HEADER_FORMAT) + header = sstruct.unpack(FVAR_HEADER_FORMAT, data[0:headerSize]) + if header["version"] != 0x00010000: + raise TTLibError("unsupported 'fvar' version %04x" % header["version"]) + pos = header["offsetToData"] + axisSize = header["axisSize"] + for _ in range(header["axisCount"]): + axis = Axis() + axis.decompile(data[pos : pos + axisSize]) + self.axes.append(axis) + pos += axisSize + instanceSize = header["instanceSize"] + axisTags = [axis.axisTag for axis in self.axes] + for _ in range(header["instanceCount"]): + instance = NamedInstance() + instance.decompile(data[pos : pos + instanceSize], axisTags) + self.instances.append(instance) + pos += instanceSize + + def toXML(self, writer, ttFont): + for axis in self.axes: + axis.toXML(writer, ttFont) + for instance in self.instances: + instance.toXML(writer, ttFont) + + def fromXML(self, name, attrs, content, ttFont): + if name == "Axis": + axis = Axis() + axis.fromXML(name, attrs, content, ttFont) + self.axes.append(axis) + elif name == "NamedInstance": + instance = NamedInstance() + instance.fromXML(name, attrs, content, ttFont) + self.instances.append(instance) + + def getAxes(self): + return {a.axisTag: (a.minValue, a.defaultValue, a.maxValue) for a in self.axes} + + +class Axis(object): + def __init__(self): + self.axisTag = None + self.axisNameID = 0 + self.flags = 0 + self.minValue = -1.0 + self.defaultValue = 0.0 + self.maxValue = 1.0 + + def compile(self): + return sstruct.pack(FVAR_AXIS_FORMAT, self) + + def decompile(self, data): + sstruct.unpack2(FVAR_AXIS_FORMAT, data, self) + + def toXML(self, writer, ttFont): + name = ( + ttFont["name"].getDebugName(self.axisNameID) if "name" in ttFont else None + ) + if name is not None: + writer.newline() + writer.comment(name) + writer.newline() + writer.begintag("Axis") + writer.newline() + for tag, value in [ + ("AxisTag", self.axisTag), + ("Flags", "0x%X" % self.flags), + ("MinValue", fl2str(self.minValue, 16)), + ("DefaultValue", fl2str(self.defaultValue, 16)), + ("MaxValue", fl2str(self.maxValue, 16)), + ("AxisNameID", str(self.axisNameID)), + ]: + writer.begintag(tag) + writer.write(value) + writer.endtag(tag) + writer.newline() + writer.endtag("Axis") + writer.newline() + + def fromXML(self, name, _attrs, content, ttFont): + assert name == "Axis" + for tag, _, value in filter(lambda t: type(t) is tuple, content): + value = "".join(value) + if tag == "AxisTag": + self.axisTag = Tag(value) + elif tag in {"Flags", "MinValue", "DefaultValue", "MaxValue", "AxisNameID"}: + setattr( + self, + tag[0].lower() + tag[1:], + str2fl(value, 16) if tag.endswith("Value") else safeEval(value), + ) + + +class NamedInstance(object): + def __init__(self): + self.subfamilyNameID = 0 + self.postscriptNameID = 0xFFFF + self.flags = 0 + self.coordinates = {} + + def compile(self, axisTags, includePostScriptName): + result = [sstruct.pack(FVAR_INSTANCE_FORMAT, self)] + for axis in axisTags: + fixedCoord = fl2fi(self.coordinates[axis], 16) + result.append(struct.pack(">l", fixedCoord)) + if includePostScriptName: + result.append(struct.pack(">H", self.postscriptNameID)) + return bytesjoin(result) + + def decompile(self, data, axisTags): + sstruct.unpack2(FVAR_INSTANCE_FORMAT, data, self) + pos = sstruct.calcsize(FVAR_INSTANCE_FORMAT) + for axis in axisTags: + value = struct.unpack(">l", data[pos : pos + 4])[0] + self.coordinates[axis] = fi2fl(value, 16) + pos += 4 + if pos + 2 <= len(data): + self.postscriptNameID = struct.unpack(">H", data[pos : pos + 2])[0] + else: + self.postscriptNameID = 0xFFFF + + def toXML(self, writer, ttFont): + name = ( + ttFont["name"].getDebugName(self.subfamilyNameID) + if "name" in ttFont + else None + ) + if name is not None: + writer.newline() + writer.comment(name) + writer.newline() + psname = ( + ttFont["name"].getDebugName(self.postscriptNameID) + if "name" in ttFont + else None + ) + if psname is not None: + writer.comment("PostScript: " + psname) + writer.newline() + if self.postscriptNameID == 0xFFFF: + writer.begintag( + "NamedInstance", + flags=("0x%X" % self.flags), + subfamilyNameID=self.subfamilyNameID, + ) + else: + writer.begintag( + "NamedInstance", + flags=("0x%X" % self.flags), + subfamilyNameID=self.subfamilyNameID, + postscriptNameID=self.postscriptNameID, + ) + writer.newline() + for axis in ttFont["fvar"].axes: + writer.simpletag( + "coord", + axis=axis.axisTag, + value=fl2str(self.coordinates[axis.axisTag], 16), + ) + writer.newline() + writer.endtag("NamedInstance") + writer.newline() + + def fromXML(self, name, attrs, content, ttFont): + assert name == "NamedInstance" + self.subfamilyNameID = safeEval(attrs["subfamilyNameID"]) + self.flags = safeEval(attrs.get("flags", "0")) + if "postscriptNameID" in attrs: + self.postscriptNameID = safeEval(attrs["postscriptNameID"]) + else: + self.postscriptNameID = 0xFFFF + + for tag, elementAttrs, _ in filter(lambda t: type(t) is tuple, content): + if tag == "coord": + value = str2fl(elementAttrs["value"], 16) + self.coordinates[elementAttrs["axis"]] = value diff --git a/shared/package-files/41/41fcaa0ad1ff3099c890a5b99bef7c1990f6323b4f60bb4f4c38bbf697081a1b/blob b/shared/package-files/41/41fcaa0ad1ff3099c890a5b99bef7c1990f6323b4f60bb4f4c38bbf697081a1b/blob new file mode 100644 index 0000000000000000000000000000000000000000..56560e9dab5c143699c918fa28236a902e530daf --- /dev/null +++ b/shared/package-files/41/41fcaa0ad1ff3099c890a5b99bef7c1990f6323b4f60bb4f4c38bbf697081a1b/blob @@ -0,0 +1,37 @@ +from collections import OrderedDict +from typing import Dict, Optional + +from torch import nn, Tensor +from torch.nn import functional as F + +from ...utils import _log_api_usage_once + + +class _SimpleSegmentationModel(nn.Module): + __constants__ = ["aux_classifier"] + + def __init__(self, backbone: nn.Module, classifier: nn.Module, aux_classifier: Optional[nn.Module] = None) -> None: + super().__init__() + _log_api_usage_once(self) + self.backbone = backbone + self.classifier = classifier + self.aux_classifier = aux_classifier + + def forward(self, x: Tensor) -> Dict[str, Tensor]: + input_shape = x.shape[-2:] + # contract: features is a dict of tensors + features = self.backbone(x) + + result = OrderedDict() + x = features["out"] + x = self.classifier(x) + x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False) + result["out"] = x + + if self.aux_classifier is not None: + x = features["aux"] + x = self.aux_classifier(x) + x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False) + result["aux"] = x + + return result diff --git a/shared/package-files/41/41fce83b12b036ea86fb8c48ade6ba30e40b5e17c000e409d2bf6ef89ea448db/blob b/shared/package-files/41/41fce83b12b036ea86fb8c48ade6ba30e40b5e17c000e409d2bf6ef89ea448db/blob new file mode 100644 index 0000000000000000000000000000000000000000..2831c484e5f5e6d2d2ab98fa7c77230a9d865450 --- /dev/null +++ b/shared/package-files/41/41fce83b12b036ea86fb8c48ade6ba30e40b5e17c000e409d2bf6ef89ea448db/blob @@ -0,0 +1 @@ +ñ \ No newline at end of file diff --git a/shared/package-files/41/41fd98a468e39d319911bd94f4e65d6ad6a7ea66559dd5aa4112f138ff9b629a/blob b/shared/package-files/41/41fd98a468e39d319911bd94f4e65d6ad6a7ea66559dd5aa4112f138ff9b629a/blob new file mode 100644 index 0000000000000000000000000000000000000000..8ae98f9375a42280a064d98edeb6470073d6ec8a --- /dev/null +++ b/shared/package-files/41/41fd98a468e39d319911bd94f4e65d6ad6a7ea66559dd5aa4112f138ff9b629a/blob @@ -0,0 +1,11 @@ +Copyright 2019 QuantStack and the Mamba contributors. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/shared/package-files/42/42010f32dfed8e0485e06fe6ca58c5b6c565990a6d85964590eeb4febe17a6da/blob b/shared/package-files/42/42010f32dfed8e0485e06fe6ca58c5b6c565990a6d85964590eeb4febe17a6da/blob new file mode 100644 index 0000000000000000000000000000000000000000..c5847d78bd44915f490dcb92230df58fb5f5099b --- /dev/null +++ b/shared/package-files/42/42010f32dfed8e0485e06fe6ca58c5b6c565990a6d85964590eeb4febe17a6da/blob @@ -0,0 +1,987 @@ +import contextlib +import warnings +import weakref +from typing import ContextManager, Dict, List, Optional, Tuple, TYPE_CHECKING + +import torch +from torch._C._functorch import ( + _add_batch_dim, + _unwrap_functional_tensor, + _wrap_functional_tensor, + current_level, + get_unwrapped, + is_batchedtensor, + is_functorch_wrapped_tensor, + is_gradtrackingtensor, + maybe_get_bdim, + maybe_get_level, + peek_interpreter_stack, + TransformType, +) +from torch._guards import Source + +from torch.multiprocessing.reductions import StorageWeakRef +from torch.utils._python_dispatch import ( + is_traceable_wrapper_subclass, + transform_subclass, +) +from torch.utils.weak import WeakIdRef + +if TYPE_CHECKING: + # Import the following modules during type checking to enable code intelligence features, + # Do not import unconditionally, as they import sympy and importing sympy is very slow + from torch.fx.experimental.symbolic_shapes import SymbolicContext + +DimList = List + + +def safe_is_leaf(t): + try: + return t.is_leaf + except RuntimeError: + # inference mode can trigger this + return False + + +def safe_grad(t): + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", "The .grad attribute of a Tensor") + return t.grad + + +def assert_eq(a, b): + assert a == b, f"{a} != {b}" + + +def assert_metadata_eq(assert_eq, m1, m2, *, skip_symbolic=False): + def go(m1, m2): + assert_eq(m1.dtype, m2.dtype) + if not skip_symbolic: + assert_eq(m1.shape, m2.shape) + assert_eq(m1.requires_grad, m2.requires_grad) + assert_eq(m1.is_leaf, m2.is_leaf) + assert_eq(m1.grad_fn is None, m2.grad_fn is None) + assert_eq(m1.is_sparse, m2.is_sparse) + assert_eq(m1.is_inference(), m2.is_inference()) + assert_eq(m1.is_conj(), m2.is_conj()) + assert_eq(m1.is_neg(), m2.is_neg()) + assert_eq(safe_grad(m1) is not None, safe_grad(m2) is not None) + if safe_grad(m1) is not None: + go(safe_grad(m1), safe_grad(m2)) + if m1.is_sparse: + assert_eq(m1.dense_dim(), m2.dense_dim()) + assert_eq(m1.sparse_dim(), m2.sparse_dim()) + assert_eq(m1.is_coalesced(), m2.is_coalesced()) + else: + if not skip_symbolic: + assert_eq(m1.stride(), m2.stride()) + assert_eq(m1.storage_offset(), m2.storage_offset()) + assert_eq(m1._is_view(), m2._is_view()) + if m1._is_view(): + go(m1._base, m2._base) + # TODO: test if is resizable (no direct query for this atm) + # TODO: audit AutogradMeta to see if it matches + # TODO: test forward AD + + return go(m1, m2) + + +def is_sparse_coo(t): + return isinstance(t, torch.Tensor) and t.layout is torch.sparse_coo + + +def is_sparse_compressed(t): + return isinstance(t, torch.Tensor) and t.layout in { + torch.sparse_csr, + torch.sparse_csc, + torch.sparse_bsr, + torch.sparse_bsc, + } + + +def is_sparse_any(t): + return is_sparse_coo(t) or is_sparse_compressed(t) + + +# This is a class for converting multiple tensors into meta tensors which +# share the same view/storage structure. The operation model is you allocate +# one of these, and then call it repeatedly on all the tensors you want to +# convert. It's important to use the same object for tensors you want to +# share storage because this is how we correlate shared storages to the same +# meta storages. This class will hold weak references to cached tenosrs +# and tensor storages. +class MetaConverter: + def __init__(self): + self.storage_memo = {} + self.tensor_memo: weakref.WeakValueDictionary = weakref.WeakValueDictionary() + self.maybe_storages_to_delete = [] + self.check_expired_frequency = 128 + self.check_expired_count = 0 + self.hit = 0 + self.miss = 0 + self.del_hook = None + self.arg_cnt = 0 + + def successful(self): + return self.hit > 0 and self.miss == 0 + + def check_for_expired_weak_storages(self): + new_li = [] + stor_to_delete = [] + for obj in self.maybe_storages_to_delete: + if not obj.expired(): + new_li.append(obj) + else: + stor_to_delete.append(obj) + for obj in stor_to_delete: + self.storage_memo.pop(obj, None) + self.maybe_storages_to_delete = new_li + + # if for some reason we have aquired many storages which have not expired + # even though a tensor with their storage has expired (aliasing or otherwise) + # check for expired storages less often so as to bound the amount of work we + # do checking for expired storages + self.check_expired_frequency = max( + self.check_expired_frequency, len(self.maybe_storages_to_delete) + ) + + def get_tensor_memo(self, t): + return self.tensor_memo.get(WeakIdRef(t), None) + + def set_tensor_memo(self, t, v): + # hold a weak ref to self, otherwise it will be kept alive + # by the del_ten closure + self_weak_ref = weakref.ref(self) + if is_sparse_any(t) or t.is_mkldnn or is_functorch_wrapped_tensor(t): + weak_st = None + else: + weak_st = StorageWeakRef(t._typed_storage()) + tensor_ref_key = WeakIdRef(t) + + def del_ten(): + # tensor outlives the converter + self_ref = self_weak_ref() + if self_ref is None: + return + # on shutdown, tensor_ref_key may not be in memo + self_ref.tensor_memo.pop(tensor_ref_key, None) + if weak_st and weak_st.expired(): + self_ref.storage_memo.pop(weak_st, None) + elif weak_st is not None: + # [expired-storages] + # NB: even though the tensor has died, + # the deallocation of its storage can take longer, + # even when the storage has no other uses/views. + # In this case, the StorageWeakRef object will be kept alive + # longer than it needs to be, however the storage itself + # will be deallocated. We retain the possibly dead storages + # and periodically check if any of them are expired and + # can be freed. + self_ref.maybe_storages_to_delete.append(weak_st) + + weakref.finalize(t, del_ten) + self.tensor_memo[tensor_ref_key] = v + + # NB: doesn't actually return a storage, because meta storage is + # not supported + def meta_storage(self, s, callback): + # NB: TypedStorage is freshly allocated and cannot be used as hash + # key index. + + # Use a Weak Ref to s in order to not leak memory + swr = StorageWeakRef(s) + if swr not in self.storage_memo: + self.storage_memo[swr] = callback( + lambda: torch.empty(s.size(), dtype=torch.uint8, device="meta") + ).untyped_storage() + return self.storage_memo[swr] + + # This function assumes that it's possible to do the conversion + # NB: name here is used in a conventional way by Dynamo; it corresponds + # precisely to the Source.name() of the tensor we're fakeifying and + # corresponds to a valid Python expression. When we construct sub-names + # as part of this process, we will maintain this invariant! (Even though + # other users of this may not need it this property to be upheld.) + def meta_tensor( + self, + t, + shape_env=None, + callback=lambda t: t(), + source: Optional[Source] = None, + symbolic_context: Optional["SymbolicContext"] = None, + ): + if source is None: + from torch._dynamo.source import ConstantSource + + # TODO: make a dedicated UnknownSource for this? + source = ConstantSource( + f"__meta_utils_unknown_tensor{len(self.tensor_memo)}" + ) + + # This indicates you set no_dispatch() before calling into this + # function. This is an error: we may be creating fake tensors and + # will perform operations on them which need fake tensor mode to + # be active. You will segfault if you are in a no_dispatch() block. + assert not torch._C._dispatch_tls_local_exclude_set().has( + torch._C.DispatchKey.Python + ) + arg_cnt = self.arg_cnt + self.arg_cnt += 1 + + # When we make as_strided calls, we end up generating a guard + # that the new as_strided tensor is in bounds for the old storage + # for the base (since as_strided calls can "bust" out of their + # bounding box.) This guard is unnecessary: if a user is able + # to provide us a tensor with the view base setup this way, we + # don't need to produce a guard, because the fact that they + # were able to produce the view base means its in bounds. + # + # Now, ordinarily, this guard would be harmless. However, the + # generated guard refers to variables bound on the base variable. + # At the moment, Dynamo doesn't actually guard on x._base, because + # according to Voz this results in a lot of spurious invalidations, + # and also if the user doesn't directly make use of _base, its + # pointless anyway (because programs should be parametric over + # whether or not the input tensor is a view or not--unless you're + # mutating the input, but that's a whole 'nother ballgame). So + # for expediency, we suppress these guards so we don't have to + # deal with this (yet, anyway.) + # + # NB: An old version of this code suppressed guards for ALL operations + # happening during meta conversion, not just as_strided calls. + # This is too aggressive: we do duck sizing and 0/1 simplification + # as we allocate variables, and we do need to register guards for + # these cases. + maybe_suppress = contextlib.nullcontext + if shape_env is not None: + maybe_suppress = shape_env.suppress_guards + + def sym_sizes_strides_storage_offset( + t, src, symbolic_context=symbolic_context + ) -> Tuple[Tuple[int, ...], Tuple[int, ...], int]: + if shape_env is not None: + fake_mode = torch._subclasses.fake_tensor.maybe_get_fake_mode(t) + if fake_mode is not None and fake_mode.shape_env is shape_env: + # Don't reallocate the sizes; the shape envs are the same, + # so reuse the old sizes/strides/etc + return (t.size(), t.stride(), t.storage_offset()) + else: + return shape_env.create_symbolic_sizes_strides_storage_offset( + t, + src, + symbolic_context=symbolic_context, + ) + else: + assert symbolic_context is None + return (t.size(), t.stride(), t.storage_offset()) + + def empty_create(inner_t, inner_src, symbolic_context=symbolic_context): + ( + inner_sizes, + inner_strides, + inner_storage_offset, + ) = sym_sizes_strides_storage_offset(inner_t, inner_src, symbolic_context) + return torch.empty_strided( + inner_sizes, + inner_strides, + dtype=inner_t.dtype, + device="meta", + ) + + # Creates a subclass instance with empty inner tensors according to the specified + # symbolic context. + def empty_create_subclass( + t, + outer_size, + outer_stride, + symbolic_context=symbolic_context, + callback=callback, + source=source, + ): + from torch._dynamo.source import AttrSource + from torch.fx.experimental.symbolic_shapes import SubclassSymbolicContext + + assert symbolic_context is None or isinstance( + symbolic_context, SubclassSymbolicContext + ) + + # Note: transform_subclass will use __tensor_unflatten__ to generate + # a fresh subclass wrapper with outer sizes / strides according to the + # outer symbolic context (passed in to this function). Inner size / stride + # / storage offset symbols are allocated according to the appropriate inner + # symbolic contexts, after which the checks in transform_subclass() will + # relate them to the outer metadata as possible. + return transform_subclass( + t, + lambda attr, inner_t: callback( + lambda: empty_create( + inner_t, + AttrSource(source, attr), + symbolic_context=( + None + if symbolic_context is None + else symbolic_context.inner_contexts[attr] + ), + ) + ), + outer_size=outer_size, + outer_stride=outer_stride, + ) + + # Returns an all-dynamic symbolic context used for metafying the given tensor with + # fully dynamic dims. This is useful when fake-ifying intermediate tensors in + # closed-over ViewFunc state, as we don't have symbolic contexts for them, but we + # don't want to over-specialize during view replay. + def all_dynamic_symbolic_context(t, source, shape_env, callback): + from torch._dynamo.source import AttrSource + from torch.fx.experimental.symbolic_shapes import ( + DimDynamic, + StatelessSymbolicContext, + SubclassSymbolicContext, + SymbolicContext, + ) + + view_base_context: Optional[SymbolicContext] = None + if t._is_view(): + view_base_context = all_dynamic_symbolic_context( + t._base, AttrSource(source, "_base"), shape_env, callback + ) + + t_symbolic_context: SymbolicContext + t_dynamic_sizes = [DimDynamic.DYNAMIC] * t.dim() + if is_traceable_wrapper_subclass(t): + inner_contexts: Dict[str, SymbolicContext] = {} + attrs, _ = t.__tensor_flatten__() + for attr in attrs: + assert isinstance(attr, str) + inner = getattr(t, attr) + inner_contexts[attr] = all_dynamic_symbolic_context( + inner, AttrSource(source, attr), shape_env, callback + ) + t_symbolic_context = SubclassSymbolicContext( + dynamic_sizes=t_dynamic_sizes, + constraint_sizes=[None] * t.dim(), + inner_contexts=inner_contexts, + tensor_source=source, + view_base_context=view_base_context, + ) + else: + t_symbolic_context = StatelessSymbolicContext( + dynamic_sizes=t_dynamic_sizes, + constraint_sizes=[None] * t.dim(), + view_base_context=view_base_context, + ) + + return t_symbolic_context + + # Returns a fake-ified version of an input view tensor t, given an already fake-ified + # base. At a high level, we want two things: + # 1. fake_t should have the same view relationship to the given fake base as the + # input t has to its _base. + # 2. fake_t should have symbolic sizes / strides / storage offset according to the + # appropriate symbolic context (i.e. from the automatic dynamic algorithm). + # + # We currently take different strategies across view types: + # * For dense -> dense views, accomplish both (1) and (2) simultaneously via an + # as_strided() call on the fake-ified base, passing symbolic metadata. + # * For views involving subclasses, perform view replay using view funcs to + # achieve (1). It's necessary for (2) to swap out any closed-over state in + # the view funcs with symbolicized SymInts and fake-ified tensors. Doing this + # avoids specialization (and thus over-eager simplification of symbols) that + # could occur during view replay on the fake-ified base. + # + # Examples: + # * t.unsqueeze(-1) with dense t is a dense -> dense view. It can be modeled + # with an as_strided() call on the fake base passing symbolic metadata. + # * sub.select(dim=0, index=3) is a subclass -> subclass view. The index arg + # is made symbolic to avoid invalid specialization and view replay is then + # done to reconstruct the view. + # * _nested_from_jagged(values, offsets) is a dense -> subclass view + # that returns a subclass instance from a dense values tensor. The offsets + # tensor is closed over in the view func, as it can be considered view metadata. + # First, the offsets tensor is fake-ified according to the inner symbolic + # context and with the correct relationship to the outer size / stride metadata. + # Then view replay is done, swapping in the fake offsets so the view replay output + # is fully fake with no invalid specialization. + def view_from_base(base, t, source=source, shape_env=shape_env): + # fake-ify t's metadata according to the outer symbolic context + (sizes, strides, storage_offset) = sym_sizes_strides_storage_offset( + t, source + ) + if not is_traceable_wrapper_subclass( + t + ) and not is_traceable_wrapper_subclass(base): + # Dense -> Dense view case uses as_strided() to construct view relationship. + # TODO: Change this logic to use view replay for consistency? + # It's likely there is no view func available. + return base.as_strided(sizes, strides, storage_offset) + + from torch._dynamo.source import EphemeralSource + from torch.fx.experimental.symbolic_shapes import sym_eq + + def symint_visitor_fn(s): + if shape_env is None: + return s + + # NB: The symbol here is expected to be simplified out because we a priori + # allocate inner and outer symbols according to the appropriate symbolic + # contexts and prefer those over this symbol during symbol simplification + # (via usage of EphemeralSource below). This -shouldn't- happen, but if + # this symbol somehow leaks out beyond the view tensor's shape metadata, our + # assumption of it being simplified out will fail and it may be guarded on, + # which will hard error. + sym_source = EphemeralSource("symint_visitor_fn") + symbol = shape_env.create_symbol(s, sym_source) + return shape_env.create_symintnode(symbol, hint=s, source=sym_source) + + real_to_fake_mapping = {} + if is_traceable_wrapper_subclass(t): + # Fake-ify t naively here; this is only done so we can get fake-ified inner + # tensors with the correct relationships to the outer sizes / strides for use + # in view replay. It's done beforehand here because it's not easy to do when + # visiting tensors one-by-one during view replay. + # + # Example: + # Consider a Dense -> NJT view. NJT has (values, offsets) components and we + # want a view of values with the offsets closed over. As the offsets component + # is needed to describe the output view, it's important that it's fakeified + # correctly. + fake_t = empty_create_subclass( + t, outer_size=sizes, outer_stride=strides + ) + attrs, _ = fake_t.__tensor_flatten__() + for attr in attrs: + real_to_fake_mapping[getattr(t, attr)] = getattr(fake_t, attr) + + def tensor_visitor_fn( + visited_t, shape_env=shape_env, callback=callback, source=source + ): + # It's possible to close over an undefined tensor (e.g. NJT's lengths). + if visited_t is None: + return None + + # Fake inner tensors of view subclasses will come from the mapping built above. + fake_visited_t = real_to_fake_mapping.get(visited_t, None) + if fake_visited_t is not None: + return fake_visited_t + + # For other closed-over tensor state, fake-ify it as all dynamic with an + # ephemeral source. This avoids invalid specialization during view replay. + # If we find that in practice the usage of ephemeral sources isn't enough + # to guarantee that we don't have guards on these symbols, we may need to + # explicitly suppress guards (as is done for _base in the dense -> dense + # view case). + temp_source = EphemeralSource("tensor_visitor_fn") + return self.meta_tensor( + visited_t, + shape_env, + callback, + source=temp_source, + symbolic_context=all_dynamic_symbolic_context( + visited_t, temp_source, shape_env, callback + ), + ) + + # Replay the view, swapping out any non-symbolic SymInts or real tensors + # for symbolic SymInts or fake tensors. + fake_t = t._view_func_unsafe(base, symint_visitor_fn, tensor_visitor_fn) + + # Ensure the output has symbolic shapes according to the outer symbolic context. + # These checks should simplify out any symbols created for closed-over view func + # SymInts. + torch._check(sym_eq(fake_t.size(), sizes)) + torch._check(sym_eq(fake_t.stride(), strides)) + torch._check(sym_eq(fake_t.storage_offset(), storage_offset)) + return fake_t + + # see expired-storages + self.check_expired_count += 1 + if self.check_expired_count >= self.check_expired_frequency: + self.check_for_expired_weak_storages() + self.check_expired_count = 0 + + if self.get_tensor_memo(t) is None: + with torch.inference_mode(t.is_inference()): + if t.is_sparse: + is_leaf = safe_is_leaf(t) + + # The lambda function below is similar to + # `t.to(device='meta')` except the latter + # preserves nnz value + r = callback( + lambda: torch.ops.aten._sparse_coo_tensor_with_dims( + t.sparse_dim(), + t.dense_dim(), + t.shape, + dtype=t.dtype, + layout=torch.sparse_coo, + device="meta", + ) + ) + assert safe_is_leaf(r), "the callback you passed in doesn't detach" + # Note [is_coalesced is dispatched] + # Strangely enough, is_coalesced() is a dispatched operator, + # which means that it will get caught by fake tensor mode. + # Ordinarily this would error, but there's some logic in + # fake tensor ensure this doesn't happen. + r._coalesced_(t.is_coalesced()) + if t.requires_grad: + r.requires_grad = True + if t.requires_grad and not is_leaf: + with torch.enable_grad(): + r = r.clone() + r._coalesced_(t.is_coalesced()) + elif is_sparse_compressed(t): + is_leaf = safe_is_leaf(t) + + def mk_meta(): + nnz = 0 + batch_dim = t.ndim - t.sparse_dim() - t.dense_dim() + batch_size = t.shape[:batch_dim] + if t.layout in {torch.sparse_csr, torch.sparse_bsr}: + index_dtype = t.crow_indices().dtype + compressed_indices = torch.empty( + t.crow_indices().shape, device="meta", dtype=index_dtype + ) + plain_indices = torch.empty( + (*t.col_indices().shape[:-1], nnz), + device="meta", + dtype=index_dtype, + ) + else: + index_dtype = t.ccol_indices().dtype + compressed_indices = torch.empty( + t.ccol_indices().shape, device="meta", dtype=index_dtype + ) + plain_indices = torch.empty( + (*t.row_indices().shape[:-1], nnz), + device="meta", + dtype=index_dtype, + ) + values_shape = t.values().shape + values = torch.empty( + ( + *values_shape[:batch_dim], + nnz, + *values_shape[batch_dim + 1 :], + ), + dtype=t.dtype, + device="meta", + ) + return torch.ops.aten.sparse_compressed_tensor( + compressed_indices, + plain_indices, + values, + t.shape, + layout=t.layout, + dtype=t.dtype, + device="meta", + ) + + # `mk_meta()` is similar to `t.to(device='meta'))` + # except `to('meta')` preserves nnz value while + # `mk_meta` result has nnz == 0. + r = callback(mk_meta) + + assert safe_is_leaf(r), "the callback you passed in doesn't detach" + if t.requires_grad: + r.requires_grad = True + if t.requires_grad and not is_leaf: + with torch.enable_grad(): + r = r.clone() + elif t.is_nested and not is_traceable_wrapper_subclass(t): + # TODO: Handle this better in Dynamo? + # There are checks there now, but this can still be triggered by a dense + # tensor graph input that is a view of a strided NT. + from torch._dynamo.exc import unimplemented + + unimplemented( + "strided nested tensors are not supported by meta conversion" + ) + elif t.is_mkldnn: + is_leaf = safe_is_leaf(t) + sizes, strides, _storage_offset = sym_sizes_strides_storage_offset( + t, source + ) + r = callback( + lambda: torch.empty_strided( + sizes, strides, dtype=t.dtype, device="meta" + ) + ) + assert safe_is_leaf(r), "the callback you passed in doesn't detach" + if t.requires_grad: + r.requires_grad = True + if t.requires_grad and not is_leaf: + with torch.enable_grad(): + r = r.clone() + elif is_functorch_wrapped_tensor(t): + if t._is_view(): + from torch._dynamo.exc import unimplemented + + unimplemented( + "view functorch tensors are not supported by meta conversion" + ) + + # Wraps a functorch tensor class (BatchedTensor, GradTrackingTensor) + # in a FakeTensor + def _to_fake_tensor(t): + if is_batchedtensor(t): + ft = _to_fake_tensor(get_unwrapped(t)) + lvl = maybe_get_level(t) + bdim = maybe_get_bdim(t) + r = _add_batch_dim(ft, bdim, lvl) + elif is_gradtrackingtensor(t): + disable_functorch = torch._C._DisableFuncTorch + with disable_functorch(): + ft = _to_fake_tensor(get_unwrapped(t)) + lvl = torch._C._functorch.maybe_get_level(t) + r = torch._C._functorch._wrap_for_grad(ft, lvl) + + is_leaf = safe_is_leaf(t) + if t.requires_grad and safe_is_leaf(r): + r.requires_grad = True + elif t.requires_grad and not is_leaf: + with torch.enable_grad(): + r = r.clone() + else: + sizes = t.size() + strides = t.stride() + r = callback( + lambda: torch.empty_strided( + sizes, + strides, + dtype=t.dtype, + device="meta", + ) + ) + return r + + r = _to_fake_tensor(t) + + elif t._is_view(): + # Construct views in two steps: recursively meta-fy their + # base, and then create view(s) off that. NB: doing it + # directly from storage is WRONG because this won't cause + # version counters to get shared. + assert t._is_view() + + base_symbolic_context = None + if shape_env and symbolic_context is not None: + from torch.fx.experimental.symbolic_shapes import ( + StatelessSymbolicContext, + ) + + assert isinstance(symbolic_context, StatelessSymbolicContext) + # NB: This should generally be set when the input is a view, + # but the exception right now is for fake-ifying grads, which is + # a work in progress. + if symbolic_context.view_base_context is not None: + base_symbolic_context = symbolic_context.view_base_context + + base = self.meta_tensor( + t._base, + shape_env, + callback, + source=torch._dynamo.source.AttrSource(source, "_base"), + symbolic_context=base_symbolic_context, + ) + + def is_c_of_r(complex_dtype, real_dtype): + return ( + utils.is_complex_dtype(complex_dtype) + and utils.corresponding_real_dtype(complex_dtype) + == real_dtype + ) + + # In some situations, MetaConverter may be called in a + # context where autograd is disabled. For the _is_view + # assert to pass, we have to setup the autograd view + # metadata anyway. Do this by reenabling the + # ADInplaceOrView key. This is kind of a hack. + old_exclude = torch._C._dispatch_tls_is_dispatch_key_excluded( + torch._C.DispatchKey.ADInplaceOrView + ) + torch._C._dispatch_tls_set_dispatch_key_excluded( + torch._C.DispatchKey.ADInplaceOrView, False + ) + try: + if base.dtype == t.dtype: + pass + elif is_c_of_r(base.dtype, t.dtype): + base = torch.view_as_real(base) + elif is_c_of_r(t.dtype, base.dtype): + base = torch.view_as_complex(base) + else: + # This is not guaranteed to succeed. If it fails, it + # means there is another dtype-converting view function + # that hasn't been handled here + base = base.view(t.dtype) + + # This is very tricky. Naively, you might expect this + # to hold: + # + # if t.requires_grad and not safe_is_leaf(t) + # assert t._base.requires_grad + # + # But it's not true! As you can see in the following + # program: + # + # x = torch.zeros(4) + # y = x.view(1, 4) + # y.requires_grad = True + # z = y.view(1, 1, 4) + # assert z._base is x + # + # So we may have to do *two* views out of the base to + # recreate this situation. + if safe_is_leaf(t): + # Leaf views that track view metadata are created by + # creating a view inside a no_grad block + with torch.no_grad(), maybe_suppress(): + r = view_from_base(base, t) + # As it's a leaf, we can directly assign requires_grad + r.requires_grad = t.requires_grad + else: + if t._base.requires_grad == t.requires_grad: + # Easy case, just run the view op + with torch.enable_grad(), maybe_suppress(): + r = view_from_base(base, t) + + # NB: We don't actaully faithfully replicate + # autograd connectivity, but that doesn't matter + # today. See following for more info: + # https://gist.github.com/soulitzer/e03f015b314c3f5fcf80888c69390913 + else: + # Obscure case. Create a leaf view and give it the + # correct requires_grad, then do the final view. + # NB: Can't have a non-leaf without requiring grad! + assert t.requires_grad + with torch.no_grad(): + mid = base.view(base.shape) + mid.requires_grad = t.requires_grad + with torch.enable_grad(), maybe_suppress(): + r = view_from_base(mid, t) + # The CreationMeta influences whether or not inplace + # mutation is an error or not. So we need to make + # sure we properly propagate this as well. + torch._C._autograd._set_creation_meta( + r, torch._C._autograd._get_creation_meta(t) + ) + finally: + torch._C._dispatch_tls_set_dispatch_key_excluded( + torch._C.DispatchKey.ADInplaceOrView, old_exclude + ) + + else: + is_leaf = safe_is_leaf(t) + + ( + sizes, + strides, + storage_offset, + ) = sym_sizes_strides_storage_offset(t, source, symbolic_context) + + # If we have a subclass that desugars into dense tensors, + # perform our callback on each inner tensor. + if is_traceable_wrapper_subclass(t): + r = empty_create_subclass( + t, outer_size=sizes, outer_stride=strides + ) + else: + r = callback( + lambda: torch.empty_strided( + sizes, + strides, + dtype=t.dtype, + device="meta", + ) + ) + + assert safe_is_leaf(r), "the callback you passed in doesn't detach" + if t.requires_grad: + r.requires_grad = t.requires_grad + if not is_leaf: + # Fake up some autograd history. + with torch.enable_grad(): + # preserve_format is the default, but we want to + # emphasize how important it is to preserve + # format here + r = r.clone(memory_format=torch.preserve_format) + + # Graph-Break for wrapped tensors + if not ( + is_batchedtensor(t) or is_gradtrackingtensor(t) + ) and torch._C._functorch.is_functorch_wrapped_tensor(t): + return NotImplemented + + s = t.untyped_storage() + swr = StorageWeakRef(s) + if swr not in self.storage_memo and ( + r.is_nested + or ( + r.stride() == strides + and r.storage_offset() == storage_offset + ) + ): + # You're normal and happy, install the fresh storage into the memo + self.storage_memo[swr] = r.untyped_storage() + else: + # You're in crazy town; somehow you gave us a tensor + # that wasn't a view, but had nonzero storage offset, + # nontrivial strides (such that clone() couldn't + # preserve them), or already aliases with another + # tensor's storage. The most typical way to end + # up here is with set_. So use set_ to bludgeon this + # in. + r_s = self.meta_storage(s, callback=callback) + # NB: In principle, this should always work, but there + # is some subtle difference in the autograd metadata + # that means we will backprop the set_ call, even if + # r is declared as an input to grad. + # See https://github.com/pytorch/pytorch/issues/87956 + # for the reproducer. + # NB: The in_kernel_invocation_manager here is necessary + # for fake tensor. If we run the set_ call with fake + # tensor on, r will improperly report that it is NOT a + # meta tensor but a cpu tensor, and then the set_ call + # will fail due to device mismatch. no_dispatch() is + # not enough, because the fake tensor will still claim + # to be a CPU tensor and you'll end up in the CPU + # kernel. Arguably this is a hack; a cleaner way to + # solve this is to have a FakeStorage concept which + # would report it's CPU device--no problem now! But + # this is difficult to do because we don't have storage + # subclasses. Relevant test is + # DynamicShapesFunctionTests::test_add_dynamic_shapes in + # test/dynamo/test_dynamic_shapes.py + maybe_fake_mgr: ContextManager[None] = contextlib.nullcontext() + from torch._subclasses.fake_tensor import ( + in_kernel_invocation_manager, + maybe_get_fake_mode, + ) + + mb_fake_mode = maybe_get_fake_mode(r) + if mb_fake_mode is not None: + maybe_fake_mgr = in_kernel_invocation_manager(mb_fake_mode) + with maybe_fake_mgr, torch.no_grad(): + r.set_(r_s, storage_offset, sizes, strides) + + if safe_grad(t) is not None: + from torch._dynamo.source import AttrSource + + # TODO: Use a valid grad-specific symbolic context instead of recycling + # the one from t. This isn't correct if e.g. t._is_view() != t.grad._is_view(). + r.grad = self.meta_tensor( + safe_grad(t), + shape_env, + callback, + source=AttrSource(source, "grad"), + symbolic_context=symbolic_context, + ) + torch._C._set_conj(r, t.is_conj()) + torch._C._set_neg(r, t.is_neg()) + # This can be skipped if necessary for performance reasons + assert_metadata_eq(assert_eq, t, r, skip_symbolic=True) + self.set_tensor_memo(t, r) + + return self.get_tensor_memo(t) + + def __call__( + self, + t, + shape_env=None, + *, + callback=lambda t: t(), + source=None, + symbolic_context=None, + ): + # TODO: zero tensors? We appear to have eliminated them by + # excluding complex for now + + if isinstance(t, torch.Tensor) or is_traceable_wrapper_subclass(t): + if t.device.type != "xla" and any( + [ + t.is_quantized, + t._is_view() and t._base is not None and t._base.is_sparse, + torch._is_functional_tensor(t), + t.device.type in ("lazy"), + # We need a way to test if a tensor is batched but there + # is no official APi to do it + # torch._C._is_batched(t), + ] + ): + # TODO: sparse should support meta + # NB technically to('meta') does work but our logging + # instrumentation will see the meta conversions and the + # tests all break so we just exclude this. In any case + # the to conversion isn't really right anyhow. + + if torch._is_functional_tensor(t) and t.device.type != "lazy": + if t._is_view(): + raise RuntimeError( + "Cannot safely fakify a view because this process drops the view information right now." + ) + + st = peek_interpreter_stack() + assert ( + st is None or st.key() == TransformType.Functionalize + ), "Expect st to be either None or have Functionalize transform key." + if st is None: + # the case of AOTAutograd + torch._sync(t) + unwrap_t = torch._from_functional_tensor(t) + with torch._dispatch.python.suspend_functionalization(): + fake_t = self.meta_tensor( + unwrap_t, + shape_env=shape_env, + callback=callback, + source=source, + symbolic_context=symbolic_context, + ) + out = torch._to_functional_tensor(fake_t) + torch._mirror_autograd_meta_to(fake_t, out) + return out + else: + # torch.func.functionalize + reapply_views = torch._C._functionalization_reapply_views_tls() + unwrap_t = _unwrap_functional_tensor(t, reapply_views) + pop_st_ctx = ( + torch._functorch.pyfunctorch.temporarily_pop_interpreter_stack() + ) + with pop_st_ctx: + fake_t = self.meta_tensor( + unwrap_t, + shape_env=shape_env, + callback=callback, + source=source, + symbolic_context=symbolic_context, + ) + return _wrap_functional_tensor(fake_t, current_level()) + self.miss += 1 + return NotImplemented + else: + self.hit += 1 + + disable_functorch = torch._C._DisableFuncTorch + with disable_functorch(): + r = self.meta_tensor( + t, + shape_env=shape_env, + callback=callback, + source=source, + symbolic_context=symbolic_context, + ) + if type(t) is torch.nn.Parameter: + # NB: Cannot directly use Parameter constructor + # because that would force a detach, not desirable + r._is_param = True + return r + elif torch.overrides.is_tensor_like(t): + self.miss += 1 + return NotImplemented + else: + # non-Tensor types don't count as hit or miss + return t + + +import torch._prims_common as utils diff --git a/shared/package-files/42/42050167d48762882bf6b01ba95a9a95c5af71552b4a2881fb4871c418709cae/blob b/shared/package-files/42/42050167d48762882bf6b01ba95a9a95c5af71552b4a2881fb4871c418709cae/blob new file mode 100644 index 0000000000000000000000000000000000000000..6bf381dfb06d1ab7c233eca11660dbb2ec017b1c --- /dev/null +++ b/shared/package-files/42/42050167d48762882bf6b01ba95a9a95c5af71552b4a2881fb4871c418709cae/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor renorm(const at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm); +TORCH_API at::Tensor & renorm_(at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/shared/package-files/42/420659c3058cb55d0b1fe347e9352065ef9fc6e494d5dcd30e9dfc7644a40c54/blob b/shared/package-files/42/420659c3058cb55d0b1fe347e9352065ef9fc6e494d5dcd30e9dfc7644a40c54/blob new file mode 100644 index 0000000000000000000000000000000000000000..f3a1061e4712361372de79e1832e4b7950c62788 --- /dev/null +++ b/shared/package-files/42/420659c3058cb55d0b1fe347e9352065ef9fc6e494d5dcd30e9dfc7644a40c54/blob @@ -0,0 +1,17 @@ +#pragma once + +#include +#include + +#include + +namespace torch { +namespace utils { + +at::Tensor nested_tensor_ctor( + c10::DispatchKey dispatch_key, + at::ScalarType scalar_type, + PythonArgs& r); + +} // namespace utils +} // namespace torch diff --git a/shared/package-files/42/4206b1ce6cc5e4575492de620ad36afad4f99438d313f4f2cfe04e1b9b3b4453/blob b/shared/package-files/42/4206b1ce6cc5e4575492de620ad36afad4f99438d313f4f2cfe04e1b9b3b4453/blob new file mode 100644 index 0000000000000000000000000000000000000000..876af8f18a312f88c508c6b2ae96f1e5c1dad96d --- /dev/null +++ b/shared/package-files/42/4206b1ce6cc5e4575492de620ad36afad4f99438d313f4f2cfe04e1b9b3b4453/blob @@ -0,0 +1,837 @@ +from os.path import join, dirname +import threading + +import numpy as np +from numpy.testing import assert_array_almost_equal, assert_equal +import pytest +from pytest import raises as assert_raises + +from scipy.fftpack._realtransforms import ( + dct, idct, dst, idst, dctn, idctn, dstn, idstn) + +# Matlab reference data +MDATA = np.load(join(dirname(__file__), 'test.npz')) +X = [MDATA['x%d' % i] for i in range(8)] +Y = [MDATA['y%d' % i] for i in range(8)] + +# FFTW reference data: the data are organized as follows: +# * SIZES is an array containing all available sizes +# * for every type (1, 2, 3, 4) and every size, the array dct_type_size +# contains the output of the DCT applied to the input np.linspace(0, size-1, +# size) +FFTWDATA_DOUBLE = np.load(join(dirname(__file__), 'fftw_double_ref.npz')) +FFTWDATA_SINGLE = np.load(join(dirname(__file__), 'fftw_single_ref.npz')) +FFTWDATA_SIZES = FFTWDATA_DOUBLE['sizes'] + + +def fftw_dct_ref(type, size, dt): + x = np.linspace(0, size-1, size).astype(dt) + dt = np.result_type(np.float32, dt) + if dt == np.float64: + data = FFTWDATA_DOUBLE + elif dt == np.float32: + data = FFTWDATA_SINGLE + else: + raise ValueError() + y = (data['dct_%d_%d' % (type, size)]).astype(dt) + return x, y, dt + + +def fftw_dst_ref(type, size, dt): + x = np.linspace(0, size-1, size).astype(dt) + dt = np.result_type(np.float32, dt) + if dt == np.float64: + data = FFTWDATA_DOUBLE + elif dt == np.float32: + data = FFTWDATA_SINGLE + else: + raise ValueError() + y = (data['dst_%d_%d' % (type, size)]).astype(dt) + return x, y, dt + + +def dct_2d_ref(x, **kwargs): + """Calculate reference values for testing dct2.""" + x = np.array(x, copy=True) + for row in range(x.shape[0]): + x[row, :] = dct(x[row, :], **kwargs) + for col in range(x.shape[1]): + x[:, col] = dct(x[:, col], **kwargs) + return x + + +def idct_2d_ref(x, **kwargs): + """Calculate reference values for testing idct2.""" + x = np.array(x, copy=True) + for row in range(x.shape[0]): + x[row, :] = idct(x[row, :], **kwargs) + for col in range(x.shape[1]): + x[:, col] = idct(x[:, col], **kwargs) + return x + + +def dst_2d_ref(x, **kwargs): + """Calculate reference values for testing dst2.""" + x = np.array(x, copy=True) + for row in range(x.shape[0]): + x[row, :] = dst(x[row, :], **kwargs) + for col in range(x.shape[1]): + x[:, col] = dst(x[:, col], **kwargs) + return x + + +def idst_2d_ref(x, **kwargs): + """Calculate reference values for testing idst2.""" + x = np.array(x, copy=True) + for row in range(x.shape[0]): + x[row, :] = idst(x[row, :], **kwargs) + for col in range(x.shape[1]): + x[:, col] = idst(x[:, col], **kwargs) + return x + + +def naive_dct1(x, norm=None): + """Calculate textbook definition version of DCT-I.""" + x = np.array(x, copy=True) + N = len(x) + M = N-1 + y = np.zeros(N) + m0, m = 1, 2 + if norm == 'ortho': + m0 = np.sqrt(1.0/M) + m = np.sqrt(2.0/M) + for k in range(N): + for n in range(1, N-1): + y[k] += m*x[n]*np.cos(np.pi*n*k/M) + y[k] += m0 * x[0] + y[k] += m0 * x[N-1] * (1 if k % 2 == 0 else -1) + if norm == 'ortho': + y[0] *= 1/np.sqrt(2) + y[N-1] *= 1/np.sqrt(2) + return y + + +def naive_dst1(x, norm=None): + """Calculate textbook definition version of DST-I.""" + x = np.array(x, copy=True) + N = len(x) + M = N+1 + y = np.zeros(N) + for k in range(N): + for n in range(N): + y[k] += 2*x[n]*np.sin(np.pi*(n+1.0)*(k+1.0)/M) + if norm == 'ortho': + y *= np.sqrt(0.5/M) + return y + + +def naive_dct4(x, norm=None): + """Calculate textbook definition version of DCT-IV.""" + x = np.array(x, copy=True) + N = len(x) + y = np.zeros(N) + for k in range(N): + for n in range(N): + y[k] += x[n]*np.cos(np.pi*(n+0.5)*(k+0.5)/(N)) + if norm == 'ortho': + y *= np.sqrt(2.0/N) + else: + y *= 2 + return y + + +def naive_dst4(x, norm=None): + """Calculate textbook definition version of DST-IV.""" + x = np.array(x, copy=True) + N = len(x) + y = np.zeros(N) + for k in range(N): + for n in range(N): + y[k] += x[n]*np.sin(np.pi*(n+0.5)*(k+0.5)/(N)) + if norm == 'ortho': + y *= np.sqrt(2.0/N) + else: + y *= 2 + return y + + +class TestComplex: + def test_dct_complex64(self): + y = dct(1j*np.arange(5, dtype=np.complex64)) + x = 1j*dct(np.arange(5)) + assert_array_almost_equal(x, y) + + def test_dct_complex(self): + y = dct(np.arange(5)*1j) + x = 1j*dct(np.arange(5)) + assert_array_almost_equal(x, y) + + def test_idct_complex(self): + y = idct(np.arange(5)*1j) + x = 1j*idct(np.arange(5)) + assert_array_almost_equal(x, y) + + def test_dst_complex64(self): + y = dst(np.arange(5, dtype=np.complex64)*1j) + x = 1j*dst(np.arange(5)) + assert_array_almost_equal(x, y) + + def test_dst_complex(self): + y = dst(np.arange(5)*1j) + x = 1j*dst(np.arange(5)) + assert_array_almost_equal(x, y) + + def test_idst_complex(self): + y = idst(np.arange(5)*1j) + x = 1j*idst(np.arange(5)) + assert_array_almost_equal(x, y) + + +class _TestDCTBase: + def setup_method(self): + self.rdt = None + self.dec = 14 + self.type = None + + @pytest.fixture + def dct_lock(self): + return threading.Lock() + + def test_definition(self, dct_lock): + for i in FFTWDATA_SIZES: + with dct_lock: + x, yr, dt = fftw_dct_ref(self.type, i, self.rdt) + y = dct(x, type=self.type) + assert_equal(y.dtype, dt) + # XXX: we divide by np.max(y) because the tests fail otherwise. We + # should really use something like assert_array_approx_equal. The + # difference is due to fftw using a better algorithm w.r.t error + # propagation compared to the ones from fftpack. + assert_array_almost_equal(y / np.max(y), yr / np.max(y), decimal=self.dec, + err_msg="Size %d failed" % i) + + def test_axis(self): + nt = 2 + rng = np.random.RandomState(1234) + for i in [7, 8, 9, 16, 32, 64]: + x = rng.randn(nt, i) + y = dct(x, type=self.type) + for j in range(nt): + assert_array_almost_equal(y[j], dct(x[j], type=self.type), + decimal=self.dec) + + x = x.T + y = dct(x, axis=0, type=self.type) + for j in range(nt): + assert_array_almost_equal(y[:,j], dct(x[:,j], type=self.type), + decimal=self.dec) + + +class _TestDCTIBase(_TestDCTBase): + def test_definition_ortho(self): + # Test orthornomal mode. + dt = np.result_type(np.float32, self.rdt) + for xr in X: + x = np.array(xr, dtype=self.rdt) + y = dct(x, norm='ortho', type=1) + y2 = naive_dct1(x, norm='ortho') + assert_equal(y.dtype, dt) + assert_array_almost_equal(y / np.max(y), y2 / np.max(y), decimal=self.dec) + +class _TestDCTIIBase(_TestDCTBase): + def test_definition_matlab(self): + # Test correspondence with MATLAB (orthornomal mode). + dt = np.result_type(np.float32, self.rdt) + for xr, yr in zip(X, Y): + x = np.array(xr, dtype=dt) + y = dct(x, norm="ortho", type=2) + assert_equal(y.dtype, dt) + assert_array_almost_equal(y, yr, decimal=self.dec) + + +class _TestDCTIIIBase(_TestDCTBase): + def test_definition_ortho(self): + # Test orthornomal mode. + dt = np.result_type(np.float32, self.rdt) + for xr in X: + x = np.array(xr, dtype=self.rdt) + y = dct(x, norm='ortho', type=2) + xi = dct(y, norm="ortho", type=3) + assert_equal(xi.dtype, dt) + assert_array_almost_equal(xi, x, decimal=self.dec) + +class _TestDCTIVBase(_TestDCTBase): + def test_definition_ortho(self): + # Test orthornomal mode. + dt = np.result_type(np.float32, self.rdt) + for xr in X: + x = np.array(xr, dtype=self.rdt) + y = dct(x, norm='ortho', type=4) + y2 = naive_dct4(x, norm='ortho') + assert_equal(y.dtype, dt) + assert_array_almost_equal(y / np.max(y), y2 / np.max(y), decimal=self.dec) + + +class TestDCTIDouble(_TestDCTIBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 10 + self.type = 1 + + +class TestDCTIFloat(_TestDCTIBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 4 + self.type = 1 + + +class TestDCTIInt(_TestDCTIBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 1 + + +class TestDCTIIDouble(_TestDCTIIBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 10 + self.type = 2 + + +class TestDCTIIFloat(_TestDCTIIBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 5 + self.type = 2 + + +class TestDCTIIInt(_TestDCTIIBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 2 + + +class TestDCTIIIDouble(_TestDCTIIIBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 14 + self.type = 3 + + +class TestDCTIIIFloat(_TestDCTIIIBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 5 + self.type = 3 + + +class TestDCTIIIInt(_TestDCTIIIBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 3 + + +class TestDCTIVDouble(_TestDCTIVBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 12 + self.type = 3 + + +class TestDCTIVFloat(_TestDCTIVBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 5 + self.type = 3 + + +class TestDCTIVInt(_TestDCTIVBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 3 + + +class _TestIDCTBase: + def setup_method(self): + self.rdt = None + self.dec = 14 + self.type = None + + @pytest.fixture + def idct_lock(self): + return threading.Lock() + + def test_definition(self, idct_lock): + for i in FFTWDATA_SIZES: + with idct_lock: + xr, yr, dt = fftw_dct_ref(self.type, i, self.rdt) + x = idct(yr, type=self.type) + if self.type == 1: + x /= 2 * (i-1) + else: + x /= 2 * i + assert_equal(x.dtype, dt) + # XXX: we divide by np.max(y) because the tests fail otherwise. We + # should really use something like assert_array_approx_equal. The + # difference is due to fftw using a better algorithm w.r.t error + # propagation compared to the ones from fftpack. + assert_array_almost_equal(x / np.max(x), xr / np.max(x), decimal=self.dec, + err_msg="Size %d failed" % i) + + +class TestIDCTIDouble(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 10 + self.type = 1 + + +class TestIDCTIFloat(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 4 + self.type = 1 + + +class TestIDCTIInt(_TestIDCTBase): + def setup_method(self): + self.rdt = int + self.dec = 4 + self.type = 1 + + +class TestIDCTIIDouble(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 10 + self.type = 2 + + +class TestIDCTIIFloat(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 5 + self.type = 2 + + +class TestIDCTIIInt(_TestIDCTBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 2 + + +class TestIDCTIIIDouble(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 14 + self.type = 3 + + +class TestIDCTIIIFloat(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 5 + self.type = 3 + + +class TestIDCTIIIInt(_TestIDCTBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 3 + +class TestIDCTIVDouble(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 12 + self.type = 4 + + +class TestIDCTIVFloat(_TestIDCTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 5 + self.type = 4 + + +class TestIDCTIVInt(_TestIDCTBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 4 + +class _TestDSTBase: + def setup_method(self): + self.rdt = None # dtype + self.dec = None # number of decimals to match + self.type = None # dst type + + @pytest.fixture + def dst_lock(self): + return threading.Lock() + + def test_definition(self, dst_lock): + for i in FFTWDATA_SIZES: + with dst_lock: + xr, yr, dt = fftw_dst_ref(self.type, i, self.rdt) + y = dst(xr, type=self.type) + assert_equal(y.dtype, dt) + # XXX: we divide by np.max(y) because the tests fail otherwise. We + # should really use something like assert_array_approx_equal. The + # difference is due to fftw using a better algorithm w.r.t error + # propagation compared to the ones from fftpack. + assert_array_almost_equal(y / np.max(y), yr / np.max(y), decimal=self.dec, + err_msg="Size %d failed" % i) + + +class _TestDSTIBase(_TestDSTBase): + def test_definition_ortho(self): + # Test orthornomal mode. + dt = np.result_type(np.float32, self.rdt) + for xr in X: + x = np.array(xr, dtype=self.rdt) + y = dst(x, norm='ortho', type=1) + y2 = naive_dst1(x, norm='ortho') + assert_equal(y.dtype, dt) + assert_array_almost_equal(y / np.max(y), y2 / np.max(y), decimal=self.dec) + +class _TestDSTIVBase(_TestDSTBase): + def test_definition_ortho(self): + # Test orthornomal mode. + dt = np.result_type(np.float32, self.rdt) + for xr in X: + x = np.array(xr, dtype=self.rdt) + y = dst(x, norm='ortho', type=4) + y2 = naive_dst4(x, norm='ortho') + assert_equal(y.dtype, dt) + assert_array_almost_equal(y, y2, decimal=self.dec) + +class TestDSTIDouble(_TestDSTIBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 12 + self.type = 1 + + +class TestDSTIFloat(_TestDSTIBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 4 + self.type = 1 + + +class TestDSTIInt(_TestDSTIBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 1 + + +class TestDSTIIDouble(_TestDSTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 14 + self.type = 2 + + +class TestDSTIIFloat(_TestDSTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 6 + self.type = 2 + + +class TestDSTIIInt(_TestDSTBase): + def setup_method(self): + self.rdt = int + self.dec = 6 + self.type = 2 + + +class TestDSTIIIDouble(_TestDSTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 14 + self.type = 3 + + +class TestDSTIIIFloat(_TestDSTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 7 + self.type = 3 + + +class TestDSTIIIInt(_TestDSTBase): + def setup_method(self): + self.rdt = int + self.dec = 7 + self.type = 3 + + +class TestDSTIVDouble(_TestDSTIVBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 12 + self.type = 4 + + +class TestDSTIVFloat(_TestDSTIVBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 4 + self.type = 4 + + +class TestDSTIVInt(_TestDSTIVBase): + def setup_method(self): + self.rdt = int + self.dec = 5 + self.type = 4 + + +class _TestIDSTBase: + def setup_method(self): + self.rdt = None + self.dec = None + self.type = None + + @pytest.fixture + def idst_lock(self): + return threading.Lock() + + def test_definition(self, idst_lock): + for i in FFTWDATA_SIZES: + with idst_lock: + xr, yr, dt = fftw_dst_ref(self.type, i, self.rdt) + x = idst(yr, type=self.type) + if self.type == 1: + x /= 2 * (i+1) + else: + x /= 2 * i + assert_equal(x.dtype, dt) + # XXX: we divide by np.max(x) because the tests fail otherwise. We + # should really use something like assert_array_approx_equal. The + # difference is due to fftw using a better algorithm w.r.t error + # propagation compared to the ones from fftpack. + assert_array_almost_equal(x / np.max(x), xr / np.max(x), decimal=self.dec, + err_msg="Size %d failed" % i) + + +class TestIDSTIDouble(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 12 + self.type = 1 + + +class TestIDSTIFloat(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 4 + self.type = 1 + + +class TestIDSTIInt(_TestIDSTBase): + def setup_method(self): + self.rdt = int + self.dec = 4 + self.type = 1 + + +class TestIDSTIIDouble(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 14 + self.type = 2 + + +class TestIDSTIIFloat(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 6 + self.type = 2 + + +class TestIDSTIIInt(_TestIDSTBase): + def setup_method(self): + self.rdt = int + self.dec = 6 + self.type = 2 + + +class TestIDSTIIIDouble(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 14 + self.type = 3 + + +class TestIDSTIIIFloat(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 6 + self.type = 3 + + +class TestIDSTIIIInt(_TestIDSTBase): + def setup_method(self): + self.rdt = int + self.dec = 6 + self.type = 3 + + +class TestIDSTIVDouble(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float64 + self.dec = 12 + self.type = 4 + + +class TestIDSTIVFloat(_TestIDSTBase): + def setup_method(self): + self.rdt = np.float32 + self.dec = 6 + self.type = 4 + + +class TestIDSTIVnt(_TestIDSTBase): + def setup_method(self): + self.rdt = int + self.dec = 6 + self.type = 4 + + +class TestOverwrite: + """Check input overwrite behavior.""" + + real_dtypes = [np.float32, np.float64] + + def _check(self, x, routine, type, fftsize, axis, norm, overwrite_x, **kw): + x2 = x.copy() + routine(x2, type, fftsize, axis, norm, overwrite_x=overwrite_x) + + sig = (f"{routine.__name__}({x.dtype}{x.shape!r}, {fftsize!r}, " + f"axis={axis!r}, overwrite_x={overwrite_x!r})") + if not overwrite_x: + assert_equal(x2, x, err_msg=f"spurious overwrite in {sig}") + + def _check_1d(self, routine, dtype, shape, axis): + rng = np.random.RandomState(1234) + if np.issubdtype(dtype, np.complexfloating): + data = rng.randn(*shape) + 1j*rng.randn(*shape) + else: + data = rng.randn(*shape) + data = data.astype(dtype) + + for type in [1, 2, 3, 4]: + for overwrite_x in [True, False]: + for norm in [None, 'ortho']: + self._check(data, routine, type, None, axis, norm, + overwrite_x) + + def test_dct(self): + for dtype in self.real_dtypes: + self._check_1d(dct, dtype, (16,), -1) + self._check_1d(dct, dtype, (16, 2), 0) + self._check_1d(dct, dtype, (2, 16), 1) + + def test_idct(self): + for dtype in self.real_dtypes: + self._check_1d(idct, dtype, (16,), -1) + self._check_1d(idct, dtype, (16, 2), 0) + self._check_1d(idct, dtype, (2, 16), 1) + + def test_dst(self): + for dtype in self.real_dtypes: + self._check_1d(dst, dtype, (16,), -1) + self._check_1d(dst, dtype, (16, 2), 0) + self._check_1d(dst, dtype, (2, 16), 1) + + def test_idst(self): + for dtype in self.real_dtypes: + self._check_1d(idst, dtype, (16,), -1) + self._check_1d(idst, dtype, (16, 2), 0) + self._check_1d(idst, dtype, (2, 16), 1) + + +class Test_DCTN_IDCTN: + dec = 14 + dct_type = [1, 2, 3, 4] + norms = [None, 'ortho'] + rstate = np.random.RandomState(1234) + shape = (32, 16) + data = rstate.randn(*shape) + + @pytest.mark.parametrize('fforward,finverse', [(dctn, idctn), + (dstn, idstn)]) + @pytest.mark.parametrize('axes', [None, + 1, (1,), [1], + 0, (0,), [0], + (0, 1), [0, 1], + (-2, -1), [-2, -1]]) + @pytest.mark.parametrize('dct_type', dct_type) + @pytest.mark.parametrize('norm', ['ortho']) + def test_axes_round_trip(self, fforward, finverse, axes, dct_type, norm): + tmp = fforward(self.data, type=dct_type, axes=axes, norm=norm) + tmp = finverse(tmp, type=dct_type, axes=axes, norm=norm) + assert_array_almost_equal(self.data, tmp, decimal=12) + + @pytest.mark.parametrize('fforward,fforward_ref', [(dctn, dct_2d_ref), + (dstn, dst_2d_ref)]) + @pytest.mark.parametrize('dct_type', dct_type) + @pytest.mark.parametrize('norm', norms) + def test_dctn_vs_2d_reference(self, fforward, fforward_ref, + dct_type, norm): + y1 = fforward(self.data, type=dct_type, axes=None, norm=norm) + y2 = fforward_ref(self.data, type=dct_type, norm=norm) + assert_array_almost_equal(y1, y2, decimal=11) + + @pytest.mark.parametrize('finverse,finverse_ref', [(idctn, idct_2d_ref), + (idstn, idst_2d_ref)]) + @pytest.mark.parametrize('dct_type', dct_type) + @pytest.mark.parametrize('norm', [None, 'ortho']) + def test_idctn_vs_2d_reference(self, finverse, finverse_ref, + dct_type, norm): + fdata = dctn(self.data, type=dct_type, norm=norm) + y1 = finverse(fdata, type=dct_type, norm=norm) + y2 = finverse_ref(fdata, type=dct_type, norm=norm) + assert_array_almost_equal(y1, y2, decimal=11) + + @pytest.mark.parametrize('fforward,finverse', [(dctn, idctn), + (dstn, idstn)]) + def test_axes_and_shape(self, fforward, finverse): + with assert_raises(ValueError, + match="when given, axes and shape arguments" + " have to be of the same length"): + fforward(self.data, shape=self.data.shape[0], axes=(0, 1)) + + with assert_raises(ValueError, + match="when given, axes and shape arguments" + " have to be of the same length"): + fforward(self.data, shape=self.data.shape[0], axes=None) + + with assert_raises(ValueError, + match="when given, axes and shape arguments" + " have to be of the same length"): + fforward(self.data, shape=self.data.shape, axes=0) + + @pytest.mark.parametrize('fforward', [dctn, dstn]) + def test_shape(self, fforward): + tmp = fforward(self.data, shape=(128, 128), axes=None) + assert_equal(tmp.shape, (128, 128)) + + @pytest.mark.parametrize('fforward,finverse', [(dctn, idctn), + (dstn, idstn)]) + @pytest.mark.parametrize('axes', [1, (1,), [1], + 0, (0,), [0]]) + def test_shape_is_none_with_axes(self, fforward, finverse, axes): + tmp = fforward(self.data, shape=None, axes=axes, norm='ortho') + tmp = finverse(tmp, shape=None, axes=axes, norm='ortho') + assert_array_almost_equal(self.data, tmp, decimal=self.dec) diff --git a/shared/package-files/42/4209ff0789de4aafa91ef14596022b6149a30dfcc39035de16a5984d7d9ab4d9/blob b/shared/package-files/42/4209ff0789de4aafa91ef14596022b6149a30dfcc39035de16a5984d7d9ab4d9/blob new file mode 100644 index 0000000000000000000000000000000000000000..867cdb3fa0ee326410e7c93e1b27b0fcaab3e100 --- /dev/null +++ b/shared/package-files/42/4209ff0789de4aafa91ef14596022b6149a30dfcc39035de16a5984d7d9ab4d9/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor mH(const at::Tensor & self); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/42/420afccf348948ecbdf16939a430d8e1db92fa0c16ce9582462cae18b8282127/blob b/shared/package-files/42/420afccf348948ecbdf16939a430d8e1db92fa0c16ce9582462cae18b8282127/blob new file mode 100644 index 0000000000000000000000000000000000000000..dd3732a5f394acc1dce48683fe76a6d57ea78a2a --- /dev/null +++ b/shared/package-files/42/420afccf348948ecbdf16939a430d8e1db92fa0c16ce9582462cae18b8282127/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor corrcoef(const at::Tensor & self); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/42/420c28a5405fde3443537963f4f75ea989148d159a600b032916663f215473b9/blob b/shared/package-files/42/420c28a5405fde3443537963f4f75ea989148d159a600b032916663f215473b9/blob new file mode 100644 index 0000000000000000000000000000000000000000..8d60da45d1e2cf1bee659cd08a8e701f9908b82b --- /dev/null +++ b/shared/package-files/42/420c28a5405fde3443537963f4f75ea989148d159a600b032916663f215473b9/blob @@ -0,0 +1,119318 @@ +{ + "initialization": { + "distribution": "Normal(0,0.01)", + "seed": 20261021, + "pretrained_weights": false + }, + "training_data": "all 19880 supplied training shots per condition; all 130 conditions", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1", + "calibration_exception": "Supplied even-fitted DEMs include validation syndromes but no logical labels or test data.", + "optimizer": "L-BFGS-B binary cross entropy plus 1e-5 L2, maximum 300 iterations", + "selection": "First trained candidate; validation reported without parameter fitting or hyperparameter selection", + "test_data_used": false, + "released_per_shot_predictions_used": false, + "history": [ + { + "group": "d3_bX_center_3_5", + "train_loss": 0.49244210477855016, + "iterations": 88, + "failure": 0.26941105769230766, + "plain_failure": 0.2847205528846154, + "correlated_failure": 0.2704326923076923, + "coset_failure": 0.2847205528846154, + "optimizer_success": true + }, + { + "group": "d3_bX_center_5_3", + "train_loss": 0.4947914557869911, + "iterations": 85, + "failure": 0.2706430288461538, + "plain_failure": 0.29103064903846154, + "correlated_failure": 0.27076322115384616, + "coset_failure": 0.29103064903846154, + "optimizer_success": true + }, + { + "group": "d3_bX_center_5_7", + "train_loss": 0.4786369068642458, + "iterations": 79, + "failure": 0.25964543269230766, + "plain_failure": 0.2741887019230769, + "correlated_failure": 0.2598106971153846, + "coset_failure": 0.2741887019230769, + "optimizer_success": true + }, + { + "group": "d3_bX_center_7_5", + "train_loss": 0.48299120621578956, + "iterations": 81, + "failure": 0.26062199519230766, + "plain_failure": 0.2762920673076923, + "correlated_failure": 0.2615234375, + "coset_failure": 0.2762920673076923, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_3_5", + "train_loss": 0.4903180822446507, + "iterations": 62, + "failure": 0.2718299278846154, + "plain_failure": 0.2878605769230769, + "correlated_failure": 0.2736778846153846, + "coset_failure": 0.2878605769230769, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_5_3", + "train_loss": 0.4886621962442568, + "iterations": 90, + "failure": 0.25896935096153845, + "plain_failure": 0.27548076923076925, + "correlated_failure": 0.2588942307692308, + "coset_failure": 0.27548076923076925, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_5_7", + "train_loss": 0.4822654448634678, + "iterations": 71, + "failure": 0.2594200721153846, + "plain_failure": 0.2823016826923077, + "correlated_failure": 0.25961538461538464, + "coset_failure": 0.2823016826923077, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_7_5", + "train_loss": 0.47379411844328495, + "iterations": 69, + "failure": 0.2542067307692308, + "plain_failure": 0.27393329326923077, + "correlated_failure": 0.2547776442307692, + "coset_failure": 0.27393329326923077, + "optimizer_success": true + }, + { + "group": "d5_bX_center_5_5", + "train_loss": 0.4801955727360068, + "iterations": 85, + "failure": 0.2616887019230769, + "plain_failure": 0.293359375, + "correlated_failure": 0.2609375, + "coset_failure": 0.293359375, + "optimizer_success": true + }, + { + "group": "d5_bZ_center_5_5", + "train_loss": 0.4661361209861219, + "iterations": 87, + "failure": 0.2465294471153846, + "plain_failure": 0.2799729567307692, + "correlated_failure": 0.24618389423076922, + "coset_failure": 0.2799729567307692, + "optimizer_success": true + } + ], + "elapsed_seconds": 30.247901678085327, + "experiment_2": { + "method": "Exact contraction of supplied DEM for d3; learned logistic mixture with matching features", + "initialization": { + "distribution": "Normal(0,0.01)", + "seed": 20261022, + "pretrained_weights": false + }, + "selection": "Minimum validation condition-mean failure per group among raw exact, calibrated exact, exact plus matching ensemble", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "exact_raw": { + "failure": 0.253125 + }, + "exact_calibrated": { + "failure": 0.25378605769230766, + "train_loss": 0.46127817271552574, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2522686298076923, + "train_loss": 0.459112999306209, + "iterations": 115 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "exact_raw": { + "failure": 0.2569711538461538 + }, + "exact_calibrated": { + "failure": 0.25790264423076925, + "train_loss": 0.46654812103904, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.257421875, + "train_loss": 0.4647701206688181, + "iterations": 80 + } + }, + "selected": "exact_raw" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "exact_raw": { + "failure": 0.23622295673076923 + }, + "exact_calibrated": { + "failure": 0.23608774038461539, + "train_loss": 0.43883548729746, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2357421875, + "train_loss": 0.43779428254411507, + "iterations": 82 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "exact_raw": { + "failure": 0.24507211538461537 + }, + "exact_calibrated": { + "failure": 0.24541766826923078, + "train_loss": 0.4551514021617466, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.24453125, + "train_loss": 0.4531701181347552, + "iterations": 87 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "exact_raw": { + "failure": 0.25402644230769234 + }, + "exact_calibrated": { + "failure": 0.2541316105769231, + "train_loss": 0.4629309494609537, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.25310997596153845, + "train_loss": 0.45978815429050657, + "iterations": 96 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "exact_raw": { + "failure": 0.24298377403846153 + }, + "exact_calibrated": { + "failure": 0.24182692307692308, + "train_loss": 0.4539302799880139, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2408203125, + "train_loss": 0.45299183982324187, + "iterations": 100 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "exact_raw": { + "failure": 0.24226262019230768 + }, + "exact_calibrated": { + "failure": 0.24166165865384615, + "train_loss": 0.4465993958308988, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.24064002403846155, + "train_loss": 0.4446921891727968, + "iterations": 121 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "exact_raw": { + "failure": 0.23793569711538462 + }, + "exact_calibrated": { + "failure": 0.2377253605769231, + "train_loss": 0.43773570264641537, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2367638221153846, + "train_loss": 0.4363258121838859, + "iterations": 103 + } + }, + "selected": "exact_ensemble" + } + ], + "numerical_check": "r01 all syndromes agrees with exhaustive enumeration to 1.2e-7" + }, + "experiment_3": { + "method": "Exact complementary CSS edge posterior marginals reweight joint error probabilities before relevant CSS exact contraction; induced correlations are factorized", + "initialization": { + "distribution": "Normal(0,0.01)", + "seed": 20261024, + "pretrained_weights": false + }, + "training": "4096 training shots sampled without replacement from each of all 26 d5 conditions, RNG seed 20261023; original matching components retain their all-training-shot fit", + "selection": "Minimum full-validation condition-mean failure per group among previous matching, raw conditional (strength 1), calibrated conditional, and learned combination of strengths 0/.5/1 with matching", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "matching": { + "failure": 0.2616887019230769 + }, + "conditional_raw": { + "failure": 0.24053485576923078 + }, + "conditional_calibrated": { + "failure": 0.24064002403846155, + "train_loss": 0.4375296643032495, + "iterations": 8 + }, + "conditional_ensemble": { + "failure": 0.24024939903846154, + "train_loss": 0.43518462432711086, + "iterations": 107 + } + }, + "selected": "conditional_ensemble" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "matching": { + "failure": 0.2465294471153846 + }, + "conditional_raw": { + "failure": 0.229296875 + }, + "conditional_calibrated": { + "failure": 0.22944711538461537, + "train_loss": 0.42155058672043744, + "iterations": 9 + }, + "conditional_ensemble": { + "failure": 0.22627704326923076, + "train_loss": 0.4183033939719488, + "iterations": 150 + } + }, + "selected": "conditional_ensemble" + } + ], + "approximation": "Complementary-check conditioning induces error dependencies. This candidate uses their marginal probabilities independently; d5 contraction is therefore approximate." + }, + "contextual_d3_pilot": { + "training": { + "initialization": "Random variance-scaled normal first two layers, random Normal(0,.001) output; zero biases; seed 20261025", + "architecture": "Two 32-unit SiLU layers, output 2*tanh correction to original hyperedge logit; 40 local detection bits and 57 static error/geometry features", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 512, + "batch_size": 128, + "optimizer": "AdamW 1e-3, weight decay 1e-4, global gradient norm clip 1", + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 512, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.5264908075332642, + "error": 0.2578125, + "gradient_norm": 0.06699763983488083, + "elapsed": 432.866411447525 + }, + { + "step": 16, + "loss": 0.3703196942806244, + "error": 0.1484375, + "gradient_norm": 0.030896008014678955, + "elapsed": 437.98383259773254 + }, + { + "step": 32, + "loss": 0.5410848259925842, + "error": 0.3125, + "gradient_norm": 0.023287978023290634, + "elapsed": 443.36136960983276 + }, + { + "step": 48, + "loss": 0.6548658609390259, + "error": 0.3984375, + "gradient_norm": 0.08600008487701416, + "elapsed": 448.5753285884857 + }, + { + "step": 64, + "loss": 0.3396199345588684, + "error": 0.1875, + "gradient_norm": 0.09408964961767197, + "elapsed": 453.55865502357483 + }, + { + "step": 80, + "loss": 0.22403547167778015, + "error": 0.09375, + "gradient_norm": 0.11353142559528351, + "elapsed": 458.8852906227112 + }, + { + "step": 96, + "loss": 0.5754531621932983, + "error": 0.34375, + "gradient_norm": 0.10487920045852661, + "elapsed": 466.05401706695557 + }, + { + "step": 112, + "loss": 0.6411566734313965, + "error": 0.4609375, + "gradient_norm": 0.0897318571805954, + "elapsed": 472.25429010391235 + }, + { + "step": 128, + "loss": 0.4312451481819153, + "error": 0.1875, + "gradient_norm": 0.024307778105139732, + "elapsed": 477.15532541275024 + }, + { + "step": 144, + "loss": 0.18217915296554565, + "error": 0.0625, + "gradient_norm": 0.02471880242228508, + "elapsed": 481.5596089363098 + }, + { + "step": 160, + "loss": 0.3044101595878601, + "error": 0.140625, + "gradient_norm": 0.11279744654893875, + "elapsed": 485.47020196914673 + }, + { + "step": 176, + "loss": 0.6485109329223633, + "error": 0.421875, + "gradient_norm": 0.09296684712171555, + "elapsed": 489.5691695213318 + }, + { + "step": 192, + "loss": 0.2566836178302765, + "error": 0.09375, + "gradient_norm": 0.03372751921415329, + "elapsed": 493.5000331401825 + }, + { + "step": 208, + "loss": 0.5453524589538574, + "error": 0.296875, + "gradient_norm": 0.09404441714286804, + "elapsed": 497.62110686302185 + }, + { + "step": 224, + "loss": 0.19316628575325012, + "error": 0.0859375, + "gradient_norm": 0.03877737745642662, + "elapsed": 501.7119605541229 + }, + { + "step": 240, + "loss": 0.5537517070770264, + "error": 0.328125, + "gradient_norm": 0.030214278027415276, + "elapsed": 505.71154594421387 + }, + { + "step": 256, + "loss": 0.5224764347076416, + "error": 0.2734375, + "gradient_norm": 0.13780595362186432, + "elapsed": 509.65054631233215 + }, + { + "step": 272, + "loss": 0.5350009202957153, + "error": 0.3046875, + "gradient_norm": 0.08942794054746628, + "elapsed": 553.2619364261627 + }, + { + "step": 288, + "loss": 0.4561898112297058, + "error": 0.21875, + "gradient_norm": 0.02774384245276451, + "elapsed": 557.1897430419922 + }, + { + "step": 304, + "loss": 0.6102809309959412, + "error": 0.390625, + "gradient_norm": 0.04374801740050316, + "elapsed": 561.1394822597504 + }, + { + "step": 320, + "loss": 0.37536823749542236, + "error": 0.171875, + "gradient_norm": 0.10325513035058975, + "elapsed": 565.0790395736694 + }, + { + "step": 336, + "loss": 0.419940710067749, + "error": 0.2265625, + "gradient_norm": 0.04723379388451576, + "elapsed": 569.050211429596 + }, + { + "step": 352, + "loss": 0.6458156108856201, + "error": 0.4609375, + "gradient_norm": 0.04816316068172455, + "elapsed": 573.0114912986755 + }, + { + "step": 368, + "loss": 0.5628451108932495, + "error": 0.328125, + "gradient_norm": 0.09256711602210999, + "elapsed": 576.9429559707642 + }, + { + "step": 384, + "loss": 0.5773618221282959, + "error": 0.359375, + "gradient_norm": 0.16693103313446045, + "elapsed": 580.8791544437408 + }, + { + "step": 400, + "loss": 0.12261693179607391, + "error": 0.046875, + "gradient_norm": 0.06734084337949753, + "elapsed": 584.8116250038147 + }, + { + "step": 416, + "loss": 0.33368560671806335, + "error": 0.125, + "gradient_norm": 0.04156317561864853, + "elapsed": 588.7308163642883 + }, + { + "step": 432, + "loss": 0.2161063849925995, + "error": 0.109375, + "gradient_norm": 0.06895668804645538, + "elapsed": 592.6584475040436 + }, + { + "step": 448, + "loss": 0.6331151723861694, + "error": 0.3828125, + "gradient_norm": 0.12380247563123703, + "elapsed": 596.5997920036316 + }, + { + "step": 464, + "loss": 0.28776052594184875, + "error": 0.1484375, + "gradient_norm": 0.03920985758304596, + "elapsed": 600.5359675884247 + }, + { + "step": 480, + "loss": 0.639541745185852, + "error": 0.421875, + "gradient_norm": 0.029632505029439926, + "elapsed": 604.4547488689423 + }, + { + "step": 496, + "loss": 0.5919073820114136, + "error": 0.359375, + "gradient_norm": 0.11676646769046783, + "elapsed": 608.3825929164886 + }, + { + "step": 512, + "loss": 0.5479233264923096, + "error": 0.265625, + "gradient_norm": 0.03692208230495453, + "elapsed": 612.3190803527832 + } + ] + }, + "selection": "Per-group minimum failure among previous decoder and pilot steps 256 and 512, using all 532480 d3 validation shots", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "previous": 0.25226862980769227, + "256": 0.2515625, + "512": 0.2510216346153846 + }, + "selected": "512" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "previous": 0.2569711538461539, + "256": 0.2557542067307692, + "512": 0.256640625 + }, + "selected": "256" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "previous": 0.23574218750000003, + "256": 0.2356820913461538, + "512": 0.23511117788461539 + }, + "selected": "512" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "previous": 0.24453125000000003, + "256": 0.24275841346153845, + "512": 0.24224759615384617 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "previous": 0.25310997596153845, + "256": 0.2524188701923077, + "512": 0.2513822115384615 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "previous": 0.24082031250000002, + "256": 0.2387469951923077, + "512": 0.23933293269230768 + }, + "selected": "256" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "previous": 0.24064002403846155, + "256": 0.24053485576923073, + "512": 0.24002403846153844 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "previous": 0.2367638221153846, + "256": 0.23635817307692306, + "512": 0.23584735576923077 + }, + "selected": "512" + } + ], + "initial_validation_subset": "First 512 validation rows/condition; then both trained checkpoints evaluated on full validation", + "features": "40 detection bits within five frames and 57 static error/geometry features; detector indices come from the ideal geometry/DEM; sample IDs are not features", + "derivative_check": "Relative error 1.16e-7 versus automatic differentiation on a small d3 example" + }, + "previous_package_validation": { + "performance": 0.76744384765625, + "failure_by_distance": { + "d3": 0.2397442157451923, + "d5": 0.2253680889423077 + }, + "scorer": "Supplied qecbench.scoring on all 130 validation conditions and 665600 shots", + "contract_checks": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "shots": 1, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r25_center_5_3", + "shots": 37, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r13_center_5_7", + "shots": 1025, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r17_center_3_5", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r17_center_5_3", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r17_center_5_7", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r17_center_7_5", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r17_center_3_5", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r17_center_5_3", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r17_center_5_7", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r17_center_7_5", + "shots": 19, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 1, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 3, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 7, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 17, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 37, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 257, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 1025, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "maximum_probability_difference": 0.0 + } + ], + "prediction_generation": "All104 d3 conditions replayed from the assembled package; unchanged d5 predictions retained. Trusted scoring covers all130 conditions.", + "d3_validation_runtime_seconds": 66.40283012390137, + "unchanged_d5_runtime_evidence": { + "performance": 0.7674372746394231, + "failure_by_distance": { + "d3": 0.23975736177884616, + "d5": 0.2253680889423077 + }, + "scorer": "Supplied qecbench.scoring on all 130 validation conditions and 665600 shots", + "contract_checks": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "shots": 1, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r25_center_5_3", + "shots": 37, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r13_center_5_7", + "shots": 1025, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 7, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 257, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 17, + "maximum_probability_difference": 0.0 + } + ], + "prediction_generation": "All26 d5 conditions replayed from the assembled package; unchanged d3 predictions retained. Full trusted scoring and relocated arbitrary-ID/subset checks.", + "runtime_evidence": "Full133120-shot d5 replay took 407.24s on one H100; d3 paths unchanged from the recorded incumbent.", + "d5_validation_runtime_seconds": 407.24485874176025, + "runtime_vs_cached": { + "scope": "Assembled runtime versus cached candidate predictions, including physical-prior recomputation and compilation/batching differences; descriptive, not a causal precision attribution", + "maximum_probability_difference": 6.309151649475098e-05, + "decision_differences": 0, + "source_sha256": "2e3e81d122f9d626d486d050c38d86bfd3e55bc6cd8e0e270b9e8eabbf69539a" + }, + "contract_execution": { + "requested_verifier_uid": 10001, + "effective_uid": 1000, + "effective_gid": 1000, + "supplementary_groups": [], + "identity_status": "Development process is already unprivileged and cannot change UID; verifier UID10001 was not executed", + "model_and_input_copy": "Owned by development UID 1000,directories0555,files0444,relocated under a fresh accessible temporary parent", + "output_directory": "Owned by execution UID 1000,mode0700", + "PYTHONPATH": "", + "backend": "Runtime default; full selected subset cases", + "scope": "Local contract check; not a Docker/network/mount-isolation test" + } + }, + "runtime_vs_cached": { + "scope": "Assembled runtime versus cached candidate predictions, including physical-prior recomputation and compilation/batching differences; descriptive, not a causal precision attribution", + "maximum_probability_difference": 0.0, + "decision_differences": 0, + "source_sha256": "2e3e81d122f9d626d486d050c38d86bfd3e55bc6cd8e0e270b9e8eabbf69539a" + }, + "runtime_evidence": "Full532480-shot d3 replay took 66.40s on one H100. D5 retains the recorded verified implementation.", + "contract_execution": { + "requested_verifier_uid": 10001, + "effective_uid": 1000, + "effective_gid": 1000, + "supplementary_groups": [], + "identity_status": "Development process is already unprivileged and cannot change UID; verifier UID10001 was not executed", + "model_and_input_copy": "Owned by development UID 1000,directories0555,files0444,relocated under a fresh accessible temporary parent", + "output_directory": "Owned by execution UID 1000,mode0700", + "PYTHONPATH": "", + "backend": "Runtime default; full selected subset cases", + "scope": "Local contract check; not a Docker/network/mount-isolation test" + } + }, + "previous_model_manifest_sha256": "d8bed57d4619a87ad756d2347796e396b3169d4146f69ab426f99f9934ef1a8f", + "contextual_updates": [ + { + "name": "large512", + "training": { + "initialization": "This session's pilot checkpoint 512; original random initialization seed 20261025", + "run_config": { + "steps": 2048, + "batch": 2048, + "output": "/run-state/workspace/research/learned_exact/continuation1", + "validation_shots": 1024, + "init_weights": "/workspace/research/learned_exact/pilot/weights-512.npz", + "learning_rate": 0.001, + "eval_every": 512, + "seed": 20261028, + "validation_batch": 1024, + "uniform_validation": true, + "original_random_seed": 20261025, + "starting_checkpoint_sha256": "b14f7bf663b0484b9a79a759455ad09aca456f83a7cc29ed2e9e1d210683c180", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1" + }, + "completed_checkpoint_steps": 512, + "new_sampled_training_shots": 1048576, + "optimizer": "AdamW 1e-3, weight decay 1e-4, global norm clip 1; optimizer reset at phase start", + "data": "Uniform sampling over all 104 d3 training conditions; training rows only", + "selection": "Checkpoint 512 evaluated on all 532480 d3 validation shots", + "full_validation_failure": 0.2428973858173077, + "termination": "Saved checkpoint 512, then stopped to restart with corrected validation NLL reporting. Any later in-flight updates were discarded.", + "reporting_correction": "Recomputed with float labels from the full checkpoint predictions; original in-flight diagnostic negated uint8 labels. Training loss and failure metrics were unaffected.", + "test_data_used": false + }, + "selection": "Minimum full validation mean failure per group between the incumbent and this trained checkpoint", + "history": [ + { + "group": "d3_bX_center_3_5", + "previous_failure": 0.2510216346153846, + "candidate_failure": 0.2491436298076923, + "selected_new": true + }, + { + "group": "d3_bX_center_5_3", + "previous_failure": 0.2557542067307692, + "candidate_failure": 0.256640625, + "selected_new": false + }, + { + "group": "d3_bX_center_5_7", + "previous_failure": 0.23511117788461539, + "candidate_failure": 0.23515625, + "selected_new": false + }, + { + "group": "d3_bX_center_7_5", + "previous_failure": 0.24224759615384617, + "candidate_failure": 0.2403996394230769, + "selected_new": true + }, + { + "group": "d3_bZ_center_3_5", + "previous_failure": 0.2513822115384615, + "candidate_failure": 0.24893329326923078, + "selected_new": true + }, + { + "group": "d3_bZ_center_5_3", + "previous_failure": 0.2387469951923077, + "candidate_failure": 0.23925781249999997, + "selected_new": false + }, + { + "group": "d3_bZ_center_5_7", + "previous_failure": 0.24002403846153844, + "candidate_failure": 0.23885216346153845, + "selected_new": true + }, + { + "group": "d3_bZ_center_7_5", + "previous_failure": 0.23584735576923077, + "candidate_failure": 0.23479567307692306, + "selected_new": true + }, + { + "group": "d5_bX_center_5_5", + "previous_failure": 0.24024939903846157, + "candidate_failure": 0.24024939903846157, + "selected_new": false + }, + { + "group": "d5_bZ_center_5_5", + "previous_failure": 0.22627704326923076, + "candidate_failure": 0.22627704326923076, + "selected_new": false + } + ], + "source_checkpoint_sha256": "7a7579b1bded95bcea7b1d26b2cf26de333c1a0f417fac6a0143eeb3a0c93aa2" + }, + { + "name": "continuation2", + "training_run": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Random variance-scaled normal first two layers, random Normal(0,.001) output; zero biases; seed 20261025", + "architecture": "Two 32-unit SiLU layers, output 2*tanh correction to original hyperedge logit; 40 local detection bits and 57 static error/geometry features", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 1536, + "batch_size": 2048, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261028, + "optimizer_restored": true, + "rng_restored": true, + "session_trained_starting_checkpoint": "/workspace/research/learned_exact/continuation1/weights-512.npz", + "starting_checkpoint_sha256": "7a7579b1bded95bcea7b1d26b2cf26de333c1a0f417fac6a0143eeb3a0c93aa2", + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.05675870552659035, + "error": 0.0166015625, + "gradient_norm": 0.007466103881597519, + "elapsed": 30.636001586914062 + }, + { + "step": 16, + "loss": 0.44421544671058655, + "error": 0.22412109375, + "gradient_norm": 0.029868461191654205, + "elapsed": 35.424378871917725 + }, + { + "step": 32, + "loss": 0.46525052189826965, + "error": 0.23681640625, + "gradient_norm": 0.022205814719200134, + "elapsed": 40.526121854782104 + }, + { + "step": 48, + "loss": 0.6177924871444702, + "error": 0.3544921875, + "gradient_norm": 0.022866439074277878, + "elapsed": 45.67929220199585 + }, + { + "step": 64, + "loss": 0.5046484470367432, + "error": 0.2666015625, + "gradient_norm": 0.0222865492105484, + "elapsed": 50.80926203727722 + }, + { + "step": 80, + "loss": 0.638379693031311, + "error": 0.41064453125, + "gradient_norm": 0.012645655311644077, + "elapsed": 55.93321657180786 + }, + { + "step": 96, + "loss": 0.18619170784950256, + "error": 0.0732421875, + "gradient_norm": 0.012208878062665462, + "elapsed": 61.002137899398804 + }, + { + "step": 112, + "loss": 0.4269826412200928, + "error": 0.2109375, + "gradient_norm": 0.021279584616422653, + "elapsed": 66.13066720962524 + }, + { + "step": 128, + "loss": 0.47232550382614136, + "error": 0.25244140625, + "gradient_norm": 0.03405005484819412, + "elapsed": 85.5297167301178 + }, + { + "step": 144, + "loss": 0.2528073787689209, + "error": 0.11279296875, + "gradient_norm": 0.013145577162504196, + "elapsed": 90.68786001205444 + }, + { + "step": 160, + "loss": 0.5877531170845032, + "error": 0.35595703125, + "gradient_norm": 0.019021881744265556, + "elapsed": 95.76396131515503 + }, + { + "step": 176, + "loss": 0.45082807540893555, + "error": 0.2314453125, + "gradient_norm": 0.023904386907815933, + "elapsed": 100.9375216960907 + }, + { + "step": 192, + "loss": 0.4175146222114563, + "error": 0.19921875, + "gradient_norm": 0.021031895652413368, + "elapsed": 105.98947334289551 + }, + { + "step": 208, + "loss": 0.5424385070800781, + "error": 0.30078125, + "gradient_norm": 0.01396750845015049, + "elapsed": 111.17936706542969 + }, + { + "step": 224, + "loss": 0.29304587841033936, + "error": 0.1259765625, + "gradient_norm": 0.014725692570209503, + "elapsed": 116.36282753944397 + }, + { + "step": 240, + "loss": 0.056691475212574005, + "error": 0.015625, + "gradient_norm": 0.002859376836568117, + "elapsed": 121.54807162284851 + }, + { + "step": 256, + "loss": 0.17413178086280823, + "error": 0.06689453125, + "gradient_norm": 0.02666049636900425, + "elapsed": 126.718514919281 + }, + { + "step": 272, + "loss": 0.6115483641624451, + "error": 0.3466796875, + "gradient_norm": 0.03685307130217552, + "elapsed": 131.77990794181824 + }, + { + "step": 288, + "loss": 0.5973552465438843, + "error": 0.3349609375, + "gradient_norm": 0.02574622817337513, + "elapsed": 138.0202260017395 + }, + { + "step": 304, + "loss": 0.18595321476459503, + "error": 0.0732421875, + "gradient_norm": 0.012303492985665798, + "elapsed": 144.16412949562073 + }, + { + "step": 320, + "loss": 0.5418114066123962, + "error": 0.30126953125, + "gradient_norm": 0.018640751019120216, + "elapsed": 150.969500541687 + }, + { + "step": 336, + "loss": 0.5024716258049011, + "error": 0.26708984375, + "gradient_norm": 0.011490182019770145, + "elapsed": 158.32421374320984 + }, + { + "step": 352, + "loss": 0.5002061128616333, + "error": 0.255859375, + "gradient_norm": 0.03905056416988373, + "elapsed": 165.20316648483276 + }, + { + "step": 368, + "loss": 0.5892350077629089, + "error": 0.33837890625, + "gradient_norm": 0.046964384615421295, + "elapsed": 171.98852562904358 + }, + { + "step": 384, + "loss": 0.526427149772644, + "error": 0.2900390625, + "gradient_norm": 0.021478066220879555, + "elapsed": 178.02048754692078 + }, + { + "step": 400, + "loss": 0.5563177466392517, + "error": 0.306640625, + "gradient_norm": 0.024061864241957664, + "elapsed": 184.09671759605408 + }, + { + "step": 416, + "loss": 0.060019996017217636, + "error": 0.0205078125, + "gradient_norm": 0.006343841087073088, + "elapsed": 190.31260657310486 + }, + { + "step": 432, + "loss": 0.5484405755996704, + "error": 0.3115234375, + "gradient_norm": 0.020139696076512337, + "elapsed": 195.41702342033386 + }, + { + "step": 448, + "loss": 0.6163954138755798, + "error": 0.37646484375, + "gradient_norm": 0.011381164193153381, + "elapsed": 200.53582382202148 + }, + { + "step": 464, + "loss": 0.47678378224372864, + "error": 0.25927734375, + "gradient_norm": 0.03807748854160309, + "elapsed": 205.69636607170105 + }, + { + "step": 480, + "loss": 0.5176759362220764, + "error": 0.2705078125, + "gradient_norm": 0.017451826483011246, + "elapsed": 210.7581787109375 + }, + { + "step": 496, + "loss": 0.3626214563846588, + "error": 0.16455078125, + "gradient_norm": 0.019456032663583755, + "elapsed": 215.82069444656372 + }, + { + "step": 512, + "loss": 0.6202600598335266, + "error": 0.35302734375, + "gradient_norm": 0.013814727775752544, + "elapsed": 220.93863129615784 + }, + { + "step": 528, + "loss": 0.5610182285308838, + "error": 0.29833984375, + "gradient_norm": 0.03955027833580971, + "elapsed": 238.0407817363739 + }, + { + "step": 544, + "loss": 0.332148015499115, + "error": 0.15380859375, + "gradient_norm": 0.013710199855268002, + "elapsed": 243.12822461128235 + }, + { + "step": 560, + "loss": 0.4678276777267456, + "error": 0.23974609375, + "gradient_norm": 0.016155347228050232, + "elapsed": 248.3209776878357 + }, + { + "step": 576, + "loss": 0.6166238784790039, + "error": 0.3740234375, + "gradient_norm": 0.017382115125656128, + "elapsed": 253.49981307983398 + }, + { + "step": 592, + "loss": 0.6137416362762451, + "error": 0.373046875, + "gradient_norm": 0.007819767110049725, + "elapsed": 258.68269968032837 + }, + { + "step": 608, + "loss": 0.2780998647212982, + "error": 0.126953125, + "gradient_norm": 0.03436559438705444, + "elapsed": 263.82615661621094 + }, + { + "step": 624, + "loss": 0.6059691309928894, + "error": 0.3623046875, + "gradient_norm": 0.010842837393283844, + "elapsed": 268.9659583568573 + }, + { + "step": 640, + "loss": 0.058036163449287415, + "error": 0.02001953125, + "gradient_norm": 0.004723707213997841, + "elapsed": 274.09823632240295 + }, + { + "step": 656, + "loss": 0.6149133443832397, + "error": 0.37255859375, + "gradient_norm": 0.008533184416592121, + "elapsed": 279.26951336860657 + }, + { + "step": 672, + "loss": 0.3015868663787842, + "error": 0.1318359375, + "gradient_norm": 0.012536457739770412, + "elapsed": 284.41987442970276 + }, + { + "step": 688, + "loss": 0.16231489181518555, + "error": 0.06494140625, + "gradient_norm": 0.0067833056673407555, + "elapsed": 289.56297039985657 + }, + { + "step": 704, + "loss": 0.04929213970899582, + "error": 0.015625, + "gradient_norm": 0.005747381132096052, + "elapsed": 294.6839826107025 + }, + { + "step": 720, + "loss": 0.5615487098693848, + "error": 0.31689453125, + "gradient_norm": 0.02115021087229252, + "elapsed": 299.8546531200409 + }, + { + "step": 736, + "loss": 0.6306260228157043, + "error": 0.3759765625, + "gradient_norm": 0.02629203163087368, + "elapsed": 305.0923271179199 + }, + { + "step": 752, + "loss": 0.03828414902091026, + "error": 0.0126953125, + "gradient_norm": 0.008905005641281605, + "elapsed": 310.5417342185974 + }, + { + "step": 768, + "loss": 0.48764050006866455, + "error": 0.2626953125, + "gradient_norm": 0.024667929857969284, + "elapsed": 316.01200103759766 + }, + { + "step": 784, + "loss": 0.5836235284805298, + "error": 0.3505859375, + "gradient_norm": 0.023319393396377563, + "elapsed": 321.33294105529785 + }, + { + "step": 800, + "loss": 0.5693534016609192, + "error": 0.31396484375, + "gradient_norm": 0.048126742243766785, + "elapsed": 326.52227997779846 + }, + { + "step": 816, + "loss": 0.5710973739624023, + "error": 0.33349609375, + "gradient_norm": 0.022565416991710663, + "elapsed": 331.62225437164307 + }, + { + "step": 832, + "loss": 0.2818760275840759, + "error": 0.11865234375, + "gradient_norm": 0.025756066665053368, + "elapsed": 336.7874104976654 + }, + { + "step": 848, + "loss": 0.6127357482910156, + "error": 0.3583984375, + "gradient_norm": 0.020077377557754517, + "elapsed": 341.92783546447754 + }, + { + "step": 864, + "loss": 0.5109728574752808, + "error": 0.26171875, + "gradient_norm": 0.022484255954623222, + "elapsed": 347.0137662887573 + }, + { + "step": 880, + "loss": 0.16892661154270172, + "error": 0.06103515625, + "gradient_norm": 0.01363676693290472, + "elapsed": 352.0768094062805 + }, + { + "step": 896, + "loss": 0.593660831451416, + "error": 0.34423828125, + "gradient_norm": 0.01379447989165783, + "elapsed": 357.1796865463257 + }, + { + "step": 912, + "loss": 0.635499119758606, + "error": 0.39306640625, + "gradient_norm": 0.012278803624212742, + "elapsed": 362.29547691345215 + }, + { + "step": 928, + "loss": 0.3966389000415802, + "error": 0.19482421875, + "gradient_norm": 0.019856182858347893, + "elapsed": 367.3532474040985 + }, + { + "step": 944, + "loss": 0.05235423520207405, + "error": 0.01611328125, + "gradient_norm": 0.005415339022874832, + "elapsed": 372.4516806602478 + }, + { + "step": 960, + "loss": 0.5913074612617493, + "error": 0.3330078125, + "gradient_norm": 0.021171825006604195, + "elapsed": 377.5324194431305 + }, + { + "step": 976, + "loss": 0.6479356288909912, + "error": 0.41650390625, + "gradient_norm": 0.02845155820250511, + "elapsed": 382.5862877368927 + }, + { + "step": 992, + "loss": 0.5470497608184814, + "error": 0.30908203125, + "gradient_norm": 0.02726798877120018, + "elapsed": 387.6820628643036 + }, + { + "step": 1008, + "loss": 0.5729615688323975, + "error": 0.32861328125, + "gradient_norm": 0.011548872105777264, + "elapsed": 392.7741017341614 + }, + { + "step": 1024, + "loss": 0.0691118910908699, + "error": 0.0205078125, + "gradient_norm": 0.009204022586345673, + "elapsed": 397.8671176433563 + }, + { + "step": 1040, + "loss": 0.5171630382537842, + "error": 0.2685546875, + "gradient_norm": 0.015718232840299606, + "elapsed": 415.6616735458374 + }, + { + "step": 1056, + "loss": 0.6505192518234253, + "error": 0.39990234375, + "gradient_norm": 0.023937702178955078, + "elapsed": 420.7646098136902 + }, + { + "step": 1072, + "loss": 0.5660485625267029, + "error": 0.32666015625, + "gradient_norm": 0.026201115921139717, + "elapsed": 426.09313225746155 + }, + { + "step": 1088, + "loss": 0.4945259094238281, + "error": 0.25048828125, + "gradient_norm": 0.014495921321213245, + "elapsed": 431.2104251384735 + }, + { + "step": 1104, + "loss": 0.5695121884346008, + "error": 0.33837890625, + "gradient_norm": 0.029924258589744568, + "elapsed": 436.3099756240845 + }, + { + "step": 1120, + "loss": 0.3591366112232208, + "error": 0.16015625, + "gradient_norm": 0.017803259193897247, + "elapsed": 441.4024531841278 + }, + { + "step": 1136, + "loss": 0.3302019536495209, + "error": 0.1572265625, + "gradient_norm": 0.01632549799978733, + "elapsed": 446.55403757095337 + }, + { + "step": 1152, + "loss": 0.6093119382858276, + "error": 0.35107421875, + "gradient_norm": 0.014888457022607327, + "elapsed": 451.6241090297699 + }, + { + "step": 1168, + "loss": 0.3500004708766937, + "error": 0.1650390625, + "gradient_norm": 0.011492405086755753, + "elapsed": 456.7753965854645 + }, + { + "step": 1184, + "loss": 0.3738429844379425, + "error": 0.1845703125, + "gradient_norm": 0.015336514450609684, + "elapsed": 461.90868854522705 + }, + { + "step": 1200, + "loss": 0.2892451882362366, + "error": 0.12890625, + "gradient_norm": 0.010124214924871922, + "elapsed": 467.1151931285858 + }, + { + "step": 1216, + "loss": 0.45089617371559143, + "error": 0.23046875, + "gradient_norm": 0.03627275303006172, + "elapsed": 472.30455207824707 + }, + { + "step": 1232, + "loss": 0.6207081079483032, + "error": 0.36376953125, + "gradient_norm": 0.028164058923721313, + "elapsed": 477.4041998386383 + }, + { + "step": 1248, + "loss": 0.6022387742996216, + "error": 0.32470703125, + "gradient_norm": 0.05243176594376564, + "elapsed": 482.5445365905762 + }, + { + "step": 1264, + "loss": 0.6383136510848999, + "error": 0.38818359375, + "gradient_norm": 0.021598732098937035, + "elapsed": 488.21457719802856 + }, + { + "step": 1280, + "loss": 0.28611207008361816, + "error": 0.13037109375, + "gradient_norm": 0.010211448185145855, + "elapsed": 494.3161232471466 + }, + { + "step": 1296, + "loss": 0.5970274209976196, + "error": 0.35009765625, + "gradient_norm": 0.025076791644096375, + "elapsed": 500.2585813999176 + }, + { + "step": 1312, + "loss": 0.48383909463882446, + "error": 0.2529296875, + "gradient_norm": 0.02830139547586441, + "elapsed": 505.9930474758148 + }, + { + "step": 1328, + "loss": 0.6087884902954102, + "error": 0.365234375, + "gradient_norm": 0.01881619170308113, + "elapsed": 512.0680301189423 + }, + { + "step": 1344, + "loss": 0.49332645535469055, + "error": 0.25634765625, + "gradient_norm": 0.02215457707643509, + "elapsed": 517.9840953350067 + }, + { + "step": 1360, + "loss": 0.6202782392501831, + "error": 0.36767578125, + "gradient_norm": 0.018839120864868164, + "elapsed": 524.07217669487 + }, + { + "step": 1376, + "loss": 0.5857731699943542, + "error": 0.3330078125, + "gradient_norm": 0.015682006254792213, + "elapsed": 529.8370056152344 + }, + { + "step": 1392, + "loss": 0.52056485414505, + "error": 0.263671875, + "gradient_norm": 0.02431550808250904, + "elapsed": 535.9721219539642 + }, + { + "step": 1408, + "loss": 0.6433448791503906, + "error": 0.40625, + "gradient_norm": 0.016954610124230385, + "elapsed": 542.0041825771332 + }, + { + "step": 1424, + "loss": 0.6105660200119019, + "error": 0.35107421875, + "gradient_norm": 0.007737957406789064, + "elapsed": 547.4241607189178 + }, + { + "step": 1440, + "loss": 0.27237576246261597, + "error": 0.12451171875, + "gradient_norm": 0.01314462162554264, + "elapsed": 553.5436873435974 + }, + { + "step": 1456, + "loss": 0.5954712629318237, + "error": 0.3623046875, + "gradient_norm": 0.03746134042739868, + "elapsed": 558.7123465538025 + }, + { + "step": 1472, + "loss": 0.4519508481025696, + "error": 0.2255859375, + "gradient_norm": 0.010652865283191204, + "elapsed": 563.8585436344147 + }, + { + "step": 1488, + "loss": 0.41647869348526, + "error": 0.212890625, + "gradient_norm": 0.028575479984283447, + "elapsed": 569.0573513507843 + }, + { + "step": 1504, + "loss": 0.4384400248527527, + "error": 0.21337890625, + "gradient_norm": 0.017627721652388573, + "elapsed": 574.296462059021 + }, + { + "step": 1520, + "loss": 0.6105232238769531, + "error": 0.37109375, + "gradient_norm": 0.016302449628710747, + "elapsed": 579.4641361236572 + }, + { + "step": 1536, + "loss": 0.6215546131134033, + "error": 0.39013671875, + "gradient_norm": 0.032154034823179245, + "elapsed": 584.5684258937836 + } + ] + }, + "selected_checkpoint_steps": [ + 512, + 1024, + 1536 + ], + "checkpoint_records": { + "1536": { + "step": 1536, + "new_training_shots": 3145728, + "weights": "weights-1536.npz", + "weights_sha256": "785132032c12fa38abbb1103774d91b41828fdc5027e1fe4d42053476eb28199", + "validation": "validation-1536.json", + "complete": true + }, + "512": { + "step": 512, + "new_training_shots": 1048576, + "weights": "weights-512.npz", + "weights_sha256": "e9ebeb958eec680c5458b3a5c39aecf0a21c926aee816517b5f9d3bac5815d7f", + "validation": "validation-512.json", + "complete": true + }, + "1024": { + "step": 1024, + "new_training_shots": 2097152, + "weights": "weights-1024.npz", + "weights_sha256": "f45c568b13c92eb4e768146debbc8c50a8ad51882523938932ba26f4afde66f2", + "validation": "validation-1024.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.2491436298076923, + "512": 0.2478215144230769, + "1024": 0.24774639423076922, + "1536": 0.2476862980769231 + }, + "selected": "1536" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2557542067307692, + "512": 0.2544320913461538, + "1024": 0.2548527644230769, + "1536": 0.2545673076923076 + }, + "selected": "512" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23511117788461539, + "512": 0.23602764423076927, + "1024": 0.23553185096153847, + "1536": 0.2345402644230769 + }, + "selected": "1536" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.2403996394230769, + "512": 0.23999399038461539, + "1024": 0.24008413461538464, + "1536": 0.2401141826923077 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24893329326923078, + "512": 0.24894831730769235, + "1024": 0.24735576923076924, + "1536": 0.24664963942307694 + }, + "selected": "1536" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.2387469951923077, + "512": 0.23849158653846156, + "1024": 0.23789062500000002, + "1536": 0.2381610576923077 + }, + "selected": "1024" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23885216346153845, + "512": 0.23807091346153844, + "1024": 0.2377704326923077, + "1536": 0.23733473557692303 + }, + "selected": "1536" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23479567307692306, + "512": 0.2340895432692308, + "1024": 0.2340444711538461, + "1536": 0.23431490384615386 + }, + "selected": "1024" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.24024939903846157 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22627704326923076 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "rich1", + "training_run": { + "initialization": "Random initialization in this session", + "original_initialization": "Random variance-scaled normal first two layers, random Normal(0,.001) output; zero biases; seed 20261030", + "architecture": "Two 128-unit SiLU layers, output 4*tanh correction to original hyperedge logit; 40 local events, 40 reconstructed measurements, 8 per-stabilizer full-shot densities and 57 static features", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 1024, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261030, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.1747799664735794, + "error": 0.068359375, + "gradient_norm": 0.03163275867700577, + "elapsed": 30.666016340255737 + }, + { + "step": 16, + "loss": 0.5729950666427612, + "error": 0.30859375, + "gradient_norm": 0.03532477840781212, + "elapsed": 34.992138385772705 + }, + { + "step": 32, + "loss": 0.33759093284606934, + "error": 0.1435546875, + "gradient_norm": 0.03938521817326546, + "elapsed": 40.51379442214966 + }, + { + "step": 48, + "loss": 0.574704647064209, + "error": 0.3212890625, + "gradient_norm": 0.03584429249167442, + "elapsed": 46.82174754142761 + }, + { + "step": 64, + "loss": 0.6351712942123413, + "error": 0.4072265625, + "gradient_norm": 0.027485841885209084, + "elapsed": 52.75151348114014 + }, + { + "step": 80, + "loss": 0.36342084407806396, + "error": 0.1708984375, + "gradient_norm": 0.040388718247413635, + "elapsed": 58.42134428024292 + }, + { + "step": 96, + "loss": 0.613252580165863, + "error": 0.3525390625, + "gradient_norm": 0.035148631781339645, + "elapsed": 64.40935254096985 + }, + { + "step": 112, + "loss": 0.6042842864990234, + "error": 0.3564453125, + "gradient_norm": 0.06634438037872314, + "elapsed": 70.4053041934967 + }, + { + "step": 128, + "loss": 0.4366868734359741, + "error": 0.20703125, + "gradient_norm": 0.040233220905065536, + "elapsed": 76.10137701034546 + }, + { + "step": 144, + "loss": 0.340861976146698, + "error": 0.154296875, + "gradient_norm": 0.03881179168820381, + "elapsed": 81.10126686096191 + }, + { + "step": 160, + "loss": 0.5801218748092651, + "error": 0.32421875, + "gradient_norm": 0.06090407446026802, + "elapsed": 86.1252555847168 + }, + { + "step": 176, + "loss": 0.37582841515541077, + "error": 0.19140625, + "gradient_norm": 0.06935373693704605, + "elapsed": 91.53376078605652 + }, + { + "step": 192, + "loss": 0.5213879346847534, + "error": 0.291015625, + "gradient_norm": 0.038788966834545135, + "elapsed": 96.78960609436035 + }, + { + "step": 208, + "loss": 0.26441627740859985, + "error": 0.115234375, + "gradient_norm": 0.04845435172319412, + "elapsed": 101.85743975639343 + }, + { + "step": 224, + "loss": 0.4369240701198578, + "error": 0.2119140625, + "gradient_norm": 0.098305843770504, + "elapsed": 106.94148802757263 + }, + { + "step": 240, + "loss": 0.5520763397216797, + "error": 0.3037109375, + "gradient_norm": 0.04845161736011505, + "elapsed": 112.27297902107239 + }, + { + "step": 256, + "loss": 0.595374345779419, + "error": 0.3369140625, + "gradient_norm": 0.03840416297316551, + "elapsed": 117.4812536239624 + }, + { + "step": 272, + "loss": 0.2569020390510559, + "error": 0.103515625, + "gradient_norm": 0.050126779824495316, + "elapsed": 137.86142945289612 + }, + { + "step": 288, + "loss": 0.32830360531806946, + "error": 0.1455078125, + "gradient_norm": 0.035532038658857346, + "elapsed": 142.83670139312744 + }, + { + "step": 304, + "loss": 0.6040379405021667, + "error": 0.36328125, + "gradient_norm": 0.0313950814306736, + "elapsed": 148.05078554153442 + }, + { + "step": 320, + "loss": 0.35434311628341675, + "error": 0.1748046875, + "gradient_norm": 0.03184249624609947, + "elapsed": 153.22213292121887 + }, + { + "step": 336, + "loss": 0.2326659858226776, + "error": 0.099609375, + "gradient_norm": 0.06624855101108551, + "elapsed": 158.455664396286 + }, + { + "step": 352, + "loss": 0.06233043968677521, + "error": 0.017578125, + "gradient_norm": 0.02635284699499607, + "elapsed": 163.10541248321533 + }, + { + "step": 368, + "loss": 0.31427502632141113, + "error": 0.1435546875, + "gradient_norm": 0.04170582816004753, + "elapsed": 167.78928112983704 + }, + { + "step": 384, + "loss": 0.41268765926361084, + "error": 0.19921875, + "gradient_norm": 0.10103361308574677, + "elapsed": 172.34387755393982 + }, + { + "step": 400, + "loss": 0.42649346590042114, + "error": 0.2119140625, + "gradient_norm": 0.03481302782893181, + "elapsed": 176.83626103401184 + }, + { + "step": 416, + "loss": 0.6373635530471802, + "error": 0.4013671875, + "gradient_norm": 0.06979350745677948, + "elapsed": 181.35168766975403 + }, + { + "step": 432, + "loss": 0.17961856722831726, + "error": 0.072265625, + "gradient_norm": 0.018565824255347252, + "elapsed": 185.80416321754456 + }, + { + "step": 448, + "loss": 0.5501771569252014, + "error": 0.287109375, + "gradient_norm": 0.04828835278749466, + "elapsed": 190.30530858039856 + }, + { + "step": 464, + "loss": 0.5648394823074341, + "error": 0.2978515625, + "gradient_norm": 0.07398489862680435, + "elapsed": 194.7985327243805 + }, + { + "step": 480, + "loss": 0.5675262212753296, + "error": 0.3125, + "gradient_norm": 0.036255236715078354, + "elapsed": 199.30496096611023 + }, + { + "step": 496, + "loss": 0.6156162023544312, + "error": 0.3779296875, + "gradient_norm": 0.02318546548485756, + "elapsed": 203.8355917930603 + }, + { + "step": 512, + "loss": 0.0660151019692421, + "error": 0.021484375, + "gradient_norm": 0.020883027464151382, + "elapsed": 208.32652711868286 + }, + { + "step": 528, + "loss": 0.6096083521842957, + "error": 0.37890625, + "gradient_norm": 0.04742306470870972, + "elapsed": 225.1866319179535 + }, + { + "step": 544, + "loss": 0.3829265236854553, + "error": 0.18359375, + "gradient_norm": 0.05981605872511864, + "elapsed": 229.68251276016235 + }, + { + "step": 560, + "loss": 0.537099301815033, + "error": 0.2900390625, + "gradient_norm": 0.0949595719575882, + "elapsed": 234.20215129852295 + }, + { + "step": 576, + "loss": 0.5903713703155518, + "error": 0.3447265625, + "gradient_norm": 0.06430540233850479, + "elapsed": 238.70998644828796 + }, + { + "step": 592, + "loss": 0.5619152188301086, + "error": 0.298828125, + "gradient_norm": 0.03404757007956505, + "elapsed": 243.21307158470154 + }, + { + "step": 608, + "loss": 0.5997255444526672, + "error": 0.3623046875, + "gradient_norm": 0.03946321830153465, + "elapsed": 247.7153992652893 + }, + { + "step": 624, + "loss": 0.5695509910583496, + "error": 0.310546875, + "gradient_norm": 0.02815800905227661, + "elapsed": 252.3102250099182 + }, + { + "step": 640, + "loss": 0.5901973247528076, + "error": 0.34765625, + "gradient_norm": 0.04673359915614128, + "elapsed": 256.89224338531494 + }, + { + "step": 656, + "loss": 0.621924877166748, + "error": 0.37890625, + "gradient_norm": 0.04227908328175545, + "elapsed": 261.43869185447693 + }, + { + "step": 672, + "loss": 0.610299825668335, + "error": 0.35546875, + "gradient_norm": 0.036825064569711685, + "elapsed": 265.97225284576416 + }, + { + "step": 688, + "loss": 0.5249245166778564, + "error": 0.2841796875, + "gradient_norm": 0.0948338434100151, + "elapsed": 270.4997045993805 + }, + { + "step": 704, + "loss": 0.2573642134666443, + "error": 0.111328125, + "gradient_norm": 0.055987801402807236, + "elapsed": 275.0399034023285 + }, + { + "step": 720, + "loss": 0.04867870360612869, + "error": 0.0146484375, + "gradient_norm": 0.03132430091500282, + "elapsed": 279.55093908309937 + }, + { + "step": 736, + "loss": 0.24808242917060852, + "error": 0.1015625, + "gradient_norm": 0.051910530775785446, + "elapsed": 284.08127522468567 + }, + { + "step": 752, + "loss": 0.4981001615524292, + "error": 0.2529296875, + "gradient_norm": 0.06427812576293945, + "elapsed": 288.70672821998596 + }, + { + "step": 768, + "loss": 0.5241370797157288, + "error": 0.28125, + "gradient_norm": 0.10227487236261368, + "elapsed": 293.331086397171 + }, + { + "step": 784, + "loss": 0.6427845358848572, + "error": 0.400390625, + "gradient_norm": 0.08984753489494324, + "elapsed": 311.0226716995239 + }, + { + "step": 800, + "loss": 0.5990085601806641, + "error": 0.3544921875, + "gradient_norm": 0.08950027078390121, + "elapsed": 315.6725699901581 + }, + { + "step": 816, + "loss": 0.5930870771408081, + "error": 0.353515625, + "gradient_norm": 0.03096434287726879, + "elapsed": 320.38578844070435 + }, + { + "step": 832, + "loss": 0.5945324897766113, + "error": 0.359375, + "gradient_norm": 0.052297625690698624, + "elapsed": 325.3292770385742 + }, + { + "step": 848, + "loss": 0.6031227111816406, + "error": 0.3642578125, + "gradient_norm": 0.032976675778627396, + "elapsed": 330.2292652130127 + }, + { + "step": 864, + "loss": 0.3953525125980377, + "error": 0.1748046875, + "gradient_norm": 0.07015999406576157, + "elapsed": 335.1212799549103 + }, + { + "step": 880, + "loss": 0.4324202835559845, + "error": 0.2080078125, + "gradient_norm": 0.1018647849559784, + "elapsed": 339.9696366786957 + }, + { + "step": 896, + "loss": 0.5024446249008179, + "error": 0.265625, + "gradient_norm": 0.03973893076181412, + "elapsed": 344.8794775009155 + }, + { + "step": 912, + "loss": 0.5731178522109985, + "error": 0.33203125, + "gradient_norm": 0.047838907688856125, + "elapsed": 349.57729148864746 + }, + { + "step": 928, + "loss": 0.6279090642929077, + "error": 0.412109375, + "gradient_norm": 0.030738679692149162, + "elapsed": 354.4736604690552 + }, + { + "step": 944, + "loss": 0.6028326153755188, + "error": 0.341796875, + "gradient_norm": 0.04459983482956886, + "elapsed": 359.2764792442322 + }, + { + "step": 960, + "loss": 0.19082097709178925, + "error": 0.0791015625, + "gradient_norm": 0.02478513866662979, + "elapsed": 364.1252644062042 + }, + { + "step": 976, + "loss": 0.443341463804245, + "error": 0.2197265625, + "gradient_norm": 0.14411240816116333, + "elapsed": 368.8472623825073 + }, + { + "step": 992, + "loss": 0.5665505528450012, + "error": 0.3125, + "gradient_norm": 0.06498897075653076, + "elapsed": 373.6812598705292 + }, + { + "step": 1008, + "loss": 0.4306175112724304, + "error": 0.1875, + "gradient_norm": 0.04873151704668999, + "elapsed": 378.56014752388 + }, + { + "step": 1024, + "loss": 0.46258389949798584, + "error": 0.244140625, + "gradient_norm": 0.09452047199010849, + "elapsed": 383.46526074409485 + } + ] + }, + "selected_checkpoint_steps": [ + 1024 + ], + "checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "weights": "weights-1024.npz", + "weights_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "validation": "validation-1024.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average incumbent and new probabilities equally", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.2476862980769231, + "512": 0.24981971153846153, + "1024": 0.24861778846153845, + "blend-512": 0.24816706730769234, + "blend-1024": 0.24764122596153845 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2544320913461538, + "512": 0.25530348557692306, + "1024": 0.2538461538461539, + "blend-512": 0.2550330528846154, + "blend-1024": 0.25369591346153847 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.2345402644230769, + "512": 0.2346905048076923, + "1024": 0.23502103365384613, + "blend-512": 0.23520132211538458, + "blend-1024": 0.23484074519230771 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23999399038461539, + "512": 0.24036959134615385, + "1024": 0.23987379807692305, + "blend-512": 0.240234375, + "blend-1024": 0.24008413461538464 + }, + "selected": "1024" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24664963942307694, + "512": 0.24878305288461539, + "1024": 0.24810697115384614, + "blend-512": 0.2468900240384615, + "blend-1024": 0.24661959134615385 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23789062500000002, + "512": 0.23919771634615386, + "1024": 0.23847656250000002, + "blend-512": 0.23802584134615382, + "blend-1024": 0.2378155048076923 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23733473557692303, + "512": 0.23939302884615382, + "1024": 0.2384465144230769, + "blend-512": 0.23829627403846151, + "blend-1024": 0.23727463942307694 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.2340444711538461, + "512": 0.23482572115384615, + "1024": 0.23378906249999998, + "blend-512": 0.23434495192307692, + "blend-1024": 0.23345853365384614 + }, + "selected": "blend-1024" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.24024939903846157 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22627704326923076 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "temporal1", + "training_run": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "selected_checkpoint_steps": [ + 1024, + 1536, + 2048 + ], + "checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "weights": "weights-2048.npz", + "weights_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "validation": "validation-2048.json", + "complete": true + }, + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "weights": "weights-1024.npz", + "weights_sha256": "6ab63cf2443420bfa5f2a817a90432dfc969348a8b23b0e6ccf3ffad3c381672", + "validation": "validation-1024.json", + "complete": true + }, + "1536": { + "step": 1536, + "new_training_shots": 1572864, + "weights": "weights-1536.npz", + "weights_sha256": "a4c6152c3b8f2f8ab8cdda41e92045ebc7eb944f9931a7937bf49c404bf96668", + "validation": "validation-1536.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24764122596153845, + "512": 0.24836237980769232, + "1024": 0.24783653846153847, + "1536": 0.24682992788461539, + "2048": 0.246875, + "blend-512": 0.24767127403846154, + "blend-1024": 0.24747596153846155, + "blend-1536": 0.24684495192307693, + "blend-2048": 0.24672475961538465 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.25369591346153847, + "512": 0.25387620192307697, + "1024": 0.25365084134615384, + "1536": 0.25392127403846154, + "2048": 0.2531550480769231, + "blend-512": 0.25429687500000003, + "blend-1024": 0.25419170673076924, + "blend-1536": 0.25338040865384615, + "blend-2048": 0.2532301682692308 + }, + "selected": "2048" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.2345402644230769, + "512": 0.23535156250000003, + "1024": 0.23467548076923078, + "1536": 0.23575721153846152, + "2048": 0.23529146634615386, + "blend-512": 0.23494591346153842, + "blend-1024": 0.2351862980769231, + "blend-1536": 0.23535156249999997, + "blend-2048": 0.23446514423076925 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23987379807692305, + "512": 0.2393028846153846, + "1024": 0.2391676682692308, + "1536": 0.2397686298076923, + "2048": 0.23969350961538463, + "blend-512": 0.23972355769230771, + "blend-1024": 0.23967848557692312, + "blend-1536": 0.24044471153846153, + "blend-2048": 0.24048978365384613 + }, + "selected": "1024" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24661959134615385, + "512": 0.24767127403846156, + "1024": 0.24747596153846155, + "1536": 0.24658954326923077, + "2048": 0.2467397836538462, + "blend-512": 0.24634915865384613, + "blend-1024": 0.24684495192307693, + "blend-1536": 0.24640925480769232, + "blend-2048": 0.24625901442307693 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.2378155048076923, + "512": 0.23912259615384615, + "1024": 0.23805588942307693, + "1536": 0.2381610576923077, + "2048": 0.2376802884615385, + "blend-512": 0.2378155048076923, + "blend-1024": 0.23765024038461538, + "blend-1536": 0.23783052884615388, + "blend-2048": 0.23760516826923078 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23727463942307694, + "512": 0.23766526442307695, + "1024": 0.23789062500000005, + "1536": 0.23713942307692307, + "2048": 0.23778545673076923, + "blend-512": 0.2376201923076923, + "blend-1024": 0.23743990384615382, + "blend-1536": 0.2375, + "blend-2048": 0.2376201923076923 + }, + "selected": "1536" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23345853365384614, + "512": 0.2344200721153846, + "1024": 0.23431490384615386, + "1536": 0.23435997596153843, + "2048": 0.23390925480769229, + "blend-512": 0.23448016826923074, + "blend-1024": 0.2340895432692308, + "blend-1536": 0.23360877403846156, + "blend-2048": 0.2338792067307692 + }, + "selected": "incumbent" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2338341346153846 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22182992788461542 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "temporal2", + "training_run": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_train.py": "7d48d2fc7f62d0bec3023b3df1c2ac28537d0417966131ae3a156697a34cda5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 1778773, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18357, + "surface_code_bX_d3_r03_center_3_5": 16816, + "surface_code_bX_d3_r05_center_3_5": 17999, + "surface_code_bX_d3_r07_center_3_5": 15225, + "surface_code_bX_d3_r09_center_3_5": 16132, + "surface_code_bX_d3_r11_center_3_5": 17041, + "surface_code_bX_d3_r13_center_3_5": 18477, + "surface_code_bX_d3_r15_center_3_5": 18214, + "surface_code_bX_d3_r17_center_3_5": 16505, + "surface_code_bX_d3_r19_center_3_5": 17120, + "surface_code_bX_d3_r21_center_3_5": 17563, + "surface_code_bX_d3_r23_center_3_5": 16681, + "surface_code_bX_d3_r25_center_3_5": 18379, + "surface_code_bX_d3_r01_center_5_3": 17450, + "surface_code_bX_d3_r03_center_5_3": 17161, + "surface_code_bX_d3_r05_center_5_3": 15797, + "surface_code_bX_d3_r07_center_5_3": 17800, + "surface_code_bX_d3_r09_center_5_3": 17190, + "surface_code_bX_d3_r11_center_5_3": 15840, + "surface_code_bX_d3_r13_center_5_3": 15178, + "surface_code_bX_d3_r15_center_5_3": 14897, + "surface_code_bX_d3_r17_center_5_3": 18252, + "surface_code_bX_d3_r19_center_5_3": 17083, + "surface_code_bX_d3_r21_center_5_3": 17229, + "surface_code_bX_d3_r23_center_5_3": 14735, + "surface_code_bX_d3_r25_center_5_3": 17949, + "surface_code_bX_d3_r01_center_5_7": 17431, + "surface_code_bX_d3_r03_center_5_7": 16583, + "surface_code_bX_d3_r05_center_5_7": 16891, + "surface_code_bX_d3_r07_center_5_7": 17969, + "surface_code_bX_d3_r09_center_5_7": 17966, + "surface_code_bX_d3_r11_center_5_7": 14424, + "surface_code_bX_d3_r13_center_5_7": 16930, + "surface_code_bX_d3_r15_center_5_7": 15205, + "surface_code_bX_d3_r17_center_5_7": 18252, + "surface_code_bX_d3_r19_center_5_7": 17077, + "surface_code_bX_d3_r21_center_5_7": 16770, + "surface_code_bX_d3_r23_center_5_7": 17308, + "surface_code_bX_d3_r25_center_5_7": 17481, + "surface_code_bX_d3_r01_center_7_5": 16630, + "surface_code_bX_d3_r03_center_7_5": 17439, + "surface_code_bX_d3_r05_center_7_5": 15811, + "surface_code_bX_d3_r07_center_7_5": 16637, + "surface_code_bX_d3_r09_center_7_5": 18306, + "surface_code_bX_d3_r11_center_7_5": 18327, + "surface_code_bX_d3_r13_center_7_5": 17974, + "surface_code_bX_d3_r15_center_7_5": 16106, + "surface_code_bX_d3_r17_center_7_5": 15834, + "surface_code_bX_d3_r19_center_7_5": 17242, + "surface_code_bX_d3_r21_center_7_5": 17889, + "surface_code_bX_d3_r23_center_7_5": 17440, + "surface_code_bX_d3_r25_center_7_5": 17087, + "surface_code_bZ_d3_r01_center_3_5": 16236, + "surface_code_bZ_d3_r03_center_3_5": 17278, + "surface_code_bZ_d3_r05_center_3_5": 16577, + "surface_code_bZ_d3_r07_center_3_5": 17376, + "surface_code_bZ_d3_r09_center_3_5": 16000, + "surface_code_bZ_d3_r11_center_3_5": 15634, + "surface_code_bZ_d3_r13_center_3_5": 14950, + "surface_code_bZ_d3_r15_center_3_5": 16600, + "surface_code_bZ_d3_r17_center_3_5": 15381, + "surface_code_bZ_d3_r19_center_3_5": 16823, + "surface_code_bZ_d3_r21_center_3_5": 18789, + "surface_code_bZ_d3_r23_center_3_5": 15616, + "surface_code_bZ_d3_r25_center_3_5": 17088, + "surface_code_bZ_d3_r01_center_5_3": 17935, + "surface_code_bZ_d3_r03_center_5_3": 16256, + "surface_code_bZ_d3_r05_center_5_3": 17959, + "surface_code_bZ_d3_r07_center_5_3": 18401, + "surface_code_bZ_d3_r09_center_5_3": 16405, + "surface_code_bZ_d3_r11_center_5_3": 17274, + "surface_code_bZ_d3_r13_center_5_3": 18172, + "surface_code_bZ_d3_r15_center_5_3": 17525, + "surface_code_bZ_d3_r17_center_5_3": 18643, + "surface_code_bZ_d3_r19_center_5_3": 17816, + "surface_code_bZ_d3_r21_center_5_3": 17404, + "surface_code_bZ_d3_r23_center_5_3": 17253, + "surface_code_bZ_d3_r25_center_5_3": 17667, + "surface_code_bZ_d3_r01_center_5_7": 16203, + "surface_code_bZ_d3_r03_center_5_7": 17214, + "surface_code_bZ_d3_r05_center_5_7": 16799, + "surface_code_bZ_d3_r07_center_5_7": 17896, + "surface_code_bZ_d3_r09_center_5_7": 16411, + "surface_code_bZ_d3_r11_center_5_7": 17726, + "surface_code_bZ_d3_r13_center_5_7": 16313, + "surface_code_bZ_d3_r15_center_5_7": 17824, + "surface_code_bZ_d3_r17_center_5_7": 15656, + "surface_code_bZ_d3_r19_center_5_7": 17169, + "surface_code_bZ_d3_r21_center_5_7": 17194, + "surface_code_bZ_d3_r23_center_5_7": 16779, + "surface_code_bZ_d3_r25_center_5_7": 16970, + "surface_code_bZ_d3_r01_center_7_5": 16762, + "surface_code_bZ_d3_r03_center_7_5": 17320, + "surface_code_bZ_d3_r05_center_7_5": 17522, + "surface_code_bZ_d3_r07_center_7_5": 17914, + "surface_code_bZ_d3_r09_center_7_5": 18439, + "surface_code_bZ_d3_r11_center_7_5": 18218, + "surface_code_bZ_d3_r13_center_7_5": 17907, + "surface_code_bZ_d3_r15_center_7_5": 17597, + "surface_code_bZ_d3_r17_center_7_5": 18252, + "surface_code_bZ_d3_r19_center_7_5": 18379, + "surface_code_bZ_d3_r21_center_7_5": 16818, + "surface_code_bZ_d3_r23_center_7_5": 18430, + "surface_code_bZ_d3_r25_center_7_5": 17924 + }, + "steps": 4096, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.0005, + "sampling_seed": 20261121, + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_exact/temporal1/rng-2048.json", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal1/weights-2048.npz", + "starting_checkpoint_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "starting_training_provenance": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.250907301902771, + "error": 0.1083984375, + "gradient_norm": 0.07171476632356644, + "elapsed": 44.811134576797485 + }, + { + "step": 16, + "loss": 0.5958679914474487, + "error": 0.3662109375, + "gradient_norm": 0.07673005014657974, + "elapsed": 49.90856671333313 + }, + { + "step": 32, + "loss": 0.47648972272872925, + "error": 0.2421875, + "gradient_norm": 0.08561501652002335, + "elapsed": 55.179388761520386 + }, + { + "step": 48, + "loss": 0.06145006790757179, + "error": 0.0234375, + "gradient_norm": 0.01556467730551958, + "elapsed": 61.0339195728302 + }, + { + "step": 64, + "loss": 0.3687053918838501, + "error": 0.1884765625, + "gradient_norm": 0.08752371370792389, + "elapsed": 65.95811891555786 + }, + { + "step": 80, + "loss": 0.6481984853744507, + "error": 0.4140625, + "gradient_norm": 0.05311283841729164, + "elapsed": 70.56021332740784 + }, + { + "step": 96, + "loss": 0.42319929599761963, + "error": 0.2138671875, + "gradient_norm": 0.05047478526830673, + "elapsed": 75.11613631248474 + }, + { + "step": 112, + "loss": 0.47527259588241577, + "error": 0.24609375, + "gradient_norm": 0.038366906344890594, + "elapsed": 79.53446984291077 + }, + { + "step": 128, + "loss": 0.5996723175048828, + "error": 0.3369140625, + "gradient_norm": 0.1213272362947464, + "elapsed": 83.97515749931335 + }, + { + "step": 144, + "loss": 0.04971993714570999, + "error": 0.0146484375, + "gradient_norm": 0.008080735802650452, + "elapsed": 88.44039463996887 + }, + { + "step": 160, + "loss": 0.35900360345840454, + "error": 0.162109375, + "gradient_norm": 0.03359593451023102, + "elapsed": 92.89548206329346 + }, + { + "step": 176, + "loss": 0.5342063903808594, + "error": 0.2978515625, + "gradient_norm": 0.04794691130518913, + "elapsed": 97.35658049583435 + }, + { + "step": 192, + "loss": 0.6300076246261597, + "error": 0.369140625, + "gradient_norm": 0.081769198179245, + "elapsed": 101.81493759155273 + }, + { + "step": 208, + "loss": 0.6191903948783875, + "error": 0.3828125, + "gradient_norm": 0.07145775109529495, + "elapsed": 106.2480263710022 + }, + { + "step": 224, + "loss": 0.5155678391456604, + "error": 0.28515625, + "gradient_norm": 0.06772179156541824, + "elapsed": 110.71284222602844 + }, + { + "step": 240, + "loss": 0.634708046913147, + "error": 0.3857421875, + "gradient_norm": 0.09493093192577362, + "elapsed": 115.14978742599487 + }, + { + "step": 256, + "loss": 0.1840895414352417, + "error": 0.0751953125, + "gradient_norm": 0.025586696341633797, + "elapsed": 119.61202120780945 + }, + { + "step": 272, + "loss": 0.2775103449821472, + "error": 0.12890625, + "gradient_norm": 0.06913147866725922, + "elapsed": 124.02584528923035 + }, + { + "step": 288, + "loss": 0.6163080334663391, + "error": 0.3642578125, + "gradient_norm": 0.05895426496863365, + "elapsed": 128.46512532234192 + }, + { + "step": 304, + "loss": 0.5276986360549927, + "error": 0.287109375, + "gradient_norm": 0.06955187022686005, + "elapsed": 132.89240765571594 + }, + { + "step": 320, + "loss": 0.44859516620635986, + "error": 0.22265625, + "gradient_norm": 0.07272452116012573, + "elapsed": 137.32864713668823 + }, + { + "step": 336, + "loss": 0.48315611481666565, + "error": 0.2626953125, + "gradient_norm": 0.03321139141917229, + "elapsed": 141.80009770393372 + }, + { + "step": 352, + "loss": 0.6107717752456665, + "error": 0.3544921875, + "gradient_norm": 0.05243214592337608, + "elapsed": 146.36439752578735 + }, + { + "step": 368, + "loss": 0.6215153932571411, + "error": 0.357421875, + "gradient_norm": 0.04383325204253197, + "elapsed": 150.99996852874756 + }, + { + "step": 384, + "loss": 0.6130329966545105, + "error": 0.35546875, + "gradient_norm": 0.04113119840621948, + "elapsed": 155.62374639511108 + }, + { + "step": 400, + "loss": 0.30471885204315186, + "error": 0.142578125, + "gradient_norm": 0.04447556659579277, + "elapsed": 160.17594957351685 + }, + { + "step": 416, + "loss": 0.6154489517211914, + "error": 0.37109375, + "gradient_norm": 0.04456057772040367, + "elapsed": 164.7639675140381 + }, + { + "step": 432, + "loss": 0.6134694218635559, + "error": 0.337890625, + "gradient_norm": 0.04219559207558632, + "elapsed": 169.32792139053345 + }, + { + "step": 448, + "loss": 0.5463185906410217, + "error": 0.2939453125, + "gradient_norm": 0.07746092975139618, + "elapsed": 173.88445162773132 + }, + { + "step": 464, + "loss": 0.06016772612929344, + "error": 0.01953125, + "gradient_norm": 0.01364185381680727, + "elapsed": 178.42725706100464 + }, + { + "step": 480, + "loss": 0.388141393661499, + "error": 0.18359375, + "gradient_norm": 0.04870256036520004, + "elapsed": 182.99062085151672 + }, + { + "step": 496, + "loss": 0.44524821639060974, + "error": 0.2216796875, + "gradient_norm": 0.03453445807099342, + "elapsed": 187.56396961212158 + }, + { + "step": 512, + "loss": 0.34312355518341064, + "error": 0.154296875, + "gradient_norm": 0.06794509291648865, + "elapsed": 192.27511191368103 + }, + { + "step": 528, + "loss": 0.19467462599277496, + "error": 0.0771484375, + "gradient_norm": 0.042381469160318375, + "elapsed": 197.7108268737793 + }, + { + "step": 544, + "loss": 0.46226584911346436, + "error": 0.2421875, + "gradient_norm": 0.06073570251464844, + "elapsed": 202.97405791282654 + }, + { + "step": 560, + "loss": 0.525318443775177, + "error": 0.2822265625, + "gradient_norm": 0.06954885274171829, + "elapsed": 208.69676971435547 + }, + { + "step": 576, + "loss": 0.6158387064933777, + "error": 0.349609375, + "gradient_norm": 0.07587578892707825, + "elapsed": 214.80397653579712 + }, + { + "step": 592, + "loss": 0.5515886545181274, + "error": 0.298828125, + "gradient_norm": 0.04969338700175285, + "elapsed": 220.27399611473083 + }, + { + "step": 608, + "loss": 0.18365338444709778, + "error": 0.0654296875, + "gradient_norm": 0.08657706528902054, + "elapsed": 224.81246256828308 + }, + { + "step": 624, + "loss": 0.4578855633735657, + "error": 0.2421875, + "gradient_norm": 0.04942100867629051, + "elapsed": 229.45902252197266 + }, + { + "step": 640, + "loss": 0.37826013565063477, + "error": 0.1865234375, + "gradient_norm": 0.047499872744083405, + "elapsed": 233.9695644378662 + }, + { + "step": 656, + "loss": 0.40863412618637085, + "error": 0.2001953125, + "gradient_norm": 0.07845330238342285, + "elapsed": 238.584894657135 + }, + { + "step": 672, + "loss": 0.5640332698822021, + "error": 0.2880859375, + "gradient_norm": 0.057469289749860764, + "elapsed": 243.0929844379425 + }, + { + "step": 688, + "loss": 0.030216243118047714, + "error": 0.0078125, + "gradient_norm": 0.04682641476392746, + "elapsed": 247.581125497818 + }, + { + "step": 704, + "loss": 0.375002384185791, + "error": 0.1826171875, + "gradient_norm": 0.04864194989204407, + "elapsed": 252.1564691066742 + }, + { + "step": 720, + "loss": 0.5145515203475952, + "error": 0.2744140625, + "gradient_norm": 0.052671682089567184, + "elapsed": 256.6466488838196 + }, + { + "step": 736, + "loss": 0.067174531519413, + "error": 0.0224609375, + "gradient_norm": 0.019299577921628952, + "elapsed": 261.1185076236725 + }, + { + "step": 752, + "loss": 0.24909992516040802, + "error": 0.111328125, + "gradient_norm": 0.06907463818788528, + "elapsed": 265.61960339546204 + }, + { + "step": 768, + "loss": 0.5088074207305908, + "error": 0.2744140625, + "gradient_norm": 0.06963017582893372, + "elapsed": 270.07474064826965 + }, + { + "step": 784, + "loss": 0.3783387839794159, + "error": 0.1826171875, + "gradient_norm": 0.05537794530391693, + "elapsed": 274.52722239494324 + }, + { + "step": 800, + "loss": 0.6107200980186462, + "error": 0.3623046875, + "gradient_norm": 0.0470259003341198, + "elapsed": 279.0401859283447 + }, + { + "step": 816, + "loss": 0.5778236389160156, + "error": 0.3212890625, + "gradient_norm": 0.10146680474281311, + "elapsed": 283.5114622116089 + }, + { + "step": 832, + "loss": 0.576002299785614, + "error": 0.3076171875, + "gradient_norm": 0.07760787010192871, + "elapsed": 288.04797434806824 + }, + { + "step": 848, + "loss": 0.6179666519165039, + "error": 0.3740234375, + "gradient_norm": 0.07383852452039719, + "elapsed": 292.60600209236145 + }, + { + "step": 864, + "loss": 0.3105512857437134, + "error": 0.1455078125, + "gradient_norm": 0.052953749895095825, + "elapsed": 297.12180352211 + }, + { + "step": 880, + "loss": 0.4802623987197876, + "error": 0.2548828125, + "gradient_norm": 0.07736275345087051, + "elapsed": 301.6091134548187 + }, + { + "step": 896, + "loss": 0.5572722554206848, + "error": 0.318359375, + "gradient_norm": 0.053303152322769165, + "elapsed": 306.1978073120117 + }, + { + "step": 912, + "loss": 0.34814420342445374, + "error": 0.1669921875, + "gradient_norm": 0.037726350128650665, + "elapsed": 310.78571581840515 + }, + { + "step": 928, + "loss": 0.41743016242980957, + "error": 0.21875, + "gradient_norm": 0.05238872766494751, + "elapsed": 315.24156188964844 + }, + { + "step": 944, + "loss": 0.5757850408554077, + "error": 0.3173828125, + "gradient_norm": 0.05837905779480934, + "elapsed": 319.78475165367126 + }, + { + "step": 960, + "loss": 0.40727972984313965, + "error": 0.197265625, + "gradient_norm": 0.059294261038303375, + "elapsed": 324.2090265750885 + }, + { + "step": 976, + "loss": 0.32715001702308655, + "error": 0.1533203125, + "gradient_norm": 0.11543179303407669, + "elapsed": 328.6462152004242 + }, + { + "step": 992, + "loss": 0.5578742623329163, + "error": 0.314453125, + "gradient_norm": 0.06282714009284973, + "elapsed": 333.0712504386902 + }, + { + "step": 1008, + "loss": 0.5052692294120789, + "error": 0.265625, + "gradient_norm": 0.04039420187473297, + "elapsed": 337.5182821750641 + }, + { + "step": 1024, + "loss": 0.18790806829929352, + "error": 0.08203125, + "gradient_norm": 0.028905188664793968, + "elapsed": 342.08340406417847 + }, + { + "step": 1040, + "loss": 0.6317684650421143, + "error": 0.3681640625, + "gradient_norm": 0.03441835194826126, + "elapsed": 358.8279616832733 + }, + { + "step": 1056, + "loss": 0.40474164485931396, + "error": 0.2021484375, + "gradient_norm": 0.036449309438467026, + "elapsed": 363.30218267440796 + }, + { + "step": 1072, + "loss": 0.518299400806427, + "error": 0.2666015625, + "gradient_norm": 0.0886964276432991, + "elapsed": 367.87997555732727 + }, + { + "step": 1088, + "loss": 0.2522922158241272, + "error": 0.099609375, + "gradient_norm": 0.07553310692310333, + "elapsed": 372.4414882659912 + }, + { + "step": 1104, + "loss": 0.6214810609817505, + "error": 0.3701171875, + "gradient_norm": 0.10188957303762436, + "elapsed": 376.9120502471924 + }, + { + "step": 1120, + "loss": 0.6307054162025452, + "error": 0.3720703125, + "gradient_norm": 0.07353860139846802, + "elapsed": 381.3824534416199 + }, + { + "step": 1136, + "loss": 0.5259381532669067, + "error": 0.2763671875, + "gradient_norm": 0.05779678374528885, + "elapsed": 385.8413143157959 + }, + { + "step": 1152, + "loss": 0.4995541572570801, + "error": 0.259765625, + "gradient_norm": 0.046648140996694565, + "elapsed": 390.28326058387756 + }, + { + "step": 1168, + "loss": 0.6075694561004639, + "error": 0.3701171875, + "gradient_norm": 0.10612073540687561, + "elapsed": 394.8162364959717 + }, + { + "step": 1184, + "loss": 0.2105136513710022, + "error": 0.080078125, + "gradient_norm": 0.0716402605175972, + "elapsed": 399.2960283756256 + }, + { + "step": 1200, + "loss": 0.6371631026268005, + "error": 0.3857421875, + "gradient_norm": 0.0549108125269413, + "elapsed": 403.7899103164673 + }, + { + "step": 1216, + "loss": 0.5450670719146729, + "error": 0.2939453125, + "gradient_norm": 0.11688558012247086, + "elapsed": 408.34677600860596 + }, + { + "step": 1232, + "loss": 0.035783201456069946, + "error": 0.01171875, + "gradient_norm": 0.02951689623296261, + "elapsed": 412.8558337688446 + }, + { + "step": 1248, + "loss": 0.5582903623580933, + "error": 0.3046875, + "gradient_norm": 0.055107031017541885, + "elapsed": 417.29854226112366 + }, + { + "step": 1264, + "loss": 0.5154441595077515, + "error": 0.27734375, + "gradient_norm": 0.04474929720163345, + "elapsed": 421.7792055606842 + }, + { + "step": 1280, + "loss": 0.35227546095848083, + "error": 0.16015625, + "gradient_norm": 0.05024837702512741, + "elapsed": 426.54427456855774 + }, + { + "step": 1296, + "loss": 0.19417589902877808, + "error": 0.0830078125, + "gradient_norm": 0.026926057413220406, + "elapsed": 431.320588350296 + }, + { + "step": 1312, + "loss": 0.4768218398094177, + "error": 0.248046875, + "gradient_norm": 0.15099607408046722, + "elapsed": 435.96817326545715 + }, + { + "step": 1328, + "loss": 0.48580923676490784, + "error": 0.2509765625, + "gradient_norm": 0.08925126492977142, + "elapsed": 440.64917039871216 + }, + { + "step": 1344, + "loss": 0.42041274905204773, + "error": 0.1982421875, + "gradient_norm": 0.08321093022823334, + "elapsed": 445.34370946884155 + }, + { + "step": 1360, + "loss": 0.06403929740190506, + "error": 0.0185546875, + "gradient_norm": 0.03817005455493927, + "elapsed": 449.98669385910034 + }, + { + "step": 1376, + "loss": 0.463126003742218, + "error": 0.2275390625, + "gradient_norm": 0.08894515782594681, + "elapsed": 454.6478977203369 + }, + { + "step": 1392, + "loss": 0.5995306968688965, + "error": 0.373046875, + "gradient_norm": 0.06733685731887817, + "elapsed": 459.35924530029297 + }, + { + "step": 1408, + "loss": 0.49053263664245605, + "error": 0.25, + "gradient_norm": 0.10475508868694305, + "elapsed": 464.100093126297 + }, + { + "step": 1424, + "loss": 0.6220744848251343, + "error": 0.3818359375, + "gradient_norm": 0.03653963655233383, + "elapsed": 468.89601135253906 + }, + { + "step": 1440, + "loss": 0.39706122875213623, + "error": 0.2021484375, + "gradient_norm": 0.04344598576426506, + "elapsed": 474.03999519348145 + }, + { + "step": 1456, + "loss": 0.5386708974838257, + "error": 0.3095703125, + "gradient_norm": 0.12589037418365479, + "elapsed": 478.8600504398346 + }, + { + "step": 1472, + "loss": 0.49776726961135864, + "error": 0.271484375, + "gradient_norm": 0.058137863874435425, + "elapsed": 483.5920066833496 + }, + { + "step": 1488, + "loss": 0.4757428765296936, + "error": 0.2412109375, + "gradient_norm": 0.050453316420316696, + "elapsed": 488.4611999988556 + }, + { + "step": 1504, + "loss": 0.5694847702980042, + "error": 0.337890625, + "gradient_norm": 0.052419569343328476, + "elapsed": 493.26151037216187 + }, + { + "step": 1520, + "loss": 0.5997745990753174, + "error": 0.3603515625, + "gradient_norm": 0.04338108375668526, + "elapsed": 498.0421245098114 + }, + { + "step": 1536, + "loss": 0.6195274591445923, + "error": 0.3876953125, + "gradient_norm": 0.04848463833332062, + "elapsed": 502.8808298110962 + }, + { + "step": 1552, + "loss": 0.46315908432006836, + "error": 0.2353515625, + "gradient_norm": 0.06380566209554672, + "elapsed": 507.5519721508026 + }, + { + "step": 1568, + "loss": 0.605262041091919, + "error": 0.36328125, + "gradient_norm": 0.05077619478106499, + "elapsed": 512.457685470581 + }, + { + "step": 1584, + "loss": 0.48782041668891907, + "error": 0.232421875, + "gradient_norm": 0.09017211943864822, + "elapsed": 517.2960062026978 + }, + { + "step": 1600, + "loss": 0.3881351947784424, + "error": 0.1875, + "gradient_norm": 0.07205695658922195, + "elapsed": 522.0911631584167 + }, + { + "step": 1616, + "loss": 0.4966873526573181, + "error": 0.24609375, + "gradient_norm": 0.0582038015127182, + "elapsed": 526.8861901760101 + }, + { + "step": 1632, + "loss": 0.5844199657440186, + "error": 0.33203125, + "gradient_norm": 0.05101500824093819, + "elapsed": 531.6640138626099 + }, + { + "step": 1648, + "loss": 0.31010180711746216, + "error": 0.1318359375, + "gradient_norm": 0.053135693073272705, + "elapsed": 536.4960391521454 + }, + { + "step": 1664, + "loss": 0.6174807548522949, + "error": 0.3779296875, + "gradient_norm": 0.04161194711923599, + "elapsed": 541.2560484409332 + }, + { + "step": 1680, + "loss": 0.18213607370853424, + "error": 0.0751953125, + "gradient_norm": 0.07171957194805145, + "elapsed": 546.0000085830688 + }, + { + "step": 1696, + "loss": 0.5445692539215088, + "error": 0.2998046875, + "gradient_norm": 0.054499462246894836, + "elapsed": 551.1221191883087 + }, + { + "step": 1712, + "loss": 0.05744167044758797, + "error": 0.017578125, + "gradient_norm": 0.013108699582517147, + "elapsed": 556.5286149978638 + }, + { + "step": 1728, + "loss": 0.6381571292877197, + "error": 0.3896484375, + "gradient_norm": 0.05157556012272835, + "elapsed": 561.8000066280365 + }, + { + "step": 1744, + "loss": 0.5301004648208618, + "error": 0.28125, + "gradient_norm": 0.04218568280339241, + "elapsed": 567.2760035991669 + }, + { + "step": 1760, + "loss": 0.5275102257728577, + "error": 0.26953125, + "gradient_norm": 0.06798839569091797, + "elapsed": 572.5601994991302 + }, + { + "step": 1776, + "loss": 0.6443773508071899, + "error": 0.4091796875, + "gradient_norm": 0.07035460323095322, + "elapsed": 577.9789206981659 + }, + { + "step": 1792, + "loss": 0.6012362241744995, + "error": 0.337890625, + "gradient_norm": 0.05189951881766319, + "elapsed": 583.028017282486 + }, + { + "step": 1808, + "loss": 0.2939091920852661, + "error": 0.12109375, + "gradient_norm": 0.05555355176329613, + "elapsed": 588.0501506328583 + }, + { + "step": 1824, + "loss": 0.2059091478586197, + "error": 0.08984375, + "gradient_norm": 0.045679714530706406, + "elapsed": 593.2120039463043 + }, + { + "step": 1840, + "loss": 0.6289581060409546, + "error": 0.349609375, + "gradient_norm": 0.04742642492055893, + "elapsed": 598.7767763137817 + }, + { + "step": 1856, + "loss": 0.5532636642456055, + "error": 0.294921875, + "gradient_norm": 0.05997413396835327, + "elapsed": 604.0475382804871 + }, + { + "step": 1872, + "loss": 0.45995670557022095, + "error": 0.228515625, + "gradient_norm": 0.05674462765455246, + "elapsed": 609.292379617691 + }, + { + "step": 1888, + "loss": 0.6178656816482544, + "error": 0.359375, + "gradient_norm": 0.08857566863298416, + "elapsed": 614.5639882087708 + }, + { + "step": 1904, + "loss": 0.5531284213066101, + "error": 0.287109375, + "gradient_norm": 0.10257937759160995, + "elapsed": 619.5600035190582 + }, + { + "step": 1920, + "loss": 0.04184349626302719, + "error": 0.013671875, + "gradient_norm": 0.04087059944868088, + "elapsed": 624.6679775714874 + }, + { + "step": 1936, + "loss": 0.5924860239028931, + "error": 0.3505859375, + "gradient_norm": 0.036822713911533356, + "elapsed": 629.936680316925 + }, + { + "step": 1952, + "loss": 0.46996980905532837, + "error": 0.2421875, + "gradient_norm": 0.034442272037267685, + "elapsed": 635.1109762191772 + }, + { + "step": 1968, + "loss": 0.17859068512916565, + "error": 0.0712890625, + "gradient_norm": 0.03440066799521446, + "elapsed": 640.32000207901 + }, + { + "step": 1984, + "loss": 0.6192275285720825, + "error": 0.3701171875, + "gradient_norm": 0.04386439174413681, + "elapsed": 645.6040184497833 + }, + { + "step": 2000, + "loss": 0.6160917282104492, + "error": 0.35546875, + "gradient_norm": 0.06268990784883499, + "elapsed": 650.7723731994629 + }, + { + "step": 2016, + "loss": 0.6343611478805542, + "error": 0.388671875, + "gradient_norm": 0.04243326932191849, + "elapsed": 655.972663640976 + }, + { + "step": 2032, + "loss": 0.062292590737342834, + "error": 0.021484375, + "gradient_norm": 0.016680095344781876, + "elapsed": 660.8079733848572 + }, + { + "step": 2048, + "loss": 0.5316072702407837, + "error": 0.26953125, + "gradient_norm": 0.057860780507326126, + "elapsed": 665.5760209560394 + }, + { + "step": 2064, + "loss": 0.605312705039978, + "error": 0.3623046875, + "gradient_norm": 0.04028146713972092, + "elapsed": 682.7294294834137 + }, + { + "step": 2080, + "loss": 0.56633460521698, + "error": 0.3330078125, + "gradient_norm": 0.09528280049562454, + "elapsed": 687.4644649028778 + }, + { + "step": 2096, + "loss": 0.3905397057533264, + "error": 0.1943359375, + "gradient_norm": 0.049456462264060974, + "elapsed": 692.1492264270782 + }, + { + "step": 2112, + "loss": 0.28124868869781494, + "error": 0.1259765625, + "gradient_norm": 0.059239838272333145, + "elapsed": 696.8701393604279 + }, + { + "step": 2128, + "loss": 0.6364338994026184, + "error": 0.392578125, + "gradient_norm": 0.08667811006307602, + "elapsed": 701.683988571167 + }, + { + "step": 2144, + "loss": 0.20683243870735168, + "error": 0.07421875, + "gradient_norm": 0.1100710779428482, + "elapsed": 706.4000360965729 + }, + { + "step": 2160, + "loss": 0.5912737250328064, + "error": 0.341796875, + "gradient_norm": 0.05641854554414749, + "elapsed": 711.2359964847565 + }, + { + "step": 2176, + "loss": 0.27793264389038086, + "error": 0.12109375, + "gradient_norm": 0.0893034040927887, + "elapsed": 715.9508004188538 + }, + { + "step": 2192, + "loss": 0.6474133133888245, + "error": 0.4072265625, + "gradient_norm": 0.06980258971452713, + "elapsed": 720.651974439621 + }, + { + "step": 2208, + "loss": 0.5961858630180359, + "error": 0.35546875, + "gradient_norm": 0.06530112773180008, + "elapsed": 725.496098279953 + }, + { + "step": 2224, + "loss": 0.47581571340560913, + "error": 0.263671875, + "gradient_norm": 0.04470043256878853, + "elapsed": 730.2880010604858 + }, + { + "step": 2240, + "loss": 0.577988862991333, + "error": 0.318359375, + "gradient_norm": 0.07201159745454788, + "elapsed": 735.006133556366 + }, + { + "step": 2256, + "loss": 0.28444671630859375, + "error": 0.1181640625, + "gradient_norm": 0.048656050115823746, + "elapsed": 739.6868116855621 + }, + { + "step": 2272, + "loss": 0.2776409089565277, + "error": 0.1201171875, + "gradient_norm": 0.05783981829881668, + "elapsed": 744.3517308235168 + }, + { + "step": 2288, + "loss": 0.621599555015564, + "error": 0.37109375, + "gradient_norm": 0.09731200337409973, + "elapsed": 749.0351710319519 + }, + { + "step": 2304, + "loss": 0.3333754539489746, + "error": 0.1513671875, + "gradient_norm": 0.07069239765405655, + "elapsed": 753.7588081359863 + }, + { + "step": 2320, + "loss": 0.4687051773071289, + "error": 0.2490234375, + "gradient_norm": 0.044891707599163055, + "elapsed": 758.4588432312012 + }, + { + "step": 2336, + "loss": 0.19801637530326843, + "error": 0.078125, + "gradient_norm": 0.10036595165729523, + "elapsed": 763.256409406662 + }, + { + "step": 2352, + "loss": 0.6186277866363525, + "error": 0.388671875, + "gradient_norm": 0.09069584310054779, + "elapsed": 767.9986386299133 + }, + { + "step": 2368, + "loss": 0.6177258491516113, + "error": 0.373046875, + "gradient_norm": 0.049019571393728256, + "elapsed": 772.730831861496 + }, + { + "step": 2384, + "loss": 0.17707547545433044, + "error": 0.0673828125, + "gradient_norm": 0.045190781354904175, + "elapsed": 777.4072704315186 + }, + { + "step": 2400, + "loss": 0.20144733786582947, + "error": 0.08203125, + "gradient_norm": 0.04537162929773331, + "elapsed": 782.0841658115387 + }, + { + "step": 2416, + "loss": 0.6151775121688843, + "error": 0.365234375, + "gradient_norm": 0.050534047186374664, + "elapsed": 786.762966632843 + }, + { + "step": 2432, + "loss": 0.5533859133720398, + "error": 0.314453125, + "gradient_norm": 0.06006559729576111, + "elapsed": 791.4656012058258 + }, + { + "step": 2448, + "loss": 0.5329082012176514, + "error": 0.2880859375, + "gradient_norm": 0.04018115997314453, + "elapsed": 796.1704161167145 + }, + { + "step": 2464, + "loss": 0.6338047981262207, + "error": 0.4140625, + "gradient_norm": 0.06069163978099823, + "elapsed": 800.9180119037628 + }, + { + "step": 2480, + "loss": 0.1603008508682251, + "error": 0.0673828125, + "gradient_norm": 0.040350593626499176, + "elapsed": 805.6127603054047 + }, + { + "step": 2496, + "loss": 0.505940318107605, + "error": 0.2568359375, + "gradient_norm": 0.05209952965378761, + "elapsed": 810.3740313053131 + }, + { + "step": 2512, + "loss": 0.5528728365898132, + "error": 0.298828125, + "gradient_norm": 0.11757992953062057, + "elapsed": 815.1708807945251 + }, + { + "step": 2528, + "loss": 0.5028313994407654, + "error": 0.2666015625, + "gradient_norm": 0.08823780715465546, + "elapsed": 819.8585045337677 + }, + { + "step": 2544, + "loss": 0.5002262592315674, + "error": 0.2783203125, + "gradient_norm": 0.04888603836297989, + "elapsed": 824.5714073181152 + }, + { + "step": 2560, + "loss": 0.6007894277572632, + "error": 0.328125, + "gradient_norm": 0.05186954140663147, + "elapsed": 829.3080432415009 + }, + { + "step": 2576, + "loss": 0.18641480803489685, + "error": 0.076171875, + "gradient_norm": 0.03799928352236748, + "elapsed": 834.044020652771 + }, + { + "step": 2592, + "loss": 0.3050769865512848, + "error": 0.1396484375, + "gradient_norm": 0.10119257122278214, + "elapsed": 838.8401296138763 + }, + { + "step": 2608, + "loss": 0.6063439846038818, + "error": 0.361328125, + "gradient_norm": 0.04979367554187775, + "elapsed": 844.3572654724121 + }, + { + "step": 2624, + "loss": 0.5751967430114746, + "error": 0.3369140625, + "gradient_norm": 0.04269539937376976, + "elapsed": 849.0660374164581 + }, + { + "step": 2640, + "loss": 0.3902108669281006, + "error": 0.193359375, + "gradient_norm": 0.10029696673154831, + "elapsed": 853.8638062477112 + }, + { + "step": 2656, + "loss": 0.15081660449504852, + "error": 0.0625, + "gradient_norm": 0.0303852129727602, + "elapsed": 858.9793758392334 + }, + { + "step": 2672, + "loss": 0.6503090858459473, + "error": 0.400390625, + "gradient_norm": 0.12611964344978333, + "elapsed": 863.9151141643524 + }, + { + "step": 2688, + "loss": 0.5587317943572998, + "error": 0.31640625, + "gradient_norm": 0.10028114914894104, + "elapsed": 868.7600305080414 + }, + { + "step": 2704, + "loss": 0.4399867355823517, + "error": 0.21484375, + "gradient_norm": 0.06889455020427704, + "elapsed": 873.4544236660004 + }, + { + "step": 2720, + "loss": 0.5865127444267273, + "error": 0.337890625, + "gradient_norm": 0.03671631962060928, + "elapsed": 878.0982644557953 + }, + { + "step": 2736, + "loss": 0.6078637838363647, + "error": 0.3701171875, + "gradient_norm": 0.04679318517446518, + "elapsed": 883.0424642562866 + }, + { + "step": 2752, + "loss": 0.5825340151786804, + "error": 0.337890625, + "gradient_norm": 0.05619681254029274, + "elapsed": 887.908124923706 + }, + { + "step": 2768, + "loss": 0.5970422029495239, + "error": 0.3369140625, + "gradient_norm": 0.041302867233753204, + "elapsed": 892.6760206222534 + }, + { + "step": 2784, + "loss": 0.3870226740837097, + "error": 0.1826171875, + "gradient_norm": 0.05731065198779106, + "elapsed": 897.6246056556702 + }, + { + "step": 2800, + "loss": 0.38130277395248413, + "error": 0.1943359375, + "gradient_norm": 0.059244755655527115, + "elapsed": 902.3360238075256 + }, + { + "step": 2816, + "loss": 0.2617901563644409, + "error": 0.1064453125, + "gradient_norm": 0.041736964136362076, + "elapsed": 907.1600468158722 + }, + { + "step": 2832, + "loss": 0.5819337368011475, + "error": 0.314453125, + "gradient_norm": 0.04097156226634979, + "elapsed": 912.0244295597076 + }, + { + "step": 2848, + "loss": 0.41393283009529114, + "error": 0.2001953125, + "gradient_norm": 0.10456771403551102, + "elapsed": 916.8225846290588 + }, + { + "step": 2864, + "loss": 0.5019145011901855, + "error": 0.2548828125, + "gradient_norm": 0.04843736067414284, + "elapsed": 921.538754940033 + }, + { + "step": 2880, + "loss": 0.04561338573694229, + "error": 0.0146484375, + "gradient_norm": 0.025407327339053154, + "elapsed": 926.2588667869568 + }, + { + "step": 2896, + "loss": 0.4338858723640442, + "error": 0.205078125, + "gradient_norm": 0.09900517761707306, + "elapsed": 930.9781975746155 + }, + { + "step": 2912, + "loss": 0.33922863006591797, + "error": 0.162109375, + "gradient_norm": 0.10189604014158249, + "elapsed": 935.6816267967224 + }, + { + "step": 2928, + "loss": 0.5294322967529297, + "error": 0.2822265625, + "gradient_norm": 0.09060791879892349, + "elapsed": 940.4373068809509 + }, + { + "step": 2944, + "loss": 0.037007369101047516, + "error": 0.01171875, + "gradient_norm": 0.05506489425897598, + "elapsed": 945.1270468235016 + }, + { + "step": 2960, + "loss": 0.6096771359443665, + "error": 0.349609375, + "gradient_norm": 0.04987221211194992, + "elapsed": 949.8300130367279 + }, + { + "step": 2976, + "loss": 0.6157823801040649, + "error": 0.373046875, + "gradient_norm": 0.03614233434200287, + "elapsed": 954.5701997280121 + }, + { + "step": 2992, + "loss": 0.1978239268064499, + "error": 0.080078125, + "gradient_norm": 0.05847112461924553, + "elapsed": 959.2756471633911 + }, + { + "step": 3008, + "loss": 0.5237340927124023, + "error": 0.2841796875, + "gradient_norm": 0.06993591040372849, + "elapsed": 963.9875864982605 + }, + { + "step": 3024, + "loss": 0.4559935927391052, + "error": 0.2373046875, + "gradient_norm": 0.05698448419570923, + "elapsed": 968.7997305393219 + }, + { + "step": 3040, + "loss": 0.5025208592414856, + "error": 0.259765625, + "gradient_norm": 0.14909739792346954, + "elapsed": 973.6042547225952 + }, + { + "step": 3056, + "loss": 0.3223109245300293, + "error": 0.1416015625, + "gradient_norm": 0.032974764704704285, + "elapsed": 978.4760546684265 + }, + { + "step": 3072, + "loss": 0.06682582199573517, + "error": 0.021484375, + "gradient_norm": 0.04433188587427139, + "elapsed": 983.2894048690796 + }, + { + "step": 3088, + "loss": 0.5919550061225891, + "error": 0.34765625, + "gradient_norm": 0.06721373647451401, + "elapsed": 1000.9520287513733 + }, + { + "step": 3104, + "loss": 0.5988063812255859, + "error": 0.3642578125, + "gradient_norm": 0.05654948577284813, + "elapsed": 1005.7442932128906 + }, + { + "step": 3120, + "loss": 0.4922299385070801, + "error": 0.2470703125, + "gradient_norm": 0.07545466721057892, + "elapsed": 1010.4616096019745 + }, + { + "step": 3136, + "loss": 0.4533671736717224, + "error": 0.236328125, + "gradient_norm": 0.06288722902536392, + "elapsed": 1015.3559956550598 + }, + { + "step": 3152, + "loss": 0.5070517063140869, + "error": 0.2666015625, + "gradient_norm": 0.07274917513132095, + "elapsed": 1020.0764343738556 + }, + { + "step": 3168, + "loss": 0.5999464988708496, + "error": 0.3408203125, + "gradient_norm": 0.05777016654610634, + "elapsed": 1024.9410600662231 + }, + { + "step": 3184, + "loss": 0.5758363008499146, + "error": 0.3427734375, + "gradient_norm": 0.051027461886405945, + "elapsed": 1029.7082171440125 + }, + { + "step": 3200, + "loss": 0.05016190931200981, + "error": 0.017578125, + "gradient_norm": 0.009175656363368034, + "elapsed": 1034.3982915878296 + }, + { + "step": 3216, + "loss": 0.5471057295799255, + "error": 0.318359375, + "gradient_norm": 0.07572721689939499, + "elapsed": 1039.117841243744 + }, + { + "step": 3232, + "loss": 0.4141446352005005, + "error": 0.193359375, + "gradient_norm": 0.10056859254837036, + "elapsed": 1043.880026102066 + }, + { + "step": 3248, + "loss": 0.5812438726425171, + "error": 0.3212890625, + "gradient_norm": 0.05781616270542145, + "elapsed": 1048.6406455039978 + }, + { + "step": 3264, + "loss": 0.19184701144695282, + "error": 0.078125, + "gradient_norm": 0.05367236211895943, + "elapsed": 1053.5672237873077 + }, + { + "step": 3280, + "loss": 0.5420833826065063, + "error": 0.28515625, + "gradient_norm": 0.052405405789613724, + "elapsed": 1058.3841104507446 + }, + { + "step": 3296, + "loss": 0.4419598877429962, + "error": 0.2177734375, + "gradient_norm": 0.05814693495631218, + "elapsed": 1063.1880333423615 + }, + { + "step": 3312, + "loss": 0.4525642991065979, + "error": 0.208984375, + "gradient_norm": 0.1061021164059639, + "elapsed": 1068.1370933055878 + }, + { + "step": 3328, + "loss": 0.32664671540260315, + "error": 0.154296875, + "gradient_norm": 0.05649850144982338, + "elapsed": 1073.1963467597961 + }, + { + "step": 3344, + "loss": 0.2655770182609558, + "error": 0.1220703125, + "gradient_norm": 0.04070372134447098, + "elapsed": 1078.2698318958282 + }, + { + "step": 3360, + "loss": 0.5894330739974976, + "error": 0.3544921875, + "gradient_norm": 0.0643400028347969, + "elapsed": 1083.0184152126312 + }, + { + "step": 3376, + "loss": 0.6118791103363037, + "error": 0.361328125, + "gradient_norm": 0.08537904173135757, + "elapsed": 1087.834038734436 + }, + { + "step": 3392, + "loss": 0.40694907307624817, + "error": 0.19921875, + "gradient_norm": 0.11411692947149277, + "elapsed": 1092.8119947910309 + }, + { + "step": 3408, + "loss": 0.04629015550017357, + "error": 0.0146484375, + "gradient_norm": 0.017204072326421738, + "elapsed": 1097.5751783847809 + }, + { + "step": 3424, + "loss": 0.20639702677726746, + "error": 0.0849609375, + "gradient_norm": 0.04801144450902939, + "elapsed": 1102.2970931529999 + }, + { + "step": 3440, + "loss": 0.6051071286201477, + "error": 0.33984375, + "gradient_norm": 0.045392412692308426, + "elapsed": 1107.1080610752106 + }, + { + "step": 3456, + "loss": 0.6553700566291809, + "error": 0.40625, + "gradient_norm": 0.05593863129615784, + "elapsed": 1111.8409752845764 + }, + { + "step": 3472, + "loss": 0.591402530670166, + "error": 0.3515625, + "gradient_norm": 0.051181379705667496, + "elapsed": 1116.5800333023071 + }, + { + "step": 3488, + "loss": 0.30494624376296997, + "error": 0.12109375, + "gradient_norm": 0.05175542086362839, + "elapsed": 1121.276373386383 + }, + { + "step": 3504, + "loss": 0.5065370798110962, + "error": 0.279296875, + "gradient_norm": 0.10419930517673492, + "elapsed": 1125.9883344173431 + }, + { + "step": 3520, + "loss": 0.3915700614452362, + "error": 0.1953125, + "gradient_norm": 0.060416825115680695, + "elapsed": 1130.7958455085754 + }, + { + "step": 3536, + "loss": 0.624374270439148, + "error": 0.3759765625, + "gradient_norm": 0.06069556251168251, + "elapsed": 1135.5360939502716 + }, + { + "step": 3552, + "loss": 0.5830206274986267, + "error": 0.3359375, + "gradient_norm": 0.046013280749320984, + "elapsed": 1140.312029838562 + }, + { + "step": 3568, + "loss": 0.4201379716396332, + "error": 0.2119140625, + "gradient_norm": 0.06909621506929398, + "elapsed": 1145.0904593467712 + }, + { + "step": 3584, + "loss": 0.28215405344963074, + "error": 0.1181640625, + "gradient_norm": 0.07625982910394669, + "elapsed": 1149.8156151771545 + }, + { + "step": 3600, + "loss": 0.5229164361953735, + "error": 0.275390625, + "gradient_norm": 0.055048178881406784, + "elapsed": 1154.5280592441559 + }, + { + "step": 3616, + "loss": 0.47238075733184814, + "error": 0.2314453125, + "gradient_norm": 0.06473162025213242, + "elapsed": 1159.2720873355865 + }, + { + "step": 3632, + "loss": 0.46245503425598145, + "error": 0.228515625, + "gradient_norm": 0.07382887601852417, + "elapsed": 1164.0119998455048 + }, + { + "step": 3648, + "loss": 0.37509745359420776, + "error": 0.171875, + "gradient_norm": 0.051260266453027725, + "elapsed": 1168.7440350055695 + }, + { + "step": 3664, + "loss": 0.1948484629392624, + "error": 0.080078125, + "gradient_norm": 0.059623416513204575, + "elapsed": 1173.3906588554382 + }, + { + "step": 3680, + "loss": 0.5552756786346436, + "error": 0.3115234375, + "gradient_norm": 0.08073585480451584, + "elapsed": 1178.0645008087158 + }, + { + "step": 3696, + "loss": 0.6405904293060303, + "error": 0.39453125, + "gradient_norm": 0.05899551138281822, + "elapsed": 1182.730489730835 + }, + { + "step": 3712, + "loss": 0.2767012119293213, + "error": 0.119140625, + "gradient_norm": 0.06593579798936844, + "elapsed": 1187.377315044403 + }, + { + "step": 3728, + "loss": 0.315812885761261, + "error": 0.134765625, + "gradient_norm": 0.035905495285987854, + "elapsed": 1192.0582301616669 + }, + { + "step": 3744, + "loss": 0.6033951640129089, + "error": 0.3544921875, + "gradient_norm": 0.05226197466254234, + "elapsed": 1196.7101175785065 + }, + { + "step": 3760, + "loss": 0.5202592611312866, + "error": 0.275390625, + "gradient_norm": 0.06367512047290802, + "elapsed": 1201.3543090820312 + }, + { + "step": 3776, + "loss": 0.24639368057250977, + "error": 0.1083984375, + "gradient_norm": 0.09370873868465424, + "elapsed": 1206.0717165470123 + }, + { + "step": 3792, + "loss": 0.6175658702850342, + "error": 0.375, + "gradient_norm": 0.06221585348248482, + "elapsed": 1210.754029750824 + }, + { + "step": 3808, + "loss": 0.41153696179389954, + "error": 0.2119140625, + "gradient_norm": 0.05355365574359894, + "elapsed": 1215.4374370574951 + }, + { + "step": 3824, + "loss": 0.28002214431762695, + "error": 0.1123046875, + "gradient_norm": 0.03846330568194389, + "elapsed": 1220.1207013130188 + }, + { + "step": 3840, + "loss": 0.0484195351600647, + "error": 0.013671875, + "gradient_norm": 0.03470242768526077, + "elapsed": 1224.8153104782104 + }, + { + "step": 3856, + "loss": 0.1407160609960556, + "error": 0.0458984375, + "gradient_norm": 0.04061700031161308, + "elapsed": 1229.5512235164642 + }, + { + "step": 3872, + "loss": 0.5881794691085815, + "error": 0.3427734375, + "gradient_norm": 0.062013477087020874, + "elapsed": 1234.3750183582306 + }, + { + "step": 3888, + "loss": 0.17833612859249115, + "error": 0.06640625, + "gradient_norm": 0.038856204599142075, + "elapsed": 1239.110375881195 + }, + { + "step": 3904, + "loss": 0.06211477518081665, + "error": 0.0224609375, + "gradient_norm": 0.02150108851492405, + "elapsed": 1243.800644159317 + }, + { + "step": 3920, + "loss": 0.06039723381400108, + "error": 0.01953125, + "gradient_norm": 0.019367367029190063, + "elapsed": 1248.4831748008728 + }, + { + "step": 3936, + "loss": 0.6010214686393738, + "error": 0.3525390625, + "gradient_norm": 0.051659151911735535, + "elapsed": 1253.1423478126526 + }, + { + "step": 3952, + "loss": 0.5867137312889099, + "error": 0.3388671875, + "gradient_norm": 0.058528851717710495, + "elapsed": 1257.9799931049347 + }, + { + "step": 3968, + "loss": 0.5231834650039673, + "error": 0.2578125, + "gradient_norm": 0.10128334909677505, + "elapsed": 1262.6990082263947 + }, + { + "step": 3984, + "loss": 0.6251651644706726, + "error": 0.353515625, + "gradient_norm": 0.06211795285344124, + "elapsed": 1267.4289934635162 + }, + { + "step": 4000, + "loss": 0.06667037308216095, + "error": 0.01953125, + "gradient_norm": 0.048018258064985275, + "elapsed": 1272.132089138031 + }, + { + "step": 4016, + "loss": 0.5286938548088074, + "error": 0.2744140625, + "gradient_norm": 0.05509360507130623, + "elapsed": 1276.8878977298737 + }, + { + "step": 4032, + "loss": 0.34016552567481995, + "error": 0.1591796875, + "gradient_norm": 0.07597329467535019, + "elapsed": 1281.7364926338196 + }, + { + "step": 4048, + "loss": 0.17750494182109833, + "error": 0.078125, + "gradient_norm": 0.06314503401517868, + "elapsed": 1286.5033600330353 + }, + { + "step": 4064, + "loss": 0.5882893800735474, + "error": 0.34375, + "gradient_norm": 0.10986580699682236, + "elapsed": 1291.1944887638092 + }, + { + "step": 4080, + "loss": 0.4923543930053711, + "error": 0.2568359375, + "gradient_norm": 0.050325747579336166, + "elapsed": 1295.9372322559357 + }, + { + "step": 4096, + "loss": 0.44146978855133057, + "error": 0.2236328125, + "gradient_norm": 0.06535191088914871, + "elapsed": 1300.641023159027 + } + ] + }, + "training_source_snapshot": "training_sources/temporal2", + "selected_checkpoint_steps": [ + "1024", + "2048", + "4096" + ], + "checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 804757, + "weights": "weights-1024.npz", + "weights_sha256": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "validation": "validation-1024.json", + "complete": true + }, + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24672475961538465, + "1024": 0.24571814903846154, + "2048": 0.24504206730769232, + "3072": 0.2456129807692308, + "4096": 0.2445763221153846, + "blend-1024": 0.2469501201923077, + "blend-2048": 0.24583834134615387, + "blend-3072": 0.2458984375, + "blend-4096": 0.2456580528846154 + }, + "selected": "4096" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2530348557692308, + "1024": 0.2528545673076923, + "2048": 0.25342548076923077, + "3072": 0.25369591346153847, + "4096": 0.25446213942307694, + "blend-1024": 0.2531550480769231, + "blend-2048": 0.2536658653846154, + "blend-3072": 0.25329026442307695, + "blend-4096": 0.2540264423076923 + }, + "selected": "1024" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23442007211538465, + "1024": 0.23445012019230768, + "2048": 0.2340895432692308, + "3072": 0.23431490384615383, + "4096": 0.23366887019230773, + "blend-1024": 0.23440504807692308, + "blend-2048": 0.2341496394230769, + "blend-3072": 0.23416466346153844, + "blend-4096": 0.23413461538461536 + }, + "selected": "4096" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.2392427884615385, + "1024": 0.23949819711538464, + "2048": 0.23907752403846155, + "3072": 0.24014423076923078, + "4096": 0.24064002403846152, + "blend-1024": 0.23916766826923075, + "blend-2048": 0.23886718750000002, + "blend-3072": 0.2392578125, + "blend-4096": 0.23900240384615387 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24630408653846156, + "1024": 0.24649939903846152, + "2048": 0.2460486778846154, + "3072": 0.24523737980769228, + "4096": 0.24463641826923077, + "blend-1024": 0.24615384615384614, + "blend-2048": 0.2456580528846154, + "blend-3072": 0.24583834134615384, + "blend-4096": 0.24576322115384613 + }, + "selected": "4096" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23760516826923078, + "1024": 0.23733473557692308, + "2048": 0.23652343749999996, + "3072": 0.23795072115384613, + "4096": 0.2379807692307692, + "blend-1024": 0.23713942307692307, + "blend-2048": 0.23740985576923077, + "blend-3072": 0.23811598557692307, + "blend-4096": 0.23780048076923077 + }, + "selected": "2048" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.2371694711538461, + "1024": 0.23689903846153845, + "2048": 0.2371243990384615, + "3072": 0.2371844951923077, + "4096": 0.23562199519230764, + "blend-1024": 0.23715444711538464, + "blend-2048": 0.23662860576923078, + "blend-3072": 0.23712439903846153, + "blend-4096": 0.23643329326923077 + }, + "selected": "4096" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23342848557692306, + "1024": 0.23353365384615385, + "2048": 0.23429987980769232, + "3072": 0.2335637019230769, + "4096": 0.2329627403846154, + "blend-1024": 0.23350360576923074, + "blend-2048": 0.23383413461538463, + "blend-3072": 0.23357872596153847, + "blend-4096": 0.2333533653846154 + }, + "selected": "4096" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2325420673076923 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "temporal2_swa", + "training_run": { + "initialization": "Uniform averages of the same session-trained temporal trajectory; no external weights", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_train.py": "7d48d2fc7f62d0bec3023b3df1c2ac28537d0417966131ae3a156697a34cda5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 1778773, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18357, + "surface_code_bX_d3_r03_center_3_5": 16816, + "surface_code_bX_d3_r05_center_3_5": 17999, + "surface_code_bX_d3_r07_center_3_5": 15225, + "surface_code_bX_d3_r09_center_3_5": 16132, + "surface_code_bX_d3_r11_center_3_5": 17041, + "surface_code_bX_d3_r13_center_3_5": 18477, + "surface_code_bX_d3_r15_center_3_5": 18214, + "surface_code_bX_d3_r17_center_3_5": 16505, + "surface_code_bX_d3_r19_center_3_5": 17120, + "surface_code_bX_d3_r21_center_3_5": 17563, + "surface_code_bX_d3_r23_center_3_5": 16681, + "surface_code_bX_d3_r25_center_3_5": 18379, + "surface_code_bX_d3_r01_center_5_3": 17450, + "surface_code_bX_d3_r03_center_5_3": 17161, + "surface_code_bX_d3_r05_center_5_3": 15797, + "surface_code_bX_d3_r07_center_5_3": 17800, + "surface_code_bX_d3_r09_center_5_3": 17190, + "surface_code_bX_d3_r11_center_5_3": 15840, + "surface_code_bX_d3_r13_center_5_3": 15178, + "surface_code_bX_d3_r15_center_5_3": 14897, + "surface_code_bX_d3_r17_center_5_3": 18252, + "surface_code_bX_d3_r19_center_5_3": 17083, + "surface_code_bX_d3_r21_center_5_3": 17229, + "surface_code_bX_d3_r23_center_5_3": 14735, + "surface_code_bX_d3_r25_center_5_3": 17949, + "surface_code_bX_d3_r01_center_5_7": 17431, + "surface_code_bX_d3_r03_center_5_7": 16583, + "surface_code_bX_d3_r05_center_5_7": 16891, + "surface_code_bX_d3_r07_center_5_7": 17969, + "surface_code_bX_d3_r09_center_5_7": 17966, + "surface_code_bX_d3_r11_center_5_7": 14424, + "surface_code_bX_d3_r13_center_5_7": 16930, + "surface_code_bX_d3_r15_center_5_7": 15205, + "surface_code_bX_d3_r17_center_5_7": 18252, + "surface_code_bX_d3_r19_center_5_7": 17077, + "surface_code_bX_d3_r21_center_5_7": 16770, + "surface_code_bX_d3_r23_center_5_7": 17308, + "surface_code_bX_d3_r25_center_5_7": 17481, + "surface_code_bX_d3_r01_center_7_5": 16630, + "surface_code_bX_d3_r03_center_7_5": 17439, + "surface_code_bX_d3_r05_center_7_5": 15811, + "surface_code_bX_d3_r07_center_7_5": 16637, + "surface_code_bX_d3_r09_center_7_5": 18306, + "surface_code_bX_d3_r11_center_7_5": 18327, + "surface_code_bX_d3_r13_center_7_5": 17974, + "surface_code_bX_d3_r15_center_7_5": 16106, + "surface_code_bX_d3_r17_center_7_5": 15834, + "surface_code_bX_d3_r19_center_7_5": 17242, + "surface_code_bX_d3_r21_center_7_5": 17889, + "surface_code_bX_d3_r23_center_7_5": 17440, + "surface_code_bX_d3_r25_center_7_5": 17087, + "surface_code_bZ_d3_r01_center_3_5": 16236, + "surface_code_bZ_d3_r03_center_3_5": 17278, + "surface_code_bZ_d3_r05_center_3_5": 16577, + "surface_code_bZ_d3_r07_center_3_5": 17376, + "surface_code_bZ_d3_r09_center_3_5": 16000, + "surface_code_bZ_d3_r11_center_3_5": 15634, + "surface_code_bZ_d3_r13_center_3_5": 14950, + "surface_code_bZ_d3_r15_center_3_5": 16600, + "surface_code_bZ_d3_r17_center_3_5": 15381, + "surface_code_bZ_d3_r19_center_3_5": 16823, + "surface_code_bZ_d3_r21_center_3_5": 18789, + "surface_code_bZ_d3_r23_center_3_5": 15616, + "surface_code_bZ_d3_r25_center_3_5": 17088, + "surface_code_bZ_d3_r01_center_5_3": 17935, + "surface_code_bZ_d3_r03_center_5_3": 16256, + "surface_code_bZ_d3_r05_center_5_3": 17959, + "surface_code_bZ_d3_r07_center_5_3": 18401, + "surface_code_bZ_d3_r09_center_5_3": 16405, + "surface_code_bZ_d3_r11_center_5_3": 17274, + "surface_code_bZ_d3_r13_center_5_3": 18172, + "surface_code_bZ_d3_r15_center_5_3": 17525, + "surface_code_bZ_d3_r17_center_5_3": 18643, + "surface_code_bZ_d3_r19_center_5_3": 17816, + "surface_code_bZ_d3_r21_center_5_3": 17404, + "surface_code_bZ_d3_r23_center_5_3": 17253, + "surface_code_bZ_d3_r25_center_5_3": 17667, + "surface_code_bZ_d3_r01_center_5_7": 16203, + "surface_code_bZ_d3_r03_center_5_7": 17214, + "surface_code_bZ_d3_r05_center_5_7": 16799, + "surface_code_bZ_d3_r07_center_5_7": 17896, + "surface_code_bZ_d3_r09_center_5_7": 16411, + "surface_code_bZ_d3_r11_center_5_7": 17726, + "surface_code_bZ_d3_r13_center_5_7": 16313, + "surface_code_bZ_d3_r15_center_5_7": 17824, + "surface_code_bZ_d3_r17_center_5_7": 15656, + "surface_code_bZ_d3_r19_center_5_7": 17169, + "surface_code_bZ_d3_r21_center_5_7": 17194, + "surface_code_bZ_d3_r23_center_5_7": 16779, + "surface_code_bZ_d3_r25_center_5_7": 16970, + "surface_code_bZ_d3_r01_center_7_5": 16762, + "surface_code_bZ_d3_r03_center_7_5": 17320, + "surface_code_bZ_d3_r05_center_7_5": 17522, + "surface_code_bZ_d3_r07_center_7_5": 17914, + "surface_code_bZ_d3_r09_center_7_5": 18439, + "surface_code_bZ_d3_r11_center_7_5": 18218, + "surface_code_bZ_d3_r13_center_7_5": 17907, + "surface_code_bZ_d3_r15_center_7_5": 17597, + "surface_code_bZ_d3_r17_center_7_5": 18252, + "surface_code_bZ_d3_r19_center_7_5": 18379, + "surface_code_bZ_d3_r21_center_7_5": 16818, + "surface_code_bZ_d3_r23_center_7_5": 18430, + "surface_code_bZ_d3_r25_center_7_5": 17924 + }, + "steps": 4096, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.0005, + "sampling_seed": 20261121, + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_exact/temporal1/rng-2048.json", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal1/weights-2048.npz", + "starting_checkpoint_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "starting_training_provenance": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.250907301902771, + "error": 0.1083984375, + "gradient_norm": 0.07171476632356644, + "elapsed": 44.811134576797485 + }, + { + "step": 16, + "loss": 0.5958679914474487, + "error": 0.3662109375, + "gradient_norm": 0.07673005014657974, + "elapsed": 49.90856671333313 + }, + { + "step": 32, + "loss": 0.47648972272872925, + "error": 0.2421875, + "gradient_norm": 0.08561501652002335, + "elapsed": 55.179388761520386 + }, + { + "step": 48, + "loss": 0.06145006790757179, + "error": 0.0234375, + "gradient_norm": 0.01556467730551958, + "elapsed": 61.0339195728302 + }, + { + "step": 64, + "loss": 0.3687053918838501, + "error": 0.1884765625, + "gradient_norm": 0.08752371370792389, + "elapsed": 65.95811891555786 + }, + { + "step": 80, + "loss": 0.6481984853744507, + "error": 0.4140625, + "gradient_norm": 0.05311283841729164, + "elapsed": 70.56021332740784 + }, + { + "step": 96, + "loss": 0.42319929599761963, + "error": 0.2138671875, + "gradient_norm": 0.05047478526830673, + "elapsed": 75.11613631248474 + }, + { + "step": 112, + "loss": 0.47527259588241577, + "error": 0.24609375, + "gradient_norm": 0.038366906344890594, + "elapsed": 79.53446984291077 + }, + { + "step": 128, + "loss": 0.5996723175048828, + "error": 0.3369140625, + "gradient_norm": 0.1213272362947464, + "elapsed": 83.97515749931335 + }, + { + "step": 144, + "loss": 0.04971993714570999, + "error": 0.0146484375, + "gradient_norm": 0.008080735802650452, + "elapsed": 88.44039463996887 + }, + { + "step": 160, + "loss": 0.35900360345840454, + "error": 0.162109375, + "gradient_norm": 0.03359593451023102, + "elapsed": 92.89548206329346 + }, + { + "step": 176, + "loss": 0.5342063903808594, + "error": 0.2978515625, + "gradient_norm": 0.04794691130518913, + "elapsed": 97.35658049583435 + }, + { + "step": 192, + "loss": 0.6300076246261597, + "error": 0.369140625, + "gradient_norm": 0.081769198179245, + "elapsed": 101.81493759155273 + }, + { + "step": 208, + "loss": 0.6191903948783875, + "error": 0.3828125, + "gradient_norm": 0.07145775109529495, + "elapsed": 106.2480263710022 + }, + { + "step": 224, + "loss": 0.5155678391456604, + "error": 0.28515625, + "gradient_norm": 0.06772179156541824, + "elapsed": 110.71284222602844 + }, + { + "step": 240, + "loss": 0.634708046913147, + "error": 0.3857421875, + "gradient_norm": 0.09493093192577362, + "elapsed": 115.14978742599487 + }, + { + "step": 256, + "loss": 0.1840895414352417, + "error": 0.0751953125, + "gradient_norm": 0.025586696341633797, + "elapsed": 119.61202120780945 + }, + { + "step": 272, + "loss": 0.2775103449821472, + "error": 0.12890625, + "gradient_norm": 0.06913147866725922, + "elapsed": 124.02584528923035 + }, + { + "step": 288, + "loss": 0.6163080334663391, + "error": 0.3642578125, + "gradient_norm": 0.05895426496863365, + "elapsed": 128.46512532234192 + }, + { + "step": 304, + "loss": 0.5276986360549927, + "error": 0.287109375, + "gradient_norm": 0.06955187022686005, + "elapsed": 132.89240765571594 + }, + { + "step": 320, + "loss": 0.44859516620635986, + "error": 0.22265625, + "gradient_norm": 0.07272452116012573, + "elapsed": 137.32864713668823 + }, + { + "step": 336, + "loss": 0.48315611481666565, + "error": 0.2626953125, + "gradient_norm": 0.03321139141917229, + "elapsed": 141.80009770393372 + }, + { + "step": 352, + "loss": 0.6107717752456665, + "error": 0.3544921875, + "gradient_norm": 0.05243214592337608, + "elapsed": 146.36439752578735 + }, + { + "step": 368, + "loss": 0.6215153932571411, + "error": 0.357421875, + "gradient_norm": 0.04383325204253197, + "elapsed": 150.99996852874756 + }, + { + "step": 384, + "loss": 0.6130329966545105, + "error": 0.35546875, + "gradient_norm": 0.04113119840621948, + "elapsed": 155.62374639511108 + }, + { + "step": 400, + "loss": 0.30471885204315186, + "error": 0.142578125, + "gradient_norm": 0.04447556659579277, + "elapsed": 160.17594957351685 + }, + { + "step": 416, + "loss": 0.6154489517211914, + "error": 0.37109375, + "gradient_norm": 0.04456057772040367, + "elapsed": 164.7639675140381 + }, + { + "step": 432, + "loss": 0.6134694218635559, + "error": 0.337890625, + "gradient_norm": 0.04219559207558632, + "elapsed": 169.32792139053345 + }, + { + "step": 448, + "loss": 0.5463185906410217, + "error": 0.2939453125, + "gradient_norm": 0.07746092975139618, + "elapsed": 173.88445162773132 + }, + { + "step": 464, + "loss": 0.06016772612929344, + "error": 0.01953125, + "gradient_norm": 0.01364185381680727, + "elapsed": 178.42725706100464 + }, + { + "step": 480, + "loss": 0.388141393661499, + "error": 0.18359375, + "gradient_norm": 0.04870256036520004, + "elapsed": 182.99062085151672 + }, + { + "step": 496, + "loss": 0.44524821639060974, + "error": 0.2216796875, + "gradient_norm": 0.03453445807099342, + "elapsed": 187.56396961212158 + }, + { + "step": 512, + "loss": 0.34312355518341064, + "error": 0.154296875, + "gradient_norm": 0.06794509291648865, + "elapsed": 192.27511191368103 + }, + { + "step": 528, + "loss": 0.19467462599277496, + "error": 0.0771484375, + "gradient_norm": 0.042381469160318375, + "elapsed": 197.7108268737793 + }, + { + "step": 544, + "loss": 0.46226584911346436, + "error": 0.2421875, + "gradient_norm": 0.06073570251464844, + "elapsed": 202.97405791282654 + }, + { + "step": 560, + "loss": 0.525318443775177, + "error": 0.2822265625, + "gradient_norm": 0.06954885274171829, + "elapsed": 208.69676971435547 + }, + { + "step": 576, + "loss": 0.6158387064933777, + "error": 0.349609375, + "gradient_norm": 0.07587578892707825, + "elapsed": 214.80397653579712 + }, + { + "step": 592, + "loss": 0.5515886545181274, + "error": 0.298828125, + "gradient_norm": 0.04969338700175285, + "elapsed": 220.27399611473083 + }, + { + "step": 608, + "loss": 0.18365338444709778, + "error": 0.0654296875, + "gradient_norm": 0.08657706528902054, + "elapsed": 224.81246256828308 + }, + { + "step": 624, + "loss": 0.4578855633735657, + "error": 0.2421875, + "gradient_norm": 0.04942100867629051, + "elapsed": 229.45902252197266 + }, + { + "step": 640, + "loss": 0.37826013565063477, + "error": 0.1865234375, + "gradient_norm": 0.047499872744083405, + "elapsed": 233.9695644378662 + }, + { + "step": 656, + "loss": 0.40863412618637085, + "error": 0.2001953125, + "gradient_norm": 0.07845330238342285, + "elapsed": 238.584894657135 + }, + { + "step": 672, + "loss": 0.5640332698822021, + "error": 0.2880859375, + "gradient_norm": 0.057469289749860764, + "elapsed": 243.0929844379425 + }, + { + "step": 688, + "loss": 0.030216243118047714, + "error": 0.0078125, + "gradient_norm": 0.04682641476392746, + "elapsed": 247.581125497818 + }, + { + "step": 704, + "loss": 0.375002384185791, + "error": 0.1826171875, + "gradient_norm": 0.04864194989204407, + "elapsed": 252.1564691066742 + }, + { + "step": 720, + "loss": 0.5145515203475952, + "error": 0.2744140625, + "gradient_norm": 0.052671682089567184, + "elapsed": 256.6466488838196 + }, + { + "step": 736, + "loss": 0.067174531519413, + "error": 0.0224609375, + "gradient_norm": 0.019299577921628952, + "elapsed": 261.1185076236725 + }, + { + "step": 752, + "loss": 0.24909992516040802, + "error": 0.111328125, + "gradient_norm": 0.06907463818788528, + "elapsed": 265.61960339546204 + }, + { + "step": 768, + "loss": 0.5088074207305908, + "error": 0.2744140625, + "gradient_norm": 0.06963017582893372, + "elapsed": 270.07474064826965 + }, + { + "step": 784, + "loss": 0.3783387839794159, + "error": 0.1826171875, + "gradient_norm": 0.05537794530391693, + "elapsed": 274.52722239494324 + }, + { + "step": 800, + "loss": 0.6107200980186462, + "error": 0.3623046875, + "gradient_norm": 0.0470259003341198, + "elapsed": 279.0401859283447 + }, + { + "step": 816, + "loss": 0.5778236389160156, + "error": 0.3212890625, + "gradient_norm": 0.10146680474281311, + "elapsed": 283.5114622116089 + }, + { + "step": 832, + "loss": 0.576002299785614, + "error": 0.3076171875, + "gradient_norm": 0.07760787010192871, + "elapsed": 288.04797434806824 + }, + { + "step": 848, + "loss": 0.6179666519165039, + "error": 0.3740234375, + "gradient_norm": 0.07383852452039719, + "elapsed": 292.60600209236145 + }, + { + "step": 864, + "loss": 0.3105512857437134, + "error": 0.1455078125, + "gradient_norm": 0.052953749895095825, + "elapsed": 297.12180352211 + }, + { + "step": 880, + "loss": 0.4802623987197876, + "error": 0.2548828125, + "gradient_norm": 0.07736275345087051, + "elapsed": 301.6091134548187 + }, + { + "step": 896, + "loss": 0.5572722554206848, + "error": 0.318359375, + "gradient_norm": 0.053303152322769165, + "elapsed": 306.1978073120117 + }, + { + "step": 912, + "loss": 0.34814420342445374, + "error": 0.1669921875, + "gradient_norm": 0.037726350128650665, + "elapsed": 310.78571581840515 + }, + { + "step": 928, + "loss": 0.41743016242980957, + "error": 0.21875, + "gradient_norm": 0.05238872766494751, + "elapsed": 315.24156188964844 + }, + { + "step": 944, + "loss": 0.5757850408554077, + "error": 0.3173828125, + "gradient_norm": 0.05837905779480934, + "elapsed": 319.78475165367126 + }, + { + "step": 960, + "loss": 0.40727972984313965, + "error": 0.197265625, + "gradient_norm": 0.059294261038303375, + "elapsed": 324.2090265750885 + }, + { + "step": 976, + "loss": 0.32715001702308655, + "error": 0.1533203125, + "gradient_norm": 0.11543179303407669, + "elapsed": 328.6462152004242 + }, + { + "step": 992, + "loss": 0.5578742623329163, + "error": 0.314453125, + "gradient_norm": 0.06282714009284973, + "elapsed": 333.0712504386902 + }, + { + "step": 1008, + "loss": 0.5052692294120789, + "error": 0.265625, + "gradient_norm": 0.04039420187473297, + "elapsed": 337.5182821750641 + }, + { + "step": 1024, + "loss": 0.18790806829929352, + "error": 0.08203125, + "gradient_norm": 0.028905188664793968, + "elapsed": 342.08340406417847 + }, + { + "step": 1040, + "loss": 0.6317684650421143, + "error": 0.3681640625, + "gradient_norm": 0.03441835194826126, + "elapsed": 358.8279616832733 + }, + { + "step": 1056, + "loss": 0.40474164485931396, + "error": 0.2021484375, + "gradient_norm": 0.036449309438467026, + "elapsed": 363.30218267440796 + }, + { + "step": 1072, + "loss": 0.518299400806427, + "error": 0.2666015625, + "gradient_norm": 0.0886964276432991, + "elapsed": 367.87997555732727 + }, + { + "step": 1088, + "loss": 0.2522922158241272, + "error": 0.099609375, + "gradient_norm": 0.07553310692310333, + "elapsed": 372.4414882659912 + }, + { + "step": 1104, + "loss": 0.6214810609817505, + "error": 0.3701171875, + "gradient_norm": 0.10188957303762436, + "elapsed": 376.9120502471924 + }, + { + "step": 1120, + "loss": 0.6307054162025452, + "error": 0.3720703125, + "gradient_norm": 0.07353860139846802, + "elapsed": 381.3824534416199 + }, + { + "step": 1136, + "loss": 0.5259381532669067, + "error": 0.2763671875, + "gradient_norm": 0.05779678374528885, + "elapsed": 385.8413143157959 + }, + { + "step": 1152, + "loss": 0.4995541572570801, + "error": 0.259765625, + "gradient_norm": 0.046648140996694565, + "elapsed": 390.28326058387756 + }, + { + "step": 1168, + "loss": 0.6075694561004639, + "error": 0.3701171875, + "gradient_norm": 0.10612073540687561, + "elapsed": 394.8162364959717 + }, + { + "step": 1184, + "loss": 0.2105136513710022, + "error": 0.080078125, + "gradient_norm": 0.0716402605175972, + "elapsed": 399.2960283756256 + }, + { + "step": 1200, + "loss": 0.6371631026268005, + "error": 0.3857421875, + "gradient_norm": 0.0549108125269413, + "elapsed": 403.7899103164673 + }, + { + "step": 1216, + "loss": 0.5450670719146729, + "error": 0.2939453125, + "gradient_norm": 0.11688558012247086, + "elapsed": 408.34677600860596 + }, + { + "step": 1232, + "loss": 0.035783201456069946, + "error": 0.01171875, + "gradient_norm": 0.02951689623296261, + "elapsed": 412.8558337688446 + }, + { + "step": 1248, + "loss": 0.5582903623580933, + "error": 0.3046875, + "gradient_norm": 0.055107031017541885, + "elapsed": 417.29854226112366 + }, + { + "step": 1264, + "loss": 0.5154441595077515, + "error": 0.27734375, + "gradient_norm": 0.04474929720163345, + "elapsed": 421.7792055606842 + }, + { + "step": 1280, + "loss": 0.35227546095848083, + "error": 0.16015625, + "gradient_norm": 0.05024837702512741, + "elapsed": 426.54427456855774 + }, + { + "step": 1296, + "loss": 0.19417589902877808, + "error": 0.0830078125, + "gradient_norm": 0.026926057413220406, + "elapsed": 431.320588350296 + }, + { + "step": 1312, + "loss": 0.4768218398094177, + "error": 0.248046875, + "gradient_norm": 0.15099607408046722, + "elapsed": 435.96817326545715 + }, + { + "step": 1328, + "loss": 0.48580923676490784, + "error": 0.2509765625, + "gradient_norm": 0.08925126492977142, + "elapsed": 440.64917039871216 + }, + { + "step": 1344, + "loss": 0.42041274905204773, + "error": 0.1982421875, + "gradient_norm": 0.08321093022823334, + "elapsed": 445.34370946884155 + }, + { + "step": 1360, + "loss": 0.06403929740190506, + "error": 0.0185546875, + "gradient_norm": 0.03817005455493927, + "elapsed": 449.98669385910034 + }, + { + "step": 1376, + "loss": 0.463126003742218, + "error": 0.2275390625, + "gradient_norm": 0.08894515782594681, + "elapsed": 454.6478977203369 + }, + { + "step": 1392, + "loss": 0.5995306968688965, + "error": 0.373046875, + "gradient_norm": 0.06733685731887817, + "elapsed": 459.35924530029297 + }, + { + "step": 1408, + "loss": 0.49053263664245605, + "error": 0.25, + "gradient_norm": 0.10475508868694305, + "elapsed": 464.100093126297 + }, + { + "step": 1424, + "loss": 0.6220744848251343, + "error": 0.3818359375, + "gradient_norm": 0.03653963655233383, + "elapsed": 468.89601135253906 + }, + { + "step": 1440, + "loss": 0.39706122875213623, + "error": 0.2021484375, + "gradient_norm": 0.04344598576426506, + "elapsed": 474.03999519348145 + }, + { + "step": 1456, + "loss": 0.5386708974838257, + "error": 0.3095703125, + "gradient_norm": 0.12589037418365479, + "elapsed": 478.8600504398346 + }, + { + "step": 1472, + "loss": 0.49776726961135864, + "error": 0.271484375, + "gradient_norm": 0.058137863874435425, + "elapsed": 483.5920066833496 + }, + { + "step": 1488, + "loss": 0.4757428765296936, + "error": 0.2412109375, + "gradient_norm": 0.050453316420316696, + "elapsed": 488.4611999988556 + }, + { + "step": 1504, + "loss": 0.5694847702980042, + "error": 0.337890625, + "gradient_norm": 0.052419569343328476, + "elapsed": 493.26151037216187 + }, + { + "step": 1520, + "loss": 0.5997745990753174, + "error": 0.3603515625, + "gradient_norm": 0.04338108375668526, + "elapsed": 498.0421245098114 + }, + { + "step": 1536, + "loss": 0.6195274591445923, + "error": 0.3876953125, + "gradient_norm": 0.04848463833332062, + "elapsed": 502.8808298110962 + }, + { + "step": 1552, + "loss": 0.46315908432006836, + "error": 0.2353515625, + "gradient_norm": 0.06380566209554672, + "elapsed": 507.5519721508026 + }, + { + "step": 1568, + "loss": 0.605262041091919, + "error": 0.36328125, + "gradient_norm": 0.05077619478106499, + "elapsed": 512.457685470581 + }, + { + "step": 1584, + "loss": 0.48782041668891907, + "error": 0.232421875, + "gradient_norm": 0.09017211943864822, + "elapsed": 517.2960062026978 + }, + { + "step": 1600, + "loss": 0.3881351947784424, + "error": 0.1875, + "gradient_norm": 0.07205695658922195, + "elapsed": 522.0911631584167 + }, + { + "step": 1616, + "loss": 0.4966873526573181, + "error": 0.24609375, + "gradient_norm": 0.0582038015127182, + "elapsed": 526.8861901760101 + }, + { + "step": 1632, + "loss": 0.5844199657440186, + "error": 0.33203125, + "gradient_norm": 0.05101500824093819, + "elapsed": 531.6640138626099 + }, + { + "step": 1648, + "loss": 0.31010180711746216, + "error": 0.1318359375, + "gradient_norm": 0.053135693073272705, + "elapsed": 536.4960391521454 + }, + { + "step": 1664, + "loss": 0.6174807548522949, + "error": 0.3779296875, + "gradient_norm": 0.04161194711923599, + "elapsed": 541.2560484409332 + }, + { + "step": 1680, + "loss": 0.18213607370853424, + "error": 0.0751953125, + "gradient_norm": 0.07171957194805145, + "elapsed": 546.0000085830688 + }, + { + "step": 1696, + "loss": 0.5445692539215088, + "error": 0.2998046875, + "gradient_norm": 0.054499462246894836, + "elapsed": 551.1221191883087 + }, + { + "step": 1712, + "loss": 0.05744167044758797, + "error": 0.017578125, + "gradient_norm": 0.013108699582517147, + "elapsed": 556.5286149978638 + }, + { + "step": 1728, + "loss": 0.6381571292877197, + "error": 0.3896484375, + "gradient_norm": 0.05157556012272835, + "elapsed": 561.8000066280365 + }, + { + "step": 1744, + "loss": 0.5301004648208618, + "error": 0.28125, + "gradient_norm": 0.04218568280339241, + "elapsed": 567.2760035991669 + }, + { + "step": 1760, + "loss": 0.5275102257728577, + "error": 0.26953125, + "gradient_norm": 0.06798839569091797, + "elapsed": 572.5601994991302 + }, + { + "step": 1776, + "loss": 0.6443773508071899, + "error": 0.4091796875, + "gradient_norm": 0.07035460323095322, + "elapsed": 577.9789206981659 + }, + { + "step": 1792, + "loss": 0.6012362241744995, + "error": 0.337890625, + "gradient_norm": 0.05189951881766319, + "elapsed": 583.028017282486 + }, + { + "step": 1808, + "loss": 0.2939091920852661, + "error": 0.12109375, + "gradient_norm": 0.05555355176329613, + "elapsed": 588.0501506328583 + }, + { + "step": 1824, + "loss": 0.2059091478586197, + "error": 0.08984375, + "gradient_norm": 0.045679714530706406, + "elapsed": 593.2120039463043 + }, + { + "step": 1840, + "loss": 0.6289581060409546, + "error": 0.349609375, + "gradient_norm": 0.04742642492055893, + "elapsed": 598.7767763137817 + }, + { + "step": 1856, + "loss": 0.5532636642456055, + "error": 0.294921875, + "gradient_norm": 0.05997413396835327, + "elapsed": 604.0475382804871 + }, + { + "step": 1872, + "loss": 0.45995670557022095, + "error": 0.228515625, + "gradient_norm": 0.05674462765455246, + "elapsed": 609.292379617691 + }, + { + "step": 1888, + "loss": 0.6178656816482544, + "error": 0.359375, + "gradient_norm": 0.08857566863298416, + "elapsed": 614.5639882087708 + }, + { + "step": 1904, + "loss": 0.5531284213066101, + "error": 0.287109375, + "gradient_norm": 0.10257937759160995, + "elapsed": 619.5600035190582 + }, + { + "step": 1920, + "loss": 0.04184349626302719, + "error": 0.013671875, + "gradient_norm": 0.04087059944868088, + "elapsed": 624.6679775714874 + }, + { + "step": 1936, + "loss": 0.5924860239028931, + "error": 0.3505859375, + "gradient_norm": 0.036822713911533356, + "elapsed": 629.936680316925 + }, + { + "step": 1952, + "loss": 0.46996980905532837, + "error": 0.2421875, + "gradient_norm": 0.034442272037267685, + "elapsed": 635.1109762191772 + }, + { + "step": 1968, + "loss": 0.17859068512916565, + "error": 0.0712890625, + "gradient_norm": 0.03440066799521446, + "elapsed": 640.32000207901 + }, + { + "step": 1984, + "loss": 0.6192275285720825, + "error": 0.3701171875, + "gradient_norm": 0.04386439174413681, + "elapsed": 645.6040184497833 + }, + { + "step": 2000, + "loss": 0.6160917282104492, + "error": 0.35546875, + "gradient_norm": 0.06268990784883499, + "elapsed": 650.7723731994629 + }, + { + "step": 2016, + "loss": 0.6343611478805542, + "error": 0.388671875, + "gradient_norm": 0.04243326932191849, + "elapsed": 655.972663640976 + }, + { + "step": 2032, + "loss": 0.062292590737342834, + "error": 0.021484375, + "gradient_norm": 0.016680095344781876, + "elapsed": 660.8079733848572 + }, + { + "step": 2048, + "loss": 0.5316072702407837, + "error": 0.26953125, + "gradient_norm": 0.057860780507326126, + "elapsed": 665.5760209560394 + }, + { + "step": 2064, + "loss": 0.605312705039978, + "error": 0.3623046875, + "gradient_norm": 0.04028146713972092, + "elapsed": 682.7294294834137 + }, + { + "step": 2080, + "loss": 0.56633460521698, + "error": 0.3330078125, + "gradient_norm": 0.09528280049562454, + "elapsed": 687.4644649028778 + }, + { + "step": 2096, + "loss": 0.3905397057533264, + "error": 0.1943359375, + "gradient_norm": 0.049456462264060974, + "elapsed": 692.1492264270782 + }, + { + "step": 2112, + "loss": 0.28124868869781494, + "error": 0.1259765625, + "gradient_norm": 0.059239838272333145, + "elapsed": 696.8701393604279 + }, + { + "step": 2128, + "loss": 0.6364338994026184, + "error": 0.392578125, + "gradient_norm": 0.08667811006307602, + "elapsed": 701.683988571167 + }, + { + "step": 2144, + "loss": 0.20683243870735168, + "error": 0.07421875, + "gradient_norm": 0.1100710779428482, + "elapsed": 706.4000360965729 + }, + { + "step": 2160, + "loss": 0.5912737250328064, + "error": 0.341796875, + "gradient_norm": 0.05641854554414749, + "elapsed": 711.2359964847565 + }, + { + "step": 2176, + "loss": 0.27793264389038086, + "error": 0.12109375, + "gradient_norm": 0.0893034040927887, + "elapsed": 715.9508004188538 + }, + { + "step": 2192, + "loss": 0.6474133133888245, + "error": 0.4072265625, + "gradient_norm": 0.06980258971452713, + "elapsed": 720.651974439621 + }, + { + "step": 2208, + "loss": 0.5961858630180359, + "error": 0.35546875, + "gradient_norm": 0.06530112773180008, + "elapsed": 725.496098279953 + }, + { + "step": 2224, + "loss": 0.47581571340560913, + "error": 0.263671875, + "gradient_norm": 0.04470043256878853, + "elapsed": 730.2880010604858 + }, + { + "step": 2240, + "loss": 0.577988862991333, + "error": 0.318359375, + "gradient_norm": 0.07201159745454788, + "elapsed": 735.006133556366 + }, + { + "step": 2256, + "loss": 0.28444671630859375, + "error": 0.1181640625, + "gradient_norm": 0.048656050115823746, + "elapsed": 739.6868116855621 + }, + { + "step": 2272, + "loss": 0.2776409089565277, + "error": 0.1201171875, + "gradient_norm": 0.05783981829881668, + "elapsed": 744.3517308235168 + }, + { + "step": 2288, + "loss": 0.621599555015564, + "error": 0.37109375, + "gradient_norm": 0.09731200337409973, + "elapsed": 749.0351710319519 + }, + { + "step": 2304, + "loss": 0.3333754539489746, + "error": 0.1513671875, + "gradient_norm": 0.07069239765405655, + "elapsed": 753.7588081359863 + }, + { + "step": 2320, + "loss": 0.4687051773071289, + "error": 0.2490234375, + "gradient_norm": 0.044891707599163055, + "elapsed": 758.4588432312012 + }, + { + "step": 2336, + "loss": 0.19801637530326843, + "error": 0.078125, + "gradient_norm": 0.10036595165729523, + "elapsed": 763.256409406662 + }, + { + "step": 2352, + "loss": 0.6186277866363525, + "error": 0.388671875, + "gradient_norm": 0.09069584310054779, + "elapsed": 767.9986386299133 + }, + { + "step": 2368, + "loss": 0.6177258491516113, + "error": 0.373046875, + "gradient_norm": 0.049019571393728256, + "elapsed": 772.730831861496 + }, + { + "step": 2384, + "loss": 0.17707547545433044, + "error": 0.0673828125, + "gradient_norm": 0.045190781354904175, + "elapsed": 777.4072704315186 + }, + { + "step": 2400, + "loss": 0.20144733786582947, + "error": 0.08203125, + "gradient_norm": 0.04537162929773331, + "elapsed": 782.0841658115387 + }, + { + "step": 2416, + "loss": 0.6151775121688843, + "error": 0.365234375, + "gradient_norm": 0.050534047186374664, + "elapsed": 786.762966632843 + }, + { + "step": 2432, + "loss": 0.5533859133720398, + "error": 0.314453125, + "gradient_norm": 0.06006559729576111, + "elapsed": 791.4656012058258 + }, + { + "step": 2448, + "loss": 0.5329082012176514, + "error": 0.2880859375, + "gradient_norm": 0.04018115997314453, + "elapsed": 796.1704161167145 + }, + { + "step": 2464, + "loss": 0.6338047981262207, + "error": 0.4140625, + "gradient_norm": 0.06069163978099823, + "elapsed": 800.9180119037628 + }, + { + "step": 2480, + "loss": 0.1603008508682251, + "error": 0.0673828125, + "gradient_norm": 0.040350593626499176, + "elapsed": 805.6127603054047 + }, + { + "step": 2496, + "loss": 0.505940318107605, + "error": 0.2568359375, + "gradient_norm": 0.05209952965378761, + "elapsed": 810.3740313053131 + }, + { + "step": 2512, + "loss": 0.5528728365898132, + "error": 0.298828125, + "gradient_norm": 0.11757992953062057, + "elapsed": 815.1708807945251 + }, + { + "step": 2528, + "loss": 0.5028313994407654, + "error": 0.2666015625, + "gradient_norm": 0.08823780715465546, + "elapsed": 819.8585045337677 + }, + { + "step": 2544, + "loss": 0.5002262592315674, + "error": 0.2783203125, + "gradient_norm": 0.04888603836297989, + "elapsed": 824.5714073181152 + }, + { + "step": 2560, + "loss": 0.6007894277572632, + "error": 0.328125, + "gradient_norm": 0.05186954140663147, + "elapsed": 829.3080432415009 + }, + { + "step": 2576, + "loss": 0.18641480803489685, + "error": 0.076171875, + "gradient_norm": 0.03799928352236748, + "elapsed": 834.044020652771 + }, + { + "step": 2592, + "loss": 0.3050769865512848, + "error": 0.1396484375, + "gradient_norm": 0.10119257122278214, + "elapsed": 838.8401296138763 + }, + { + "step": 2608, + "loss": 0.6063439846038818, + "error": 0.361328125, + "gradient_norm": 0.04979367554187775, + "elapsed": 844.3572654724121 + }, + { + "step": 2624, + "loss": 0.5751967430114746, + "error": 0.3369140625, + "gradient_norm": 0.04269539937376976, + "elapsed": 849.0660374164581 + }, + { + "step": 2640, + "loss": 0.3902108669281006, + "error": 0.193359375, + "gradient_norm": 0.10029696673154831, + "elapsed": 853.8638062477112 + }, + { + "step": 2656, + "loss": 0.15081660449504852, + "error": 0.0625, + "gradient_norm": 0.0303852129727602, + "elapsed": 858.9793758392334 + }, + { + "step": 2672, + "loss": 0.6503090858459473, + "error": 0.400390625, + "gradient_norm": 0.12611964344978333, + "elapsed": 863.9151141643524 + }, + { + "step": 2688, + "loss": 0.5587317943572998, + "error": 0.31640625, + "gradient_norm": 0.10028114914894104, + "elapsed": 868.7600305080414 + }, + { + "step": 2704, + "loss": 0.4399867355823517, + "error": 0.21484375, + "gradient_norm": 0.06889455020427704, + "elapsed": 873.4544236660004 + }, + { + "step": 2720, + "loss": 0.5865127444267273, + "error": 0.337890625, + "gradient_norm": 0.03671631962060928, + "elapsed": 878.0982644557953 + }, + { + "step": 2736, + "loss": 0.6078637838363647, + "error": 0.3701171875, + "gradient_norm": 0.04679318517446518, + "elapsed": 883.0424642562866 + }, + { + "step": 2752, + "loss": 0.5825340151786804, + "error": 0.337890625, + "gradient_norm": 0.05619681254029274, + "elapsed": 887.908124923706 + }, + { + "step": 2768, + "loss": 0.5970422029495239, + "error": 0.3369140625, + "gradient_norm": 0.041302867233753204, + "elapsed": 892.6760206222534 + }, + { + "step": 2784, + "loss": 0.3870226740837097, + "error": 0.1826171875, + "gradient_norm": 0.05731065198779106, + "elapsed": 897.6246056556702 + }, + { + "step": 2800, + "loss": 0.38130277395248413, + "error": 0.1943359375, + "gradient_norm": 0.059244755655527115, + "elapsed": 902.3360238075256 + }, + { + "step": 2816, + "loss": 0.2617901563644409, + "error": 0.1064453125, + "gradient_norm": 0.041736964136362076, + "elapsed": 907.1600468158722 + }, + { + "step": 2832, + "loss": 0.5819337368011475, + "error": 0.314453125, + "gradient_norm": 0.04097156226634979, + "elapsed": 912.0244295597076 + }, + { + "step": 2848, + "loss": 0.41393283009529114, + "error": 0.2001953125, + "gradient_norm": 0.10456771403551102, + "elapsed": 916.8225846290588 + }, + { + "step": 2864, + "loss": 0.5019145011901855, + "error": 0.2548828125, + "gradient_norm": 0.04843736067414284, + "elapsed": 921.538754940033 + }, + { + "step": 2880, + "loss": 0.04561338573694229, + "error": 0.0146484375, + "gradient_norm": 0.025407327339053154, + "elapsed": 926.2588667869568 + }, + { + "step": 2896, + "loss": 0.4338858723640442, + "error": 0.205078125, + "gradient_norm": 0.09900517761707306, + "elapsed": 930.9781975746155 + }, + { + "step": 2912, + "loss": 0.33922863006591797, + "error": 0.162109375, + "gradient_norm": 0.10189604014158249, + "elapsed": 935.6816267967224 + }, + { + "step": 2928, + "loss": 0.5294322967529297, + "error": 0.2822265625, + "gradient_norm": 0.09060791879892349, + "elapsed": 940.4373068809509 + }, + { + "step": 2944, + "loss": 0.037007369101047516, + "error": 0.01171875, + "gradient_norm": 0.05506489425897598, + "elapsed": 945.1270468235016 + }, + { + "step": 2960, + "loss": 0.6096771359443665, + "error": 0.349609375, + "gradient_norm": 0.04987221211194992, + "elapsed": 949.8300130367279 + }, + { + "step": 2976, + "loss": 0.6157823801040649, + "error": 0.373046875, + "gradient_norm": 0.03614233434200287, + "elapsed": 954.5701997280121 + }, + { + "step": 2992, + "loss": 0.1978239268064499, + "error": 0.080078125, + "gradient_norm": 0.05847112461924553, + "elapsed": 959.2756471633911 + }, + { + "step": 3008, + "loss": 0.5237340927124023, + "error": 0.2841796875, + "gradient_norm": 0.06993591040372849, + "elapsed": 963.9875864982605 + }, + { + "step": 3024, + "loss": 0.4559935927391052, + "error": 0.2373046875, + "gradient_norm": 0.05698448419570923, + "elapsed": 968.7997305393219 + }, + { + "step": 3040, + "loss": 0.5025208592414856, + "error": 0.259765625, + "gradient_norm": 0.14909739792346954, + "elapsed": 973.6042547225952 + }, + { + "step": 3056, + "loss": 0.3223109245300293, + "error": 0.1416015625, + "gradient_norm": 0.032974764704704285, + "elapsed": 978.4760546684265 + }, + { + "step": 3072, + "loss": 0.06682582199573517, + "error": 0.021484375, + "gradient_norm": 0.04433188587427139, + "elapsed": 983.2894048690796 + }, + { + "step": 3088, + "loss": 0.5919550061225891, + "error": 0.34765625, + "gradient_norm": 0.06721373647451401, + "elapsed": 1000.9520287513733 + }, + { + "step": 3104, + "loss": 0.5988063812255859, + "error": 0.3642578125, + "gradient_norm": 0.05654948577284813, + "elapsed": 1005.7442932128906 + }, + { + "step": 3120, + "loss": 0.4922299385070801, + "error": 0.2470703125, + "gradient_norm": 0.07545466721057892, + "elapsed": 1010.4616096019745 + }, + { + "step": 3136, + "loss": 0.4533671736717224, + "error": 0.236328125, + "gradient_norm": 0.06288722902536392, + "elapsed": 1015.3559956550598 + }, + { + "step": 3152, + "loss": 0.5070517063140869, + "error": 0.2666015625, + "gradient_norm": 0.07274917513132095, + "elapsed": 1020.0764343738556 + }, + { + "step": 3168, + "loss": 0.5999464988708496, + "error": 0.3408203125, + "gradient_norm": 0.05777016654610634, + "elapsed": 1024.9410600662231 + }, + { + "step": 3184, + "loss": 0.5758363008499146, + "error": 0.3427734375, + "gradient_norm": 0.051027461886405945, + "elapsed": 1029.7082171440125 + }, + { + "step": 3200, + "loss": 0.05016190931200981, + "error": 0.017578125, + "gradient_norm": 0.009175656363368034, + "elapsed": 1034.3982915878296 + }, + { + "step": 3216, + "loss": 0.5471057295799255, + "error": 0.318359375, + "gradient_norm": 0.07572721689939499, + "elapsed": 1039.117841243744 + }, + { + "step": 3232, + "loss": 0.4141446352005005, + "error": 0.193359375, + "gradient_norm": 0.10056859254837036, + "elapsed": 1043.880026102066 + }, + { + "step": 3248, + "loss": 0.5812438726425171, + "error": 0.3212890625, + "gradient_norm": 0.05781616270542145, + "elapsed": 1048.6406455039978 + }, + { + "step": 3264, + "loss": 0.19184701144695282, + "error": 0.078125, + "gradient_norm": 0.05367236211895943, + "elapsed": 1053.5672237873077 + }, + { + "step": 3280, + "loss": 0.5420833826065063, + "error": 0.28515625, + "gradient_norm": 0.052405405789613724, + "elapsed": 1058.3841104507446 + }, + { + "step": 3296, + "loss": 0.4419598877429962, + "error": 0.2177734375, + "gradient_norm": 0.05814693495631218, + "elapsed": 1063.1880333423615 + }, + { + "step": 3312, + "loss": 0.4525642991065979, + "error": 0.208984375, + "gradient_norm": 0.1061021164059639, + "elapsed": 1068.1370933055878 + }, + { + "step": 3328, + "loss": 0.32664671540260315, + "error": 0.154296875, + "gradient_norm": 0.05649850144982338, + "elapsed": 1073.1963467597961 + }, + { + "step": 3344, + "loss": 0.2655770182609558, + "error": 0.1220703125, + "gradient_norm": 0.04070372134447098, + "elapsed": 1078.2698318958282 + }, + { + "step": 3360, + "loss": 0.5894330739974976, + "error": 0.3544921875, + "gradient_norm": 0.0643400028347969, + "elapsed": 1083.0184152126312 + }, + { + "step": 3376, + "loss": 0.6118791103363037, + "error": 0.361328125, + "gradient_norm": 0.08537904173135757, + "elapsed": 1087.834038734436 + }, + { + "step": 3392, + "loss": 0.40694907307624817, + "error": 0.19921875, + "gradient_norm": 0.11411692947149277, + "elapsed": 1092.8119947910309 + }, + { + "step": 3408, + "loss": 0.04629015550017357, + "error": 0.0146484375, + "gradient_norm": 0.017204072326421738, + "elapsed": 1097.5751783847809 + }, + { + "step": 3424, + "loss": 0.20639702677726746, + "error": 0.0849609375, + "gradient_norm": 0.04801144450902939, + "elapsed": 1102.2970931529999 + }, + { + "step": 3440, + "loss": 0.6051071286201477, + "error": 0.33984375, + "gradient_norm": 0.045392412692308426, + "elapsed": 1107.1080610752106 + }, + { + "step": 3456, + "loss": 0.6553700566291809, + "error": 0.40625, + "gradient_norm": 0.05593863129615784, + "elapsed": 1111.8409752845764 + }, + { + "step": 3472, + "loss": 0.591402530670166, + "error": 0.3515625, + "gradient_norm": 0.051181379705667496, + "elapsed": 1116.5800333023071 + }, + { + "step": 3488, + "loss": 0.30494624376296997, + "error": 0.12109375, + "gradient_norm": 0.05175542086362839, + "elapsed": 1121.276373386383 + }, + { + "step": 3504, + "loss": 0.5065370798110962, + "error": 0.279296875, + "gradient_norm": 0.10419930517673492, + "elapsed": 1125.9883344173431 + }, + { + "step": 3520, + "loss": 0.3915700614452362, + "error": 0.1953125, + "gradient_norm": 0.060416825115680695, + "elapsed": 1130.7958455085754 + }, + { + "step": 3536, + "loss": 0.624374270439148, + "error": 0.3759765625, + "gradient_norm": 0.06069556251168251, + "elapsed": 1135.5360939502716 + }, + { + "step": 3552, + "loss": 0.5830206274986267, + "error": 0.3359375, + "gradient_norm": 0.046013280749320984, + "elapsed": 1140.312029838562 + }, + { + "step": 3568, + "loss": 0.4201379716396332, + "error": 0.2119140625, + "gradient_norm": 0.06909621506929398, + "elapsed": 1145.0904593467712 + }, + { + "step": 3584, + "loss": 0.28215405344963074, + "error": 0.1181640625, + "gradient_norm": 0.07625982910394669, + "elapsed": 1149.8156151771545 + }, + { + "step": 3600, + "loss": 0.5229164361953735, + "error": 0.275390625, + "gradient_norm": 0.055048178881406784, + "elapsed": 1154.5280592441559 + }, + { + "step": 3616, + "loss": 0.47238075733184814, + "error": 0.2314453125, + "gradient_norm": 0.06473162025213242, + "elapsed": 1159.2720873355865 + }, + { + "step": 3632, + "loss": 0.46245503425598145, + "error": 0.228515625, + "gradient_norm": 0.07382887601852417, + "elapsed": 1164.0119998455048 + }, + { + "step": 3648, + "loss": 0.37509745359420776, + "error": 0.171875, + "gradient_norm": 0.051260266453027725, + "elapsed": 1168.7440350055695 + }, + { + "step": 3664, + "loss": 0.1948484629392624, + "error": 0.080078125, + "gradient_norm": 0.059623416513204575, + "elapsed": 1173.3906588554382 + }, + { + "step": 3680, + "loss": 0.5552756786346436, + "error": 0.3115234375, + "gradient_norm": 0.08073585480451584, + "elapsed": 1178.0645008087158 + }, + { + "step": 3696, + "loss": 0.6405904293060303, + "error": 0.39453125, + "gradient_norm": 0.05899551138281822, + "elapsed": 1182.730489730835 + }, + { + "step": 3712, + "loss": 0.2767012119293213, + "error": 0.119140625, + "gradient_norm": 0.06593579798936844, + "elapsed": 1187.377315044403 + }, + { + "step": 3728, + "loss": 0.315812885761261, + "error": 0.134765625, + "gradient_norm": 0.035905495285987854, + "elapsed": 1192.0582301616669 + }, + { + "step": 3744, + "loss": 0.6033951640129089, + "error": 0.3544921875, + "gradient_norm": 0.05226197466254234, + "elapsed": 1196.7101175785065 + }, + { + "step": 3760, + "loss": 0.5202592611312866, + "error": 0.275390625, + "gradient_norm": 0.06367512047290802, + "elapsed": 1201.3543090820312 + }, + { + "step": 3776, + "loss": 0.24639368057250977, + "error": 0.1083984375, + "gradient_norm": 0.09370873868465424, + "elapsed": 1206.0717165470123 + }, + { + "step": 3792, + "loss": 0.6175658702850342, + "error": 0.375, + "gradient_norm": 0.06221585348248482, + "elapsed": 1210.754029750824 + }, + { + "step": 3808, + "loss": 0.41153696179389954, + "error": 0.2119140625, + "gradient_norm": 0.05355365574359894, + "elapsed": 1215.4374370574951 + }, + { + "step": 3824, + "loss": 0.28002214431762695, + "error": 0.1123046875, + "gradient_norm": 0.03846330568194389, + "elapsed": 1220.1207013130188 + }, + { + "step": 3840, + "loss": 0.0484195351600647, + "error": 0.013671875, + "gradient_norm": 0.03470242768526077, + "elapsed": 1224.8153104782104 + }, + { + "step": 3856, + "loss": 0.1407160609960556, + "error": 0.0458984375, + "gradient_norm": 0.04061700031161308, + "elapsed": 1229.5512235164642 + }, + { + "step": 3872, + "loss": 0.5881794691085815, + "error": 0.3427734375, + "gradient_norm": 0.062013477087020874, + "elapsed": 1234.3750183582306 + }, + { + "step": 3888, + "loss": 0.17833612859249115, + "error": 0.06640625, + "gradient_norm": 0.038856204599142075, + "elapsed": 1239.110375881195 + }, + { + "step": 3904, + "loss": 0.06211477518081665, + "error": 0.0224609375, + "gradient_norm": 0.02150108851492405, + "elapsed": 1243.800644159317 + }, + { + "step": 3920, + "loss": 0.06039723381400108, + "error": 0.01953125, + "gradient_norm": 0.019367367029190063, + "elapsed": 1248.4831748008728 + }, + { + "step": 3936, + "loss": 0.6010214686393738, + "error": 0.3525390625, + "gradient_norm": 0.051659151911735535, + "elapsed": 1253.1423478126526 + }, + { + "step": 3952, + "loss": 0.5867137312889099, + "error": 0.3388671875, + "gradient_norm": 0.058528851717710495, + "elapsed": 1257.9799931049347 + }, + { + "step": 3968, + "loss": 0.5231834650039673, + "error": 0.2578125, + "gradient_norm": 0.10128334909677505, + "elapsed": 1262.6990082263947 + }, + { + "step": 3984, + "loss": 0.6251651644706726, + "error": 0.353515625, + "gradient_norm": 0.06211795285344124, + "elapsed": 1267.4289934635162 + }, + { + "step": 4000, + "loss": 0.06667037308216095, + "error": 0.01953125, + "gradient_norm": 0.048018258064985275, + "elapsed": 1272.132089138031 + }, + { + "step": 4016, + "loss": 0.5286938548088074, + "error": 0.2744140625, + "gradient_norm": 0.05509360507130623, + "elapsed": 1276.8878977298737 + }, + { + "step": 4032, + "loss": 0.34016552567481995, + "error": 0.1591796875, + "gradient_norm": 0.07597329467535019, + "elapsed": 1281.7364926338196 + }, + { + "step": 4048, + "loss": 0.17750494182109833, + "error": 0.078125, + "gradient_norm": 0.06314503401517868, + "elapsed": 1286.5033600330353 + }, + { + "step": 4064, + "loss": 0.5882893800735474, + "error": 0.34375, + "gradient_norm": 0.10986580699682236, + "elapsed": 1291.1944887638092 + }, + { + "step": 4080, + "loss": 0.4923543930053711, + "error": 0.2568359375, + "gradient_norm": 0.050325747579336166, + "elapsed": 1295.9372322559357 + }, + { + "step": 4096, + "loss": 0.44146978855133057, + "error": 0.2236328125, + "gradient_norm": 0.06535191088914871, + "elapsed": 1300.641023159027 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 1024, + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "1024": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 804757, + "weights": "weights-1024.npz", + "weights_sha256": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "validation": "validation-1024.json", + "complete": true + }, + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "ff4595e8f3eb7cfaa8da5a58a31e106d9684c7b8437f330573a1291f19f5777a", + "complete": true + } + }, + "selection": "Predefined last-three and all-four noninitial temporal2 checkpoint means; every validation condition evaluated before group selection", + "test_data_used": false, + "derivation_source_sha256": "b68813c7dab697a554185020c430ef05f1c35bedcda5b85b7d165af75461e914" + }, + "training_source_snapshot": "training_sources/temporal2_swa", + "selected_checkpoint_steps": [ + "mean3" + ], + "checkpoint_records": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.2445763221153846, + "mean3": 0.24451622596153846, + "mean4": 0.24484675480769236, + "blend-mean3": 0.24570312499999997, + "blend-mean4": 0.24591346153846153 + }, + "selected": "mean3" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2528545673076923, + "mean3": 0.25321514423076924, + "mean4": 0.2538611778846154, + "blend-mean3": 0.25310997596153845, + "blend-mean4": 0.2530498798076923 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23366887019230773, + "mean3": 0.23392427884615385, + "mean4": 0.234375, + "blend-mean3": 0.2338792067307692, + "blend-mean4": 0.23404447115384613 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23886718750000002, + "mean3": 0.23937800480769234, + "mean4": 0.2393780048076923, + "blend-mean3": 0.23942307692307693, + "blend-mean4": 0.2392578125 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24463641826923077, + "mean3": 0.24471153846153845, + "mean4": 0.24505709134615386, + "blend-mean3": 0.24580829326923076, + "blend-mean4": 0.2457782451923077 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23652343749999996, + "mean3": 0.2379957932692308, + "mean4": 0.23756009615384613, + "blend-mean3": 0.23751502403846153, + "blend-mean4": 0.23737980769230768 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23562199519230764, + "mean3": 0.23643329326923077, + "mean4": 0.2361177884615384, + "blend-mean3": 0.23662860576923078, + "blend-mean4": 0.23634314903846157 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.2329627403846154, + "mean3": 0.2335186298076923, + "mean4": 0.23344350961538457, + "blend-mean3": 0.23333834134615383, + "blend-mean4": 0.2334134615384615 + }, + "selected": "incumbent" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2325420673076923 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "condition_same1", + "training_run": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_accumulate_train.py": "9f672468a8b72966b3aa04fd22e5d40b47b0768f1c802c267a1da08244c4323b", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 803777, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 11639, + "surface_code_bX_d3_r03_center_3_5": 10232, + "surface_code_bX_d3_r05_center_3_5": 9180, + "surface_code_bX_d3_r07_center_3_5": 10239, + "surface_code_bX_d3_r09_center_3_5": 6051, + "surface_code_bX_d3_r11_center_3_5": 8012, + "surface_code_bX_d3_r13_center_3_5": 6713, + "surface_code_bX_d3_r15_center_3_5": 6022, + "surface_code_bX_d3_r17_center_3_5": 7425, + "surface_code_bX_d3_r19_center_3_5": 8635, + "surface_code_bX_d3_r21_center_3_5": 10217, + "surface_code_bX_d3_r23_center_3_5": 6026, + "surface_code_bX_d3_r25_center_3_5": 4490, + "surface_code_bX_d3_r01_center_5_3": 7371, + "surface_code_bX_d3_r03_center_5_3": 5992, + "surface_code_bX_d3_r05_center_5_3": 6712, + "surface_code_bX_d3_r07_center_5_3": 6716, + "surface_code_bX_d3_r09_center_5_3": 7941, + "surface_code_bX_d3_r11_center_5_3": 6001, + "surface_code_bX_d3_r13_center_5_3": 8037, + "surface_code_bX_d3_r15_center_5_3": 8542, + "surface_code_bX_d3_r17_center_5_3": 10153, + "surface_code_bX_d3_r19_center_5_3": 10675, + "surface_code_bX_d3_r21_center_5_3": 7993, + "surface_code_bX_d3_r23_center_5_3": 6652, + "surface_code_bX_d3_r25_center_5_3": 8608, + "surface_code_bX_d3_r01_center_5_7": 8590, + "surface_code_bX_d3_r03_center_5_7": 11633, + "surface_code_bX_d3_r05_center_5_7": 8588, + "surface_code_bX_d3_r07_center_5_7": 10695, + "surface_code_bX_d3_r09_center_5_7": 7964, + "surface_code_bX_d3_r11_center_5_7": 11658, + "surface_code_bX_d3_r13_center_5_7": 6021, + "surface_code_bX_d3_r15_center_5_7": 9727, + "surface_code_bX_d3_r17_center_5_7": 4526, + "surface_code_bX_d3_r19_center_5_7": 9642, + "surface_code_bX_d3_r21_center_5_7": 3708, + "surface_code_bX_d3_r23_center_5_7": 6687, + "surface_code_bX_d3_r25_center_5_7": 7972, + "surface_code_bX_d3_r01_center_7_5": 6757, + "surface_code_bX_d3_r03_center_7_5": 6726, + "surface_code_bX_d3_r05_center_7_5": 4504, + "surface_code_bX_d3_r07_center_7_5": 8034, + "surface_code_bX_d3_r09_center_7_5": 8633, + "surface_code_bX_d3_r11_center_7_5": 11109, + "surface_code_bX_d3_r13_center_7_5": 9695, + "surface_code_bX_d3_r15_center_7_5": 7370, + "surface_code_bX_d3_r17_center_7_5": 7323, + "surface_code_bX_d3_r19_center_7_5": 10247, + "surface_code_bX_d3_r21_center_7_5": 6718, + "surface_code_bX_d3_r23_center_7_5": 8064, + "surface_code_bX_d3_r25_center_7_5": 8018, + "surface_code_bZ_d3_r01_center_3_5": 2856, + "surface_code_bZ_d3_r03_center_3_5": 6780, + "surface_code_bZ_d3_r05_center_3_5": 8610, + "surface_code_bZ_d3_r07_center_3_5": 9152, + "surface_code_bZ_d3_r09_center_3_5": 4522, + "surface_code_bZ_d3_r11_center_3_5": 3703, + "surface_code_bZ_d3_r13_center_3_5": 6001, + "surface_code_bZ_d3_r15_center_3_5": 7377, + "surface_code_bZ_d3_r17_center_3_5": 4517, + "surface_code_bZ_d3_r19_center_3_5": 10242, + "surface_code_bZ_d3_r21_center_3_5": 6747, + "surface_code_bZ_d3_r23_center_3_5": 7422, + "surface_code_bZ_d3_r25_center_3_5": 10606, + "surface_code_bZ_d3_r01_center_5_3": 5272, + "surface_code_bZ_d3_r03_center_5_3": 11200, + "surface_code_bZ_d3_r05_center_5_3": 4514, + "surface_code_bZ_d3_r07_center_5_3": 8002, + "surface_code_bZ_d3_r09_center_5_3": 8008, + "surface_code_bZ_d3_r11_center_5_3": 8689, + "surface_code_bZ_d3_r13_center_5_3": 8604, + "surface_code_bZ_d3_r15_center_5_3": 5981, + "surface_code_bZ_d3_r17_center_5_3": 5307, + "surface_code_bZ_d3_r19_center_5_3": 6713, + "surface_code_bZ_d3_r21_center_5_3": 8570, + "surface_code_bZ_d3_r23_center_5_3": 6700, + "surface_code_bZ_d3_r25_center_5_3": 10199, + "surface_code_bZ_d3_r01_center_5_7": 6730, + "surface_code_bZ_d3_r03_center_5_7": 7959, + "surface_code_bZ_d3_r05_center_5_7": 9741, + "surface_code_bZ_d3_r07_center_5_7": 10727, + "surface_code_bZ_d3_r09_center_5_7": 11979, + "surface_code_bZ_d3_r11_center_5_7": 3694, + "surface_code_bZ_d3_r13_center_5_7": 6746, + "surface_code_bZ_d3_r15_center_5_7": 6686, + "surface_code_bZ_d3_r17_center_5_7": 10647, + "surface_code_bZ_d3_r19_center_5_7": 8011, + "surface_code_bZ_d3_r21_center_5_7": 6000, + "surface_code_bZ_d3_r23_center_5_7": 9176, + "surface_code_bZ_d3_r25_center_5_7": 6009, + "surface_code_bZ_d3_r01_center_7_5": 9076, + "surface_code_bZ_d3_r03_center_7_5": 9182, + "surface_code_bZ_d3_r05_center_7_5": 6769, + "surface_code_bZ_d3_r07_center_7_5": 11140, + "surface_code_bZ_d3_r09_center_7_5": 7359, + "surface_code_bZ_d3_r11_center_7_5": 8582, + "surface_code_bZ_d3_r13_center_7_5": 5284, + "surface_code_bZ_d3_r15_center_7_5": 6694, + "surface_code_bZ_d3_r17_center_7_5": 5965, + "surface_code_bZ_d3_r19_center_7_5": 6016, + "surface_code_bZ_d3_r21_center_7_5": 9225, + "surface_code_bZ_d3_r23_center_7_5": 4509, + "surface_code_bZ_d3_r25_center_7_5": 6694 + }, + "steps": 1024, + "batch_size": 256, + "accumulate_conditions": 4, + "effective_batch_size": 1024, + "condition_policy": "same", + "training_draws": 1048576, + "condition_sampling": "Draw one condition index per microbatch in both arms; same-condition control reuses the first index while mixed arm uses all indices. Both arms consume identical RNG draws with equal-sized condition pools.", + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.00025, + "sampling_seed": 20261190, + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": true, + "explicit_rng_reset": true, + "sampling_state_source": "Fresh NumPy default_rng seed 20261190", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal2_swa/weights-mean3.npz", + "starting_checkpoint_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "starting_training_provenance": { + "initialization": "Uniform averages of the same session-trained temporal trajectory; no external weights", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_train.py": "7d48d2fc7f62d0bec3023b3df1c2ac28537d0417966131ae3a156697a34cda5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 1778773, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18357, + "surface_code_bX_d3_r03_center_3_5": 16816, + "surface_code_bX_d3_r05_center_3_5": 17999, + "surface_code_bX_d3_r07_center_3_5": 15225, + "surface_code_bX_d3_r09_center_3_5": 16132, + "surface_code_bX_d3_r11_center_3_5": 17041, + "surface_code_bX_d3_r13_center_3_5": 18477, + "surface_code_bX_d3_r15_center_3_5": 18214, + "surface_code_bX_d3_r17_center_3_5": 16505, + "surface_code_bX_d3_r19_center_3_5": 17120, + "surface_code_bX_d3_r21_center_3_5": 17563, + "surface_code_bX_d3_r23_center_3_5": 16681, + "surface_code_bX_d3_r25_center_3_5": 18379, + "surface_code_bX_d3_r01_center_5_3": 17450, + "surface_code_bX_d3_r03_center_5_3": 17161, + "surface_code_bX_d3_r05_center_5_3": 15797, + "surface_code_bX_d3_r07_center_5_3": 17800, + "surface_code_bX_d3_r09_center_5_3": 17190, + "surface_code_bX_d3_r11_center_5_3": 15840, + "surface_code_bX_d3_r13_center_5_3": 15178, + "surface_code_bX_d3_r15_center_5_3": 14897, + "surface_code_bX_d3_r17_center_5_3": 18252, + "surface_code_bX_d3_r19_center_5_3": 17083, + "surface_code_bX_d3_r21_center_5_3": 17229, + "surface_code_bX_d3_r23_center_5_3": 14735, + "surface_code_bX_d3_r25_center_5_3": 17949, + "surface_code_bX_d3_r01_center_5_7": 17431, + "surface_code_bX_d3_r03_center_5_7": 16583, + "surface_code_bX_d3_r05_center_5_7": 16891, + "surface_code_bX_d3_r07_center_5_7": 17969, + "surface_code_bX_d3_r09_center_5_7": 17966, + "surface_code_bX_d3_r11_center_5_7": 14424, + "surface_code_bX_d3_r13_center_5_7": 16930, + "surface_code_bX_d3_r15_center_5_7": 15205, + "surface_code_bX_d3_r17_center_5_7": 18252, + "surface_code_bX_d3_r19_center_5_7": 17077, + "surface_code_bX_d3_r21_center_5_7": 16770, + "surface_code_bX_d3_r23_center_5_7": 17308, + "surface_code_bX_d3_r25_center_5_7": 17481, + "surface_code_bX_d3_r01_center_7_5": 16630, + "surface_code_bX_d3_r03_center_7_5": 17439, + "surface_code_bX_d3_r05_center_7_5": 15811, + "surface_code_bX_d3_r07_center_7_5": 16637, + "surface_code_bX_d3_r09_center_7_5": 18306, + "surface_code_bX_d3_r11_center_7_5": 18327, + "surface_code_bX_d3_r13_center_7_5": 17974, + "surface_code_bX_d3_r15_center_7_5": 16106, + "surface_code_bX_d3_r17_center_7_5": 15834, + "surface_code_bX_d3_r19_center_7_5": 17242, + "surface_code_bX_d3_r21_center_7_5": 17889, + "surface_code_bX_d3_r23_center_7_5": 17440, + "surface_code_bX_d3_r25_center_7_5": 17087, + "surface_code_bZ_d3_r01_center_3_5": 16236, + "surface_code_bZ_d3_r03_center_3_5": 17278, + "surface_code_bZ_d3_r05_center_3_5": 16577, + "surface_code_bZ_d3_r07_center_3_5": 17376, + "surface_code_bZ_d3_r09_center_3_5": 16000, + "surface_code_bZ_d3_r11_center_3_5": 15634, + "surface_code_bZ_d3_r13_center_3_5": 14950, + "surface_code_bZ_d3_r15_center_3_5": 16600, + "surface_code_bZ_d3_r17_center_3_5": 15381, + "surface_code_bZ_d3_r19_center_3_5": 16823, + "surface_code_bZ_d3_r21_center_3_5": 18789, + "surface_code_bZ_d3_r23_center_3_5": 15616, + "surface_code_bZ_d3_r25_center_3_5": 17088, + "surface_code_bZ_d3_r01_center_5_3": 17935, + "surface_code_bZ_d3_r03_center_5_3": 16256, + "surface_code_bZ_d3_r05_center_5_3": 17959, + "surface_code_bZ_d3_r07_center_5_3": 18401, + "surface_code_bZ_d3_r09_center_5_3": 16405, + "surface_code_bZ_d3_r11_center_5_3": 17274, + "surface_code_bZ_d3_r13_center_5_3": 18172, + "surface_code_bZ_d3_r15_center_5_3": 17525, + "surface_code_bZ_d3_r17_center_5_3": 18643, + "surface_code_bZ_d3_r19_center_5_3": 17816, + "surface_code_bZ_d3_r21_center_5_3": 17404, + "surface_code_bZ_d3_r23_center_5_3": 17253, + "surface_code_bZ_d3_r25_center_5_3": 17667, + "surface_code_bZ_d3_r01_center_5_7": 16203, + "surface_code_bZ_d3_r03_center_5_7": 17214, + "surface_code_bZ_d3_r05_center_5_7": 16799, + "surface_code_bZ_d3_r07_center_5_7": 17896, + "surface_code_bZ_d3_r09_center_5_7": 16411, + "surface_code_bZ_d3_r11_center_5_7": 17726, + "surface_code_bZ_d3_r13_center_5_7": 16313, + "surface_code_bZ_d3_r15_center_5_7": 17824, + "surface_code_bZ_d3_r17_center_5_7": 15656, + "surface_code_bZ_d3_r19_center_5_7": 17169, + "surface_code_bZ_d3_r21_center_5_7": 17194, + "surface_code_bZ_d3_r23_center_5_7": 16779, + "surface_code_bZ_d3_r25_center_5_7": 16970, + "surface_code_bZ_d3_r01_center_7_5": 16762, + "surface_code_bZ_d3_r03_center_7_5": 17320, + "surface_code_bZ_d3_r05_center_7_5": 17522, + "surface_code_bZ_d3_r07_center_7_5": 17914, + "surface_code_bZ_d3_r09_center_7_5": 18439, + "surface_code_bZ_d3_r11_center_7_5": 18218, + "surface_code_bZ_d3_r13_center_7_5": 17907, + "surface_code_bZ_d3_r15_center_7_5": 17597, + "surface_code_bZ_d3_r17_center_7_5": 18252, + "surface_code_bZ_d3_r19_center_7_5": 18379, + "surface_code_bZ_d3_r21_center_7_5": 16818, + "surface_code_bZ_d3_r23_center_7_5": 18430, + "surface_code_bZ_d3_r25_center_7_5": 17924 + }, + "steps": 4096, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.0005, + "sampling_seed": 20261121, + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_exact/temporal1/rng-2048.json", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal1/weights-2048.npz", + "starting_checkpoint_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "starting_training_provenance": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.250907301902771, + "error": 0.1083984375, + "gradient_norm": 0.07171476632356644, + "elapsed": 44.811134576797485 + }, + { + "step": 16, + "loss": 0.5958679914474487, + "error": 0.3662109375, + "gradient_norm": 0.07673005014657974, + "elapsed": 49.90856671333313 + }, + { + "step": 32, + "loss": 0.47648972272872925, + "error": 0.2421875, + "gradient_norm": 0.08561501652002335, + "elapsed": 55.179388761520386 + }, + { + "step": 48, + "loss": 0.06145006790757179, + "error": 0.0234375, + "gradient_norm": 0.01556467730551958, + "elapsed": 61.0339195728302 + }, + { + "step": 64, + "loss": 0.3687053918838501, + "error": 0.1884765625, + "gradient_norm": 0.08752371370792389, + "elapsed": 65.95811891555786 + }, + { + "step": 80, + "loss": 0.6481984853744507, + "error": 0.4140625, + "gradient_norm": 0.05311283841729164, + "elapsed": 70.56021332740784 + }, + { + "step": 96, + "loss": 0.42319929599761963, + "error": 0.2138671875, + "gradient_norm": 0.05047478526830673, + "elapsed": 75.11613631248474 + }, + { + "step": 112, + "loss": 0.47527259588241577, + "error": 0.24609375, + "gradient_norm": 0.038366906344890594, + "elapsed": 79.53446984291077 + }, + { + "step": 128, + "loss": 0.5996723175048828, + "error": 0.3369140625, + "gradient_norm": 0.1213272362947464, + "elapsed": 83.97515749931335 + }, + { + "step": 144, + "loss": 0.04971993714570999, + "error": 0.0146484375, + "gradient_norm": 0.008080735802650452, + "elapsed": 88.44039463996887 + }, + { + "step": 160, + "loss": 0.35900360345840454, + "error": 0.162109375, + "gradient_norm": 0.03359593451023102, + "elapsed": 92.89548206329346 + }, + { + "step": 176, + "loss": 0.5342063903808594, + "error": 0.2978515625, + "gradient_norm": 0.04794691130518913, + "elapsed": 97.35658049583435 + }, + { + "step": 192, + "loss": 0.6300076246261597, + "error": 0.369140625, + "gradient_norm": 0.081769198179245, + "elapsed": 101.81493759155273 + }, + { + "step": 208, + "loss": 0.6191903948783875, + "error": 0.3828125, + "gradient_norm": 0.07145775109529495, + "elapsed": 106.2480263710022 + }, + { + "step": 224, + "loss": 0.5155678391456604, + "error": 0.28515625, + "gradient_norm": 0.06772179156541824, + "elapsed": 110.71284222602844 + }, + { + "step": 240, + "loss": 0.634708046913147, + "error": 0.3857421875, + "gradient_norm": 0.09493093192577362, + "elapsed": 115.14978742599487 + }, + { + "step": 256, + "loss": 0.1840895414352417, + "error": 0.0751953125, + "gradient_norm": 0.025586696341633797, + "elapsed": 119.61202120780945 + }, + { + "step": 272, + "loss": 0.2775103449821472, + "error": 0.12890625, + "gradient_norm": 0.06913147866725922, + "elapsed": 124.02584528923035 + }, + { + "step": 288, + "loss": 0.6163080334663391, + "error": 0.3642578125, + "gradient_norm": 0.05895426496863365, + "elapsed": 128.46512532234192 + }, + { + "step": 304, + "loss": 0.5276986360549927, + "error": 0.287109375, + "gradient_norm": 0.06955187022686005, + "elapsed": 132.89240765571594 + }, + { + "step": 320, + "loss": 0.44859516620635986, + "error": 0.22265625, + "gradient_norm": 0.07272452116012573, + "elapsed": 137.32864713668823 + }, + { + "step": 336, + "loss": 0.48315611481666565, + "error": 0.2626953125, + "gradient_norm": 0.03321139141917229, + "elapsed": 141.80009770393372 + }, + { + "step": 352, + "loss": 0.6107717752456665, + "error": 0.3544921875, + "gradient_norm": 0.05243214592337608, + "elapsed": 146.36439752578735 + }, + { + "step": 368, + "loss": 0.6215153932571411, + "error": 0.357421875, + "gradient_norm": 0.04383325204253197, + "elapsed": 150.99996852874756 + }, + { + "step": 384, + "loss": 0.6130329966545105, + "error": 0.35546875, + "gradient_norm": 0.04113119840621948, + "elapsed": 155.62374639511108 + }, + { + "step": 400, + "loss": 0.30471885204315186, + "error": 0.142578125, + "gradient_norm": 0.04447556659579277, + "elapsed": 160.17594957351685 + }, + { + "step": 416, + "loss": 0.6154489517211914, + "error": 0.37109375, + "gradient_norm": 0.04456057772040367, + "elapsed": 164.7639675140381 + }, + { + "step": 432, + "loss": 0.6134694218635559, + "error": 0.337890625, + "gradient_norm": 0.04219559207558632, + "elapsed": 169.32792139053345 + }, + { + "step": 448, + "loss": 0.5463185906410217, + "error": 0.2939453125, + "gradient_norm": 0.07746092975139618, + "elapsed": 173.88445162773132 + }, + { + "step": 464, + "loss": 0.06016772612929344, + "error": 0.01953125, + "gradient_norm": 0.01364185381680727, + "elapsed": 178.42725706100464 + }, + { + "step": 480, + "loss": 0.388141393661499, + "error": 0.18359375, + "gradient_norm": 0.04870256036520004, + "elapsed": 182.99062085151672 + }, + { + "step": 496, + "loss": 0.44524821639060974, + "error": 0.2216796875, + "gradient_norm": 0.03453445807099342, + "elapsed": 187.56396961212158 + }, + { + "step": 512, + "loss": 0.34312355518341064, + "error": 0.154296875, + "gradient_norm": 0.06794509291648865, + "elapsed": 192.27511191368103 + }, + { + "step": 528, + "loss": 0.19467462599277496, + "error": 0.0771484375, + "gradient_norm": 0.042381469160318375, + "elapsed": 197.7108268737793 + }, + { + "step": 544, + "loss": 0.46226584911346436, + "error": 0.2421875, + "gradient_norm": 0.06073570251464844, + "elapsed": 202.97405791282654 + }, + { + "step": 560, + "loss": 0.525318443775177, + "error": 0.2822265625, + "gradient_norm": 0.06954885274171829, + "elapsed": 208.69676971435547 + }, + { + "step": 576, + "loss": 0.6158387064933777, + "error": 0.349609375, + "gradient_norm": 0.07587578892707825, + "elapsed": 214.80397653579712 + }, + { + "step": 592, + "loss": 0.5515886545181274, + "error": 0.298828125, + "gradient_norm": 0.04969338700175285, + "elapsed": 220.27399611473083 + }, + { + "step": 608, + "loss": 0.18365338444709778, + "error": 0.0654296875, + "gradient_norm": 0.08657706528902054, + "elapsed": 224.81246256828308 + }, + { + "step": 624, + "loss": 0.4578855633735657, + "error": 0.2421875, + "gradient_norm": 0.04942100867629051, + "elapsed": 229.45902252197266 + }, + { + "step": 640, + "loss": 0.37826013565063477, + "error": 0.1865234375, + "gradient_norm": 0.047499872744083405, + "elapsed": 233.9695644378662 + }, + { + "step": 656, + "loss": 0.40863412618637085, + "error": 0.2001953125, + "gradient_norm": 0.07845330238342285, + "elapsed": 238.584894657135 + }, + { + "step": 672, + "loss": 0.5640332698822021, + "error": 0.2880859375, + "gradient_norm": 0.057469289749860764, + "elapsed": 243.0929844379425 + }, + { + "step": 688, + "loss": 0.030216243118047714, + "error": 0.0078125, + "gradient_norm": 0.04682641476392746, + "elapsed": 247.581125497818 + }, + { + "step": 704, + "loss": 0.375002384185791, + "error": 0.1826171875, + "gradient_norm": 0.04864194989204407, + "elapsed": 252.1564691066742 + }, + { + "step": 720, + "loss": 0.5145515203475952, + "error": 0.2744140625, + "gradient_norm": 0.052671682089567184, + "elapsed": 256.6466488838196 + }, + { + "step": 736, + "loss": 0.067174531519413, + "error": 0.0224609375, + "gradient_norm": 0.019299577921628952, + "elapsed": 261.1185076236725 + }, + { + "step": 752, + "loss": 0.24909992516040802, + "error": 0.111328125, + "gradient_norm": 0.06907463818788528, + "elapsed": 265.61960339546204 + }, + { + "step": 768, + "loss": 0.5088074207305908, + "error": 0.2744140625, + "gradient_norm": 0.06963017582893372, + "elapsed": 270.07474064826965 + }, + { + "step": 784, + "loss": 0.3783387839794159, + "error": 0.1826171875, + "gradient_norm": 0.05537794530391693, + "elapsed": 274.52722239494324 + }, + { + "step": 800, + "loss": 0.6107200980186462, + "error": 0.3623046875, + "gradient_norm": 0.0470259003341198, + "elapsed": 279.0401859283447 + }, + { + "step": 816, + "loss": 0.5778236389160156, + "error": 0.3212890625, + "gradient_norm": 0.10146680474281311, + "elapsed": 283.5114622116089 + }, + { + "step": 832, + "loss": 0.576002299785614, + "error": 0.3076171875, + "gradient_norm": 0.07760787010192871, + "elapsed": 288.04797434806824 + }, + { + "step": 848, + "loss": 0.6179666519165039, + "error": 0.3740234375, + "gradient_norm": 0.07383852452039719, + "elapsed": 292.60600209236145 + }, + { + "step": 864, + "loss": 0.3105512857437134, + "error": 0.1455078125, + "gradient_norm": 0.052953749895095825, + "elapsed": 297.12180352211 + }, + { + "step": 880, + "loss": 0.4802623987197876, + "error": 0.2548828125, + "gradient_norm": 0.07736275345087051, + "elapsed": 301.6091134548187 + }, + { + "step": 896, + "loss": 0.5572722554206848, + "error": 0.318359375, + "gradient_norm": 0.053303152322769165, + "elapsed": 306.1978073120117 + }, + { + "step": 912, + "loss": 0.34814420342445374, + "error": 0.1669921875, + "gradient_norm": 0.037726350128650665, + "elapsed": 310.78571581840515 + }, + { + "step": 928, + "loss": 0.41743016242980957, + "error": 0.21875, + "gradient_norm": 0.05238872766494751, + "elapsed": 315.24156188964844 + }, + { + "step": 944, + "loss": 0.5757850408554077, + "error": 0.3173828125, + "gradient_norm": 0.05837905779480934, + "elapsed": 319.78475165367126 + }, + { + "step": 960, + "loss": 0.40727972984313965, + "error": 0.197265625, + "gradient_norm": 0.059294261038303375, + "elapsed": 324.2090265750885 + }, + { + "step": 976, + "loss": 0.32715001702308655, + "error": 0.1533203125, + "gradient_norm": 0.11543179303407669, + "elapsed": 328.6462152004242 + }, + { + "step": 992, + "loss": 0.5578742623329163, + "error": 0.314453125, + "gradient_norm": 0.06282714009284973, + "elapsed": 333.0712504386902 + }, + { + "step": 1008, + "loss": 0.5052692294120789, + "error": 0.265625, + "gradient_norm": 0.04039420187473297, + "elapsed": 337.5182821750641 + }, + { + "step": 1024, + "loss": 0.18790806829929352, + "error": 0.08203125, + "gradient_norm": 0.028905188664793968, + "elapsed": 342.08340406417847 + }, + { + "step": 1040, + "loss": 0.6317684650421143, + "error": 0.3681640625, + "gradient_norm": 0.03441835194826126, + "elapsed": 358.8279616832733 + }, + { + "step": 1056, + "loss": 0.40474164485931396, + "error": 0.2021484375, + "gradient_norm": 0.036449309438467026, + "elapsed": 363.30218267440796 + }, + { + "step": 1072, + "loss": 0.518299400806427, + "error": 0.2666015625, + "gradient_norm": 0.0886964276432991, + "elapsed": 367.87997555732727 + }, + { + "step": 1088, + "loss": 0.2522922158241272, + "error": 0.099609375, + "gradient_norm": 0.07553310692310333, + "elapsed": 372.4414882659912 + }, + { + "step": 1104, + "loss": 0.6214810609817505, + "error": 0.3701171875, + "gradient_norm": 0.10188957303762436, + "elapsed": 376.9120502471924 + }, + { + "step": 1120, + "loss": 0.6307054162025452, + "error": 0.3720703125, + "gradient_norm": 0.07353860139846802, + "elapsed": 381.3824534416199 + }, + { + "step": 1136, + "loss": 0.5259381532669067, + "error": 0.2763671875, + "gradient_norm": 0.05779678374528885, + "elapsed": 385.8413143157959 + }, + { + "step": 1152, + "loss": 0.4995541572570801, + "error": 0.259765625, + "gradient_norm": 0.046648140996694565, + "elapsed": 390.28326058387756 + }, + { + "step": 1168, + "loss": 0.6075694561004639, + "error": 0.3701171875, + "gradient_norm": 0.10612073540687561, + "elapsed": 394.8162364959717 + }, + { + "step": 1184, + "loss": 0.2105136513710022, + "error": 0.080078125, + "gradient_norm": 0.0716402605175972, + "elapsed": 399.2960283756256 + }, + { + "step": 1200, + "loss": 0.6371631026268005, + "error": 0.3857421875, + "gradient_norm": 0.0549108125269413, + "elapsed": 403.7899103164673 + }, + { + "step": 1216, + "loss": 0.5450670719146729, + "error": 0.2939453125, + "gradient_norm": 0.11688558012247086, + "elapsed": 408.34677600860596 + }, + { + "step": 1232, + "loss": 0.035783201456069946, + "error": 0.01171875, + "gradient_norm": 0.02951689623296261, + "elapsed": 412.8558337688446 + }, + { + "step": 1248, + "loss": 0.5582903623580933, + "error": 0.3046875, + "gradient_norm": 0.055107031017541885, + "elapsed": 417.29854226112366 + }, + { + "step": 1264, + "loss": 0.5154441595077515, + "error": 0.27734375, + "gradient_norm": 0.04474929720163345, + "elapsed": 421.7792055606842 + }, + { + "step": 1280, + "loss": 0.35227546095848083, + "error": 0.16015625, + "gradient_norm": 0.05024837702512741, + "elapsed": 426.54427456855774 + }, + { + "step": 1296, + "loss": 0.19417589902877808, + "error": 0.0830078125, + "gradient_norm": 0.026926057413220406, + "elapsed": 431.320588350296 + }, + { + "step": 1312, + "loss": 0.4768218398094177, + "error": 0.248046875, + "gradient_norm": 0.15099607408046722, + "elapsed": 435.96817326545715 + }, + { + "step": 1328, + "loss": 0.48580923676490784, + "error": 0.2509765625, + "gradient_norm": 0.08925126492977142, + "elapsed": 440.64917039871216 + }, + { + "step": 1344, + "loss": 0.42041274905204773, + "error": 0.1982421875, + "gradient_norm": 0.08321093022823334, + "elapsed": 445.34370946884155 + }, + { + "step": 1360, + "loss": 0.06403929740190506, + "error": 0.0185546875, + "gradient_norm": 0.03817005455493927, + "elapsed": 449.98669385910034 + }, + { + "step": 1376, + "loss": 0.463126003742218, + "error": 0.2275390625, + "gradient_norm": 0.08894515782594681, + "elapsed": 454.6478977203369 + }, + { + "step": 1392, + "loss": 0.5995306968688965, + "error": 0.373046875, + "gradient_norm": 0.06733685731887817, + "elapsed": 459.35924530029297 + }, + { + "step": 1408, + "loss": 0.49053263664245605, + "error": 0.25, + "gradient_norm": 0.10475508868694305, + "elapsed": 464.100093126297 + }, + { + "step": 1424, + "loss": 0.6220744848251343, + "error": 0.3818359375, + "gradient_norm": 0.03653963655233383, + "elapsed": 468.89601135253906 + }, + { + "step": 1440, + "loss": 0.39706122875213623, + "error": 0.2021484375, + "gradient_norm": 0.04344598576426506, + "elapsed": 474.03999519348145 + }, + { + "step": 1456, + "loss": 0.5386708974838257, + "error": 0.3095703125, + "gradient_norm": 0.12589037418365479, + "elapsed": 478.8600504398346 + }, + { + "step": 1472, + "loss": 0.49776726961135864, + "error": 0.271484375, + "gradient_norm": 0.058137863874435425, + "elapsed": 483.5920066833496 + }, + { + "step": 1488, + "loss": 0.4757428765296936, + "error": 0.2412109375, + "gradient_norm": 0.050453316420316696, + "elapsed": 488.4611999988556 + }, + { + "step": 1504, + "loss": 0.5694847702980042, + "error": 0.337890625, + "gradient_norm": 0.052419569343328476, + "elapsed": 493.26151037216187 + }, + { + "step": 1520, + "loss": 0.5997745990753174, + "error": 0.3603515625, + "gradient_norm": 0.04338108375668526, + "elapsed": 498.0421245098114 + }, + { + "step": 1536, + "loss": 0.6195274591445923, + "error": 0.3876953125, + "gradient_norm": 0.04848463833332062, + "elapsed": 502.8808298110962 + }, + { + "step": 1552, + "loss": 0.46315908432006836, + "error": 0.2353515625, + "gradient_norm": 0.06380566209554672, + "elapsed": 507.5519721508026 + }, + { + "step": 1568, + "loss": 0.605262041091919, + "error": 0.36328125, + "gradient_norm": 0.05077619478106499, + "elapsed": 512.457685470581 + }, + { + "step": 1584, + "loss": 0.48782041668891907, + "error": 0.232421875, + "gradient_norm": 0.09017211943864822, + "elapsed": 517.2960062026978 + }, + { + "step": 1600, + "loss": 0.3881351947784424, + "error": 0.1875, + "gradient_norm": 0.07205695658922195, + "elapsed": 522.0911631584167 + }, + { + "step": 1616, + "loss": 0.4966873526573181, + "error": 0.24609375, + "gradient_norm": 0.0582038015127182, + "elapsed": 526.8861901760101 + }, + { + "step": 1632, + "loss": 0.5844199657440186, + "error": 0.33203125, + "gradient_norm": 0.05101500824093819, + "elapsed": 531.6640138626099 + }, + { + "step": 1648, + "loss": 0.31010180711746216, + "error": 0.1318359375, + "gradient_norm": 0.053135693073272705, + "elapsed": 536.4960391521454 + }, + { + "step": 1664, + "loss": 0.6174807548522949, + "error": 0.3779296875, + "gradient_norm": 0.04161194711923599, + "elapsed": 541.2560484409332 + }, + { + "step": 1680, + "loss": 0.18213607370853424, + "error": 0.0751953125, + "gradient_norm": 0.07171957194805145, + "elapsed": 546.0000085830688 + }, + { + "step": 1696, + "loss": 0.5445692539215088, + "error": 0.2998046875, + "gradient_norm": 0.054499462246894836, + "elapsed": 551.1221191883087 + }, + { + "step": 1712, + "loss": 0.05744167044758797, + "error": 0.017578125, + "gradient_norm": 0.013108699582517147, + "elapsed": 556.5286149978638 + }, + { + "step": 1728, + "loss": 0.6381571292877197, + "error": 0.3896484375, + "gradient_norm": 0.05157556012272835, + "elapsed": 561.8000066280365 + }, + { + "step": 1744, + "loss": 0.5301004648208618, + "error": 0.28125, + "gradient_norm": 0.04218568280339241, + "elapsed": 567.2760035991669 + }, + { + "step": 1760, + "loss": 0.5275102257728577, + "error": 0.26953125, + "gradient_norm": 0.06798839569091797, + "elapsed": 572.5601994991302 + }, + { + "step": 1776, + "loss": 0.6443773508071899, + "error": 0.4091796875, + "gradient_norm": 0.07035460323095322, + "elapsed": 577.9789206981659 + }, + { + "step": 1792, + "loss": 0.6012362241744995, + "error": 0.337890625, + "gradient_norm": 0.05189951881766319, + "elapsed": 583.028017282486 + }, + { + "step": 1808, + "loss": 0.2939091920852661, + "error": 0.12109375, + "gradient_norm": 0.05555355176329613, + "elapsed": 588.0501506328583 + }, + { + "step": 1824, + "loss": 0.2059091478586197, + "error": 0.08984375, + "gradient_norm": 0.045679714530706406, + "elapsed": 593.2120039463043 + }, + { + "step": 1840, + "loss": 0.6289581060409546, + "error": 0.349609375, + "gradient_norm": 0.04742642492055893, + "elapsed": 598.7767763137817 + }, + { + "step": 1856, + "loss": 0.5532636642456055, + "error": 0.294921875, + "gradient_norm": 0.05997413396835327, + "elapsed": 604.0475382804871 + }, + { + "step": 1872, + "loss": 0.45995670557022095, + "error": 0.228515625, + "gradient_norm": 0.05674462765455246, + "elapsed": 609.292379617691 + }, + { + "step": 1888, + "loss": 0.6178656816482544, + "error": 0.359375, + "gradient_norm": 0.08857566863298416, + "elapsed": 614.5639882087708 + }, + { + "step": 1904, + "loss": 0.5531284213066101, + "error": 0.287109375, + "gradient_norm": 0.10257937759160995, + "elapsed": 619.5600035190582 + }, + { + "step": 1920, + "loss": 0.04184349626302719, + "error": 0.013671875, + "gradient_norm": 0.04087059944868088, + "elapsed": 624.6679775714874 + }, + { + "step": 1936, + "loss": 0.5924860239028931, + "error": 0.3505859375, + "gradient_norm": 0.036822713911533356, + "elapsed": 629.936680316925 + }, + { + "step": 1952, + "loss": 0.46996980905532837, + "error": 0.2421875, + "gradient_norm": 0.034442272037267685, + "elapsed": 635.1109762191772 + }, + { + "step": 1968, + "loss": 0.17859068512916565, + "error": 0.0712890625, + "gradient_norm": 0.03440066799521446, + "elapsed": 640.32000207901 + }, + { + "step": 1984, + "loss": 0.6192275285720825, + "error": 0.3701171875, + "gradient_norm": 0.04386439174413681, + "elapsed": 645.6040184497833 + }, + { + "step": 2000, + "loss": 0.6160917282104492, + "error": 0.35546875, + "gradient_norm": 0.06268990784883499, + "elapsed": 650.7723731994629 + }, + { + "step": 2016, + "loss": 0.6343611478805542, + "error": 0.388671875, + "gradient_norm": 0.04243326932191849, + "elapsed": 655.972663640976 + }, + { + "step": 2032, + "loss": 0.062292590737342834, + "error": 0.021484375, + "gradient_norm": 0.016680095344781876, + "elapsed": 660.8079733848572 + }, + { + "step": 2048, + "loss": 0.5316072702407837, + "error": 0.26953125, + "gradient_norm": 0.057860780507326126, + "elapsed": 665.5760209560394 + }, + { + "step": 2064, + "loss": 0.605312705039978, + "error": 0.3623046875, + "gradient_norm": 0.04028146713972092, + "elapsed": 682.7294294834137 + }, + { + "step": 2080, + "loss": 0.56633460521698, + "error": 0.3330078125, + "gradient_norm": 0.09528280049562454, + "elapsed": 687.4644649028778 + }, + { + "step": 2096, + "loss": 0.3905397057533264, + "error": 0.1943359375, + "gradient_norm": 0.049456462264060974, + "elapsed": 692.1492264270782 + }, + { + "step": 2112, + "loss": 0.28124868869781494, + "error": 0.1259765625, + "gradient_norm": 0.059239838272333145, + "elapsed": 696.8701393604279 + }, + { + "step": 2128, + "loss": 0.6364338994026184, + "error": 0.392578125, + "gradient_norm": 0.08667811006307602, + "elapsed": 701.683988571167 + }, + { + "step": 2144, + "loss": 0.20683243870735168, + "error": 0.07421875, + "gradient_norm": 0.1100710779428482, + "elapsed": 706.4000360965729 + }, + { + "step": 2160, + "loss": 0.5912737250328064, + "error": 0.341796875, + "gradient_norm": 0.05641854554414749, + "elapsed": 711.2359964847565 + }, + { + "step": 2176, + "loss": 0.27793264389038086, + "error": 0.12109375, + "gradient_norm": 0.0893034040927887, + "elapsed": 715.9508004188538 + }, + { + "step": 2192, + "loss": 0.6474133133888245, + "error": 0.4072265625, + "gradient_norm": 0.06980258971452713, + "elapsed": 720.651974439621 + }, + { + "step": 2208, + "loss": 0.5961858630180359, + "error": 0.35546875, + "gradient_norm": 0.06530112773180008, + "elapsed": 725.496098279953 + }, + { + "step": 2224, + "loss": 0.47581571340560913, + "error": 0.263671875, + "gradient_norm": 0.04470043256878853, + "elapsed": 730.2880010604858 + }, + { + "step": 2240, + "loss": 0.577988862991333, + "error": 0.318359375, + "gradient_norm": 0.07201159745454788, + "elapsed": 735.006133556366 + }, + { + "step": 2256, + "loss": 0.28444671630859375, + "error": 0.1181640625, + "gradient_norm": 0.048656050115823746, + "elapsed": 739.6868116855621 + }, + { + "step": 2272, + "loss": 0.2776409089565277, + "error": 0.1201171875, + "gradient_norm": 0.05783981829881668, + "elapsed": 744.3517308235168 + }, + { + "step": 2288, + "loss": 0.621599555015564, + "error": 0.37109375, + "gradient_norm": 0.09731200337409973, + "elapsed": 749.0351710319519 + }, + { + "step": 2304, + "loss": 0.3333754539489746, + "error": 0.1513671875, + "gradient_norm": 0.07069239765405655, + "elapsed": 753.7588081359863 + }, + { + "step": 2320, + "loss": 0.4687051773071289, + "error": 0.2490234375, + "gradient_norm": 0.044891707599163055, + "elapsed": 758.4588432312012 + }, + { + "step": 2336, + "loss": 0.19801637530326843, + "error": 0.078125, + "gradient_norm": 0.10036595165729523, + "elapsed": 763.256409406662 + }, + { + "step": 2352, + "loss": 0.6186277866363525, + "error": 0.388671875, + "gradient_norm": 0.09069584310054779, + "elapsed": 767.9986386299133 + }, + { + "step": 2368, + "loss": 0.6177258491516113, + "error": 0.373046875, + "gradient_norm": 0.049019571393728256, + "elapsed": 772.730831861496 + }, + { + "step": 2384, + "loss": 0.17707547545433044, + "error": 0.0673828125, + "gradient_norm": 0.045190781354904175, + "elapsed": 777.4072704315186 + }, + { + "step": 2400, + "loss": 0.20144733786582947, + "error": 0.08203125, + "gradient_norm": 0.04537162929773331, + "elapsed": 782.0841658115387 + }, + { + "step": 2416, + "loss": 0.6151775121688843, + "error": 0.365234375, + "gradient_norm": 0.050534047186374664, + "elapsed": 786.762966632843 + }, + { + "step": 2432, + "loss": 0.5533859133720398, + "error": 0.314453125, + "gradient_norm": 0.06006559729576111, + "elapsed": 791.4656012058258 + }, + { + "step": 2448, + "loss": 0.5329082012176514, + "error": 0.2880859375, + "gradient_norm": 0.04018115997314453, + "elapsed": 796.1704161167145 + }, + { + "step": 2464, + "loss": 0.6338047981262207, + "error": 0.4140625, + "gradient_norm": 0.06069163978099823, + "elapsed": 800.9180119037628 + }, + { + "step": 2480, + "loss": 0.1603008508682251, + "error": 0.0673828125, + "gradient_norm": 0.040350593626499176, + "elapsed": 805.6127603054047 + }, + { + "step": 2496, + "loss": 0.505940318107605, + "error": 0.2568359375, + "gradient_norm": 0.05209952965378761, + "elapsed": 810.3740313053131 + }, + { + "step": 2512, + "loss": 0.5528728365898132, + "error": 0.298828125, + "gradient_norm": 0.11757992953062057, + "elapsed": 815.1708807945251 + }, + { + "step": 2528, + "loss": 0.5028313994407654, + "error": 0.2666015625, + "gradient_norm": 0.08823780715465546, + "elapsed": 819.8585045337677 + }, + { + "step": 2544, + "loss": 0.5002262592315674, + "error": 0.2783203125, + "gradient_norm": 0.04888603836297989, + "elapsed": 824.5714073181152 + }, + { + "step": 2560, + "loss": 0.6007894277572632, + "error": 0.328125, + "gradient_norm": 0.05186954140663147, + "elapsed": 829.3080432415009 + }, + { + "step": 2576, + "loss": 0.18641480803489685, + "error": 0.076171875, + "gradient_norm": 0.03799928352236748, + "elapsed": 834.044020652771 + }, + { + "step": 2592, + "loss": 0.3050769865512848, + "error": 0.1396484375, + "gradient_norm": 0.10119257122278214, + "elapsed": 838.8401296138763 + }, + { + "step": 2608, + "loss": 0.6063439846038818, + "error": 0.361328125, + "gradient_norm": 0.04979367554187775, + "elapsed": 844.3572654724121 + }, + { + "step": 2624, + "loss": 0.5751967430114746, + "error": 0.3369140625, + "gradient_norm": 0.04269539937376976, + "elapsed": 849.0660374164581 + }, + { + "step": 2640, + "loss": 0.3902108669281006, + "error": 0.193359375, + "gradient_norm": 0.10029696673154831, + "elapsed": 853.8638062477112 + }, + { + "step": 2656, + "loss": 0.15081660449504852, + "error": 0.0625, + "gradient_norm": 0.0303852129727602, + "elapsed": 858.9793758392334 + }, + { + "step": 2672, + "loss": 0.6503090858459473, + "error": 0.400390625, + "gradient_norm": 0.12611964344978333, + "elapsed": 863.9151141643524 + }, + { + "step": 2688, + "loss": 0.5587317943572998, + "error": 0.31640625, + "gradient_norm": 0.10028114914894104, + "elapsed": 868.7600305080414 + }, + { + "step": 2704, + "loss": 0.4399867355823517, + "error": 0.21484375, + "gradient_norm": 0.06889455020427704, + "elapsed": 873.4544236660004 + }, + { + "step": 2720, + "loss": 0.5865127444267273, + "error": 0.337890625, + "gradient_norm": 0.03671631962060928, + "elapsed": 878.0982644557953 + }, + { + "step": 2736, + "loss": 0.6078637838363647, + "error": 0.3701171875, + "gradient_norm": 0.04679318517446518, + "elapsed": 883.0424642562866 + }, + { + "step": 2752, + "loss": 0.5825340151786804, + "error": 0.337890625, + "gradient_norm": 0.05619681254029274, + "elapsed": 887.908124923706 + }, + { + "step": 2768, + "loss": 0.5970422029495239, + "error": 0.3369140625, + "gradient_norm": 0.041302867233753204, + "elapsed": 892.6760206222534 + }, + { + "step": 2784, + "loss": 0.3870226740837097, + "error": 0.1826171875, + "gradient_norm": 0.05731065198779106, + "elapsed": 897.6246056556702 + }, + { + "step": 2800, + "loss": 0.38130277395248413, + "error": 0.1943359375, + "gradient_norm": 0.059244755655527115, + "elapsed": 902.3360238075256 + }, + { + "step": 2816, + "loss": 0.2617901563644409, + "error": 0.1064453125, + "gradient_norm": 0.041736964136362076, + "elapsed": 907.1600468158722 + }, + { + "step": 2832, + "loss": 0.5819337368011475, + "error": 0.314453125, + "gradient_norm": 0.04097156226634979, + "elapsed": 912.0244295597076 + }, + { + "step": 2848, + "loss": 0.41393283009529114, + "error": 0.2001953125, + "gradient_norm": 0.10456771403551102, + "elapsed": 916.8225846290588 + }, + { + "step": 2864, + "loss": 0.5019145011901855, + "error": 0.2548828125, + "gradient_norm": 0.04843736067414284, + "elapsed": 921.538754940033 + }, + { + "step": 2880, + "loss": 0.04561338573694229, + "error": 0.0146484375, + "gradient_norm": 0.025407327339053154, + "elapsed": 926.2588667869568 + }, + { + "step": 2896, + "loss": 0.4338858723640442, + "error": 0.205078125, + "gradient_norm": 0.09900517761707306, + "elapsed": 930.9781975746155 + }, + { + "step": 2912, + "loss": 0.33922863006591797, + "error": 0.162109375, + "gradient_norm": 0.10189604014158249, + "elapsed": 935.6816267967224 + }, + { + "step": 2928, + "loss": 0.5294322967529297, + "error": 0.2822265625, + "gradient_norm": 0.09060791879892349, + "elapsed": 940.4373068809509 + }, + { + "step": 2944, + "loss": 0.037007369101047516, + "error": 0.01171875, + "gradient_norm": 0.05506489425897598, + "elapsed": 945.1270468235016 + }, + { + "step": 2960, + "loss": 0.6096771359443665, + "error": 0.349609375, + "gradient_norm": 0.04987221211194992, + "elapsed": 949.8300130367279 + }, + { + "step": 2976, + "loss": 0.6157823801040649, + "error": 0.373046875, + "gradient_norm": 0.03614233434200287, + "elapsed": 954.5701997280121 + }, + { + "step": 2992, + "loss": 0.1978239268064499, + "error": 0.080078125, + "gradient_norm": 0.05847112461924553, + "elapsed": 959.2756471633911 + }, + { + "step": 3008, + "loss": 0.5237340927124023, + "error": 0.2841796875, + "gradient_norm": 0.06993591040372849, + "elapsed": 963.9875864982605 + }, + { + "step": 3024, + "loss": 0.4559935927391052, + "error": 0.2373046875, + "gradient_norm": 0.05698448419570923, + "elapsed": 968.7997305393219 + }, + { + "step": 3040, + "loss": 0.5025208592414856, + "error": 0.259765625, + "gradient_norm": 0.14909739792346954, + "elapsed": 973.6042547225952 + }, + { + "step": 3056, + "loss": 0.3223109245300293, + "error": 0.1416015625, + "gradient_norm": 0.032974764704704285, + "elapsed": 978.4760546684265 + }, + { + "step": 3072, + "loss": 0.06682582199573517, + "error": 0.021484375, + "gradient_norm": 0.04433188587427139, + "elapsed": 983.2894048690796 + }, + { + "step": 3088, + "loss": 0.5919550061225891, + "error": 0.34765625, + "gradient_norm": 0.06721373647451401, + "elapsed": 1000.9520287513733 + }, + { + "step": 3104, + "loss": 0.5988063812255859, + "error": 0.3642578125, + "gradient_norm": 0.05654948577284813, + "elapsed": 1005.7442932128906 + }, + { + "step": 3120, + "loss": 0.4922299385070801, + "error": 0.2470703125, + "gradient_norm": 0.07545466721057892, + "elapsed": 1010.4616096019745 + }, + { + "step": 3136, + "loss": 0.4533671736717224, + "error": 0.236328125, + "gradient_norm": 0.06288722902536392, + "elapsed": 1015.3559956550598 + }, + { + "step": 3152, + "loss": 0.5070517063140869, + "error": 0.2666015625, + "gradient_norm": 0.07274917513132095, + "elapsed": 1020.0764343738556 + }, + { + "step": 3168, + "loss": 0.5999464988708496, + "error": 0.3408203125, + "gradient_norm": 0.05777016654610634, + "elapsed": 1024.9410600662231 + }, + { + "step": 3184, + "loss": 0.5758363008499146, + "error": 0.3427734375, + "gradient_norm": 0.051027461886405945, + "elapsed": 1029.7082171440125 + }, + { + "step": 3200, + "loss": 0.05016190931200981, + "error": 0.017578125, + "gradient_norm": 0.009175656363368034, + "elapsed": 1034.3982915878296 + }, + { + "step": 3216, + "loss": 0.5471057295799255, + "error": 0.318359375, + "gradient_norm": 0.07572721689939499, + "elapsed": 1039.117841243744 + }, + { + "step": 3232, + "loss": 0.4141446352005005, + "error": 0.193359375, + "gradient_norm": 0.10056859254837036, + "elapsed": 1043.880026102066 + }, + { + "step": 3248, + "loss": 0.5812438726425171, + "error": 0.3212890625, + "gradient_norm": 0.05781616270542145, + "elapsed": 1048.6406455039978 + }, + { + "step": 3264, + "loss": 0.19184701144695282, + "error": 0.078125, + "gradient_norm": 0.05367236211895943, + "elapsed": 1053.5672237873077 + }, + { + "step": 3280, + "loss": 0.5420833826065063, + "error": 0.28515625, + "gradient_norm": 0.052405405789613724, + "elapsed": 1058.3841104507446 + }, + { + "step": 3296, + "loss": 0.4419598877429962, + "error": 0.2177734375, + "gradient_norm": 0.05814693495631218, + "elapsed": 1063.1880333423615 + }, + { + "step": 3312, + "loss": 0.4525642991065979, + "error": 0.208984375, + "gradient_norm": 0.1061021164059639, + "elapsed": 1068.1370933055878 + }, + { + "step": 3328, + "loss": 0.32664671540260315, + "error": 0.154296875, + "gradient_norm": 0.05649850144982338, + "elapsed": 1073.1963467597961 + }, + { + "step": 3344, + "loss": 0.2655770182609558, + "error": 0.1220703125, + "gradient_norm": 0.04070372134447098, + "elapsed": 1078.2698318958282 + }, + { + "step": 3360, + "loss": 0.5894330739974976, + "error": 0.3544921875, + "gradient_norm": 0.0643400028347969, + "elapsed": 1083.0184152126312 + }, + { + "step": 3376, + "loss": 0.6118791103363037, + "error": 0.361328125, + "gradient_norm": 0.08537904173135757, + "elapsed": 1087.834038734436 + }, + { + "step": 3392, + "loss": 0.40694907307624817, + "error": 0.19921875, + "gradient_norm": 0.11411692947149277, + "elapsed": 1092.8119947910309 + }, + { + "step": 3408, + "loss": 0.04629015550017357, + "error": 0.0146484375, + "gradient_norm": 0.017204072326421738, + "elapsed": 1097.5751783847809 + }, + { + "step": 3424, + "loss": 0.20639702677726746, + "error": 0.0849609375, + "gradient_norm": 0.04801144450902939, + "elapsed": 1102.2970931529999 + }, + { + "step": 3440, + "loss": 0.6051071286201477, + "error": 0.33984375, + "gradient_norm": 0.045392412692308426, + "elapsed": 1107.1080610752106 + }, + { + "step": 3456, + "loss": 0.6553700566291809, + "error": 0.40625, + "gradient_norm": 0.05593863129615784, + "elapsed": 1111.8409752845764 + }, + { + "step": 3472, + "loss": 0.591402530670166, + "error": 0.3515625, + "gradient_norm": 0.051181379705667496, + "elapsed": 1116.5800333023071 + }, + { + "step": 3488, + "loss": 0.30494624376296997, + "error": 0.12109375, + "gradient_norm": 0.05175542086362839, + "elapsed": 1121.276373386383 + }, + { + "step": 3504, + "loss": 0.5065370798110962, + "error": 0.279296875, + "gradient_norm": 0.10419930517673492, + "elapsed": 1125.9883344173431 + }, + { + "step": 3520, + "loss": 0.3915700614452362, + "error": 0.1953125, + "gradient_norm": 0.060416825115680695, + "elapsed": 1130.7958455085754 + }, + { + "step": 3536, + "loss": 0.624374270439148, + "error": 0.3759765625, + "gradient_norm": 0.06069556251168251, + "elapsed": 1135.5360939502716 + }, + { + "step": 3552, + "loss": 0.5830206274986267, + "error": 0.3359375, + "gradient_norm": 0.046013280749320984, + "elapsed": 1140.312029838562 + }, + { + "step": 3568, + "loss": 0.4201379716396332, + "error": 0.2119140625, + "gradient_norm": 0.06909621506929398, + "elapsed": 1145.0904593467712 + }, + { + "step": 3584, + "loss": 0.28215405344963074, + "error": 0.1181640625, + "gradient_norm": 0.07625982910394669, + "elapsed": 1149.8156151771545 + }, + { + "step": 3600, + "loss": 0.5229164361953735, + "error": 0.275390625, + "gradient_norm": 0.055048178881406784, + "elapsed": 1154.5280592441559 + }, + { + "step": 3616, + "loss": 0.47238075733184814, + "error": 0.2314453125, + "gradient_norm": 0.06473162025213242, + "elapsed": 1159.2720873355865 + }, + { + "step": 3632, + "loss": 0.46245503425598145, + "error": 0.228515625, + "gradient_norm": 0.07382887601852417, + "elapsed": 1164.0119998455048 + }, + { + "step": 3648, + "loss": 0.37509745359420776, + "error": 0.171875, + "gradient_norm": 0.051260266453027725, + "elapsed": 1168.7440350055695 + }, + { + "step": 3664, + "loss": 0.1948484629392624, + "error": 0.080078125, + "gradient_norm": 0.059623416513204575, + "elapsed": 1173.3906588554382 + }, + { + "step": 3680, + "loss": 0.5552756786346436, + "error": 0.3115234375, + "gradient_norm": 0.08073585480451584, + "elapsed": 1178.0645008087158 + }, + { + "step": 3696, + "loss": 0.6405904293060303, + "error": 0.39453125, + "gradient_norm": 0.05899551138281822, + "elapsed": 1182.730489730835 + }, + { + "step": 3712, + "loss": 0.2767012119293213, + "error": 0.119140625, + "gradient_norm": 0.06593579798936844, + "elapsed": 1187.377315044403 + }, + { + "step": 3728, + "loss": 0.315812885761261, + "error": 0.134765625, + "gradient_norm": 0.035905495285987854, + "elapsed": 1192.0582301616669 + }, + { + "step": 3744, + "loss": 0.6033951640129089, + "error": 0.3544921875, + "gradient_norm": 0.05226197466254234, + "elapsed": 1196.7101175785065 + }, + { + "step": 3760, + "loss": 0.5202592611312866, + "error": 0.275390625, + "gradient_norm": 0.06367512047290802, + "elapsed": 1201.3543090820312 + }, + { + "step": 3776, + "loss": 0.24639368057250977, + "error": 0.1083984375, + "gradient_norm": 0.09370873868465424, + "elapsed": 1206.0717165470123 + }, + { + "step": 3792, + "loss": 0.6175658702850342, + "error": 0.375, + "gradient_norm": 0.06221585348248482, + "elapsed": 1210.754029750824 + }, + { + "step": 3808, + "loss": 0.41153696179389954, + "error": 0.2119140625, + "gradient_norm": 0.05355365574359894, + "elapsed": 1215.4374370574951 + }, + { + "step": 3824, + "loss": 0.28002214431762695, + "error": 0.1123046875, + "gradient_norm": 0.03846330568194389, + "elapsed": 1220.1207013130188 + }, + { + "step": 3840, + "loss": 0.0484195351600647, + "error": 0.013671875, + "gradient_norm": 0.03470242768526077, + "elapsed": 1224.8153104782104 + }, + { + "step": 3856, + "loss": 0.1407160609960556, + "error": 0.0458984375, + "gradient_norm": 0.04061700031161308, + "elapsed": 1229.5512235164642 + }, + { + "step": 3872, + "loss": 0.5881794691085815, + "error": 0.3427734375, + "gradient_norm": 0.062013477087020874, + "elapsed": 1234.3750183582306 + }, + { + "step": 3888, + "loss": 0.17833612859249115, + "error": 0.06640625, + "gradient_norm": 0.038856204599142075, + "elapsed": 1239.110375881195 + }, + { + "step": 3904, + "loss": 0.06211477518081665, + "error": 0.0224609375, + "gradient_norm": 0.02150108851492405, + "elapsed": 1243.800644159317 + }, + { + "step": 3920, + "loss": 0.06039723381400108, + "error": 0.01953125, + "gradient_norm": 0.019367367029190063, + "elapsed": 1248.4831748008728 + }, + { + "step": 3936, + "loss": 0.6010214686393738, + "error": 0.3525390625, + "gradient_norm": 0.051659151911735535, + "elapsed": 1253.1423478126526 + }, + { + "step": 3952, + "loss": 0.5867137312889099, + "error": 0.3388671875, + "gradient_norm": 0.058528851717710495, + "elapsed": 1257.9799931049347 + }, + { + "step": 3968, + "loss": 0.5231834650039673, + "error": 0.2578125, + "gradient_norm": 0.10128334909677505, + "elapsed": 1262.6990082263947 + }, + { + "step": 3984, + "loss": 0.6251651644706726, + "error": 0.353515625, + "gradient_norm": 0.06211795285344124, + "elapsed": 1267.4289934635162 + }, + { + "step": 4000, + "loss": 0.06667037308216095, + "error": 0.01953125, + "gradient_norm": 0.048018258064985275, + "elapsed": 1272.132089138031 + }, + { + "step": 4016, + "loss": 0.5286938548088074, + "error": 0.2744140625, + "gradient_norm": 0.05509360507130623, + "elapsed": 1276.8878977298737 + }, + { + "step": 4032, + "loss": 0.34016552567481995, + "error": 0.1591796875, + "gradient_norm": 0.07597329467535019, + "elapsed": 1281.7364926338196 + }, + { + "step": 4048, + "loss": 0.17750494182109833, + "error": 0.078125, + "gradient_norm": 0.06314503401517868, + "elapsed": 1286.5033600330353 + }, + { + "step": 4064, + "loss": 0.5882893800735474, + "error": 0.34375, + "gradient_norm": 0.10986580699682236, + "elapsed": 1291.1944887638092 + }, + { + "step": 4080, + "loss": 0.4923543930053711, + "error": 0.2568359375, + "gradient_norm": 0.050325747579336166, + "elapsed": 1295.9372322559357 + }, + { + "step": 4096, + "loss": 0.44146978855133057, + "error": 0.2236328125, + "gradient_norm": 0.06535191088914871, + "elapsed": 1300.641023159027 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 1024, + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "1024": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 804757, + "weights": "weights-1024.npz", + "weights_sha256": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "validation": "validation-1024.json", + "complete": true + }, + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "ff4595e8f3eb7cfaa8da5a58a31e106d9684c7b8437f330573a1291f19f5777a", + "complete": true + } + }, + "selection": "Predefined last-three and all-four noninitial temporal2 checkpoint means; every validation condition evaluated before group selection", + "test_data_used": false, + "derivation_source_sha256": "b68813c7dab697a554185020c430ef05f1c35bedcda5b85b7d165af75461e914" + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.5063965320587158, + "error": 0.263671875, + "gradient_norm": 0.05583755671977997, + "elapsed": 33.61826181411743 + }, + { + "step": 16, + "loss": 0.5231766700744629, + "error": 0.2822265625, + "gradient_norm": 0.05158894136548042, + "elapsed": 48.65802335739136 + }, + { + "step": 32, + "loss": 0.2955678701400757, + "error": 0.1376953125, + "gradient_norm": 0.0717208981513977, + "elapsed": 64.75103712081909 + }, + { + "step": 48, + "loss": 0.5808531045913696, + "error": 0.337890625, + "gradient_norm": 0.0497879758477211, + "elapsed": 81.12590050697327 + }, + { + "step": 64, + "loss": 0.6466071605682373, + "error": 0.3955078125, + "gradient_norm": 0.05340445786714554, + "elapsed": 97.40131282806396 + }, + { + "step": 80, + "loss": 0.43967077136039734, + "error": 0.2197265625, + "gradient_norm": 0.05488451197743416, + "elapsed": 113.68819904327393 + }, + { + "step": 96, + "loss": 0.3481931686401367, + "error": 0.166015625, + "gradient_norm": 0.08198399841785431, + "elapsed": 129.79422783851624 + }, + { + "step": 112, + "loss": 0.37728914618492126, + "error": 0.177734375, + "gradient_norm": 0.04957005754113197, + "elapsed": 146.01310849189758 + }, + { + "step": 128, + "loss": 0.19336706399917603, + "error": 0.07421875, + "gradient_norm": 0.03228567913174629, + "elapsed": 162.3233504295349 + }, + { + "step": 144, + "loss": 0.05673666670918465, + "error": 0.013671875, + "gradient_norm": 0.010086167603731155, + "elapsed": 178.27910375595093 + }, + { + "step": 160, + "loss": 0.05576886981725693, + "error": 0.0185546875, + "gradient_norm": 0.015833213925361633, + "elapsed": 194.4404194355011 + }, + { + "step": 176, + "loss": 0.6271512508392334, + "error": 0.39453125, + "gradient_norm": 0.0890795886516571, + "elapsed": 210.55058026313782 + }, + { + "step": 192, + "loss": 0.5520341992378235, + "error": 0.2998046875, + "gradient_norm": 0.12568876147270203, + "elapsed": 226.60093927383423 + }, + { + "step": 208, + "loss": 0.5262938737869263, + "error": 0.2822265625, + "gradient_norm": 0.055265434086322784, + "elapsed": 244.85273218154907 + }, + { + "step": 224, + "loss": 0.5956001281738281, + "error": 0.3369140625, + "gradient_norm": 0.06895016878843307, + "elapsed": 264.53393387794495 + }, + { + "step": 240, + "loss": 0.25704875588417053, + "error": 0.1259765625, + "gradient_norm": 0.11300098150968552, + "elapsed": 283.89024353027344 + }, + { + "step": 256, + "loss": 0.6143664121627808, + "error": 0.369140625, + "gradient_norm": 0.05419369786977768, + "elapsed": 300.05279064178467 + }, + { + "step": 272, + "loss": 0.5590812563896179, + "error": 0.294921875, + "gradient_norm": 0.06284675002098083, + "elapsed": 315.92391777038574 + }, + { + "step": 288, + "loss": 0.6163386106491089, + "error": 0.353515625, + "gradient_norm": 0.06826888024806976, + "elapsed": 331.96330738067627 + }, + { + "step": 304, + "loss": 0.6250298619270325, + "error": 0.37890625, + "gradient_norm": 0.0710018053650856, + "elapsed": 348.11866188049316 + }, + { + "step": 320, + "loss": 0.3802686631679535, + "error": 0.1796875, + "gradient_norm": 0.05896822363138199, + "elapsed": 364.3013961315155 + }, + { + "step": 336, + "loss": 0.2594846487045288, + "error": 0.1123046875, + "gradient_norm": 0.0468285046517849, + "elapsed": 380.80411195755005 + }, + { + "step": 352, + "loss": 0.19520026445388794, + "error": 0.076171875, + "gradient_norm": 0.032125141471624374, + "elapsed": 396.8971872329712 + }, + { + "step": 368, + "loss": 0.621718168258667, + "error": 0.37890625, + "gradient_norm": 0.0545712448656559, + "elapsed": 412.920996427536 + }, + { + "step": 384, + "loss": 0.6092393398284912, + "error": 0.349609375, + "gradient_norm": 0.04697328060865402, + "elapsed": 428.92249155044556 + }, + { + "step": 400, + "loss": 0.33656495809555054, + "error": 0.171875, + "gradient_norm": 0.04851065203547478, + "elapsed": 444.8614237308502 + }, + { + "step": 416, + "loss": 0.563441812992096, + "error": 0.302734375, + "gradient_norm": 0.06761237233877182, + "elapsed": 460.89916157722473 + }, + { + "step": 432, + "loss": 0.41032207012176514, + "error": 0.205078125, + "gradient_norm": 0.07552587240934372, + "elapsed": 476.91754388809204 + }, + { + "step": 448, + "loss": 0.6176105737686157, + "error": 0.3583984375, + "gradient_norm": 0.03991354629397392, + "elapsed": 492.909494638443 + }, + { + "step": 464, + "loss": 0.47970300912857056, + "error": 0.26171875, + "gradient_norm": 0.08514834195375443, + "elapsed": 508.9842050075531 + }, + { + "step": 480, + "loss": 0.6145294904708862, + "error": 0.3779296875, + "gradient_norm": 0.04053078964352608, + "elapsed": 525.0681574344635 + }, + { + "step": 496, + "loss": 0.5232605934143066, + "error": 0.28125, + "gradient_norm": 0.07535209506750107, + "elapsed": 541.048586845398 + }, + { + "step": 512, + "loss": 0.06574343144893646, + "error": 0.01953125, + "gradient_norm": 0.038100212812423706, + "elapsed": 557.0923149585724 + }, + { + "step": 528, + "loss": 0.052529145032167435, + "error": 0.021484375, + "gradient_norm": 0.017167840152978897, + "elapsed": 588.7646441459656 + }, + { + "step": 544, + "loss": 0.5886420011520386, + "error": 0.3447265625, + "gradient_norm": 0.04695608466863632, + "elapsed": 607.2257866859436 + }, + { + "step": 560, + "loss": 0.6055985689163208, + "error": 0.3466796875, + "gradient_norm": 0.032950498163700104, + "elapsed": 625.9134004116058 + }, + { + "step": 576, + "loss": 0.4632350206375122, + "error": 0.2431640625, + "gradient_norm": 0.07214360684156418, + "elapsed": 642.5683023929596 + }, + { + "step": 592, + "loss": 0.5995157361030579, + "error": 0.33984375, + "gradient_norm": 0.05927892401814461, + "elapsed": 659.0285487174988 + }, + { + "step": 608, + "loss": 0.2751845121383667, + "error": 0.1171875, + "gradient_norm": 0.06076137721538544, + "elapsed": 675.2659955024719 + }, + { + "step": 624, + "loss": 0.0518009215593338, + "error": 0.0205078125, + "gradient_norm": 0.017002176493406296, + "elapsed": 691.3256914615631 + }, + { + "step": 640, + "loss": 0.6293823719024658, + "error": 0.4013671875, + "gradient_norm": 0.07381543517112732, + "elapsed": 707.3796145915985 + }, + { + "step": 656, + "loss": 0.2956032454967499, + "error": 0.126953125, + "gradient_norm": 0.06658996641635895, + "elapsed": 723.4796185493469 + }, + { + "step": 672, + "loss": 0.5275129079818726, + "error": 0.28125, + "gradient_norm": 0.0742238238453865, + "elapsed": 739.52592253685 + }, + { + "step": 688, + "loss": 0.48426946997642517, + "error": 0.251953125, + "gradient_norm": 0.08587855845689774, + "elapsed": 755.599978685379 + }, + { + "step": 704, + "loss": 0.5284034013748169, + "error": 0.298828125, + "gradient_norm": 0.07507473230361938, + "elapsed": 771.6798233985901 + }, + { + "step": 720, + "loss": 0.45124661922454834, + "error": 0.2333984375, + "gradient_norm": 0.040898919105529785, + "elapsed": 787.8532867431641 + }, + { + "step": 736, + "loss": 0.04965062811970711, + "error": 0.0146484375, + "gradient_norm": 0.013609266839921474, + "elapsed": 804.1182470321655 + }, + { + "step": 752, + "loss": 0.04790960252285004, + "error": 0.01171875, + "gradient_norm": 0.01157061941921711, + "elapsed": 820.3099284172058 + }, + { + "step": 768, + "loss": 0.046329010277986526, + "error": 0.0146484375, + "gradient_norm": 0.013687756843864918, + "elapsed": 836.2443821430206 + }, + { + "step": 784, + "loss": 0.20798391103744507, + "error": 0.0830078125, + "gradient_norm": 0.10879658162593842, + "elapsed": 853.994068145752 + }, + { + "step": 800, + "loss": 0.3236527144908905, + "error": 0.1494140625, + "gradient_norm": 0.04277466610074043, + "elapsed": 872.6724886894226 + }, + { + "step": 816, + "loss": 0.5978351831436157, + "error": 0.3310546875, + "gradient_norm": 0.09687308222055435, + "elapsed": 890.0722959041595 + }, + { + "step": 832, + "loss": 0.5914890766143799, + "error": 0.3515625, + "gradient_norm": 0.05389918386936188, + "elapsed": 907.574702501297 + }, + { + "step": 848, + "loss": 0.3500230312347412, + "error": 0.154296875, + "gradient_norm": 0.05182121321558952, + "elapsed": 925.516667842865 + }, + { + "step": 864, + "loss": 0.3173527717590332, + "error": 0.126953125, + "gradient_norm": 0.10333289951086044, + "elapsed": 943.2102818489075 + }, + { + "step": 880, + "loss": 0.6407152414321899, + "error": 0.41015625, + "gradient_norm": 0.03933756425976753, + "elapsed": 960.0137810707092 + }, + { + "step": 896, + "loss": 0.3448338210582733, + "error": 0.1591796875, + "gradient_norm": 0.048397257924079895, + "elapsed": 976.2672023773193 + }, + { + "step": 912, + "loss": 0.2199687361717224, + "error": 0.0830078125, + "gradient_norm": 0.11513829976320267, + "elapsed": 992.4728758335114 + }, + { + "step": 928, + "loss": 0.16880497336387634, + "error": 0.072265625, + "gradient_norm": 0.031767718493938446, + "elapsed": 1008.5988037586212 + }, + { + "step": 944, + "loss": 0.053500816226005554, + "error": 0.017578125, + "gradient_norm": 0.014627245254814625, + "elapsed": 1024.7008044719696 + }, + { + "step": 960, + "loss": 0.5974152684211731, + "error": 0.341796875, + "gradient_norm": 0.09594274312257767, + "elapsed": 1040.908540725708 + }, + { + "step": 976, + "loss": 0.34772756695747375, + "error": 0.1572265625, + "gradient_norm": 0.04134370759129524, + "elapsed": 1056.9926254749298 + }, + { + "step": 992, + "loss": 0.4953954815864563, + "error": 0.2744140625, + "gradient_norm": 0.09671331197023392, + "elapsed": 1073.0582761764526 + }, + { + "step": 1008, + "loss": 0.6424463987350464, + "error": 0.4013671875, + "gradient_norm": 0.13621115684509277, + "elapsed": 1089.2002465724945 + }, + { + "step": 1024, + "loss": 0.1914748251438141, + "error": 0.0771484375, + "gradient_norm": 0.05097605288028717, + "elapsed": 1105.341599225998 + } + ], + "condition_mixing_plan": { + "hypothesis": "Mixing uniformly sampled geometry/basis/duration conditions in each gradient update reduces condition-gradient fluctuations", + "parent": "temporal2_swa/weights-mean3.npz", + "new_random_parameter_initializations": 0, + "sampling_seed": 20261190, + "arms": [ + "same", + "mixed" + ], + "microbatches_per_update": 4, + "microbatch_size": 256, + "effective_batch_size": 1024, + "optimizer_updates": 1024, + "learning_rate": 0.00025, + "optimizer": "Fresh AdamW state, weight decay1e-4, global gradient norm clip1 after averaging gradients", + "sampling_control": "Both arms draw four condition indices then four256-row batches per update. Same arm reuses the first condition index; mixed uses all four. Equal-sized condition pools make RNG states identical.", + "training": "All104 d3 conditions and all supplied training rows eligible;1,048,576 training draws in each arm", + "selection": "Full validation checkpoints512/1024, per-group mean across all13 durations; raw or equal blend with recorded small contextual reference; incumbent retained on ties", + "test_data_used": false + }, + "accumulation_numerical_control": { + "status": "passed", + "device": "cpu", + "condition": "surface_code_bZ_d3_r13_center_5_7", + "parent_checkpoint_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "trainer_source_sha256": "9f672468a8b72966b3aa04fd22e5d40b47b0768f1c802c267a1da08244c4323b", + "gradient_relative_l2_difference": 1.0312139158546257e-06, + "maximum_gradient_difference": 4.023313522338867e-07, + "mean_loss_difference": 0.0, + "maximum_optimizer_update_difference": 1.0697840480133891e-06, + "matched_rng_state_after_1024_updates": true, + "precision_audit": { + "float64_full_vs_accumulated_gradient_relative_l2": 2.4022986924332267e-15, + "float64_full_vs_accumulated_update_maximum_difference": 1.6631390275384517e-15, + "float32_full_gradient_relative_l2_vs_float64": 1.1454018534911662e-06, + "float32_accumulated_gradient_relative_l2_vs_float64": 9.16593382832008e-07, + "float32_full_update_maximum_difference_vs_float64": 6.5271394129382524e-06, + "float32_accumulated_update_maximum_difference_vs_float64": 7.5969234609516415e-06, + "initial_failed_check": { + "maximum_float32_update_difference": 1.0697840480133891e-06, + "original_tolerance": 1e-06 + }, + "interpretation": "Float64 audit checks accumulation algebra independently of float32 reduction rounding and first-Adam-step sensitivity near zero gradients. Original failure is retained; production model/gradient precision and optimizer are unchanged." + }, + "training_draws_each_arm": 1048576, + "draws_by_condition": { + "same": [ + 17408, + 14336, + 12288, + 14336, + 7168, + 10240, + 8192, + 7168, + 9216, + 11264, + 14336, + 7168, + 5120, + 9216, + 7168, + 8192, + 8192, + 10240, + 7168, + 10240, + 11264, + 14336, + 15360, + 10240, + 8192, + 11264, + 11264, + 17408, + 11264, + 15360, + 10240, + 17408, + 7168, + 13312, + 5120, + 13312, + 4096, + 8192, + 10240, + 8192, + 8192, + 5120, + 10240, + 11264, + 16384, + 13312, + 9216, + 9216, + 14336, + 8192, + 10240, + 10240, + 3072, + 8192, + 11264, + 12288, + 5120, + 4096, + 7168, + 9216, + 5120, + 14336, + 8192, + 9216, + 15360, + 6144, + 16384, + 5120, + 10240, + 10240, + 11264, + 11264, + 7168, + 6144, + 8192, + 11264, + 8192, + 14336, + 8192, + 10240, + 13312, + 15360, + 18432, + 4096, + 8192, + 8192, + 15360, + 10240, + 7168, + 12288, + 7168, + 12288, + 12288, + 8192, + 16384, + 9216, + 11264, + 6144, + 8192, + 7168, + 7168, + 12288, + 5120, + 8192 + ], + "mixed": [ + 14336, + 9472, + 8448, + 12032, + 8960, + 11776, + 9984, + 8448, + 9216, + 11264, + 12288, + 11008, + 7936, + 11008, + 9984, + 8448, + 11776, + 9984, + 9984, + 10752, + 8448, + 9984, + 9728, + 10240, + 8704, + 8448, + 8192, + 10496, + 8704, + 11008, + 9984, + 13824, + 8960, + 11264, + 9984, + 11008, + 13824, + 11264, + 9984, + 9216, + 9472, + 11008, + 9472, + 11776, + 12800, + 10240, + 8192, + 8192, + 9728, + 11008, + 8960, + 11264, + 8704, + 10496, + 10240, + 11776, + 7936, + 9216, + 9472, + 10752, + 8448, + 12288, + 9216, + 9728, + 11008, + 9472, + 11008, + 10240, + 8704, + 8448, + 9216, + 9728, + 9728, + 8960, + 10496, + 11520, + 9216, + 8704, + 6400, + 12032, + 11008, + 12288, + 12288, + 7936, + 10752, + 7936, + 12032, + 9216, + 8448, + 9472, + 9472, + 10752, + 10752, + 10752, + 12800, + 10496, + 10496, + 12032, + 8448, + 8960, + 7680, + 9472, + 11008, + 8448 + ] + }, + "scope": "Numerical and sampling controls only. All gradient/update probes are discarded; no trained candidate checkpoint or validation score is produced.", + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/condition_same1", + "selected_checkpoint_steps": [ + "1024", + "512" + ], + "checkpoint_records": { + "512": { + "step": 512, + "new_training_shots": 524288, + "unique_training_rows_seen_in_this_phase": 451734, + "weights": "weights-512.npz", + "weights_sha256": "4cf3ebae65f19ed882d90aac2157db4127d715f9c688c987280c9aac28efad84", + "validation": "validation-512.json", + "complete": true + }, + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 803777, + "weights": "weights-1024.npz", + "weights_sha256": "c515815d285cc2eafe52d8ced2df1c754ac578ba54786b98770e15238dc4eaad", + "validation": "validation-1024.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24451622596153846, + "512": 0.24528245192307693, + "1024": 0.24529747596153847, + "blend-512": 0.24562800480769229, + "blend-1024": 0.24574819711538462 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2527794471153846, + "512": 0.25326021634615387, + "1024": 0.252734375, + "blend-512": 0.2533954326923077, + "blend-1024": 0.25307992788461536 + }, + "selected": "1024" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23366887019230773, + "512": 0.23359375, + "1024": 0.2334435096153846, + "blend-512": 0.23426983173076926, + "blend-1024": 0.23384915865384612 + }, + "selected": "1024" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23889723557692305, + "512": 0.23933293269230774, + "1024": 0.23951322115384613, + "blend-512": 0.23915264423076918, + "blend-1024": 0.239453125 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.2446213942307692, + "512": 0.2444561298076923, + "1024": 0.24489182692307693, + "blend-512": 0.24508713942307692, + "blend-1024": 0.24568810096153845 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23652343749999996, + "512": 0.23765024038461538, + "1024": 0.2379206730769231, + "blend-512": 0.23787560096153845, + "blend-1024": 0.23759014423076924 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.2356670673076923, + "512": 0.23619290865384618, + "1024": 0.23629807692307692, + "blend-512": 0.23610276442307693, + "blend-1024": 0.23593750000000002 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23294771634615385, + "512": 0.23398437499999997, + "1024": 0.23342848557692308, + "blend-512": 0.2337590144230769, + "blend-1024": 0.2334435096153846 + }, + "selected": "incumbent" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23228665865384618 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "group_specialize1", + "training_run": { + "experiment": "group-specific d3 continuation", + "groups": { + "d3_bX_center_3_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_3_5", + "parent_model": { + "weights": "weights/contextual-temporal2_swa-mean3.npz", + "training_checkpoint": "temporal2_swa/mean3" + }, + "parent_weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162496, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 11586, + "surface_code_bX_d3_r03_center_3_5": 13164, + "surface_code_bX_d3_r05_center_3_5": 14692, + "surface_code_bX_d3_r07_center_3_5": 12423, + "surface_code_bX_d3_r09_center_3_5": 13507, + "surface_code_bX_d3_r11_center_3_5": 9165, + "surface_code_bX_d3_r13_center_3_5": 14569, + "surface_code_bX_d3_r15_center_3_5": 11563, + "surface_code_bX_d3_r17_center_3_5": 14132, + "surface_code_bX_d3_r19_center_3_5": 9704, + "surface_code_bX_d3_r21_center_3_5": 12014, + "surface_code_bX_d3_r23_center_3_5": 13117, + "surface_code_bX_d3_r25_center_3_5": 12860 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261200, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_3_5", + "step": 1, + "loss": 0.5817165970802307, + "error": 0.3388671875, + "gradient_norm": 0.07810031622648239, + "elapsed": 23.888731479644775 + }, + { + "group": "d3_bX_center_3_5", + "step": 16, + "loss": 0.43716299533843994, + "error": 0.2177734375, + "gradient_norm": 0.05689458176493645, + "elapsed": 28.204753398895264 + }, + { + "group": "d3_bX_center_3_5", + "step": 32, + "loss": 0.44627559185028076, + "error": 0.208984375, + "gradient_norm": 0.056756604462862015, + "elapsed": 32.84233617782593 + }, + { + "group": "d3_bX_center_3_5", + "step": 48, + "loss": 0.4319554567337036, + "error": 0.234375, + "gradient_norm": 0.05750993266701698, + "elapsed": 37.434494495391846 + }, + { + "group": "d3_bX_center_3_5", + "step": 64, + "loss": 0.2955609858036041, + "error": 0.1279296875, + "gradient_norm": 0.07982950657606125, + "elapsed": 42.03733849525452 + }, + { + "group": "d3_bX_center_3_5", + "step": 80, + "loss": 0.051099054515361786, + "error": 0.01953125, + "gradient_norm": 0.01472504436969757, + "elapsed": 46.64323449134827 + }, + { + "group": "d3_bX_center_3_5", + "step": 96, + "loss": 0.3553770184516907, + "error": 0.1767578125, + "gradient_norm": 0.04556305333971977, + "elapsed": 51.289584159851074 + }, + { + "group": "d3_bX_center_3_5", + "step": 112, + "loss": 0.49853652715682983, + "error": 0.255859375, + "gradient_norm": 0.05837372690439224, + "elapsed": 55.921807527542114 + }, + { + "group": "d3_bX_center_3_5", + "step": 128, + "loss": 0.6128357648849487, + "error": 0.3759765625, + "gradient_norm": 0.04268687590956688, + "elapsed": 60.54293370246887 + }, + { + "group": "d3_bX_center_3_5", + "step": 144, + "loss": 0.40158310532569885, + "error": 0.2109375, + "gradient_norm": 0.06899380683898926, + "elapsed": 66.70903372764587 + }, + { + "group": "d3_bX_center_3_5", + "step": 160, + "loss": 0.6189148426055908, + "error": 0.369140625, + "gradient_norm": 0.049649614840745926, + "elapsed": 71.31301522254944 + }, + { + "group": "d3_bX_center_3_5", + "step": 176, + "loss": 0.5736979246139526, + "error": 0.3271484375, + "gradient_norm": 0.06365907937288284, + "elapsed": 75.90330648422241 + }, + { + "group": "d3_bX_center_3_5", + "step": 192, + "loss": 0.5324695706367493, + "error": 0.294921875, + "gradient_norm": 0.05174271762371063, + "elapsed": 80.51115894317627 + }, + { + "group": "d3_bX_center_3_5", + "step": 208, + "loss": 0.6137855052947998, + "error": 0.3623046875, + "gradient_norm": 0.04891493543982506, + "elapsed": 85.1122133731842 + }, + { + "group": "d3_bX_center_3_5", + "step": 224, + "loss": 0.6262054443359375, + "error": 0.400390625, + "gradient_norm": 0.0478600338101387, + "elapsed": 89.77170705795288 + }, + { + "group": "d3_bX_center_3_5", + "step": 240, + "loss": 0.5114355087280273, + "error": 0.2802734375, + "gradient_norm": 0.06124471500515938, + "elapsed": 94.34836196899414 + }, + { + "group": "d3_bX_center_3_5", + "step": 256, + "loss": 0.3812999129295349, + "error": 0.181640625, + "gradient_norm": 0.050427597016096115, + "elapsed": 98.88006901741028 + } + ] + }, + "d3_bX_center_5_3": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_5_3", + "parent_model": { + "weights": "weights/contextual-condition_same1-1024.npz", + "training_checkpoint": "condition_same1/1024" + }, + "parent_weights_sha256": "c515815d285cc2eafe52d8ced2df1c754ac578ba54786b98770e15238dc4eaad", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 161233, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_3": 11129, + "surface_code_bX_d3_r03_center_5_3": 15369, + "surface_code_bX_d3_r05_center_5_3": 14677, + "surface_code_bX_d3_r07_center_5_3": 9707, + "surface_code_bX_d3_r09_center_5_3": 11152, + "surface_code_bX_d3_r11_center_5_3": 12800, + "surface_code_bX_d3_r13_center_5_3": 13443, + "surface_code_bX_d3_r15_center_5_3": 12388, + "surface_code_bX_d3_r17_center_5_3": 15158, + "surface_code_bX_d3_r19_center_5_3": 10218, + "surface_code_bX_d3_r21_center_5_3": 10711, + "surface_code_bX_d3_r23_center_5_3": 13773, + "surface_code_bX_d3_r25_center_5_3": 10708 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261201, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_5_3", + "step": 1, + "loss": 0.4805193245410919, + "error": 0.2578125, + "gradient_norm": 0.05444623902440071, + "elapsed": 102.3664813041687 + }, + { + "group": "d3_bX_center_5_3", + "step": 16, + "loss": 0.2784017324447632, + "error": 0.11328125, + "gradient_norm": 0.08824625611305237, + "elapsed": 106.75308656692505 + }, + { + "group": "d3_bX_center_5_3", + "step": 32, + "loss": 0.6410393118858337, + "error": 0.412109375, + "gradient_norm": 0.03859763592481613, + "elapsed": 111.4091112613678 + }, + { + "group": "d3_bX_center_5_3", + "step": 48, + "loss": 0.42605704069137573, + "error": 0.2099609375, + "gradient_norm": 0.050592850893735886, + "elapsed": 116.04315447807312 + }, + { + "group": "d3_bX_center_5_3", + "step": 64, + "loss": 0.5663277506828308, + "error": 0.298828125, + "gradient_norm": 0.055698245763778687, + "elapsed": 120.68257761001587 + }, + { + "group": "d3_bX_center_5_3", + "step": 80, + "loss": 0.6572779417037964, + "error": 0.4267578125, + "gradient_norm": 0.07223570346832275, + "elapsed": 125.41016721725464 + }, + { + "group": "d3_bX_center_5_3", + "step": 96, + "loss": 0.5440086126327515, + "error": 0.2998046875, + "gradient_norm": 0.08954599499702454, + "elapsed": 130.22392392158508 + }, + { + "group": "d3_bX_center_5_3", + "step": 112, + "loss": 0.5094837546348572, + "error": 0.2548828125, + "gradient_norm": 0.06551362574100494, + "elapsed": 134.7945008277893 + }, + { + "group": "d3_bX_center_5_3", + "step": 128, + "loss": 0.5803394317626953, + "error": 0.3193359375, + "gradient_norm": 0.06082230061292648, + "elapsed": 139.35728001594543 + }, + { + "group": "d3_bX_center_5_3", + "step": 144, + "loss": 0.616602897644043, + "error": 0.375, + "gradient_norm": 0.050001099705696106, + "elapsed": 145.55171418190002 + }, + { + "group": "d3_bX_center_5_3", + "step": 160, + "loss": 0.5520708560943604, + "error": 0.2880859375, + "gradient_norm": 0.06085196137428284, + "elapsed": 150.15428566932678 + }, + { + "group": "d3_bX_center_5_3", + "step": 176, + "loss": 0.6117234230041504, + "error": 0.3740234375, + "gradient_norm": 0.0825766772031784, + "elapsed": 154.74532389640808 + }, + { + "group": "d3_bX_center_5_3", + "step": 192, + "loss": 0.5692043304443359, + "error": 0.3203125, + "gradient_norm": 0.07800327241420746, + "elapsed": 159.3635880947113 + }, + { + "group": "d3_bX_center_5_3", + "step": 208, + "loss": 0.30638742446899414, + "error": 0.130859375, + "gradient_norm": 0.049805574119091034, + "elapsed": 163.99608540534973 + }, + { + "group": "d3_bX_center_5_3", + "step": 224, + "loss": 0.5141903758049011, + "error": 0.28515625, + "gradient_norm": 0.06405262649059296, + "elapsed": 168.6415627002716 + }, + { + "group": "d3_bX_center_5_3", + "step": 240, + "loss": 0.5797978639602661, + "error": 0.34765625, + "gradient_norm": 0.10031016170978546, + "elapsed": 173.26013374328613 + }, + { + "group": "d3_bX_center_5_3", + "step": 256, + "loss": 0.2809719741344452, + "error": 0.12890625, + "gradient_norm": 0.04573458060622215, + "elapsed": 177.8879518508911 + } + ] + }, + "d3_bX_center_5_7": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_5_7", + "parent_model": { + "weights": "weights/contextual-condition_same1-1024.npz", + "training_checkpoint": "condition_same1/1024" + }, + "parent_weights_sha256": "c515815d285cc2eafe52d8ced2df1c754ac578ba54786b98770e15238dc4eaad", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162612, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_7": 13532, + "surface_code_bX_d3_r03_center_5_7": 12060, + "surface_code_bX_d3_r05_center_5_7": 14744, + "surface_code_bX_d3_r07_center_5_7": 11642, + "surface_code_bX_d3_r09_center_5_7": 13167, + "surface_code_bX_d3_r11_center_5_7": 8639, + "surface_code_bX_d3_r13_center_5_7": 14627, + "surface_code_bX_d3_r15_center_5_7": 11178, + "surface_code_bX_d3_r17_center_5_7": 10160, + "surface_code_bX_d3_r19_center_5_7": 13125, + "surface_code_bX_d3_r21_center_5_7": 13464, + "surface_code_bX_d3_r23_center_5_7": 13143, + "surface_code_bX_d3_r25_center_5_7": 13131 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261202, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_5_7", + "step": 1, + "loss": 0.18060244619846344, + "error": 0.0712890625, + "gradient_norm": 0.035179879516363144, + "elapsed": 181.32161450386047 + }, + { + "group": "d3_bX_center_5_7", + "step": 16, + "loss": 0.5082811117172241, + "error": 0.2705078125, + "gradient_norm": 0.07098715752363205, + "elapsed": 185.63990426063538 + }, + { + "group": "d3_bX_center_5_7", + "step": 32, + "loss": 0.5253040790557861, + "error": 0.2880859375, + "gradient_norm": 0.16328570246696472, + "elapsed": 190.24219703674316 + }, + { + "group": "d3_bX_center_5_7", + "step": 48, + "loss": 0.631301760673523, + "error": 0.3994140625, + "gradient_norm": 0.057355962693691254, + "elapsed": 194.84725713729858 + }, + { + "group": "d3_bX_center_5_7", + "step": 64, + "loss": 0.27920418977737427, + "error": 0.1240234375, + "gradient_norm": 0.06183589994907379, + "elapsed": 199.47137212753296 + }, + { + "group": "d3_bX_center_5_7", + "step": 80, + "loss": 0.611309289932251, + "error": 0.3544921875, + "gradient_norm": 0.07737621665000916, + "elapsed": 204.0849051475525 + }, + { + "group": "d3_bX_center_5_7", + "step": 96, + "loss": 0.2803115248680115, + "error": 0.1279296875, + "gradient_norm": 0.05086443945765495, + "elapsed": 208.7057957649231 + }, + { + "group": "d3_bX_center_5_7", + "step": 112, + "loss": 0.5856442451477051, + "error": 0.330078125, + "gradient_norm": 0.09568645805120468, + "elapsed": 213.3731656074524 + }, + { + "group": "d3_bX_center_5_7", + "step": 128, + "loss": 0.6120781898498535, + "error": 0.3486328125, + "gradient_norm": 0.07464266568422318, + "elapsed": 218.0141613483429 + }, + { + "group": "d3_bX_center_5_7", + "step": 144, + "loss": 0.4921022355556488, + "error": 0.24609375, + "gradient_norm": 0.04171774536371231, + "elapsed": 224.291086435318 + }, + { + "group": "d3_bX_center_5_7", + "step": 160, + "loss": 0.6169480085372925, + "error": 0.375, + "gradient_norm": 0.06097063049674034, + "elapsed": 229.43670320510864 + }, + { + "group": "d3_bX_center_5_7", + "step": 176, + "loss": 0.6014459729194641, + "error": 0.3720703125, + "gradient_norm": 0.049403320997953415, + "elapsed": 235.6041157245636 + }, + { + "group": "d3_bX_center_5_7", + "step": 192, + "loss": 0.5643549561500549, + "error": 0.3076171875, + "gradient_norm": 0.034399617463350296, + "elapsed": 242.02996158599854 + }, + { + "group": "d3_bX_center_5_7", + "step": 208, + "loss": 0.04667453467845917, + "error": 0.0146484375, + "gradient_norm": 0.021298106759786606, + "elapsed": 247.37174129486084 + }, + { + "group": "d3_bX_center_5_7", + "step": 224, + "loss": 0.5067787170410156, + "error": 0.2607421875, + "gradient_norm": 0.056687332689762115, + "elapsed": 251.9976110458374 + }, + { + "group": "d3_bX_center_5_7", + "step": 240, + "loss": 0.42991048097610474, + "error": 0.2255859375, + "gradient_norm": 0.061536215245723724, + "elapsed": 256.75613379478455 + }, + { + "group": "d3_bX_center_5_7", + "step": 256, + "loss": 0.47317343950271606, + "error": 0.2529296875, + "gradient_norm": 0.060076676309108734, + "elapsed": 261.4124813079834 + } + ] + }, + "d3_bX_center_7_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_7_5", + "parent_model": { + "weights": "weights/contextual-temporal2-2048.npz", + "training_checkpoint": "temporal2/2048", + "blend_contextual": true + }, + "parent_weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162880, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_7_5": 13450, + "surface_code_bX_d3_r03_center_7_5": 11109, + "surface_code_bX_d3_r05_center_7_5": 14012, + "surface_code_bX_d3_r07_center_7_5": 13898, + "surface_code_bX_d3_r09_center_7_5": 12398, + "surface_code_bX_d3_r11_center_7_5": 9664, + "surface_code_bX_d3_r13_center_7_5": 11550, + "surface_code_bX_d3_r15_center_7_5": 12809, + "surface_code_bX_d3_r17_center_7_5": 10673, + "surface_code_bX_d3_r19_center_7_5": 13751, + "surface_code_bX_d3_r21_center_7_5": 13442, + "surface_code_bX_d3_r23_center_7_5": 13774, + "surface_code_bX_d3_r25_center_7_5": 12350 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261203, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_7_5", + "step": 1, + "loss": 0.6286593675613403, + "error": 0.3916015625, + "gradient_norm": 0.048550695180892944, + "elapsed": 264.77757954597473 + }, + { + "group": "d3_bX_center_7_5", + "step": 16, + "loss": 0.5998052954673767, + "error": 0.3564453125, + "gradient_norm": 0.04667327180504799, + "elapsed": 269.1457931995392 + }, + { + "group": "d3_bX_center_7_5", + "step": 32, + "loss": 0.6372991800308228, + "error": 0.3984375, + "gradient_norm": 0.03931272402405739, + "elapsed": 273.81044721603394 + }, + { + "group": "d3_bX_center_7_5", + "step": 48, + "loss": 0.32325083017349243, + "error": 0.1455078125, + "gradient_norm": 0.053585249930620193, + "elapsed": 278.48719453811646 + }, + { + "group": "d3_bX_center_7_5", + "step": 64, + "loss": 0.6184052228927612, + "error": 0.3974609375, + "gradient_norm": 0.04405878111720085, + "elapsed": 283.16093349456787 + }, + { + "group": "d3_bX_center_7_5", + "step": 80, + "loss": 0.30300217866897583, + "error": 0.1318359375, + "gradient_norm": 0.03475452959537506, + "elapsed": 287.8628993034363 + }, + { + "group": "d3_bX_center_7_5", + "step": 96, + "loss": 0.4532725214958191, + "error": 0.23828125, + "gradient_norm": 0.053579334169626236, + "elapsed": 292.54087567329407 + }, + { + "group": "d3_bX_center_7_5", + "step": 112, + "loss": 0.5722991824150085, + "error": 0.333984375, + "gradient_norm": 0.05200285091996193, + "elapsed": 297.2698106765747 + }, + { + "group": "d3_bX_center_7_5", + "step": 128, + "loss": 0.47720301151275635, + "error": 0.248046875, + "gradient_norm": 0.08435481041669846, + "elapsed": 301.9647386074066 + }, + { + "group": "d3_bX_center_7_5", + "step": 144, + "loss": 0.49832063913345337, + "error": 0.2666015625, + "gradient_norm": 0.06509781628847122, + "elapsed": 308.208101272583 + }, + { + "group": "d3_bX_center_7_5", + "step": 160, + "loss": 0.05153600126504898, + "error": 0.015625, + "gradient_norm": 0.018944455310702324, + "elapsed": 312.88946986198425 + }, + { + "group": "d3_bX_center_7_5", + "step": 176, + "loss": 0.3049379885196686, + "error": 0.1376953125, + "gradient_norm": 0.03572608530521393, + "elapsed": 317.5962097644806 + }, + { + "group": "d3_bX_center_7_5", + "step": 192, + "loss": 0.4833422899246216, + "error": 0.2275390625, + "gradient_norm": 0.11588290333747864, + "elapsed": 322.2771329879761 + }, + { + "group": "d3_bX_center_7_5", + "step": 208, + "loss": 0.5812653303146362, + "error": 0.34765625, + "gradient_norm": 0.04924288019537926, + "elapsed": 326.9544439315796 + }, + { + "group": "d3_bX_center_7_5", + "step": 224, + "loss": 0.5518968105316162, + "error": 0.2919921875, + "gradient_norm": 0.049676258116960526, + "elapsed": 331.7683095932007 + }, + { + "group": "d3_bX_center_7_5", + "step": 240, + "loss": 0.599678099155426, + "error": 0.353515625, + "gradient_norm": 0.09019427001476288, + "elapsed": 337.0053963661194 + }, + { + "group": "d3_bX_center_7_5", + "step": 256, + "loss": 0.6168051362037659, + "error": 0.373046875, + "gradient_norm": 0.045873139053583145, + "elapsed": 342.27088832855225 + } + ] + }, + "d3_bZ_center_3_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_3_5", + "parent_model": { + "weights": "weights/contextual-condition_same1-512.npz", + "training_checkpoint": "condition_same1/512" + }, + "parent_weights_sha256": "4cf3ebae65f19ed882d90aac2157db4127d715f9c688c987280c9aac28efad84", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162257, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_3_5": 13149, + "surface_code_bZ_d3_r03_center_3_5": 12112, + "surface_code_bZ_d3_r05_center_3_5": 12434, + "surface_code_bZ_d3_r07_center_3_5": 13778, + "surface_code_bZ_d3_r09_center_3_5": 12830, + "surface_code_bZ_d3_r11_center_3_5": 6034, + "surface_code_bZ_d3_r13_center_3_5": 13524, + "surface_code_bZ_d3_r15_center_3_5": 13160, + "surface_code_bZ_d3_r17_center_3_5": 12823, + "surface_code_bZ_d3_r19_center_3_5": 11129, + "surface_code_bZ_d3_r21_center_3_5": 13793, + "surface_code_bZ_d3_r23_center_3_5": 14080, + "surface_code_bZ_d3_r25_center_3_5": 13411 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261204, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_3_5", + "step": 1, + "loss": 0.36515435576438904, + "error": 0.17578125, + "gradient_norm": 0.068653903901577, + "elapsed": 346.68829584121704 + }, + { + "group": "d3_bZ_center_3_5", + "step": 16, + "loss": 0.2806941568851471, + "error": 0.1318359375, + "gradient_norm": 0.06498919427394867, + "elapsed": 352.6486053466797 + }, + { + "group": "d3_bZ_center_3_5", + "step": 32, + "loss": 0.5172728300094604, + "error": 0.2578125, + "gradient_norm": 0.06919123977422714, + "elapsed": 358.0916488170624 + }, + { + "group": "d3_bZ_center_3_5", + "step": 48, + "loss": 0.5654157400131226, + "error": 0.3134765625, + "gradient_norm": 0.062110695987939835, + "elapsed": 364.1197271347046 + }, + { + "group": "d3_bZ_center_3_5", + "step": 64, + "loss": 0.5950935482978821, + "error": 0.349609375, + "gradient_norm": 0.06901932507753372, + "elapsed": 370.44589829444885 + }, + { + "group": "d3_bZ_center_3_5", + "step": 80, + "loss": 0.3655591607093811, + "error": 0.1865234375, + "gradient_norm": 0.06035780534148216, + "elapsed": 376.3442976474762 + }, + { + "group": "d3_bZ_center_3_5", + "step": 96, + "loss": 0.5849340558052063, + "error": 0.345703125, + "gradient_norm": 0.0669141560792923, + "elapsed": 381.8527054786682 + }, + { + "group": "d3_bZ_center_3_5", + "step": 112, + "loss": 0.04215944558382034, + "error": 0.013671875, + "gradient_norm": 0.029389331117272377, + "elapsed": 386.54820346832275 + }, + { + "group": "d3_bZ_center_3_5", + "step": 128, + "loss": 0.619553804397583, + "error": 0.3876953125, + "gradient_norm": 0.053926873952150345, + "elapsed": 391.31534695625305 + }, + { + "group": "d3_bZ_center_3_5", + "step": 144, + "loss": 0.3793254494667053, + "error": 0.1923828125, + "gradient_norm": 0.07844529300928116, + "elapsed": 397.51641821861267 + }, + { + "group": "d3_bZ_center_3_5", + "step": 160, + "loss": 0.3429756164550781, + "error": 0.1572265625, + "gradient_norm": 0.06213530898094177, + "elapsed": 402.1174716949463 + }, + { + "group": "d3_bZ_center_3_5", + "step": 176, + "loss": 0.2883482277393341, + "error": 0.1416015625, + "gradient_norm": 0.07786665111780167, + "elapsed": 406.72908902168274 + }, + { + "group": "d3_bZ_center_3_5", + "step": 192, + "loss": 0.03280383348464966, + "error": 0.0087890625, + "gradient_norm": 0.035463444888591766, + "elapsed": 411.33272552490234 + }, + { + "group": "d3_bZ_center_3_5", + "step": 208, + "loss": 0.6251656413078308, + "error": 0.38671875, + "gradient_norm": 0.08498021215200424, + "elapsed": 415.93534207344055 + }, + { + "group": "d3_bZ_center_3_5", + "step": 224, + "loss": 0.43049943447113037, + "error": 0.232421875, + "gradient_norm": 0.08405832201242447, + "elapsed": 420.54495644569397 + }, + { + "group": "d3_bZ_center_3_5", + "step": 240, + "loss": 0.5978946089744568, + "error": 0.3349609375, + "gradient_norm": 0.06633604317903519, + "elapsed": 425.1712546348572 + }, + { + "group": "d3_bZ_center_3_5", + "step": 256, + "loss": 0.5690029859542847, + "error": 0.341796875, + "gradient_norm": 0.06171220913529396, + "elapsed": 430.0519812107086 + } + ] + }, + "d3_bZ_center_5_3": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_5_3", + "parent_model": { + "weights": "weights/contextual-temporal2-2048.npz", + "training_checkpoint": "temporal2/2048" + }, + "parent_weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162569, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_5_3": 11619, + "surface_code_bZ_d3_r03_center_5_3": 13126, + "surface_code_bZ_d3_r05_center_5_3": 12742, + "surface_code_bZ_d3_r07_center_5_3": 9136, + "surface_code_bZ_d3_r09_center_5_3": 15337, + "surface_code_bZ_d3_r11_center_5_3": 11996, + "surface_code_bZ_d3_r13_center_5_3": 12732, + "surface_code_bZ_d3_r15_center_5_3": 13128, + "surface_code_bZ_d3_r17_center_5_3": 14689, + "surface_code_bZ_d3_r19_center_5_3": 11983, + "surface_code_bZ_d3_r21_center_5_3": 11992, + "surface_code_bZ_d3_r23_center_5_3": 11625, + "surface_code_bZ_d3_r25_center_5_3": 12464 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261205, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_5_3", + "step": 1, + "loss": 0.6346971988677979, + "error": 0.3818359375, + "gradient_norm": 0.046160198748111725, + "elapsed": 433.7457048892975 + }, + { + "group": "d3_bZ_center_5_3", + "step": 16, + "loss": 0.46678581833839417, + "error": 0.23828125, + "gradient_norm": 0.04110230877995491, + "elapsed": 438.16989040374756 + }, + { + "group": "d3_bZ_center_5_3", + "step": 32, + "loss": 0.17910712957382202, + "error": 0.064453125, + "gradient_norm": 0.030056120827794075, + "elapsed": 442.8582558631897 + }, + { + "group": "d3_bZ_center_5_3", + "step": 48, + "loss": 0.5041052103042603, + "error": 0.27734375, + "gradient_norm": 0.045486729592084885, + "elapsed": 447.66860795021057 + }, + { + "group": "d3_bZ_center_5_3", + "step": 64, + "loss": 0.5663014054298401, + "error": 0.310546875, + "gradient_norm": 0.04649529233574867, + "elapsed": 452.51550030708313 + }, + { + "group": "d3_bZ_center_5_3", + "step": 80, + "loss": 0.5388609766960144, + "error": 0.2841796875, + "gradient_norm": 0.05346957594156265, + "elapsed": 457.18010997772217 + }, + { + "group": "d3_bZ_center_5_3", + "step": 96, + "loss": 0.6176578998565674, + "error": 0.375, + "gradient_norm": 0.08028864115476608, + "elapsed": 461.89074301719666 + }, + { + "group": "d3_bZ_center_5_3", + "step": 112, + "loss": 0.6225342750549316, + "error": 0.36328125, + "gradient_norm": 0.030471889302134514, + "elapsed": 466.5776717662811 + }, + { + "group": "d3_bZ_center_5_3", + "step": 128, + "loss": 0.2725566625595093, + "error": 0.111328125, + "gradient_norm": 0.05236189067363739, + "elapsed": 471.32313442230225 + }, + { + "group": "d3_bZ_center_5_3", + "step": 144, + "loss": 0.6361372470855713, + "error": 0.3984375, + "gradient_norm": 0.07191100716590881, + "elapsed": 478.3580629825592 + }, + { + "group": "d3_bZ_center_5_3", + "step": 160, + "loss": 0.2549514174461365, + "error": 0.1025390625, + "gradient_norm": 0.0485384576022625, + "elapsed": 484.5399954319 + }, + { + "group": "d3_bZ_center_5_3", + "step": 176, + "loss": 0.06202135607600212, + "error": 0.0205078125, + "gradient_norm": 0.01821581833064556, + "elapsed": 490.2966978549957 + }, + { + "group": "d3_bZ_center_5_3", + "step": 192, + "loss": 0.5546645522117615, + "error": 0.296875, + "gradient_norm": 0.07931670546531677, + "elapsed": 496.1227023601532 + }, + { + "group": "d3_bZ_center_5_3", + "step": 208, + "loss": 0.2724062502384186, + "error": 0.1220703125, + "gradient_norm": 0.0482773631811142, + "elapsed": 501.8398952484131 + }, + { + "group": "d3_bZ_center_5_3", + "step": 224, + "loss": 0.6230898499488831, + "error": 0.3671875, + "gradient_norm": 0.05214303359389305, + "elapsed": 508.2803044319153 + }, + { + "group": "d3_bZ_center_5_3", + "step": 240, + "loss": 0.4187527894973755, + "error": 0.2080078125, + "gradient_norm": 0.046042900532484055, + "elapsed": 513.7485942840576 + }, + { + "group": "d3_bZ_center_5_3", + "step": 256, + "loss": 0.5760256052017212, + "error": 0.3271484375, + "gradient_norm": 0.03505929186940193, + "elapsed": 519.0282807350159 + } + ] + }, + "d3_bZ_center_5_7": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_5_7", + "parent_model": { + "weights": "weights/contextual-temporal2-4096.npz", + "training_checkpoint": "temporal2/4096" + }, + "parent_weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 163281, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_5_7": 11175, + "surface_code_bZ_d3_r03_center_5_7": 13171, + "surface_code_bZ_d3_r05_center_5_7": 12697, + "surface_code_bZ_d3_r07_center_5_7": 11648, + "surface_code_bZ_d3_r09_center_5_7": 14077, + "surface_code_bZ_d3_r11_center_5_7": 13454, + "surface_code_bZ_d3_r13_center_5_7": 11564, + "surface_code_bZ_d3_r15_center_5_7": 12728, + "surface_code_bZ_d3_r17_center_5_7": 12048, + "surface_code_bZ_d3_r19_center_5_7": 14459, + "surface_code_bZ_d3_r21_center_5_7": 14010, + "surface_code_bZ_d3_r23_center_5_7": 10239, + "surface_code_bZ_d3_r25_center_5_7": 12011 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261206, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_5_7", + "step": 1, + "loss": 0.5979939103126526, + "error": 0.357421875, + "gradient_norm": 0.0660991370677948, + "elapsed": 523.6322765350342 + }, + { + "group": "d3_bZ_center_5_7", + "step": 16, + "loss": 0.6150602102279663, + "error": 0.3701171875, + "gradient_norm": 0.04266919568181038, + "elapsed": 528.4157238006592 + }, + { + "group": "d3_bZ_center_5_7", + "step": 32, + "loss": 0.44577696919441223, + "error": 0.2099609375, + "gradient_norm": 0.06689892709255219, + "elapsed": 533.0822012424469 + }, + { + "group": "d3_bZ_center_5_7", + "step": 48, + "loss": 0.4075019657611847, + "error": 0.1884765625, + "gradient_norm": 0.05801992863416672, + "elapsed": 537.763840675354 + }, + { + "group": "d3_bZ_center_5_7", + "step": 64, + "loss": 0.5356203317642212, + "error": 0.2939453125, + "gradient_norm": 0.0543823316693306, + "elapsed": 542.4880893230438 + }, + { + "group": "d3_bZ_center_5_7", + "step": 80, + "loss": 0.45208629965782166, + "error": 0.2275390625, + "gradient_norm": 0.05819695070385933, + "elapsed": 547.1561362743378 + }, + { + "group": "d3_bZ_center_5_7", + "step": 96, + "loss": 0.4151451587677002, + "error": 0.2119140625, + "gradient_norm": 0.07201892882585526, + "elapsed": 551.8683395385742 + }, + { + "group": "d3_bZ_center_5_7", + "step": 112, + "loss": 0.5576318502426147, + "error": 0.31640625, + "gradient_norm": 0.04457806423306465, + "elapsed": 556.642165184021 + }, + { + "group": "d3_bZ_center_5_7", + "step": 128, + "loss": 0.20078304409980774, + "error": 0.08984375, + "gradient_norm": 0.040219370275735855, + "elapsed": 561.4243121147156 + }, + { + "group": "d3_bZ_center_5_7", + "step": 144, + "loss": 0.45917582511901855, + "error": 0.2236328125, + "gradient_norm": 0.0707971602678299, + "elapsed": 567.7284438610077 + }, + { + "group": "d3_bZ_center_5_7", + "step": 160, + "loss": 0.5936293601989746, + "error": 0.345703125, + "gradient_norm": 0.12180078029632568, + "elapsed": 572.3563349246979 + }, + { + "group": "d3_bZ_center_5_7", + "step": 176, + "loss": 0.24654456973075867, + "error": 0.1044921875, + "gradient_norm": 0.04859209433197975, + "elapsed": 577.008533000946 + }, + { + "group": "d3_bZ_center_5_7", + "step": 192, + "loss": 0.4809238612651825, + "error": 0.2509765625, + "gradient_norm": 0.09741280972957611, + "elapsed": 581.7403192520142 + }, + { + "group": "d3_bZ_center_5_7", + "step": 208, + "loss": 0.36378931999206543, + "error": 0.166015625, + "gradient_norm": 0.04881134256720543, + "elapsed": 586.367921590805 + }, + { + "group": "d3_bZ_center_5_7", + "step": 224, + "loss": 0.5131937265396118, + "error": 0.279296875, + "gradient_norm": 0.08562120050191879, + "elapsed": 591.1944098472595 + }, + { + "group": "d3_bZ_center_5_7", + "step": 240, + "loss": 0.4193183183670044, + "error": 0.2099609375, + "gradient_norm": 0.0680096298456192, + "elapsed": 595.8478200435638 + }, + { + "group": "d3_bZ_center_5_7", + "step": 256, + "loss": 0.467867910861969, + "error": 0.24609375, + "gradient_norm": 0.07342159003019333, + "elapsed": 600.4172458648682 + } + ] + }, + "d3_bZ_center_7_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_7_5", + "parent_model": { + "weights": "weights/contextual-temporal2-4096.npz", + "training_checkpoint": "temporal2/4096" + }, + "parent_weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 159856, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_7_5": 10637, + "surface_code_bZ_d3_r03_center_7_5": 13460, + "surface_code_bZ_d3_r05_center_7_5": 12002, + "surface_code_bZ_d3_r07_center_7_5": 8000, + "surface_code_bZ_d3_r09_center_7_5": 10743, + "surface_code_bZ_d3_r11_center_7_5": 16789, + "surface_code_bZ_d3_r13_center_7_5": 12364, + "surface_code_bZ_d3_r15_center_7_5": 15213, + "surface_code_bZ_d3_r17_center_7_5": 14167, + "surface_code_bZ_d3_r19_center_7_5": 11099, + "surface_code_bZ_d3_r21_center_7_5": 13178, + "surface_code_bZ_d3_r23_center_7_5": 12014, + "surface_code_bZ_d3_r25_center_7_5": 10190 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261207, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_7_5", + "step": 1, + "loss": 0.4038092792034149, + "error": 0.197265625, + "gradient_norm": 0.05896063148975372, + "elapsed": 603.840416431427 + }, + { + "group": "d3_bZ_center_7_5", + "step": 16, + "loss": 0.6033527851104736, + "error": 0.3515625, + "gradient_norm": 0.05784430727362633, + "elapsed": 608.1250426769257 + }, + { + "group": "d3_bZ_center_7_5", + "step": 32, + "loss": 0.5283372402191162, + "error": 0.283203125, + "gradient_norm": 0.050800539553165436, + "elapsed": 612.7134759426117 + }, + { + "group": "d3_bZ_center_7_5", + "step": 48, + "loss": 0.5995811820030212, + "error": 0.3291015625, + "gradient_norm": 0.05547967553138733, + "elapsed": 617.2784404754639 + }, + { + "group": "d3_bZ_center_7_5", + "step": 64, + "loss": 0.40154707431793213, + "error": 0.205078125, + "gradient_norm": 0.06852669268846512, + "elapsed": 621.8420352935791 + }, + { + "group": "d3_bZ_center_7_5", + "step": 80, + "loss": 0.4995174705982208, + "error": 0.2763671875, + "gradient_norm": 0.061341386288404465, + "elapsed": 626.40260887146 + }, + { + "group": "d3_bZ_center_7_5", + "step": 96, + "loss": 0.5751184225082397, + "error": 0.3251953125, + "gradient_norm": 0.07929262518882751, + "elapsed": 630.9725329875946 + }, + { + "group": "d3_bZ_center_7_5", + "step": 112, + "loss": 0.624832808971405, + "error": 0.369140625, + "gradient_norm": 0.045014865696430206, + "elapsed": 635.5494453907013 + }, + { + "group": "d3_bZ_center_7_5", + "step": 128, + "loss": 0.4616764783859253, + "error": 0.224609375, + "gradient_norm": 0.0743650421500206, + "elapsed": 640.093489408493 + }, + { + "group": "d3_bZ_center_7_5", + "step": 144, + "loss": 0.5214440822601318, + "error": 0.2724609375, + "gradient_norm": 0.05418862774968147, + "elapsed": 646.2130215167999 + }, + { + "group": "d3_bZ_center_7_5", + "step": 160, + "loss": 0.27278852462768555, + "error": 0.12109375, + "gradient_norm": 0.059856753796339035, + "elapsed": 650.7696936130524 + }, + { + "group": "d3_bZ_center_7_5", + "step": 176, + "loss": 0.5251824259757996, + "error": 0.2734375, + "gradient_norm": 0.0982872024178505, + "elapsed": 655.3179745674133 + }, + { + "group": "d3_bZ_center_7_5", + "step": 192, + "loss": 0.510776937007904, + "error": 0.2744140625, + "gradient_norm": 0.0638406053185463, + "elapsed": 659.8532302379608 + }, + { + "group": "d3_bZ_center_7_5", + "step": 208, + "loss": 0.4173796772956848, + "error": 0.20703125, + "gradient_norm": 0.0652337446808815, + "elapsed": 664.3970146179199 + }, + { + "group": "d3_bZ_center_7_5", + "step": 224, + "loss": 0.42136240005493164, + "error": 0.203125, + "gradient_norm": 0.04171523451805115, + "elapsed": 668.9384174346924 + }, + { + "group": "d3_bZ_center_7_5", + "step": 240, + "loss": 0.2494639754295349, + "error": 0.1201171875, + "gradient_norm": 0.06969694793224335, + "elapsed": 673.4954979419708 + }, + { + "group": "d3_bZ_center_7_5", + "step": 256, + "loss": 0.26821407675743103, + "error": 0.1181640625, + "gradient_norm": 0.04254033416509628, + "elapsed": 678.0544662475586 + } + ] + } + }, + "initialization": "Continue session-trained selected temporal components; no new random parameters", + "training": "Each group samples uniformly over its own13 durations; supplied training labels only", + "eligible_training_shots": 2067520, + "steps": 2048, + "steps_per_group": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer_restored": false, + "rng_restored": false, + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "run_config": { + "package": "/run-state/workspace/research/context_upgrades/short_categorical3/package", + "output": "/run-state/workspace/research/learned_exact/group_specialize1", + "steps": 256, + "eval_every": 128, + "batch": 1024, + "validation_shots": 1024, + "validation_batch": 1024, + "learning_rate": 0.0001, + "seed": 20261200, + "groups": [ + "d3_bX_center_3_5", + "d3_bX_center_5_3", + "d3_bX_center_5_7", + "d3_bX_center_7_5", + "d3_bZ_center_3_5", + "d3_bZ_center_5_3", + "d3_bZ_center_5_7", + "d3_bZ_center_7_5" + ], + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "parent_config_sha256": "50123b5d6a4515814bb74a93963e83d17c2d3eb47af4d12b7757f523ac7c2f6a", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1" + }, + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "new_random_parameters": 0, + "training_draws": 2097152, + "test_data_used": false, + "declared_plan": { + "hypothesis": "Group-specific fine-tuning may reduce conflicting updates across d3 geometries and bases", + "parents": "The temporal component selected for each of the8 groups in CURRENT after fresh2_continuation_finished.json", + "new_random_parameters": 0, + "sampling_seeds": "20261200 plus lexicographic group rank0..7", + "training": "256 updates per group,B1024,LR.0001; uniform sampling of all13 durations and all258440 training rows per group", + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global gradient norm clip1", + "total_optimizer_updates": 2048, + "total_training_draws": 2097152, + "validation": "Screen at0/128/256. Full validation at0/128/256; step0 is a diagnostic, excluded from new checkpoint selection", + "selection": "Per-group mean failure over all13 durations: incumbent, raw128/256, or equal small-contextual blend128/256; retain incumbent on ties", + "short_model_followup": "Recheck the previously training-fitted categorical1 heads after group replacement", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "selection_eligible": false, + "submission_eligible": false, + "trainer_sha256": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "run": "/run-state/workspace/research/learned_exact/specialize_smoke2", + "checks": [ + { + "group": "d3_bX_center_3_5", + "parent_exact": true, + "fresh_zero_optimizer": true, + "one_update_changes_parameters": true, + "sampling_replay_exact": true, + "all13_durations_evaluated": true + }, + { + "group": "d3_bZ_center_7_5", + "parent_exact": true, + "fresh_zero_optimizer": true, + "one_update_changes_parameters": true, + "sampling_replay_exact": true, + "all13_durations_evaluated": true + } + ], + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/group_specialize1", + "selected_checkpoints": { + "d3_bX_center_3_5": 128, + "d3_bX_center_5_7": 256, + "d3_bX_center_7_5": 128, + "d3_bZ_center_7_5": 128 + }, + "checkpoint_records": { + "d3_bX_center_3_5": { + "group": "d3_bX_center_3_5", + "step": 128, + "training_draws": 131072, + "unique_training_rows_seen_in_this_phase": 101608, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 7393, + "surface_code_bX_d3_r03_center_3_5": 9191, + "surface_code_bX_d3_r05_center_3_5": 9634, + "surface_code_bX_d3_r07_center_3_5": 9218, + "surface_code_bX_d3_r09_center_3_5": 6691, + "surface_code_bX_d3_r11_center_3_5": 6028, + "surface_code_bX_d3_r13_center_3_5": 9122, + "surface_code_bX_d3_r15_center_3_5": 5301, + "surface_code_bX_d3_r17_center_3_5": 8630, + "surface_code_bX_d3_r19_center_3_5": 5276, + "surface_code_bX_d3_r21_center_3_5": 8553, + "surface_code_bX_d3_r23_center_3_5": 7977, + "surface_code_bX_d3_r25_center_3_5": 8594 + }, + "weights": "weights-128.npz", + "weights_sha256": "90c6cb7fd3be8d363318f45257de6670ba19d9336d096dc3efb309bac88b2bf9", + "complete": true + }, + "d3_bX_center_5_7": { + "group": "d3_bX_center_5_7", + "step": 256, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162612, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_7": 13532, + "surface_code_bX_d3_r03_center_5_7": 12060, + "surface_code_bX_d3_r05_center_5_7": 14744, + "surface_code_bX_d3_r07_center_5_7": 11642, + "surface_code_bX_d3_r09_center_5_7": 13167, + "surface_code_bX_d3_r11_center_5_7": 8639, + "surface_code_bX_d3_r13_center_5_7": 14627, + "surface_code_bX_d3_r15_center_5_7": 11178, + "surface_code_bX_d3_r17_center_5_7": 10160, + "surface_code_bX_d3_r19_center_5_7": 13125, + "surface_code_bX_d3_r21_center_5_7": 13464, + "surface_code_bX_d3_r23_center_5_7": 13143, + "surface_code_bX_d3_r25_center_5_7": 13131 + }, + "weights": "weights-256.npz", + "weights_sha256": "7dc5b5ed51423bae023bb2c15de420850fef4fedb82760a7bcd993393301e038", + "complete": true + }, + "d3_bX_center_7_5": { + "group": "d3_bX_center_7_5", + "step": 128, + "training_draws": 131072, + "unique_training_rows_seen_in_this_phase": 101875, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_7_5": 7327, + "surface_code_bX_d3_r03_center_7_5": 6711, + "surface_code_bX_d3_r05_center_7_5": 9068, + "surface_code_bX_d3_r07_center_7_5": 9212, + "surface_code_bX_d3_r09_center_7_5": 6001, + "surface_code_bX_d3_r11_center_7_5": 7353, + "surface_code_bX_d3_r13_center_7_5": 7373, + "surface_code_bX_d3_r15_center_7_5": 8580, + "surface_code_bX_d3_r17_center_7_5": 6713, + "surface_code_bX_d3_r19_center_7_5": 9686, + "surface_code_bX_d3_r21_center_7_5": 8553, + "surface_code_bX_d3_r23_center_7_5": 7325, + "surface_code_bX_d3_r25_center_7_5": 7973 + }, + "weights": "weights-128.npz", + "weights_sha256": "1dc16b14813ebfd874acf9c907870144bc6ac98c8de8b4e8c47e41cdcfb3f1c3", + "complete": true + }, + "d3_bZ_center_7_5": { + "group": "d3_bZ_center_7_5", + "step": 128, + "training_draws": 131072, + "unique_training_rows_seen_in_this_phase": 101460, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_7_5": 7386, + "surface_code_bZ_d3_r03_center_7_5": 7382, + "surface_code_bZ_d3_r05_center_7_5": 7375, + "surface_code_bZ_d3_r07_center_7_5": 4523, + "surface_code_bZ_d3_r09_center_7_5": 6016, + "surface_code_bZ_d3_r11_center_7_5": 10680, + "surface_code_bZ_d3_r13_center_7_5": 9644, + "surface_code_bZ_d3_r15_center_7_5": 7341, + "surface_code_bZ_d3_r17_center_7_5": 9210, + "surface_code_bZ_d3_r19_center_7_5": 8536, + "surface_code_bZ_d3_r21_center_7_5": 7410, + "surface_code_bZ_d3_r23_center_7_5": 8625, + "surface_code_bZ_d3_r25_center_7_5": 7332 + }, + "weights": "weights-128.npz", + "weights_sha256": "8f78092b6539927132aebd28deb0e0d1b72f43596b79e074e3206f4a784dd000", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure across all13 durations per group among incumbent, specialized128/256 and equal small-contextual blends; retain incumbent on ties", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24451622596153846, + "128": 0.2444110576923077, + "blend-128": 0.24523737980769234, + "256": 0.24468149038461534, + "blend-256": 0.24532752403846156 + }, + "selected": "128" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2526592548076923, + "128": 0.2528094951923077, + "blend-128": 0.25312499999999993, + "256": 0.2532001201923077, + "blend-256": 0.25318509615384616 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.2333984375, + "128": 0.23329326923076926, + "blend-128": 0.23414963942307693, + "256": 0.233203125, + "blend-256": 0.2338641826923077 + }, + "selected": "256" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23889723557692305, + "128": 0.23933293269230768, + "blend-128": 0.23880709134615385, + "256": 0.23907752403846153, + "blend-256": 0.23888221153846154 + }, + "selected": "blend-128" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24447115384615387, + "128": 0.24456129807692306, + "blend-128": 0.24534254807692307, + "256": 0.24462139423076923, + "blend-256": 0.24505709134615386 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23652343749999996, + "128": 0.2371394230769231, + "blend-128": 0.23753004807692307, + "256": 0.2373347355769231, + "blend-256": 0.23728966346153849 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.2356670673076923, + "128": 0.23635817307692306, + "blend-128": 0.23662860576923073, + "256": 0.23571213942307687, + "blend-256": 0.23638822115384614 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23294771634615385, + "128": 0.23282752403846158, + "blend-128": 0.2331280048076923, + "256": 0.23348858173076922, + "blend-256": 0.23336838942307692 + }, + "selected": "128" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23228665865384618 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "fresh_specialize1", + "training_run": { + "experiment": "group-specific d3 continuation", + "groups": { + "d3_bX_center_3_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bX_center_3_5", + "parent_model": { + "weights": "weights/d3_bX_center_3_5.npz", + "training_checkpoint": "fresh_temporal1_swa/mean3" + }, + "parent_weights_sha256": "e3f13efc5e5af11a8591a90b3176b224c892a91c98925cde79d20d3f3de8f184", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162520, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 13115, + "surface_code_bX_d3_r03_center_3_5": 14116, + "surface_code_bX_d3_r05_center_3_5": 11622, + "surface_code_bX_d3_r07_center_3_5": 14040, + "surface_code_bX_d3_r09_center_3_5": 11161, + "surface_code_bX_d3_r11_center_3_5": 13522, + "surface_code_bX_d3_r13_center_3_5": 12798, + "surface_code_bX_d3_r15_center_3_5": 11592, + "surface_code_bX_d3_r17_center_3_5": 14901, + "surface_code_bX_d3_r19_center_3_5": 11912, + "surface_code_bX_d3_r21_center_3_5": 13434, + "surface_code_bX_d3_r23_center_3_5": 11123, + "surface_code_bX_d3_r25_center_3_5": 9184 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261340, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_3_5", + "step": 1, + "loss": 0.5972281098365784, + "error": 0.3662109375, + "gradient_norm": 0.09729045629501343, + "elapsed": 22.526862859725952 + }, + { + "group": "d3_bX_center_3_5", + "step": 16, + "loss": 0.5871584415435791, + "error": 0.3408203125, + "gradient_norm": 0.055138200521469116, + "elapsed": 26.965821504592896 + }, + { + "group": "d3_bX_center_3_5", + "step": 32, + "loss": 0.042685166001319885, + "error": 0.013671875, + "gradient_norm": 0.02088288962841034, + "elapsed": 31.70876169204712 + }, + { + "group": "d3_bX_center_3_5", + "step": 48, + "loss": 0.4546062648296356, + "error": 0.228515625, + "gradient_norm": 0.04970305413007736, + "elapsed": 36.47229552268982 + }, + { + "group": "d3_bX_center_3_5", + "step": 64, + "loss": 0.4556293487548828, + "error": 0.2392578125, + "gradient_norm": 0.054844047874212265, + "elapsed": 41.22984075546265 + }, + { + "group": "d3_bX_center_3_5", + "step": 80, + "loss": 0.6321922540664673, + "error": 0.3837890625, + "gradient_norm": 0.06692170351743698, + "elapsed": 45.95981740951538 + }, + { + "group": "d3_bX_center_3_5", + "step": 96, + "loss": 0.6371946334838867, + "error": 0.390625, + "gradient_norm": 0.05255212262272835, + "elapsed": 50.691991567611694 + }, + { + "group": "d3_bX_center_3_5", + "step": 112, + "loss": 0.4951903223991394, + "error": 0.259765625, + "gradient_norm": 0.055461276322603226, + "elapsed": 55.39455461502075 + }, + { + "group": "d3_bX_center_3_5", + "step": 128, + "loss": 0.4276946187019348, + "error": 0.2265625, + "gradient_norm": 0.0767400711774826, + "elapsed": 60.12631702423096 + }, + { + "group": "d3_bX_center_3_5", + "step": 144, + "loss": 0.36871206760406494, + "error": 0.181640625, + "gradient_norm": 0.09697986394166946, + "elapsed": 66.26382994651794 + }, + { + "group": "d3_bX_center_3_5", + "step": 160, + "loss": 0.35108059644699097, + "error": 0.154296875, + "gradient_norm": 0.07385196536779404, + "elapsed": 70.9672303199768 + }, + { + "group": "d3_bX_center_3_5", + "step": 176, + "loss": 0.5217756032943726, + "error": 0.287109375, + "gradient_norm": 0.09417059272527695, + "elapsed": 75.7307870388031 + }, + { + "group": "d3_bX_center_3_5", + "step": 192, + "loss": 0.5395345091819763, + "error": 0.2822265625, + "gradient_norm": 0.06037866696715355, + "elapsed": 80.4467306137085 + }, + { + "group": "d3_bX_center_3_5", + "step": 208, + "loss": 0.5697548985481262, + "error": 0.328125, + "gradient_norm": 0.04918132722377777, + "elapsed": 85.22002744674683 + }, + { + "group": "d3_bX_center_3_5", + "step": 224, + "loss": 0.5538840293884277, + "error": 0.3115234375, + "gradient_norm": 0.048242222517728806, + "elapsed": 89.97812533378601 + }, + { + "group": "d3_bX_center_3_5", + "step": 240, + "loss": 0.05894186347723007, + "error": 0.0244140625, + "gradient_norm": 0.018116898834705353, + "elapsed": 94.70312404632568 + }, + { + "group": "d3_bX_center_3_5", + "step": 256, + "loss": 0.628689169883728, + "error": 0.3955078125, + "gradient_norm": 0.08658003807067871, + "elapsed": 99.46653890609741 + } + ] + }, + "d3_bX_center_5_3": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bX_center_5_3", + "parent_model": { + "weights": "weights/d3_bX_center_5_3.npz", + "training_checkpoint": "fresh_temporal1_full/2048" + }, + "parent_weights_sha256": "841f3989d6ba86b179109e2d80cea037ba38a28446f962f9104651e4f4504322", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162696, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_3": 13794, + "surface_code_bX_d3_r03_center_5_3": 11934, + "surface_code_bX_d3_r05_center_5_3": 14628, + "surface_code_bX_d3_r07_center_5_3": 13165, + "surface_code_bX_d3_r09_center_5_3": 10271, + "surface_code_bX_d3_r11_center_5_3": 13099, + "surface_code_bX_d3_r13_center_5_3": 12397, + "surface_code_bX_d3_r15_center_5_3": 13762, + "surface_code_bX_d3_r17_center_5_3": 14406, + "surface_code_bX_d3_r19_center_5_3": 10228, + "surface_code_bX_d3_r21_center_5_3": 10240, + "surface_code_bX_d3_r23_center_5_3": 11633, + "surface_code_bX_d3_r25_center_5_3": 13139 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261341, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_5_3", + "step": 1, + "loss": 0.5862298011779785, + "error": 0.34375, + "gradient_norm": 0.05147814378142357, + "elapsed": 102.5717089176178 + }, + { + "group": "d3_bX_center_5_3", + "step": 16, + "loss": 0.05524348467588425, + "error": 0.017578125, + "gradient_norm": 0.013652711175382137, + "elapsed": 107.07693839073181 + }, + { + "group": "d3_bX_center_5_3", + "step": 32, + "loss": 0.07757126539945602, + "error": 0.0283203125, + "gradient_norm": 0.07544182986021042, + "elapsed": 111.80529713630676 + }, + { + "group": "d3_bX_center_5_3", + "step": 48, + "loss": 0.6146149039268494, + "error": 0.361328125, + "gradient_norm": 0.09188499301671982, + "elapsed": 116.46751403808594 + }, + { + "group": "d3_bX_center_5_3", + "step": 64, + "loss": 0.612895131111145, + "error": 0.3525390625, + "gradient_norm": 0.03351254388689995, + "elapsed": 121.1200020313263 + }, + { + "group": "d3_bX_center_5_3", + "step": 80, + "loss": 0.36469078063964844, + "error": 0.1748046875, + "gradient_norm": 0.03757704794406891, + "elapsed": 125.76470494270325 + }, + { + "group": "d3_bX_center_5_3", + "step": 96, + "loss": 0.5000208616256714, + "error": 0.2666015625, + "gradient_norm": 0.08713047206401825, + "elapsed": 130.3763153553009 + }, + { + "group": "d3_bX_center_5_3", + "step": 112, + "loss": 0.618985652923584, + "error": 0.3759765625, + "gradient_norm": 0.04596935585141182, + "elapsed": 135.02144193649292 + }, + { + "group": "d3_bX_center_5_3", + "step": 128, + "loss": 0.5212572813034058, + "error": 0.2744140625, + "gradient_norm": 0.04318114370107651, + "elapsed": 139.6484034061432 + }, + { + "group": "d3_bX_center_5_3", + "step": 144, + "loss": 0.5770317316055298, + "error": 0.31640625, + "gradient_norm": 0.045092009007930756, + "elapsed": 145.6771833896637 + }, + { + "group": "d3_bX_center_5_3", + "step": 160, + "loss": 0.30534493923187256, + "error": 0.1259765625, + "gradient_norm": 0.06594840437173843, + "elapsed": 150.30831336975098 + }, + { + "group": "d3_bX_center_5_3", + "step": 176, + "loss": 0.6136740446090698, + "error": 0.3623046875, + "gradient_norm": 0.05478309467434883, + "elapsed": 154.93900394439697 + }, + { + "group": "d3_bX_center_5_3", + "step": 192, + "loss": 0.6192128658294678, + "error": 0.3974609375, + "gradient_norm": 0.0520634800195694, + "elapsed": 159.5931694507599 + }, + { + "group": "d3_bX_center_5_3", + "step": 208, + "loss": 0.03610404580831528, + "error": 0.013671875, + "gradient_norm": 0.0536193922162056, + "elapsed": 164.6801688671112 + }, + { + "group": "d3_bX_center_5_3", + "step": 224, + "loss": 0.2998519837856293, + "error": 0.1279296875, + "gradient_norm": 0.04463409259915352, + "elapsed": 169.92359042167664 + }, + { + "group": "d3_bX_center_5_3", + "step": 240, + "loss": 0.41369059681892395, + "error": 0.208984375, + "gradient_norm": 0.06100081279873848, + "elapsed": 174.74760675430298 + }, + { + "group": "d3_bX_center_5_3", + "step": 256, + "loss": 0.39370015263557434, + "error": 0.1904296875, + "gradient_norm": 0.05426454544067383, + "elapsed": 179.55323243141174 + } + ] + }, + "d3_bX_center_5_7": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bX_center_5_7", + "parent_model": { + "weights": "weights/d3_bX_center_5_7.npz", + "training_checkpoint": "fresh_temporal1_swa/mean3" + }, + "parent_weights_sha256": "e3f13efc5e5af11a8591a90b3176b224c892a91c98925cde79d20d3f3de8f184", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 161668, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_7": 10228, + "surface_code_bX_d3_r03_center_5_7": 10635, + "surface_code_bX_d3_r05_center_5_7": 12806, + "surface_code_bX_d3_r07_center_5_7": 13760, + "surface_code_bX_d3_r09_center_5_7": 12011, + "surface_code_bX_d3_r11_center_5_7": 13837, + "surface_code_bX_d3_r13_center_5_7": 8569, + "surface_code_bX_d3_r15_center_5_7": 11210, + "surface_code_bX_d3_r17_center_5_7": 15584, + "surface_code_bX_d3_r19_center_5_7": 12771, + "surface_code_bX_d3_r21_center_5_7": 12434, + "surface_code_bX_d3_r23_center_5_7": 13116, + "surface_code_bX_d3_r25_center_5_7": 14707 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261342, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_5_7", + "step": 1, + "loss": 0.5559697151184082, + "error": 0.30859375, + "gradient_norm": 0.06185061112046242, + "elapsed": 182.80661964416504 + }, + { + "group": "d3_bX_center_5_7", + "step": 16, + "loss": 0.03614909201860428, + "error": 0.0107421875, + "gradient_norm": 0.03212688863277435, + "elapsed": 187.18737983703613 + }, + { + "group": "d3_bX_center_5_7", + "step": 32, + "loss": 0.604283332824707, + "error": 0.3662109375, + "gradient_norm": 0.03913086652755737, + "elapsed": 191.79740977287292 + }, + { + "group": "d3_bX_center_5_7", + "step": 48, + "loss": 0.31246620416641235, + "error": 0.1396484375, + "gradient_norm": 0.03126392886042595, + "elapsed": 196.3891875743866 + }, + { + "group": "d3_bX_center_5_7", + "step": 64, + "loss": 0.6091776490211487, + "error": 0.3671875, + "gradient_norm": 0.0495346337556839, + "elapsed": 200.97459626197815 + }, + { + "group": "d3_bX_center_5_7", + "step": 80, + "loss": 0.16633003950119019, + "error": 0.076171875, + "gradient_norm": 0.04027097672224045, + "elapsed": 205.58613395690918 + }, + { + "group": "d3_bX_center_5_7", + "step": 96, + "loss": 0.5015680193901062, + "error": 0.26953125, + "gradient_norm": 0.030774686485528946, + "elapsed": 210.19216585159302 + }, + { + "group": "d3_bX_center_5_7", + "step": 112, + "loss": 0.32114508748054504, + "error": 0.162109375, + "gradient_norm": 0.02747691608965397, + "elapsed": 214.76673650741577 + }, + { + "group": "d3_bX_center_5_7", + "step": 128, + "loss": 0.5680451989173889, + "error": 0.322265625, + "gradient_norm": 0.048092134296894073, + "elapsed": 219.33806443214417 + }, + { + "group": "d3_bX_center_5_7", + "step": 144, + "loss": 0.29577186703681946, + "error": 0.125, + "gradient_norm": 0.07507020980119705, + "elapsed": 225.3518705368042 + }, + { + "group": "d3_bX_center_5_7", + "step": 160, + "loss": 0.3614932894706726, + "error": 0.173828125, + "gradient_norm": 0.10962968319654465, + "elapsed": 229.94857144355774 + }, + { + "group": "d3_bX_center_5_7", + "step": 176, + "loss": 0.6085208654403687, + "error": 0.3603515625, + "gradient_norm": 0.068535715341568, + "elapsed": 234.55318641662598 + }, + { + "group": "d3_bX_center_5_7", + "step": 192, + "loss": 0.48541295528411865, + "error": 0.240234375, + "gradient_norm": 0.04494304582476616, + "elapsed": 239.12522220611572 + }, + { + "group": "d3_bX_center_5_7", + "step": 208, + "loss": 0.5066522359848022, + "error": 0.2578125, + "gradient_norm": 0.10582146048545837, + "elapsed": 243.7482135295868 + }, + { + "group": "d3_bX_center_5_7", + "step": 224, + "loss": 0.5992171764373779, + "error": 0.3564453125, + "gradient_norm": 0.032183557748794556, + "elapsed": 248.27840328216553 + }, + { + "group": "d3_bX_center_5_7", + "step": 240, + "loss": 0.6387370228767395, + "error": 0.38671875, + "gradient_norm": 0.05276519060134888, + "elapsed": 252.89431762695312 + }, + { + "group": "d3_bX_center_5_7", + "step": 256, + "loss": 0.616998553276062, + "error": 0.3828125, + "gradient_norm": 0.04336182028055191, + "elapsed": 257.7164134979248 + } + ] + }, + "d3_bX_center_7_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bX_center_7_5", + "parent_model": { + "weights": "weights/d3_bX_center_7_5.npz", + "training_checkpoint": "fresh_temporal1_swa/mean3" + }, + "parent_weights_sha256": "e3f13efc5e5af11a8591a90b3176b224c892a91c98925cde79d20d3f3de8f184", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 161884, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_7_5": 13539, + "surface_code_bX_d3_r03_center_7_5": 11179, + "surface_code_bX_d3_r05_center_7_5": 13449, + "surface_code_bX_d3_r07_center_7_5": 12018, + "surface_code_bX_d3_r09_center_7_5": 9147, + "surface_code_bX_d3_r11_center_7_5": 14130, + "surface_code_bX_d3_r13_center_7_5": 13589, + "surface_code_bX_d3_r15_center_7_5": 11584, + "surface_code_bX_d3_r17_center_7_5": 15812, + "surface_code_bX_d3_r19_center_7_5": 10710, + "surface_code_bX_d3_r21_center_7_5": 11648, + "surface_code_bX_d3_r23_center_7_5": 10685, + "surface_code_bX_d3_r25_center_7_5": 14394 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261343, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_7_5", + "step": 1, + "loss": 0.6189323663711548, + "error": 0.3798828125, + "gradient_norm": 0.0824144259095192, + "elapsed": 261.9800066947937 + }, + { + "group": "d3_bX_center_7_5", + "step": 16, + "loss": 0.5183702707290649, + "error": 0.2841796875, + "gradient_norm": 0.05808177590370178, + "elapsed": 266.4418783187866 + }, + { + "group": "d3_bX_center_7_5", + "step": 32, + "loss": 0.41057348251342773, + "error": 0.1962890625, + "gradient_norm": 0.1098952442407608, + "elapsed": 271.3727798461914 + }, + { + "group": "d3_bX_center_7_5", + "step": 48, + "loss": 0.5978471040725708, + "error": 0.3583984375, + "gradient_norm": 0.0427558533847332, + "elapsed": 276.22037172317505 + }, + { + "group": "d3_bX_center_7_5", + "step": 64, + "loss": 0.4469044506549835, + "error": 0.2177734375, + "gradient_norm": 0.09126068651676178, + "elapsed": 280.94955015182495 + }, + { + "group": "d3_bX_center_7_5", + "step": 80, + "loss": 0.5190691947937012, + "error": 0.2841796875, + "gradient_norm": 0.0591721348464489, + "elapsed": 285.5891811847687 + }, + { + "group": "d3_bX_center_7_5", + "step": 96, + "loss": 0.5192885398864746, + "error": 0.279296875, + "gradient_norm": 0.04653405770659447, + "elapsed": 290.2212941646576 + }, + { + "group": "d3_bX_center_7_5", + "step": 112, + "loss": 0.5319864749908447, + "error": 0.27734375, + "gradient_norm": 0.0542965903878212, + "elapsed": 294.8361167907715 + }, + { + "group": "d3_bX_center_7_5", + "step": 128, + "loss": 0.6141693592071533, + "error": 0.3681640625, + "gradient_norm": 0.04398813098669052, + "elapsed": 299.45729517936707 + }, + { + "group": "d3_bX_center_7_5", + "step": 144, + "loss": 0.18833772838115692, + "error": 0.076171875, + "gradient_norm": 0.030775347724556923, + "elapsed": 305.5211350917816 + }, + { + "group": "d3_bX_center_7_5", + "step": 160, + "loss": 0.2638503909111023, + "error": 0.10546875, + "gradient_norm": 0.0835186094045639, + "elapsed": 310.09098768234253 + }, + { + "group": "d3_bX_center_7_5", + "step": 176, + "loss": 0.5000225305557251, + "error": 0.26171875, + "gradient_norm": 0.0485658198595047, + "elapsed": 314.71282410621643 + }, + { + "group": "d3_bX_center_7_5", + "step": 192, + "loss": 0.5176602602005005, + "error": 0.265625, + "gradient_norm": 0.06985300034284592, + "elapsed": 319.29910349845886 + }, + { + "group": "d3_bX_center_7_5", + "step": 208, + "loss": 0.609516978263855, + "error": 0.365234375, + "gradient_norm": 0.09265986829996109, + "elapsed": 323.95228028297424 + }, + { + "group": "d3_bX_center_7_5", + "step": 224, + "loss": 0.6175316572189331, + "error": 0.353515625, + "gradient_norm": 0.057954009622335434, + "elapsed": 328.61600732803345 + }, + { + "group": "d3_bX_center_7_5", + "step": 240, + "loss": 0.04259520396590233, + "error": 0.015625, + "gradient_norm": 0.03689190000295639, + "elapsed": 333.3176386356354 + }, + { + "group": "d3_bX_center_7_5", + "step": 256, + "loss": 0.36711788177490234, + "error": 0.16796875, + "gradient_norm": 0.04969492554664612, + "elapsed": 337.96771335601807 + } + ] + }, + "d3_bZ_center_3_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bZ_center_3_5", + "parent_model": { + "weights": "weights/d3_bZ_center_3_5.npz", + "training_checkpoint": "fresh_temporal1_swa/mean2" + }, + "parent_weights_sha256": "9f56d54ae6f2bf3996b647027e798f4933b982e98351a9e0a67a325d2ffe4b7e", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 161680, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_3_5": 8672, + "surface_code_bZ_d3_r03_center_3_5": 13543, + "surface_code_bZ_d3_r05_center_3_5": 15111, + "surface_code_bZ_d3_r07_center_3_5": 11127, + "surface_code_bZ_d3_r09_center_3_5": 10714, + "surface_code_bZ_d3_r11_center_3_5": 14628, + "surface_code_bZ_d3_r13_center_3_5": 13786, + "surface_code_bZ_d3_r15_center_3_5": 12815, + "surface_code_bZ_d3_r17_center_3_5": 11924, + "surface_code_bZ_d3_r19_center_3_5": 13769, + "surface_code_bZ_d3_r21_center_3_5": 11181, + "surface_code_bZ_d3_r23_center_3_5": 14129, + "surface_code_bZ_d3_r25_center_3_5": 10281 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261344, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_3_5", + "step": 1, + "loss": 0.47788742184638977, + "error": 0.248046875, + "gradient_norm": 0.050734370946884155, + "elapsed": 340.9673058986664 + }, + { + "group": "d3_bZ_center_3_5", + "step": 16, + "loss": 0.2594061493873596, + "error": 0.109375, + "gradient_norm": 0.08124404400587082, + "elapsed": 345.32833337783813 + }, + { + "group": "d3_bZ_center_3_5", + "step": 32, + "loss": 0.6352876424789429, + "error": 0.40234375, + "gradient_norm": 0.03613949567079544, + "elapsed": 349.96400570869446 + }, + { + "group": "d3_bZ_center_3_5", + "step": 48, + "loss": 0.638174295425415, + "error": 0.38671875, + "gradient_norm": 0.07320883125066757, + "elapsed": 355.5214445590973 + }, + { + "group": "d3_bZ_center_3_5", + "step": 64, + "loss": 0.21355925500392914, + "error": 0.0849609375, + "gradient_norm": 0.10349047929048538, + "elapsed": 360.30482625961304 + }, + { + "group": "d3_bZ_center_3_5", + "step": 80, + "loss": 0.5702664852142334, + "error": 0.3359375, + "gradient_norm": 0.04307207465171814, + "elapsed": 365.07440519332886 + }, + { + "group": "d3_bZ_center_3_5", + "step": 96, + "loss": 0.1742643117904663, + "error": 0.0732421875, + "gradient_norm": 0.05012699216604233, + "elapsed": 369.9997477531433 + }, + { + "group": "d3_bZ_center_3_5", + "step": 112, + "loss": 0.3111470341682434, + "error": 0.130859375, + "gradient_norm": 0.0680793821811676, + "elapsed": 374.67388105392456 + }, + { + "group": "d3_bZ_center_3_5", + "step": 128, + "loss": 0.3615894913673401, + "error": 0.1513671875, + "gradient_norm": 0.049869757145643234, + "elapsed": 379.287935256958 + }, + { + "group": "d3_bZ_center_3_5", + "step": 144, + "loss": 0.5365645885467529, + "error": 0.2978515625, + "gradient_norm": 0.06663104146718979, + "elapsed": 385.31509280204773 + }, + { + "group": "d3_bZ_center_3_5", + "step": 160, + "loss": 0.3594626188278198, + "error": 0.1767578125, + "gradient_norm": 0.045305266976356506, + "elapsed": 389.9340662956238 + }, + { + "group": "d3_bZ_center_3_5", + "step": 176, + "loss": 0.2880062460899353, + "error": 0.13671875, + "gradient_norm": 0.05932651460170746, + "elapsed": 394.5479998588562 + }, + { + "group": "d3_bZ_center_3_5", + "step": 192, + "loss": 0.6218544244766235, + "error": 0.3740234375, + "gradient_norm": 0.05894651263952255, + "elapsed": 399.13436126708984 + }, + { + "group": "d3_bZ_center_3_5", + "step": 208, + "loss": 0.27658650279045105, + "error": 0.119140625, + "gradient_norm": 0.05780112370848656, + "elapsed": 403.72834944725037 + }, + { + "group": "d3_bZ_center_3_5", + "step": 224, + "loss": 0.5815422534942627, + "error": 0.318359375, + "gradient_norm": 0.05921272933483124, + "elapsed": 408.3639187812805 + }, + { + "group": "d3_bZ_center_3_5", + "step": 240, + "loss": 0.580683708190918, + "error": 0.33984375, + "gradient_norm": 0.06363344937562943, + "elapsed": 412.98073863983154 + }, + { + "group": "d3_bZ_center_3_5", + "step": 256, + "loss": 0.05897409841418266, + "error": 0.017578125, + "gradient_norm": 0.028501272201538086, + "elapsed": 417.61120891571045 + } + ] + }, + "d3_bZ_center_5_3": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bZ_center_5_3", + "parent_model": { + "weights": "weights/d3_bZ_center_5_3.npz", + "training_checkpoint": "fresh_temporal1_swa/mean3" + }, + "parent_weights_sha256": "e3f13efc5e5af11a8591a90b3176b224c892a91c98925cde79d20d3f3de8f184", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162183, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_5_3": 10703, + "surface_code_bZ_d3_r03_center_5_3": 12405, + "surface_code_bZ_d3_r05_center_5_3": 11188, + "surface_code_bZ_d3_r07_center_5_3": 13546, + "surface_code_bZ_d3_r09_center_5_3": 13491, + "surface_code_bZ_d3_r11_center_5_3": 12386, + "surface_code_bZ_d3_r13_center_5_3": 10636, + "surface_code_bZ_d3_r15_center_5_3": 14135, + "surface_code_bZ_d3_r17_center_5_3": 13134, + "surface_code_bZ_d3_r19_center_5_3": 13810, + "surface_code_bZ_d3_r21_center_5_3": 13770, + "surface_code_bZ_d3_r23_center_5_3": 14976, + "surface_code_bZ_d3_r25_center_5_3": 8003 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261345, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_5_3", + "step": 1, + "loss": 0.584247887134552, + "error": 0.3291015625, + "gradient_norm": 0.04042685776948929, + "elapsed": 420.66772532463074 + }, + { + "group": "d3_bZ_center_5_3", + "step": 16, + "loss": 0.598501443862915, + "error": 0.3486328125, + "gradient_norm": 0.0449318028986454, + "elapsed": 424.9922022819519 + }, + { + "group": "d3_bZ_center_5_3", + "step": 32, + "loss": 0.20120704174041748, + "error": 0.080078125, + "gradient_norm": 0.028083574026823044, + "elapsed": 429.54314064979553 + }, + { + "group": "d3_bZ_center_5_3", + "step": 48, + "loss": 0.5097494125366211, + "error": 0.2666015625, + "gradient_norm": 0.04180379956960678, + "elapsed": 434.1016581058502 + }, + { + "group": "d3_bZ_center_5_3", + "step": 64, + "loss": 0.6209287643432617, + "error": 0.3603515625, + "gradient_norm": 0.060613926500082016, + "elapsed": 438.71377825737 + }, + { + "group": "d3_bZ_center_5_3", + "step": 80, + "loss": 0.6014095544815063, + "error": 0.33984375, + "gradient_norm": 0.047140710055828094, + "elapsed": 443.32533049583435 + }, + { + "group": "d3_bZ_center_5_3", + "step": 96, + "loss": 0.5019375085830688, + "error": 0.248046875, + "gradient_norm": 0.04958032816648483, + "elapsed": 448.4864926338196 + }, + { + "group": "d3_bZ_center_5_3", + "step": 112, + "loss": 0.5555987358093262, + "error": 0.2900390625, + "gradient_norm": 0.055340297520160675, + "elapsed": 453.64413261413574 + }, + { + "group": "d3_bZ_center_5_3", + "step": 128, + "loss": 0.45399999618530273, + "error": 0.2177734375, + "gradient_norm": 0.08485554903745651, + "elapsed": 458.3601851463318 + }, + { + "group": "d3_bZ_center_5_3", + "step": 144, + "loss": 0.4906202256679535, + "error": 0.2646484375, + "gradient_norm": 0.06261137127876282, + "elapsed": 464.8638753890991 + }, + { + "group": "d3_bZ_center_5_3", + "step": 160, + "loss": 0.32003381848335266, + "error": 0.1259765625, + "gradient_norm": 0.11741635203361511, + "elapsed": 469.67992210388184 + }, + { + "group": "d3_bZ_center_5_3", + "step": 176, + "loss": 0.586884617805481, + "error": 0.3349609375, + "gradient_norm": 0.08502229303121567, + "elapsed": 474.4645907878876 + }, + { + "group": "d3_bZ_center_5_3", + "step": 192, + "loss": 0.5280842781066895, + "error": 0.2744140625, + "gradient_norm": 0.05432337895035744, + "elapsed": 479.31645464897156 + }, + { + "group": "d3_bZ_center_5_3", + "step": 208, + "loss": 0.591776967048645, + "error": 0.328125, + "gradient_norm": 0.05962146818637848, + "elapsed": 484.29061913490295 + }, + { + "group": "d3_bZ_center_5_3", + "step": 224, + "loss": 0.28461942076683044, + "error": 0.12890625, + "gradient_norm": 0.03928481787443161, + "elapsed": 489.1320414543152 + }, + { + "group": "d3_bZ_center_5_3", + "step": 240, + "loss": 0.6413301825523376, + "error": 0.3876953125, + "gradient_norm": 0.06751421093940735, + "elapsed": 493.9832320213318 + }, + { + "group": "d3_bZ_center_5_3", + "step": 256, + "loss": 0.5496821403503418, + "error": 0.2919921875, + "gradient_norm": 0.08730755001306534, + "elapsed": 498.8968222141266 + } + ] + }, + "d3_bZ_center_5_7": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bZ_center_5_7", + "parent_model": { + "weights": "weights/d3_bZ_center_5_7.npz", + "training_checkpoint": "fresh_temporal1_full/6144" + }, + "parent_weights_sha256": "08718ad705a9b35495054ffa65e35ac29445fe5ef610620778964a4413901d10", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162577, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_5_7": 14921, + "surface_code_bZ_d3_r03_center_5_7": 14121, + "surface_code_bZ_d3_r05_center_5_7": 11150, + "surface_code_bZ_d3_r07_center_5_7": 12395, + "surface_code_bZ_d3_r09_center_5_7": 12730, + "surface_code_bZ_d3_r11_center_5_7": 13087, + "surface_code_bZ_d3_r13_center_5_7": 14103, + "surface_code_bZ_d3_r15_center_5_7": 12046, + "surface_code_bZ_d3_r17_center_5_7": 8641, + "surface_code_bZ_d3_r19_center_5_7": 11997, + "surface_code_bZ_d3_r21_center_5_7": 11556, + "surface_code_bZ_d3_r23_center_5_7": 13516, + "surface_code_bZ_d3_r25_center_5_7": 12314 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261346, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_5_7", + "step": 1, + "loss": 0.5747274160385132, + "error": 0.3291015625, + "gradient_norm": 0.06017044931650162, + "elapsed": 502.0316376686096 + }, + { + "group": "d3_bZ_center_5_7", + "step": 16, + "loss": 0.4942818582057953, + "error": 0.2568359375, + "gradient_norm": 0.05011248588562012, + "elapsed": 506.5715844631195 + }, + { + "group": "d3_bZ_center_5_7", + "step": 32, + "loss": 0.597930371761322, + "error": 0.3369140625, + "gradient_norm": 0.0735473781824112, + "elapsed": 511.3786220550537 + }, + { + "group": "d3_bZ_center_5_7", + "step": 48, + "loss": 0.41166993975639343, + "error": 0.2138671875, + "gradient_norm": 0.07957416027784348, + "elapsed": 516.1893982887268 + }, + { + "group": "d3_bZ_center_5_7", + "step": 64, + "loss": 0.5240586400032043, + "error": 0.267578125, + "gradient_norm": 0.051741909235715866, + "elapsed": 521.0595190525055 + }, + { + "group": "d3_bZ_center_5_7", + "step": 80, + "loss": 0.561062216758728, + "error": 0.3046875, + "gradient_norm": 0.07625891268253326, + "elapsed": 525.8756060600281 + }, + { + "group": "d3_bZ_center_5_7", + "step": 96, + "loss": 0.5280863642692566, + "error": 0.2802734375, + "gradient_norm": 0.12549085915088654, + "elapsed": 530.7218787670135 + }, + { + "group": "d3_bZ_center_5_7", + "step": 112, + "loss": 0.28337764739990234, + "error": 0.1220703125, + "gradient_norm": 0.08876372873783112, + "elapsed": 535.6294462680817 + }, + { + "group": "d3_bZ_center_5_7", + "step": 128, + "loss": 0.5810858011245728, + "error": 0.3466796875, + "gradient_norm": 0.06555280089378357, + "elapsed": 540.4129066467285 + }, + { + "group": "d3_bZ_center_5_7", + "step": 144, + "loss": 0.594068706035614, + "error": 0.3525390625, + "gradient_norm": 0.10098904371261597, + "elapsed": 546.7937984466553 + }, + { + "group": "d3_bZ_center_5_7", + "step": 160, + "loss": 0.48728978633880615, + "error": 0.248046875, + "gradient_norm": 0.052944667637348175, + "elapsed": 551.6402502059937 + }, + { + "group": "d3_bZ_center_5_7", + "step": 176, + "loss": 0.5920928716659546, + "error": 0.3349609375, + "gradient_norm": 0.06545946002006531, + "elapsed": 556.4367039203644 + }, + { + "group": "d3_bZ_center_5_7", + "step": 192, + "loss": 0.5887892246246338, + "error": 0.33203125, + "gradient_norm": 0.05726401135325432, + "elapsed": 561.2481727600098 + }, + { + "group": "d3_bZ_center_5_7", + "step": 208, + "loss": 0.5332534909248352, + "error": 0.294921875, + "gradient_norm": 0.06918492168188095, + "elapsed": 566.0451543331146 + }, + { + "group": "d3_bZ_center_5_7", + "step": 224, + "loss": 0.5972811579704285, + "error": 0.3642578125, + "gradient_norm": 0.08325426280498505, + "elapsed": 570.8561356067657 + }, + { + "group": "d3_bZ_center_5_7", + "step": 240, + "loss": 0.6303989291191101, + "error": 0.3740234375, + "gradient_norm": 0.0895395427942276, + "elapsed": 575.6860072612762 + }, + { + "group": "d3_bZ_center_5_7", + "step": 256, + "loss": 0.4506179988384247, + "error": 0.224609375, + "gradient_norm": 0.060342516750097275, + "elapsed": 580.5050556659698 + } + ] + }, + "d3_bZ_center_7_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session", + "group": "d3_bZ_center_7_5", + "parent_model": { + "weights": "weights/d3_bZ_center_7_5.npz", + "training_checkpoint": "fresh_temporal1_swa/mean3" + }, + "parent_weights_sha256": "e3f13efc5e5af11a8591a90b3176b224c892a91c98925cde79d20d3f3de8f184", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 160942, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_7_5": 12819, + "surface_code_bZ_d3_r03_center_7_5": 12786, + "surface_code_bZ_d3_r05_center_7_5": 9716, + "surface_code_bZ_d3_r07_center_7_5": 12002, + "surface_code_bZ_d3_r09_center_7_5": 14067, + "surface_code_bZ_d3_r11_center_7_5": 16516, + "surface_code_bZ_d3_r13_center_7_5": 10227, + "surface_code_bZ_d3_r15_center_7_5": 13396, + "surface_code_bZ_d3_r17_center_7_5": 9794, + "surface_code_bZ_d3_r19_center_7_5": 12008, + "surface_code_bZ_d3_r21_center_7_5": 10696, + "surface_code_bZ_d3_r23_center_7_5": 14141, + "surface_code_bZ_d3_r25_center_7_5": 12774 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261347, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_7_5", + "step": 1, + "loss": 0.6144076585769653, + "error": 0.3671875, + "gradient_norm": 0.039164863526821136, + "elapsed": 583.7055065631866 + }, + { + "group": "d3_bZ_center_7_5", + "step": 16, + "loss": 0.5576651096343994, + "error": 0.328125, + "gradient_norm": 0.06476780027151108, + "elapsed": 588.1772332191467 + }, + { + "group": "d3_bZ_center_7_5", + "step": 32, + "loss": 0.6103681921958923, + "error": 0.359375, + "gradient_norm": 0.04977516457438469, + "elapsed": 592.8536393642426 + }, + { + "group": "d3_bZ_center_7_5", + "step": 48, + "loss": 0.5900484919548035, + "error": 0.349609375, + "gradient_norm": 0.06423825025558472, + "elapsed": 597.5265238285065 + }, + { + "group": "d3_bZ_center_7_5", + "step": 64, + "loss": 0.0579155832529068, + "error": 0.0185546875, + "gradient_norm": 0.013793736696243286, + "elapsed": 602.1600217819214 + }, + { + "group": "d3_bZ_center_7_5", + "step": 80, + "loss": 0.38035351037979126, + "error": 0.197265625, + "gradient_norm": 0.07356167584657669, + "elapsed": 606.8025267124176 + }, + { + "group": "d3_bZ_center_7_5", + "step": 96, + "loss": 0.42583924531936646, + "error": 0.216796875, + "gradient_norm": 0.05063934996724129, + "elapsed": 611.4477169513702 + }, + { + "group": "d3_bZ_center_7_5", + "step": 112, + "loss": 0.5206998586654663, + "error": 0.275390625, + "gradient_norm": 0.07564505189657211, + "elapsed": 616.1010994911194 + }, + { + "group": "d3_bZ_center_7_5", + "step": 128, + "loss": 0.3255320191383362, + "error": 0.140625, + "gradient_norm": 0.037035856395959854, + "elapsed": 620.7465217113495 + }, + { + "group": "d3_bZ_center_7_5", + "step": 144, + "loss": 0.43108513951301575, + "error": 0.21484375, + "gradient_norm": 0.049782443791627884, + "elapsed": 626.7363336086273 + }, + { + "group": "d3_bZ_center_7_5", + "step": 160, + "loss": 0.2835412919521332, + "error": 0.1171875, + "gradient_norm": 0.050377003848552704, + "elapsed": 631.3785309791565 + }, + { + "group": "d3_bZ_center_7_5", + "step": 176, + "loss": 0.5867167711257935, + "error": 0.3349609375, + "gradient_norm": 0.06457746028900146, + "elapsed": 636.0238540172577 + }, + { + "group": "d3_bZ_center_7_5", + "step": 192, + "loss": 0.5748473405838013, + "error": 0.33984375, + "gradient_norm": 0.08190807700157166, + "elapsed": 640.6925184726715 + }, + { + "group": "d3_bZ_center_7_5", + "step": 208, + "loss": 0.41684162616729736, + "error": 0.201171875, + "gradient_norm": 0.041826918721199036, + "elapsed": 645.3304302692413 + }, + { + "group": "d3_bZ_center_7_5", + "step": 224, + "loss": 0.459583580493927, + "error": 0.224609375, + "gradient_norm": 0.08492636680603027, + "elapsed": 649.9758613109589 + }, + { + "group": "d3_bZ_center_7_5", + "step": 240, + "loss": 0.49334800243377686, + "error": 0.25, + "gradient_norm": 0.09639982134103775, + "elapsed": 654.6043367385864 + }, + { + "group": "d3_bZ_center_7_5", + "step": 256, + "loss": 0.038483474403619766, + "error": 0.0078125, + "gradient_norm": 0.02851962484419346, + "elapsed": 659.2644209861755 + } + ] + } + }, + "initialization": "Continue session-trained selected temporal components; no new random parameters", + "training": "Each group samples uniformly over its own13 durations; supplied training labels only", + "eligible_training_shots": 2067520, + "steps": 2048, + "steps_per_group": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer_restored": false, + "rng_restored": false, + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "run_config": { + "package": "/run-state/workspace/research/learned_exact/fresh_specialize1_parents", + "output": "/run-state/workspace/research/learned_exact/fresh_specialize1", + "steps": 256, + "eval_every": 128, + "batch": 1024, + "validation_shots": 1024, + "validation_batch": 1024, + "learning_rate": 0.0001, + "seed": 20261340, + "groups": [ + "d3_bX_center_3_5", + "d3_bX_center_5_3", + "d3_bX_center_5_7", + "d3_bX_center_7_5", + "d3_bZ_center_3_5", + "d3_bZ_center_5_3", + "d3_bZ_center_5_7", + "d3_bZ_center_7_5" + ], + "training_source_sha256": { + "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "parent_config_sha256": "7aaeceb1cb1b1de03d151539dfaf13bd195361484e553a8c0e7085eb3d563127", + "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1" + }, + "parent_record": "training_sources/fresh_specialize1/parent_training_provenance.json", + "new_random_parameters": 0, + "training_draws": 2097152, + "test_data_used": false, + "declared_plan": { + "hypothesis": "Group-specific adaptation may improve the new independent d3 model, which trailed the incumbent raw but supplied a complementary Z7,5 component; previous original-seed specialization helped some groups", + "parents": "Per group choose the minimum raw full-validation failure among fresh_temporal1_full [0,2048,4096,6144] and fresh_temporal1_swa [mean2,mean3], in that tie order; never use a probability mixture as training weights", + "initialization": "All parents descend only from session-random fresh trunk20261300/encoder20261301; parameter averages stay within that trajectory; zero new random parameters", + "sampling_seeds": "20261340 plus lexicographic group rank0..7", + "optimizer": "Fresh AdamW for every group, LR.0001, decay1e-4, norm1 clipping; explicit reset because averaged parents have no optimizer state", + "training": "256x1024 updates per group; uniform13duration/row sampling over all258440 supplied training rows in eachgroup;2048totalupdates,2097152draws", + "validation": "Screens0/128/256; full104condition evaluation at0/128/256; step0 diagnostic only", + "selection": "Per group retain incumbent or choose raw128/256, equal-small-context128/256, equal original-temporal/new128/256, or equal-small-context of that fixed pair. All13durations; ties retain incumbent. Frozen original-temporal reference is fresh_temporal1_reference.json. Recheck already-fitted categoricalheads afterward", + "runtime": "Same temporal/exact architecture; preserve any incumbent d5 wrappers and d3 fixed ensembles. Full assembled replay/score/relocation/runtimeprojection before publication", + "serial_after": "learned_exact/fresh_temporal1_swa_finished.json", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "selection_eligible": false, + "submission_eligible": false, + "trainer_sha256": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f", + "run": "/run-state/workspace/research/learned_exact/fresh_specialize_smoke1", + "checks": [ + { + "group": "d3_bX_center_3_5", + "parent_exact": true, + "fresh_zero_optimizer": true, + "one_update_changes_parameters": true, + "sampling_replay_exact": true, + "all13_durations_evaluated": true + }, + { + "group": "d3_bZ_center_7_5", + "parent_exact": true, + "fresh_zero_optimizer": true, + "one_update_changes_parameters": true, + "sampling_replay_exact": true, + "all13_durations_evaluated": true + } + ], + "test_data_used": false + }, + "sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_exact/fresh_specialize1", + "groups": [ + { + "group": "d3_bX_center_3_5", + "seed": 20261340, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 162520 + }, + { + "group": "d3_bX_center_5_3", + "seed": 20261341, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 162696 + }, + { + "group": "d3_bX_center_5_7", + "seed": 20261342, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 161668 + }, + { + "group": "d3_bX_center_7_5", + "seed": 20261343, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 161884 + }, + { + "group": "d3_bZ_center_3_5", + "seed": 20261344, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 161680 + }, + { + "group": "d3_bZ_center_5_3", + "seed": 20261345, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 162183 + }, + { + "group": "d3_bZ_center_5_7", + "seed": 20261346, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 162577 + }, + { + "group": "d3_bZ_center_7_5", + "seed": 20261347, + "parent_exact": true, + "fresh_zero_optimizer": true, + "sampling_replayed_checkpoints": [ + 128, + 256 + ], + "training_draws": 262144, + "distinct_group_rows": 160942 + } + ], + "training_draws": 2097152, + "distinct_phase_rows": 1296150, + "source_sha256": "61737500a6ba03f69968bee3c261ba8c7ad385ccabc85d52249cb61851b37cc2", + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/fresh_specialize1", + "selected_checkpoints": { + "d3_bZ_center_5_7": 128 + }, + "checkpoint_records": { + "d3_bZ_center_5_7": { + "group": "d3_bZ_center_5_7", + "step": 128, + "training_draws": 131072, + "unique_training_rows_seen_in_this_phase": 100069, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_5_7": 11662, + "surface_code_bZ_d3_r03_center_5_7": 10239, + "surface_code_bZ_d3_r05_center_5_7": 7959, + "surface_code_bZ_d3_r07_center_5_7": 6713, + "surface_code_bZ_d3_r09_center_5_7": 3722, + "surface_code_bZ_d3_r11_center_5_7": 8555, + "surface_code_bZ_d3_r13_center_5_7": 8023, + "surface_code_bZ_d3_r15_center_5_7": 8599, + "surface_code_bZ_d3_r17_center_5_7": 4507, + "surface_code_bZ_d3_r19_center_5_7": 6749, + "surface_code_bZ_d3_r21_center_5_7": 4487, + "surface_code_bZ_d3_r23_center_5_7": 9749, + "surface_code_bZ_d3_r25_center_5_7": 9105 + }, + "weights": "weights-128.npz", + "weights_sha256": "2a31791d4c242dfc7ca1f8fb60f3f53f092cc70d8331a6458af70d43de647024", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure across all13 durations per group among incumbent, fresh-specialized128/256, equal small-contextual blends, equal original/new temporal pairs and equal small-contextual blends of those pairs; retain incumbent on ties", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "original_temporal_reference": { + "package": "/run-state/workspace/research/context_upgrades/reserved_gate1/package", + "predictions": "/run-state/workspace/research/context_upgrades/reserved_gate1/predictions", + "score": "/run-state/workspace/research/context_upgrades/reserved_gate1/score.json", + "P": 0.7672475961538461 + }, + "original_temporal_settings": { + "d3_bX_center_3_5": { + "weights": "weights/specialized-group_specialize1-d3_bX_center_3_5-128.npz", + "training_checkpoint": "group_specialize1/d3_bX_center_3_5/128" + }, + "d3_bX_center_5_3": { + "weights": "weights/contextual-condition_same1-1024.npz", + "training_checkpoint": "condition_same1/1024" + }, + "d3_bX_center_5_7": { + "weights": "weights/specialized-group_specialize1-d3_bX_center_5_7-256.npz", + "training_checkpoint": "group_specialize1/d3_bX_center_5_7/256" + }, + "d3_bX_center_7_5": { + "weights": "weights/specialized-group_specialize1-d3_bX_center_7_5-128.npz", + "training_checkpoint": "group_specialize1/d3_bX_center_7_5/128", + "blend_contextual": true + }, + "d3_bZ_center_3_5": { + "weights": "weights/contextual-condition_same1-512.npz", + "training_checkpoint": "condition_same1/512" + }, + "d3_bZ_center_5_3": { + "weights": "weights/contextual-temporal2-2048.npz", + "training_checkpoint": "temporal2/2048" + }, + "d3_bZ_center_5_7": { + "weights": "weights/contextual-temporal2-4096.npz", + "training_checkpoint": "temporal2/4096" + }, + "d3_bZ_center_7_5": { + "weights": "weights/specialized-group_specialize1-d3_bZ_center_7_5-128.npz", + "training_checkpoint": "group_specialize1/d3_bZ_center_7_5/128" + } + }, + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.2444110576923077, + "128": 0.24537259615384613, + "blend-128": 0.24577824519230768, + "pair-128": 0.24475661057692305, + "pair-small-128": 0.24583834134615384, + "256": 0.24514723557692308, + "blend-256": 0.24571814903846154, + "pair-256": 0.2444711538461539, + "pair-small-256": 0.2460486778846154 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2526592548076923, + "128": 0.25423677884615387, + "blend-128": 0.25443209134615385, + "pair-128": 0.25330528846153844, + "pair-small-128": 0.25348557692307694, + "256": 0.2545222355769231, + "blend-256": 0.25441706730769226, + "pair-256": 0.25294471153846154, + "pair-small-256": 0.2533954326923077 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.233203125, + "128": 0.2342397836538461, + "blend-128": 0.23445012019230774, + "pair-128": 0.2338641826923077, + "pair-small-128": 0.2338792067307692, + "256": 0.23481069711538463, + "blend-256": 0.23429987980769226, + "pair-256": 0.23380408653846155, + "pair-small-256": 0.23392427884615385 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.2385667067307692, + "128": 0.23894230769230768, + "blend-128": 0.23970853365384615, + "pair-128": 0.23901742788461536, + "pair-small-128": 0.2394080528846154, + "256": 0.2395282451923077, + "blend-256": 0.2393780048076923, + "pair-256": 0.23900240384615387, + "pair-small-256": 0.23892728365384613 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24447115384615387, + "128": 0.24580829326923076, + "blend-128": 0.24628906250000002, + "pair-128": 0.2449819711538462, + "pair-small-128": 0.24552283653846155, + "256": 0.24514723557692308, + "blend-256": 0.2456280048076923, + "pair-256": 0.24505709134615386, + "pair-small-256": 0.24522235576923077 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23652343749999996, + "128": 0.23810096153846153, + "blend-128": 0.23825120192307692, + "pair-128": 0.23709435096153844, + "pair-small-128": 0.2375, + "256": 0.23795072115384613, + "blend-256": 0.2380859375, + "pair-256": 0.2369741586538462, + "pair-small-256": 0.23760516826923078 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.2356670673076923, + "128": 0.23641826923076922, + "blend-128": 0.2361328125, + "pair-128": 0.23556189903846156, + "pair-small-128": 0.2361328125, + "256": 0.2362079326923077, + "blend-256": 0.23625300480769235, + "pair-256": 0.2359975961538462, + "pair-small-256": 0.2365384615384616 + }, + "selected": "pair-128" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23266225961538464, + "128": 0.23389423076923077, + "blend-128": 0.23336838942307692, + "pair-128": 0.23275240384615387, + "pair-small-128": 0.23296274038461534, + "256": 0.23335336538461535, + "blend-256": 0.2335486778846154, + "pair-256": 0.23294771634615385, + "pair-small-256": 0.2332481971153846 + }, + "selected": "incumbent" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23168569711538464 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998 + }, + "selected": "incumbent" + } + ] + } + ], + "turbo_d5_experiment": { + "method": "Three passes of extrinsic log-odds feedback between complementary exact CSS syndrome-likelihood contractions, damping 1, messages clipped to [-8,8]. Induced dependencies are approximated.", + "initialization": "Logistic coefficients randomly initialized Normal(0,.01), seed 20261103; all underlying states built in this session from permitted even-fitted DEMs.", + "training": "4096 uniformly sampled training rows per all 26 d5 conditions (sample seed 20261023); BCE plus 1e-5 L2, L-BFGS-B up to 300 iterations.", + "screen": { + "scope": "Diagnostic screen only: both d5 bases, rounds 5/13/25, 1024 uniform validation samples per condition", + "sample_seed": 20261031, + "results": [ + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "rounds": 5, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 5.466358661651611, + "elapsed": 7.00129771232605, + "first_pass_max_delta": 8.940696716308594e-07, + "failure": [ + 0.1025390625, + 0.1044921875, + 0.1025390625 + ], + "peak_gpu_bytes": 4742925056 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "rounds": 5, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 1.1764235496520996, + "elapsed": 8.178237438201904, + "first_pass_max_delta": 8.940696716308594e-07, + "failure": [ + 0.1025390625, + 0.0966796875, + 0.1005859375 + ], + "peak_gpu_bytes": 4742925056 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "rounds": 13, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 7.137438058853149, + "elapsed": 16.021901607513428, + "first_pass_max_delta": 1.1324882507324219e-06, + "failure": [ + 0.2548828125, + 0.2490234375, + 0.25 + ], + "peak_gpu_bytes": 11611887104 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "rounds": 13, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 3.088695526123047, + "elapsed": 19.11112403869629, + "first_pass_max_delta": 1.1324882507324219e-06, + "failure": [ + 0.2548828125, + 0.2490234375, + 0.2412109375 + ], + "peak_gpu_bytes": 11611887104 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "rounds": 25, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 10.504217624664307, + "elapsed": 30.677946090698242, + "first_pass_max_delta": 1.5497207641601562e-06, + "failure": [ + 0.3916015625, + 0.38671875, + 0.3896484375 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "rounds": 25, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 5.937381267547607, + "elapsed": 36.615668296813965, + "first_pass_max_delta": 1.5497207641601562e-06, + "failure": [ + 0.3916015625, + 0.3857421875, + 0.3896484375 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "rounds": 5, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 4.611798286437988, + "elapsed": 41.71111083030701, + "first_pass_max_delta": 2.0265579223632812e-06, + "failure": [ + 0.1005859375, + 0.1015625, + 0.09765625 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "rounds": 5, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 1.1570250988006592, + "elapsed": 42.86858010292053, + "first_pass_max_delta": 2.0265579223632812e-06, + "failure": [ + 0.1005859375, + 0.0986328125, + 0.095703125 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "rounds": 13, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 6.715797185897827, + "elapsed": 50.234126567840576, + "first_pass_max_delta": 1.0132789611816406e-06, + "failure": [ + 0.236328125, + 0.234375, + 0.2314453125 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "rounds": 13, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 3.08017635345459, + "elapsed": 53.31461310386658, + "first_pass_max_delta": 1.0132789611816406e-06, + "failure": [ + 0.236328125, + 0.23828125, + 0.234375 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "rounds": 25, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 9.802945375442505, + "elapsed": 64.01536726951599, + "first_pass_max_delta": 1.4901161193847656e-06, + "failure": [ + 0.384765625, + 0.3857421875, + 0.38671875 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "rounds": 25, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 5.927323341369629, + "elapsed": 69.9429976940155, + "first_pass_max_delta": 1.4901161193847656e-06, + "failure": [ + 0.384765625, + 0.3701171875, + 0.361328125 + ], + "peak_gpu_bytes": 21913887488 + } + ] + }, + "cache": { + "method": "Three extrinsic-message passes between exact CSS likelihoods, damping 1, extrinsic clipping [-8,8]", + "scope": "All 26 d5 conditions. Full validation and 4096 training shots per condition.", + "training_selection": "Same uniformly sampled training indices as d5_cache, seed 20261023; labels are only used downstream in ensemble fitting.", + "model_selection": "Damping 1 and three passes chosen from a six-condition, 1024-validation-shot diagnostic screen of .5/1 damping and 1/2/3 passes.", + "batch": 384, + "test_data_used": false, + "resume_note": "Initial dynamic allocator failed at X/r21 after saving X/r1 through r19. Those complete records are retained; remaining conditions resumed with a 90 percent preallocated pool.", + "records": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "batch": 384, + "validation": { + "seconds": 0.0023708343505859375, + "shots": 5120, + "first_pass_max_delta": 0.0, + "failure": [ + 0.0080078125, + 0.0080078125, + 0.0080078125 + ] + }, + "train": { + "seconds": 0.00203704833984375, + "shots": 4096, + "first_pass_max_delta": 0.0, + "failure": [ + 0.00830078125, + 0.00830078125, + 0.00830078125 + ] + }, + "elapsed": 0.031897783279418945, + "peak_gpu_bytes": 0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "batch": 384, + "validation": { + "seconds": 6.5025129318237305, + "shots": 5120, + "first_pass_max_delta": 1.1622905731201172e-06, + "failure": [ + 0.05390625, + 0.05234375, + 0.0515625 + ] + }, + "train": { + "seconds": 1.8498849868774414, + "shots": 4096, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.056640625, + 0.056884765625, + 0.057373046875 + ] + }, + "elapsed": 9.963430881500244, + "peak_gpu_bytes": 6053389568 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "batch": 384, + "validation": { + "seconds": 7.887800455093384, + "shots": 5120, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.1111328125, + 0.1078125, + 0.1078125 + ] + }, + "train": { + "seconds": 3.1277287006378174, + "shots": 4096, + "first_pass_max_delta": 1.5497207641601562e-06, + "failure": [ + 0.110595703125, + 0.1044921875, + 0.106689453125 + ] + }, + "elapsed": 21.591607809066772, + "peak_gpu_bytes": 9485051136 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "batch": 384, + "validation": { + "seconds": 9.284316062927246, + "shots": 5120, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.1638671875, + 0.16328125, + 0.16328125 + ] + }, + "train": { + "seconds": 4.408588647842407, + "shots": 4096, + "first_pass_max_delta": 3.2186508178710938e-06, + "failure": [ + 0.165771484375, + 0.15966796875, + 0.160888671875 + ] + }, + "elapsed": 35.83207678794861, + "peak_gpu_bytes": 12921052416 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "batch": 384, + "validation": { + "seconds": 10.81107211112976, + "shots": 5120, + "first_pass_max_delta": 4.172325134277344e-06, + "failure": [ + 0.1994140625, + 0.1947265625, + 0.192578125 + ] + }, + "train": { + "seconds": 5.6971564292907715, + "shots": 4096, + "first_pass_max_delta": 1.9073486328125e-06, + "failure": [ + 0.193603515625, + 0.190185546875, + 0.1865234375 + ] + }, + "elapsed": 52.94058084487915, + "peak_gpu_bytes": 16355555584 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "batch": 384, + "validation": { + "seconds": 13.042934894561768, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.2330078125, + 0.229296875, + 0.2283203125 + ] + }, + "train": { + "seconds": 6.935072898864746, + "shots": 4096, + "first_pass_max_delta": 1.043081283569336e-06, + "failure": [ + 0.237060546875, + 0.2373046875, + 0.23388671875 + ] + }, + "elapsed": 73.53631615638733, + "peak_gpu_bytes": 19787549696 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "batch": 384, + "validation": { + "seconds": 14.011132955551147, + "shots": 5120, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.251953125, + 0.243359375, + 0.2427734375 + ] + }, + "train": { + "seconds": 8.214681386947632, + "shots": 4096, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.261962890625, + 0.257080078125, + 0.254150390625 + ] + }, + "elapsed": 96.39840364456177, + "peak_gpu_bytes": 23221127680 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "batch": 384, + "validation": { + "seconds": 15.821684837341309, + "shots": 5120, + "first_pass_max_delta": 2.3245811462402344e-06, + "failure": [ + 0.2822265625, + 0.286328125, + 0.2798828125 + ] + }, + "train": { + "seconds": 9.5097815990448, + "shots": 4096, + "first_pass_max_delta": 1.8477439880371094e-06, + "failure": [ + 0.294677734375, + 0.28515625, + 0.2861328125 + ] + }, + "elapsed": 122.39457035064697, + "peak_gpu_bytes": 26659319552 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "batch": 384, + "validation": { + "seconds": 18.90661311149597, + "shots": 5120, + "first_pass_max_delta": 2.3245811462402344e-06, + "failure": [ + 0.329296875, + 0.323828125, + 0.3169921875 + ] + }, + "train": { + "seconds": 11.201237440109253, + "shots": 4096, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.3046875, + 0.304931640625, + 0.302978515625 + ] + }, + "elapsed": 153.40053129196167, + "peak_gpu_bytes": 30096252672 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "batch": 384, + "validation": { + "seconds": 22.513427734375, + "shots": 5120, + "first_pass_max_delta": 1.4007091522216797e-06, + "failure": [ + 0.3560546875, + 0.3458984375, + 0.3455078125 + ] + }, + "train": { + "seconds": 16.373472213745117, + "shots": 4096, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.350341796875, + 0.3447265625, + 0.339111328125 + ] + }, + "elapsed": 193.22454714775085, + "peak_gpu_bytes": 33531435520 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 20.595962524414062, + "shots": 5120, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.3640625, + 0.3626953125, + 0.3607421875 + ] + }, + "train": { + "seconds": 13.13056755065918, + "shots": 4096, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.366455078125, + 0.364013671875, + 0.3603515625 + ] + }, + "elapsed": 36.23082995414734, + "peak_gpu_bytes": 36971696384 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 21.875932693481445, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.3857421875, + 0.3837890625, + 0.3794921875 + ] + }, + "train": { + "seconds": 14.333576440811157, + "shots": 4096, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.37841796875, + 0.380859375, + 0.378173828125 + ] + }, + "elapsed": 73.29396986961365, + "peak_gpu_bytes": 40408369664 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 23.68450117111206, + "shots": 5120, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.38828125, + 0.39140625, + 0.390234375 + ] + }, + "train": { + "seconds": 15.625046253204346, + "shots": 4096, + "first_pass_max_delta": 2.3543834686279297e-06, + "failure": [ + 0.401611328125, + 0.3984375, + 0.3896484375 + ] + }, + "elapsed": 113.62051224708557, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 0.0020935535430908203, + "shots": 5120, + "first_pass_max_delta": 0.0, + "failure": [ + 0.0078125, + 0.0078125, + 0.0078125 + ] + }, + "train": { + "seconds": 0.0018491744995117188, + "shots": 4096, + "first_pass_max_delta": 0.0, + "failure": [ + 0.006103515625, + 0.006103515625, + 0.006103515625 + ] + }, + "elapsed": 113.74299573898315, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 6.421818256378174, + "shots": 5120, + "first_pass_max_delta": 9.5367431640625e-07, + "failure": [ + 0.0474609375, + 0.0466796875, + 0.04609375 + ] + }, + "train": { + "seconds": 2.009964942932129, + "shots": 4096, + "first_pass_max_delta": 1.6093254089355469e-06, + "failure": [ + 0.05224609375, + 0.050537109375, + 0.050537109375 + ] + }, + "elapsed": 122.82617926597595, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 8.133492231369019, + "shots": 5120, + "first_pass_max_delta": 2.115964889526367e-06, + "failure": [ + 0.1037109375, + 0.1029296875, + 0.102734375 + ] + }, + "train": { + "seconds": 3.179387331008911, + "shots": 4096, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.108642578125, + 0.1044921875, + 0.10595703125 + ] + }, + "elapsed": 134.6406970024109, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 13.694931983947754, + "shots": 5120, + "first_pass_max_delta": 2.3245811462402344e-06, + "failure": [ + 0.1484375, + 0.14765625, + 0.1494140625 + ] + }, + "train": { + "seconds": 6.147953748703003, + "shots": 4096, + "first_pass_max_delta": 2.0563602447509766e-06, + "failure": [ + 0.147705078125, + 0.144775390625, + 0.143310546875 + ] + }, + "elapsed": 155.0307319164276, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 14.462661504745483, + "shots": 5120, + "first_pass_max_delta": 1.4901161193847656e-06, + "failure": [ + 0.181640625, + 0.1765625, + 0.1734375 + ] + }, + "train": { + "seconds": 6.59630274772644, + "shots": 4096, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.181640625, + 0.173583984375, + 0.17431640625 + ] + }, + "elapsed": 176.9893820285797, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 15.458272933959961, + "shots": 5120, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.2208984375, + 0.2169921875, + 0.2189453125 + ] + }, + "train": { + "seconds": 8.347567081451416, + "shots": 4096, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.2216796875, + 0.214111328125, + 0.209716796875 + ] + }, + "elapsed": 201.48220419883728, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 16.03638219833374, + "shots": 5120, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.2439453125, + 0.2349609375, + 0.2333984375 + ] + }, + "train": { + "seconds": 8.29888391494751, + "shots": 4096, + "first_pass_max_delta": 8.344650268554688e-07, + "failure": [ + 0.24365234375, + 0.248046875, + 0.2451171875 + ] + }, + "elapsed": 226.75215530395508, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 16.009416103363037, + "shots": 5120, + "first_pass_max_delta": 1.341104507446289e-06, + "failure": [ + 0.271875, + 0.264453125, + 0.2638671875 + ] + }, + "train": { + "seconds": 9.500921726226807, + "shots": 4096, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.28076171875, + 0.267333984375, + 0.267333984375 + ] + }, + "elapsed": 252.95993447303772, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 17.426681518554688, + "shots": 5120, + "first_pass_max_delta": 1.6242265701293945e-06, + "failure": [ + 0.31484375, + 0.3056640625, + 0.3087890625 + ] + }, + "train": { + "seconds": 10.742947816848755, + "shots": 4096, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.310791015625, + 0.309814453125, + 0.31103515625 + ] + }, + "elapsed": 281.84620356559753, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 18.49993872642517, + "shots": 5120, + "first_pass_max_delta": 1.9073486328125e-06, + "failure": [ + 0.334375, + 0.334765625, + 0.33515625 + ] + }, + "train": { + "seconds": 11.90273404121399, + "shots": 4096, + "first_pass_max_delta": 1.3113021850585938e-06, + "failure": [ + 0.327880859375, + 0.315673828125, + 0.310546875 + ] + }, + "elapsed": 313.02247071266174, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 20.121089458465576, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.34609375, + 0.342578125, + 0.344140625 + ] + }, + "train": { + "seconds": 13.077136278152466, + "shots": 4096, + "first_pass_max_delta": 1.6391277313232422e-06, + "failure": [ + 0.349853515625, + 0.34765625, + 0.352294921875 + ] + }, + "elapsed": 347.0259063243866, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 22.116555213928223, + "shots": 5120, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.3625, + 0.3625, + 0.3564453125 + ] + }, + "train": { + "seconds": 14.53529953956604, + "shots": 4096, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.361572265625, + 0.36083984375, + 0.35205078125 + ] + }, + "elapsed": 384.53587651252747, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 24.039794921875, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.397265625, + 0.3810546875, + 0.3755859375 + ] + }, + "train": { + "seconds": 15.72797179222107, + "shots": 4096, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.378662109375, + 0.370849609375, + 0.369384765625 + ] + }, + "elapsed": 425.2448420524597, + "peak_gpu_bytes": 43842280448 + } + ] + }, + "selection": "Full-validation mean failure per basis group, comparing incumbent, raw pass3, calibrated pass3, confidence ensemble, and confidence+matching ensemble.", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": { + "failure": 0.24024939903846157 + }, + "turbo_raw": { + "failure": 0.2359375 + }, + "turbo_calibrated": { + "failure": 0.23592247596153845, + "train_loss": 0.4342440304618462, + "iterations": 8, + "optimizer_success": true + }, + "turbo_confidence": { + "failure": 0.23646334134615385, + "train_loss": 0.4325824823965761, + "iterations": 31, + "optimizer_success": true + }, + "turbo_ensemble": { + "failure": 0.23825120192307692, + "train_loss": 0.43104343457008354, + "iterations": 128, + "optimizer_success": true + } + }, + "selected": "turbo_calibrated" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": { + "failure": 0.22627704326923076 + }, + "turbo_raw": { + "failure": 0.2242938701923077 + }, + "turbo_calibrated": { + "failure": 0.22444411057692307, + "train_loss": 0.41862854651685183, + "iterations": 8, + "optimizer_success": true + }, + "turbo_confidence": { + "failure": 0.22463942307692308, + "train_loss": 0.4165407454935999, + "iterations": 28, + "optimizer_success": true + }, + "turbo_ensemble": { + "failure": 0.22291165865384616, + "train_loss": 0.4143765903988058, + "iterations": 153, + "optimizer_success": true + } + }, + "selected": "turbo_ensemble" + } + ], + "test_data_used": false, + "memory_optimization": { + "method": "Logical parity retained in forward state, marginalized out of stored histories and backward syndrome-likelihood messages; half the on-partition history size.", + "equivalence_checks": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 3.2687214002180554e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 3.698800981055683e-07 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 4.061699030444288e-07 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 4.5500107148654934e-07 + } + ], + "runtime_batch": 512, + "gpu_pool": "90 percent preallocated before JAX backend initialization" + } + }, + "neural_d5_history": [ + { + "training": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261101", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to exact complementary-CSS-conditioned relevant-edge logits; exact width-14 contraction predicts logical probability", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; complementary conditioning held fixed", + "steps": 512, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261101, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 512, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.12617039680480957, + "error": 0.0390625, + "gradient_norm": 0.04250018671154976, + "elapsed": 18.675416231155396 + }, + { + "step": 16, + "loss": 0.6377020478248596, + "error": 0.4140625, + "gradient_norm": 0.09590183943510056, + "elapsed": 23.17981266975403 + }, + { + "step": 32, + "loss": 0.29977816343307495, + "error": 0.12109375, + "gradient_norm": 0.07157808542251587, + "elapsed": 28.000701189041138 + }, + { + "step": 48, + "loss": 0.34505343437194824, + "error": 0.1484375, + "gradient_norm": 0.07669594883918762, + "elapsed": 32.97374606132507 + }, + { + "step": 64, + "loss": 0.5405071973800659, + "error": 0.29296875, + "gradient_norm": 0.08529861271381378, + "elapsed": 37.794785499572754 + }, + { + "step": 80, + "loss": 0.5131822228431702, + "error": 0.28515625, + "gradient_norm": 0.12556222081184387, + "elapsed": 42.73275876045227 + }, + { + "step": 96, + "loss": 0.6790875196456909, + "error": 0.421875, + "gradient_norm": 0.19858981668949127, + "elapsed": 47.55139684677124 + }, + { + "step": 112, + "loss": 0.4744196832180023, + "error": 0.2421875, + "gradient_norm": 0.14321450889110565, + "elapsed": 52.42716360092163 + }, + { + "step": 128, + "loss": 0.01264211069792509, + "error": 0.00390625, + "gradient_norm": 0.007236324716359377, + "elapsed": 57.2592077255249 + }, + { + "step": 144, + "loss": 0.35788118839263916, + "error": 0.15234375, + "gradient_norm": 0.07203944772481918, + "elapsed": 64.91656231880188 + }, + { + "step": 160, + "loss": 0.6330419778823853, + "error": 0.3671875, + "gradient_norm": 0.08350329101085663, + "elapsed": 69.75011849403381 + }, + { + "step": 176, + "loss": 0.6195905208587646, + "error": 0.4140625, + "gradient_norm": 0.11415330320596695, + "elapsed": 74.56864047050476 + }, + { + "step": 192, + "loss": 0.5832147598266602, + "error": 0.37109375, + "gradient_norm": 0.3569585978984833, + "elapsed": 79.38981986045837 + }, + { + "step": 208, + "loss": 0.6469261646270752, + "error": 0.4296875, + "gradient_norm": 0.18999285995960236, + "elapsed": 84.23919153213501 + }, + { + "step": 224, + "loss": 0.5015400648117065, + "error": 0.26171875, + "gradient_norm": 0.14661277830600739, + "elapsed": 89.08856391906738 + }, + { + "step": 240, + "loss": 0.5771075487136841, + "error": 0.30859375, + "gradient_norm": 0.16081298887729645, + "elapsed": 94.75072908401489 + }, + { + "step": 256, + "loss": 0.4888438582420349, + "error": 0.265625, + "gradient_norm": 0.0695391371846199, + "elapsed": 101.01203680038452 + }, + { + "step": 272, + "loss": 0.4024130702018738, + "error": 0.171875, + "gradient_norm": 0.12405848503112793, + "elapsed": 110.68109226226807 + }, + { + "step": 288, + "loss": 0.5895810723304749, + "error": 0.34375, + "gradient_norm": 0.11818791180849075, + "elapsed": 117.13554787635803 + }, + { + "step": 304, + "loss": 0.4740591049194336, + "error": 0.23828125, + "gradient_norm": 0.12323135882616043, + "elapsed": 123.14409065246582 + }, + { + "step": 320, + "loss": 0.007106379605829716, + "error": 0.0, + "gradient_norm": 0.011303205043077469, + "elapsed": 129.3651967048645 + }, + { + "step": 336, + "loss": 0.11020991206169128, + "error": 0.046875, + "gradient_norm": 0.09031850099563599, + "elapsed": 135.01193165779114 + }, + { + "step": 352, + "loss": 0.47800248861312866, + "error": 0.23046875, + "gradient_norm": 0.09636854380369186, + "elapsed": 141.10205006599426 + }, + { + "step": 368, + "loss": 0.4062168598175049, + "error": 0.203125, + "gradient_norm": 0.17921771109104156, + "elapsed": 146.6507167816162 + }, + { + "step": 384, + "loss": 0.24366013705730438, + "error": 0.12109375, + "gradient_norm": 0.11793741583824158, + "elapsed": 152.7517864704132 + }, + { + "step": 400, + "loss": 0.4949762225151062, + "error": 0.28515625, + "gradient_norm": 0.09550267457962036, + "elapsed": 160.96661829948425 + }, + { + "step": 416, + "loss": 0.21066513657569885, + "error": 0.08984375, + "gradient_norm": 0.07445460557937622, + "elapsed": 165.83068180084229 + }, + { + "step": 432, + "loss": 0.4017776548862457, + "error": 0.18359375, + "gradient_norm": 0.1278357356786728, + "elapsed": 170.6406123638153 + }, + { + "step": 448, + "loss": 0.11823543906211853, + "error": 0.04296875, + "gradient_norm": 0.09968453645706177, + "elapsed": 175.4701704978943 + }, + { + "step": 464, + "loss": 0.47654634714126587, + "error": 0.2265625, + "gradient_norm": 0.18101797997951508, + "elapsed": 180.26738119125366 + }, + { + "step": 480, + "loss": 0.4916652739048004, + "error": 0.24609375, + "gradient_norm": 0.08958703279495239, + "elapsed": 185.08883357048035 + }, + { + "step": 496, + "loss": 0.5418418645858765, + "error": 0.3515625, + "gradient_norm": 0.08218713104724884, + "elapsed": 189.9677882194519 + }, + { + "step": 512, + "loss": 0.5470219850540161, + "error": 0.359375, + "gradient_norm": 0.07939601689577103, + "elapsed": 194.77887177467346 + } + ] + }, + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with incumbent.", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23592247596153845, + "128": 0.23888221153846154, + "blend-128": 0.23536658653846151, + "256": 0.23865685096153846, + "blend-256": 0.23538161057692308, + "384": 0.23852163461538461, + "blend-384": 0.23487079326923077, + "512": 0.23870192307692306, + "blend-512": 0.23482572115384615 + }, + "selected": "blend-512" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22291165865384616, + "128": 0.2279897836538462, + "blend-128": 0.22366286057692308, + "256": 0.2274188701923077, + "blend-256": 0.22304687500000003, + "384": 0.22729867788461536, + "blend-384": 0.22337740384615384, + "512": 0.22662259615384617, + "blend-512": 0.22355769230769235 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "512": { + "step": 512, + "training_samples": 131072, + "weights_sha256": "86aa65455686eb06a430030bd4b8242ac78521dccf4e9b07f1e93b2aa2ec40af", + "complete": true + } + }, + "runtime": "Shared initial complementary-CSS priors between neural and physical branches in blended groups. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + { + "training": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23482572115384615, + "256": 0.2346754807692308, + "blend-256": 0.23484074519230771, + "512": 0.23569711538461538, + "blend-512": 0.2338341346153846, + "768": 0.23470552884615387, + "blend-768": 0.23464543269230764, + "1024": 0.23653846153846153, + "blend-1024": 0.23445012019230768 + }, + "selected": "blend-512" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22291165865384616, + "256": 0.2231520432692308, + "blend-256": 0.2219951923076923, + "512": 0.22303185096153846, + "blend-512": 0.22211538461538463, + "768": 0.22279146634615382, + "blend-768": 0.2219501201923077, + "1024": 0.22291165865384616, + "blend-1024": 0.22182992788461542 + }, + "selected": "blend-1024" + } + ], + "checkpoints": { + "512": { + "step": 512, + "training_samples": 131072, + "weights_sha256": "6109f95c51d7b8803085c84b6bb34e3f199cc349bd846d6007c8f9a4f2a0c4fe", + "complete": true + }, + "1024": { + "step": 1024, + "training_samples": 262144, + "weights_sha256": "46aa01e703f38fa153206c54ff0ce7083d839de7aeb51bf14c8e732d52d5bd2d", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "training_source_sha256": { + "learned_d5__train.py": "b73af9da21332dee9a43f653b514695b020fbc3516604b2e721d8cf0ea876d53", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "5e9420df1f6dd56518925e910096fb9bc93bd796a5933b13bf894a1a96256cdf", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 507282, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 19592, + "surface_code_bX_d5_r03_center_5_5": 19646, + "surface_code_bX_d5_r05_center_5_5": 19513, + "surface_code_bX_d5_r07_center_5_5": 19341, + "surface_code_bX_d5_r09_center_5_5": 19211, + "surface_code_bX_d5_r11_center_5_5": 19239, + "surface_code_bX_d5_r13_center_5_5": 19679, + "surface_code_bX_d5_r15_center_5_5": 19455, + "surface_code_bX_d5_r17_center_5_5": 19479, + "surface_code_bX_d5_r19_center_5_5": 19479, + "surface_code_bX_d5_r21_center_5_5": 19551, + "surface_code_bX_d5_r23_center_5_5": 19586, + "surface_code_bX_d5_r25_center_5_5": 19526, + "surface_code_bZ_d5_r01_center_5_5": 19652, + "surface_code_bZ_d5_r03_center_5_5": 19732, + "surface_code_bZ_d5_r05_center_5_5": 19754, + "surface_code_bZ_d5_r07_center_5_5": 19194, + "surface_code_bZ_d5_r09_center_5_5": 19641, + "surface_code_bZ_d5_r11_center_5_5": 19611, + "surface_code_bZ_d5_r13_center_5_5": 19424, + "surface_code_bZ_d5_r15_center_5_5": 19380, + "surface_code_bZ_d5_r17_center_5_5": 19384, + "surface_code_bZ_d5_r19_center_5_5": 19684, + "surface_code_bZ_d5_r21_center_5_5": 19559, + "surface_code_bZ_d5_r23_center_5_5": 19524, + "surface_code_bZ_d5_r25_center_5_5": 19446 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 2048, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261113, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_d5/feedback3_pilot/rng-768.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/feedback3_pilot/weights-768.npz", + "starting_checkpoint_sha256": "bc2ba1c529317ce1b5b661efae4707eca49c6995d6f22b04193fe7642662fed8", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4341062307357788, + "objective": 0.4341062307357788, + "error": 0.208984375, + "gradient_norm": 0.07617632299661636, + "elapsed": 31.45817995071411 + }, + { + "step": 16, + "loss": 0.5996706485748291, + "objective": 0.5996706485748291, + "error": 0.359375, + "gradient_norm": 0.05249844491481781, + "elapsed": 56.34200572967529 + }, + { + "step": 32, + "loss": 0.4388691186904907, + "objective": 0.4388691186904907, + "error": 0.2041015625, + "gradient_norm": 0.0376109778881073, + "elapsed": 67.83739852905273 + }, + { + "step": 48, + "loss": 0.5373439788818359, + "objective": 0.5373439788818359, + "error": 0.2919921875, + "gradient_norm": 0.06261218339204788, + "elapsed": 76.69065475463867 + }, + { + "step": 64, + "loss": 0.24871854484081268, + "objective": 0.24871854484081268, + "error": 0.1162109375, + "gradient_norm": 0.05284671485424042, + "elapsed": 86.3852767944336 + }, + { + "step": 80, + "loss": 0.26628297567367554, + "objective": 0.26628297567367554, + "error": 0.123046875, + "gradient_norm": 0.04054367542266846, + "elapsed": 95.77356100082397 + }, + { + "step": 96, + "loss": 0.48436349630355835, + "objective": 0.48436349630355835, + "error": 0.259765625, + "gradient_norm": 0.05399860441684723, + "elapsed": 107.06293416023254 + }, + { + "step": 112, + "loss": 0.41063767671585083, + "objective": 0.41063767671585083, + "error": 0.1943359375, + "gradient_norm": 0.043602071702480316, + "elapsed": 116.78119611740112 + }, + { + "step": 128, + "loss": 0.3990316390991211, + "objective": 0.3990316390991211, + "error": 0.1865234375, + "gradient_norm": 0.0424419641494751, + "elapsed": 125.6915397644043 + }, + { + "step": 144, + "loss": 0.5119550228118896, + "objective": 0.5119550228118896, + "error": 0.2646484375, + "gradient_norm": 0.07688591629266739, + "elapsed": 136.20711088180542 + }, + { + "step": 160, + "loss": 0.3388235569000244, + "objective": 0.3388235569000244, + "error": 0.1630859375, + "gradient_norm": 0.07015731930732727, + "elapsed": 145.3505516052246 + }, + { + "step": 176, + "loss": 0.5952156186103821, + "objective": 0.5952156186103821, + "error": 0.3369140625, + "gradient_norm": 0.039373140782117844, + "elapsed": 154.77994871139526 + }, + { + "step": 192, + "loss": 0.15157413482666016, + "objective": 0.15157413482666016, + "error": 0.0634765625, + "gradient_norm": 0.029710670933127403, + "elapsed": 164.46801733970642 + }, + { + "step": 208, + "loss": 0.3120684027671814, + "objective": 0.3120684027671814, + "error": 0.1474609375, + "gradient_norm": 0.035548821091651917, + "elapsed": 173.24825358390808 + }, + { + "step": 224, + "loss": 0.5486405491828918, + "objective": 0.5486405491828918, + "error": 0.2900390625, + "gradient_norm": 0.0503678023815155, + "elapsed": 185.29849314689636 + }, + { + "step": 240, + "loss": 0.6046283841133118, + "objective": 0.6046283841133118, + "error": 0.3349609375, + "gradient_norm": 0.05043461173772812, + "elapsed": 197.54880928993225 + }, + { + "step": 256, + "loss": 0.5926339626312256, + "objective": 0.5926339626312256, + "error": 0.3359375, + "gradient_norm": 0.051241543143987656, + "elapsed": 211.79861068725586 + }, + { + "step": 272, + "loss": 0.4018518924713135, + "objective": 0.4018518924713135, + "error": 0.1943359375, + "gradient_norm": 0.0772147998213768, + "elapsed": 222.41974115371704 + }, + { + "step": 288, + "loss": 0.13863243162631989, + "objective": 0.13863243162631989, + "error": 0.0556640625, + "gradient_norm": 0.03334609419107437, + "elapsed": 234.04247426986694 + }, + { + "step": 304, + "loss": 0.562490701675415, + "objective": 0.562490701675415, + "error": 0.337890625, + "gradient_norm": 0.04585934057831764, + "elapsed": 242.65421533584595 + }, + { + "step": 320, + "loss": 0.5352796316146851, + "objective": 0.5352796316146851, + "error": 0.294921875, + "gradient_norm": 0.0837635025382042, + "elapsed": 252.10656356811523 + }, + { + "step": 336, + "loss": 0.26082637906074524, + "objective": 0.26082637906074524, + "error": 0.1220703125, + "gradient_norm": 0.048336997628211975, + "elapsed": 262.33449625968933 + }, + { + "step": 352, + "loss": 0.5959363579750061, + "objective": 0.5959363579750061, + "error": 0.3388671875, + "gradient_norm": 0.06797357648611069, + "elapsed": 271.9942307472229 + }, + { + "step": 368, + "loss": 0.48994284868240356, + "objective": 0.48994284868240356, + "error": 0.2587890625, + "gradient_norm": 0.06296153366565704, + "elapsed": 283.0493588447571 + }, + { + "step": 384, + "loss": 0.5710494518280029, + "objective": 0.5710494518280029, + "error": 0.3134765625, + "gradient_norm": 0.045333269983530045, + "elapsed": 294.64637446403503 + }, + { + "step": 400, + "loss": 0.5957783460617065, + "objective": 0.5957783460617065, + "error": 0.349609375, + "gradient_norm": 0.03918786719441414, + "elapsed": 307.6200888156891 + }, + { + "step": 416, + "loss": 0.27521568536758423, + "objective": 0.27521568536758423, + "error": 0.1220703125, + "gradient_norm": 0.038001637905836105, + "elapsed": 317.01610231399536 + }, + { + "step": 432, + "loss": 0.02379823848605156, + "objective": 0.02379823848605156, + "error": 0.0078125, + "gradient_norm": 0.007661945186555386, + "elapsed": 326.9360330104828 + }, + { + "step": 448, + "loss": 0.56734299659729, + "objective": 0.56734299659729, + "error": 0.3271484375, + "gradient_norm": 0.057416290044784546, + "elapsed": 339.6289041042328 + }, + { + "step": 464, + "loss": 0.10715995728969574, + "objective": 0.10715995728969574, + "error": 0.0380859375, + "gradient_norm": 0.02532491274178028, + "elapsed": 349.8584108352661 + }, + { + "step": 480, + "loss": 0.6143364310264587, + "objective": 0.6143364310264587, + "error": 0.36328125, + "gradient_norm": 0.08023032546043396, + "elapsed": 360.36362075805664 + }, + { + "step": 496, + "loss": 0.44069671630859375, + "objective": 0.44069671630859375, + "error": 0.2197265625, + "gradient_norm": 0.048025116324424744, + "elapsed": 369.48225808143616 + }, + { + "step": 512, + "loss": 0.019900165498256683, + "objective": 0.019900165498256683, + "error": 0.0107421875, + "gradient_norm": 0.0038635791279375553, + "elapsed": 378.59970593452454 + }, + { + "step": 528, + "loss": 0.033316534012556076, + "objective": 0.033316534012556076, + "error": 0.009765625, + "gradient_norm": 0.009174940176308155, + "elapsed": 393.4021761417389 + }, + { + "step": 544, + "loss": 0.41130945086479187, + "objective": 0.41130945086479187, + "error": 0.20703125, + "gradient_norm": 0.04695262759923935, + "elapsed": 402.8586280345917 + }, + { + "step": 560, + "loss": 0.5885373950004578, + "objective": 0.5885373950004578, + "error": 0.3544921875, + "gradient_norm": 0.08534500002861023, + "elapsed": 416.98661041259766 + }, + { + "step": 576, + "loss": 0.3804720640182495, + "objective": 0.3804720640182495, + "error": 0.19140625, + "gradient_norm": 0.05163278803229332, + "elapsed": 427.7550480365753 + }, + { + "step": 592, + "loss": 0.6101120710372925, + "objective": 0.6101120710372925, + "error": 0.3525390625, + "gradient_norm": 0.05593184754252434, + "elapsed": 441.05026268959045 + }, + { + "step": 608, + "loss": 0.5586092472076416, + "objective": 0.5586092472076416, + "error": 0.302734375, + "gradient_norm": 0.07458740472793579, + "elapsed": 452.95383286476135 + }, + { + "step": 624, + "loss": 0.5992780923843384, + "objective": 0.5992780923843384, + "error": 0.357421875, + "gradient_norm": 0.03618372976779938, + "elapsed": 466.1582691669464 + }, + { + "step": 640, + "loss": 0.3536975383758545, + "objective": 0.3536975383758545, + "error": 0.1650390625, + "gradient_norm": 0.05353165790438652, + "elapsed": 477.166255235672 + }, + { + "step": 656, + "loss": 0.4926893711090088, + "objective": 0.4926893711090088, + "error": 0.2626953125, + "gradient_norm": 0.05201377719640732, + "elapsed": 491.1417751312256 + }, + { + "step": 672, + "loss": 0.5754991173744202, + "objective": 0.5754991173744202, + "error": 0.3271484375, + "gradient_norm": 0.08167096972465515, + "elapsed": 501.630366563797 + }, + { + "step": 688, + "loss": 0.5685014724731445, + "objective": 0.5685014724731445, + "error": 0.333984375, + "gradient_norm": 0.043775107711553574, + "elapsed": 514.2880456447601 + }, + { + "step": 704, + "loss": 0.022465089336037636, + "objective": 0.022465089336037636, + "error": 0.0068359375, + "gradient_norm": 0.010172540321946144, + "elapsed": 522.9173214435577 + }, + { + "step": 720, + "loss": 0.035460107028484344, + "objective": 0.035460107028484344, + "error": 0.0107421875, + "gradient_norm": 0.010515578091144562, + "elapsed": 532.8470129966736 + }, + { + "step": 736, + "loss": 0.44765588641166687, + "objective": 0.44765588641166687, + "error": 0.2138671875, + "gradient_norm": 0.09050357341766357, + "elapsed": 541.9488840103149 + }, + { + "step": 752, + "loss": 0.5933939218521118, + "objective": 0.5933939218521118, + "error": 0.3359375, + "gradient_norm": 0.0665116235613823, + "elapsed": 552.9967355728149 + }, + { + "step": 768, + "loss": 0.6100764870643616, + "objective": 0.6100764870643616, + "error": 0.3515625, + "gradient_norm": 0.0821211114525795, + "elapsed": 563.7709202766418 + }, + { + "step": 784, + "loss": 0.02964692935347557, + "objective": 0.02964692935347557, + "error": 0.009765625, + "gradient_norm": 0.012663272209465504, + "elapsed": 573.1517221927643 + }, + { + "step": 800, + "loss": 0.38091832399368286, + "objective": 0.38091832399368286, + "error": 0.1904296875, + "gradient_norm": 0.060622021555900574, + "elapsed": 582.5687477588654 + }, + { + "step": 816, + "loss": 0.552335262298584, + "objective": 0.552335262298584, + "error": 0.3076171875, + "gradient_norm": 0.14419035613536835, + "elapsed": 594.4292685985565 + }, + { + "step": 832, + "loss": 0.5943340063095093, + "objective": 0.5943340063095093, + "error": 0.34375, + "gradient_norm": 0.0633513554930687, + "elapsed": 605.2052299976349 + }, + { + "step": 848, + "loss": 0.6074100732803345, + "objective": 0.6074100732803345, + "error": 0.3486328125, + "gradient_norm": 0.04225531220436096, + "elapsed": 614.8996202945709 + }, + { + "step": 864, + "loss": 0.6198879480361938, + "objective": 0.6198879480361938, + "error": 0.361328125, + "gradient_norm": 0.04208856821060181, + "elapsed": 625.4266908168793 + }, + { + "step": 880, + "loss": 0.6151762008666992, + "objective": 0.6151762008666992, + "error": 0.369140625, + "gradient_norm": 0.06261089444160461, + "elapsed": 636.0696911811829 + }, + { + "step": 896, + "loss": 0.49680083990097046, + "objective": 0.49680083990097046, + "error": 0.25390625, + "gradient_norm": 0.0827067643404007, + "elapsed": 644.6893246173859 + }, + { + "step": 912, + "loss": 0.4610927402973175, + "objective": 0.4610927402973175, + "error": 0.23828125, + "gradient_norm": 0.06652095168828964, + "elapsed": 655.969132900238 + }, + { + "step": 928, + "loss": 0.5218505859375, + "objective": 0.5218505859375, + "error": 0.2685546875, + "gradient_norm": 0.07188194245100021, + "elapsed": 667.5352523326874 + }, + { + "step": 944, + "loss": 0.33009427785873413, + "objective": 0.33009427785873413, + "error": 0.1533203125, + "gradient_norm": 0.05718810483813286, + "elapsed": 677.8397319316864 + }, + { + "step": 960, + "loss": 0.5703234672546387, + "objective": 0.5703234672546387, + "error": 0.3193359375, + "gradient_norm": 0.11168288439512253, + "elapsed": 687.8742904663086 + }, + { + "step": 976, + "loss": 0.025548014789819717, + "objective": 0.025548014789819717, + "error": 0.0107421875, + "gradient_norm": 0.009453393518924713, + "elapsed": 698.294285774231 + }, + { + "step": 992, + "loss": 0.45398157835006714, + "objective": 0.45398157835006714, + "error": 0.2412109375, + "gradient_norm": 0.04607952758669853, + "elapsed": 707.903199672699 + }, + { + "step": 1008, + "loss": 0.3412189781665802, + "objective": 0.3412189781665802, + "error": 0.1513671875, + "gradient_norm": 0.0432075597345829, + "elapsed": 718.5662748813629 + }, + { + "step": 1024, + "loss": 0.4376429319381714, + "objective": 0.4376429319381714, + "error": 0.2275390625, + "gradient_norm": 0.07974351197481155, + "elapsed": 728.8954858779907 + }, + { + "step": 1040, + "loss": 0.33512815833091736, + "objective": 0.33512815833091736, + "error": 0.150390625, + "gradient_norm": 0.04476875811815262, + "elapsed": 744.0822694301605 + }, + { + "step": 1056, + "loss": 0.5214208364486694, + "objective": 0.5214208364486694, + "error": 0.283203125, + "gradient_norm": 0.08898192644119263, + "elapsed": 755.1484262943268 + }, + { + "step": 1072, + "loss": 0.13849599659442902, + "objective": 0.13849599659442902, + "error": 0.052734375, + "gradient_norm": 0.028359953314065933, + "elapsed": 764.3303108215332 + }, + { + "step": 1088, + "loss": 0.323838472366333, + "objective": 0.323838472366333, + "error": 0.1435546875, + "gradient_norm": 0.04081716760993004, + "elapsed": 773.2739362716675 + }, + { + "step": 1104, + "loss": 0.5627881288528442, + "objective": 0.5627881288528442, + "error": 0.3125, + "gradient_norm": 0.08322097361087799, + "elapsed": 784.7223973274231 + }, + { + "step": 1120, + "loss": 0.44111010432243347, + "objective": 0.44111010432243347, + "error": 0.2216796875, + "gradient_norm": 0.05700977146625519, + "elapsed": 795.085648059845 + }, + { + "step": 1136, + "loss": 0.6395992040634155, + "objective": 0.6395992040634155, + "error": 0.39453125, + "gradient_norm": 0.0744553729891777, + "elapsed": 805.7942585945129 + }, + { + "step": 1152, + "loss": 0.5433304309844971, + "objective": 0.5433304309844971, + "error": 0.287109375, + "gradient_norm": 0.04814797267317772, + "elapsed": 817.3382890224457 + }, + { + "step": 1168, + "loss": 0.5708576440811157, + "objective": 0.5708576440811157, + "error": 0.3203125, + "gradient_norm": 0.051331400871276855, + "elapsed": 829.288791179657 + }, + { + "step": 1184, + "loss": 0.5447035431861877, + "objective": 0.5447035431861877, + "error": 0.2939453125, + "gradient_norm": 0.10116687417030334, + "elapsed": 839.6822843551636 + }, + { + "step": 1200, + "loss": 0.6125671863555908, + "objective": 0.6125671863555908, + "error": 0.3642578125, + "gradient_norm": 0.04368080571293831, + "elapsed": 850.2262740135193 + }, + { + "step": 1216, + "loss": 0.5002380609512329, + "objective": 0.5002380609512329, + "error": 0.259765625, + "gradient_norm": 0.04939017817378044, + "elapsed": 862.3783452510834 + }, + { + "step": 1232, + "loss": 0.5698772668838501, + "objective": 0.5698772668838501, + "error": 0.3173828125, + "gradient_norm": 0.04916854575276375, + "elapsed": 871.4622664451599 + }, + { + "step": 1248, + "loss": 0.6046518683433533, + "objective": 0.6046518683433533, + "error": 0.341796875, + "gradient_norm": 0.04919794574379921, + "elapsed": 883.3905737400055 + }, + { + "step": 1264, + "loss": 0.5913128852844238, + "objective": 0.5913128852844238, + "error": 0.357421875, + "gradient_norm": 0.046917904168367386, + "elapsed": 892.4264807701111 + }, + { + "step": 1280, + "loss": 0.5027461051940918, + "objective": 0.5027461051940918, + "error": 0.2626953125, + "gradient_norm": 0.04705750197172165, + "elapsed": 902.5875842571259 + }, + { + "step": 1296, + "loss": 0.13519814610481262, + "objective": 0.13519814610481262, + "error": 0.052734375, + "gradient_norm": 0.02625490538775921, + "elapsed": 912.4087471961975 + }, + { + "step": 1312, + "loss": 0.5862359404563904, + "objective": 0.5862359404563904, + "error": 0.3271484375, + "gradient_norm": 0.05441493168473244, + "elapsed": 923.992555141449 + }, + { + "step": 1328, + "loss": 0.6031408309936523, + "objective": 0.6031408309936523, + "error": 0.3505859375, + "gradient_norm": 0.05901554971933365, + "elapsed": 933.3936491012573 + }, + { + "step": 1344, + "loss": 0.5823733806610107, + "objective": 0.5823733806610107, + "error": 0.3310546875, + "gradient_norm": 0.0842989832162857, + "elapsed": 941.979998588562 + }, + { + "step": 1360, + "loss": 0.6241492033004761, + "objective": 0.6241492033004761, + "error": 0.3720703125, + "gradient_norm": 0.04446673393249512, + "elapsed": 954.969649553299 + }, + { + "step": 1376, + "loss": 0.5829156637191772, + "objective": 0.5829156637191772, + "error": 0.361328125, + "gradient_norm": 0.06615480780601501, + "elapsed": 966.0245676040649 + }, + { + "step": 1392, + "loss": 0.5968320369720459, + "objective": 0.5968320369720459, + "error": 0.34765625, + "gradient_norm": 0.05093541368842125, + "elapsed": 975.1022663116455 + }, + { + "step": 1408, + "loss": 0.045559000223875046, + "objective": 0.045559000223875046, + "error": 0.01171875, + "gradient_norm": 0.02514980360865593, + "elapsed": 987.2391452789307 + }, + { + "step": 1424, + "loss": 0.22601813077926636, + "objective": 0.22601813077926636, + "error": 0.09765625, + "gradient_norm": 0.04834206402301788, + "elapsed": 996.4583384990692 + }, + { + "step": 1440, + "loss": 0.23011144995689392, + "objective": 0.23011144995689392, + "error": 0.111328125, + "gradient_norm": 0.050687842071056366, + "elapsed": 1007.1440904140472 + }, + { + "step": 1456, + "loss": 0.018240466713905334, + "objective": 0.018240466713905334, + "error": 0.0078125, + "gradient_norm": 0.005604141391813755, + "elapsed": 1016.4502851963043 + }, + { + "step": 1472, + "loss": 0.4498720169067383, + "objective": 0.4498720169067383, + "error": 0.232421875, + "gradient_norm": 0.08179625123739243, + "elapsed": 1028.8303294181824 + }, + { + "step": 1488, + "loss": 0.24151627719402313, + "objective": 0.24151627719402313, + "error": 0.107421875, + "gradient_norm": 0.03838668763637543, + "elapsed": 1037.8867321014404 + }, + { + "step": 1504, + "loss": 0.46122002601623535, + "objective": 0.46122002601623535, + "error": 0.232421875, + "gradient_norm": 0.0726623386144638, + "elapsed": 1047.7258644104004 + }, + { + "step": 1520, + "loss": 0.5085602402687073, + "objective": 0.5085602402687073, + "error": 0.2705078125, + "gradient_norm": 0.06673175096511841, + "elapsed": 1059.352120399475 + }, + { + "step": 1536, + "loss": 0.6105246543884277, + "objective": 0.6105246543884277, + "error": 0.3818359375, + "gradient_norm": 0.04271261766552925, + "elapsed": 1070.1413230895996 + }, + { + "step": 1552, + "loss": 0.4792126417160034, + "objective": 0.4792126417160034, + "error": 0.2578125, + "gradient_norm": 0.05200039595365524, + "elapsed": 1086.444006204605 + }, + { + "step": 1568, + "loss": 0.5814266204833984, + "objective": 0.5814266204833984, + "error": 0.330078125, + "gradient_norm": 0.05867309868335724, + "elapsed": 1097.2902619838715 + }, + { + "step": 1584, + "loss": 0.6321226358413696, + "objective": 0.6321226358413696, + "error": 0.3798828125, + "gradient_norm": 0.05418067052960396, + "elapsed": 1107.9767682552338 + }, + { + "step": 1600, + "loss": 0.5931253433227539, + "objective": 0.5931253433227539, + "error": 0.3603515625, + "gradient_norm": 0.06396215409040451, + "elapsed": 1121.782609462738 + }, + { + "step": 1616, + "loss": 0.6411516666412354, + "objective": 0.6411516666412354, + "error": 0.38671875, + "gradient_norm": 0.05035768821835518, + "elapsed": 1132.7197887897491 + }, + { + "step": 1632, + "loss": 0.4267754852771759, + "objective": 0.4267754852771759, + "error": 0.2080078125, + "gradient_norm": 0.09109894186258316, + "elapsed": 1139.1667578220367 + }, + { + "step": 1648, + "loss": 0.21246182918548584, + "objective": 0.21246182918548584, + "error": 0.095703125, + "gradient_norm": 0.04478950425982475, + "elapsed": 1149.1183021068573 + }, + { + "step": 1664, + "loss": 0.46360665559768677, + "objective": 0.46360665559768677, + "error": 0.251953125, + "gradient_norm": 0.07668188214302063, + "elapsed": 1161.1197745800018 + }, + { + "step": 1680, + "loss": 0.46281397342681885, + "objective": 0.46281397342681885, + "error": 0.236328125, + "gradient_norm": 0.07954126596450806, + "elapsed": 1171.8474535942078 + }, + { + "step": 1696, + "loss": 0.2484058141708374, + "objective": 0.2484058141708374, + "error": 0.12109375, + "gradient_norm": 0.047261305153369904, + "elapsed": 1185.6542596817017 + }, + { + "step": 1712, + "loss": 0.24310235679149628, + "objective": 0.24310235679149628, + "error": 0.1064453125, + "gradient_norm": 0.07262872904539108, + "elapsed": 1197.8986082077026 + }, + { + "step": 1728, + "loss": 0.009729458019137383, + "objective": 0.009729458019137383, + "error": 0.001953125, + "gradient_norm": 0.01146845705807209, + "elapsed": 1208.495581150055 + }, + { + "step": 1744, + "loss": 0.24568752944469452, + "objective": 0.24568752944469452, + "error": 0.10546875, + "gradient_norm": 0.05830742046236992, + "elapsed": 1219.9394850730896 + }, + { + "step": 1760, + "loss": 0.022546378895640373, + "objective": 0.022546378895640373, + "error": 0.0068359375, + "gradient_norm": 0.007667526602745056, + "elapsed": 1229.5703229904175 + }, + { + "step": 1776, + "loss": 0.5848401784896851, + "objective": 0.5848401784896851, + "error": 0.3271484375, + "gradient_norm": 0.061901818960905075, + "elapsed": 1238.750280380249 + }, + { + "step": 1792, + "loss": 0.6031335592269897, + "objective": 0.6031335592269897, + "error": 0.3671875, + "gradient_norm": 0.0676632970571518, + "elapsed": 1247.7468683719635 + }, + { + "step": 1808, + "loss": 0.6210961937904358, + "objective": 0.6210961937904358, + "error": 0.3603515625, + "gradient_norm": 0.0718468651175499, + "elapsed": 1256.1821897029877 + }, + { + "step": 1824, + "loss": 0.570877730846405, + "objective": 0.570877730846405, + "error": 0.3212890625, + "gradient_norm": 0.05575930327177048, + "elapsed": 1266.4091975688934 + }, + { + "step": 1840, + "loss": 0.5711429119110107, + "objective": 0.5711429119110107, + "error": 0.31640625, + "gradient_norm": 0.0691002607345581, + "elapsed": 1277.4722146987915 + }, + { + "step": 1856, + "loss": 0.36046335101127625, + "objective": 0.36046335101127625, + "error": 0.16796875, + "gradient_norm": 0.04694395884871483, + "elapsed": 1287.1420249938965 + }, + { + "step": 1872, + "loss": 0.4688999652862549, + "objective": 0.4688999652862549, + "error": 0.2216796875, + "gradient_norm": 0.07401346415281296, + "elapsed": 1297.3945078849792 + }, + { + "step": 1888, + "loss": 0.46385282278060913, + "objective": 0.46385282278060913, + "error": 0.2373046875, + "gradient_norm": 0.05608939751982689, + "elapsed": 1305.9779334068298 + }, + { + "step": 1904, + "loss": 0.60875403881073, + "objective": 0.60875403881073, + "error": 0.365234375, + "gradient_norm": 0.05085878074169159, + "elapsed": 1317.3097081184387 + }, + { + "step": 1920, + "loss": 0.12223530560731888, + "objective": 0.12223530560731888, + "error": 0.0458984375, + "gradient_norm": 0.024870412424206734, + "elapsed": 1328.6486887931824 + }, + { + "step": 1936, + "loss": 0.3486189544200897, + "objective": 0.3486189544200897, + "error": 0.16796875, + "gradient_norm": 0.04780663549900055, + "elapsed": 1336.6701011657715 + }, + { + "step": 1952, + "loss": 0.5777363777160645, + "objective": 0.5777363777160645, + "error": 0.3427734375, + "gradient_norm": 0.0571451336145401, + "elapsed": 1346.9158833026886 + }, + { + "step": 1968, + "loss": 0.39320266246795654, + "objective": 0.39320266246795654, + "error": 0.1884765625, + "gradient_norm": 0.05673858895897865, + "elapsed": 1354.9182631969452 + }, + { + "step": 1984, + "loss": 0.5900611281394958, + "objective": 0.5900611281394958, + "error": 0.3349609375, + "gradient_norm": 0.06593932211399078, + "elapsed": 1364.2754452228546 + }, + { + "step": 2000, + "loss": 0.6212430000305176, + "objective": 0.6212430000305176, + "error": 0.3857421875, + "gradient_norm": 0.040818918496370316, + "elapsed": 1374.7192046642303 + }, + { + "step": 2016, + "loss": 0.15605247020721436, + "objective": 0.15605247020721436, + "error": 0.0556640625, + "gradient_norm": 0.03108786791563034, + "elapsed": 1386.2740807533264 + }, + { + "step": 2032, + "loss": 0.22049596905708313, + "objective": 0.22049596905708313, + "error": 0.1015625, + "gradient_norm": 0.042733557522296906, + "elapsed": 1396.6422457695007 + }, + { + "step": 2048, + "loss": 0.5642613172531128, + "objective": 0.5642613172531128, + "error": 0.306640625, + "gradient_norm": 0.07527482509613037, + "elapsed": 1407.6688070297241 + } + ] + }, + "training_source_snapshot": "training_sources/full3_1", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2338341346153846, + "512": 0.2336688701923077, + "blend-512": 0.23399939903846154, + "1024": 0.23329326923076923, + "blend-1024": 0.23342848557692306, + "1536": 0.2330679086538462, + "blend-1536": 0.23291766826923077, + "2048": 0.2335186298076923, + "blend-2048": 0.23290264423076928 + }, + "selected": "blend-2048" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22182992788461542, + "512": 0.22143930288461539, + "blend-512": 0.22125901442307694, + "1024": 0.22104867788461538, + "blend-1024": 0.22079326923076922, + "1536": 0.22017728365384615, + "blend-1536": 0.22095853365384618, + "2048": 0.22076322115384617, + "blend-2048": 0.22025240384615385 + }, + "selected": "1536" + } + ], + "checkpoints": { + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "gpu_gradient_control.json": { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "data": "First1024 rows of the authorized4096 training sample; no validation labels", + "weights": "Random scratch parameters, seed20261112; gradients only, no parameter update", + "block_size": 32, + "records": [ + { + "batch": 256, + "seconds_per_gradient": 0.38611968358357746, + "shots_per_second": 663.0068625977924, + "memory_stats": { + "num_allocs": 694, + "bytes_in_use": 306432, + "peak_bytes_in_use": 3054084608, + "largest_alloc_size": 3047267584, + "bytes_limit": 76526240993, + "bytes_reserved": 0, + "peak_bytes_reserved": 0, + "largest_free_block_bytes": 0, + "pool_bytes": 76526240768, + "peak_pool_bytes": 76526240768 + } + }, + { + "batch": 512, + "seconds_per_gradient": 0.6622018814086914, + "shots_per_second": 773.178111350017, + "memory_stats": { + "num_allocs": 1332, + "bytes_in_use": 308480, + "peak_bytes_in_use": 6079704832, + "largest_alloc_size": 6069432576, + "bytes_limit": 76526240993, + "bytes_reserved": 0, + "peak_bytes_reserved": 0, + "largest_free_block_bytes": 0, + "pool_bytes": 76526240768, + "peak_pool_bytes": 76526240768 + } + }, + { + "batch": 1024, + "seconds_per_gradient": 1.117707888285319, + "shots_per_second": 916.1606630252231, + "memory_stats": { + "num_allocs": 1970, + "bytes_in_use": 312576, + "peak_bytes_in_use": 12138994176, + "largest_alloc_size": 12122019840, + "bytes_limit": 76526240993, + "bytes_reserved": 0, + "peak_bytes_reserved": 0, + "largest_free_block_bytes": 0, + "pool_bytes": 76526240768, + "peak_pool_bytes": 76526240768 + } + } + ], + "original_gradient_gpu_control": { + "loss_max_difference": 1.6689300537109375e-06, + "prediction_max_difference": 1.0132789611816406e-06, + "neural_gradient_relative_difference": 5.505155786522664e-05, + "float64_precision_audit": "/run-state/workspace/research/learned_d5/full3_1/gpu_gradient_precision.json", + "tolerance_rationale": "Original3e-5 GPU gradient threshold failed at5.51e-5. Independent float64 audits of both float32 algorithms across six X/Z durations found comparable relative rounding errors up to5.72e-5, with probability errors below6.2e-7. Use1e-4 relative for this accumulated derivative." + } + }, + "gpu_gradient_precision.json": { + "data": "First16 supplied training rows per listed condition; no parameter updates", + "weights": "full3_1/weights-1536.npz", + "reference": "Original unblocked algorithm in float64, fixed float32 neural edge probabilities", + "source_sha256": { + "gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8" + }, + "initial_gpu_control_failure": { + "relative_neural_gradient_difference": 5.505155786522664e-05, + "original_tolerance": 3e-05, + "maximum_loss_difference": 1.6689300537109375e-06, + "maximum_prediction_difference": 1.0132789611816406e-06 + }, + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.30205945019442737, + "unblocked_float32": { + "maximum_loss_error": 2.966804864001915e-07, + "maximum_probability_error": 9.592670685565352e-08, + "neural_gradient_maximum_absolute_error": 1.6391277313232422e-07, + "neural_gradient_relative_error": 3.6604459916077934e-06, + "neural_gradient_cosine": 0.9999999999933656 + }, + "blocked_float32": { + "maximum_loss_error": 1.7747119684941026e-07, + "maximum_probability_error": 8.879568846875685e-08, + "neural_gradient_maximum_absolute_error": 1.7881393432617188e-07, + "neural_gradient_relative_error": 4.366049097416422e-06, + "neural_gradient_cosine": 0.9999999999904692 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.22069588396473294, + "unblocked_float32": { + "maximum_loss_error": 5.498523059088711e-07, + "maximum_probability_error": 9.703680636796719e-08, + "neural_gradient_maximum_absolute_error": 6.686605047434568e-08, + "neural_gradient_relative_error": 2.392500410145668e-06, + "neural_gradient_cosine": 0.999999999997144 + }, + "blocked_float32": { + "maximum_loss_error": 8.745212829311194e-08, + "maximum_probability_error": 6.418482079162402e-08, + "neural_gradient_maximum_absolute_error": 6.705522537231445e-08, + "neural_gradient_relative_error": 1.7739189351699108e-06, + "neural_gradient_cosine": 0.9999999999984265 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.4664494516878606, + "unblocked_float32": { + "maximum_loss_error": 3.922858555771569e-07, + "maximum_probability_error": 2.581999101192167e-07, + "neural_gradient_maximum_absolute_error": 1.7015263438224792e-06, + "neural_gradient_relative_error": 2.234804892316077e-05, + "neural_gradient_cosine": 0.9999999997509151 + }, + "blocked_float32": { + "maximum_loss_error": 3.3479861938356947e-07, + "maximum_probability_error": 1.4954284288659636e-07, + "neural_gradient_maximum_absolute_error": 1.6633421182632446e-06, + "neural_gradient_relative_error": 2.4167285966292737e-05, + "neural_gradient_cosine": 0.9999999997089409 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.438354906018253, + "unblocked_float32": { + "maximum_loss_error": 6.361644384611509e-07, + "maximum_probability_error": 3.6173952677742705e-07, + "neural_gradient_maximum_absolute_error": 1.9436702132225037e-06, + "neural_gradient_relative_error": 5.252014500992631e-05, + "neural_gradient_cosine": 0.9999999986254251 + }, + "blocked_float32": { + "maximum_loss_error": 5.060161181180689e-07, + "maximum_probability_error": 2.589724067414423e-07, + "neural_gradient_maximum_absolute_error": 1.946929842233658e-06, + "neural_gradient_relative_error": 5.71756656511251e-05, + "neural_gradient_cosine": 0.999999998372327 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.3057787329709659, + "unblocked_float32": { + "maximum_loss_error": 6.74491174690317e-07, + "maximum_probability_error": 4.3885854938974234e-07, + "neural_gradient_maximum_absolute_error": 8.174683898687363e-07, + "neural_gradient_relative_error": 4.090547224844183e-05, + "neural_gradient_cosine": 0.9999999991633716 + }, + "blocked_float32": { + "maximum_loss_error": 6.643292806973733e-07, + "maximum_probability_error": 4.835620329712853e-07, + "neural_gradient_maximum_absolute_error": 1.1210795491933823e-06, + "neural_gradient_relative_error": 5.584921905818847e-05, + "neural_gradient_cosine": 0.9999999984491473 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.2501411033127809, + "unblocked_float32": { + "maximum_loss_error": 1.167099820564843e-06, + "maximum_probability_error": 4.921027032533942e-07, + "neural_gradient_maximum_absolute_error": 7.14324414730072e-07, + "neural_gradient_relative_error": 4.528117886548381e-05, + "neural_gradient_cosine": 0.9999999989770499 + }, + "blocked_float32": { + "maximum_loss_error": 1.4055183996664056e-06, + "maximum_probability_error": 6.113119928041755e-07, + "neural_gradient_maximum_absolute_error": 7.075723260641098e-07, + "neural_gradient_relative_error": 5.112087336342683e-05, + "neural_gradient_cosine": 0.9999999986947755 + } + } + ], + "status": "passed" + } + } + }, + { + "training": { + "initialization": "Uniform parameter averages of checkpoints from the same session-initialized training trajectory; no external weights", + "prior_pass": 3, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "hidden_width": 64, + "training": "No new optimizer updates; all learning comes from the recorded source trajectory and its session-trained parent", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "training_source_sha256": { + "learned_d5__train.py": "b73af9da21332dee9a43f653b514695b020fbc3516604b2e721d8cf0ea876d53", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "5e9420df1f6dd56518925e910096fb9bc93bd796a5933b13bf894a1a96256cdf", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 507282, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 19592, + "surface_code_bX_d5_r03_center_5_5": 19646, + "surface_code_bX_d5_r05_center_5_5": 19513, + "surface_code_bX_d5_r07_center_5_5": 19341, + "surface_code_bX_d5_r09_center_5_5": 19211, + "surface_code_bX_d5_r11_center_5_5": 19239, + "surface_code_bX_d5_r13_center_5_5": 19679, + "surface_code_bX_d5_r15_center_5_5": 19455, + "surface_code_bX_d5_r17_center_5_5": 19479, + "surface_code_bX_d5_r19_center_5_5": 19479, + "surface_code_bX_d5_r21_center_5_5": 19551, + "surface_code_bX_d5_r23_center_5_5": 19586, + "surface_code_bX_d5_r25_center_5_5": 19526, + "surface_code_bZ_d5_r01_center_5_5": 19652, + "surface_code_bZ_d5_r03_center_5_5": 19732, + "surface_code_bZ_d5_r05_center_5_5": 19754, + "surface_code_bZ_d5_r07_center_5_5": 19194, + "surface_code_bZ_d5_r09_center_5_5": 19641, + "surface_code_bZ_d5_r11_center_5_5": 19611, + "surface_code_bZ_d5_r13_center_5_5": 19424, + "surface_code_bZ_d5_r15_center_5_5": 19380, + "surface_code_bZ_d5_r17_center_5_5": 19384, + "surface_code_bZ_d5_r19_center_5_5": 19684, + "surface_code_bZ_d5_r21_center_5_5": 19559, + "surface_code_bZ_d5_r23_center_5_5": 19524, + "surface_code_bZ_d5_r25_center_5_5": 19446 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 2048, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261113, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_d5/feedback3_pilot/rng-768.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/feedback3_pilot/weights-768.npz", + "starting_checkpoint_sha256": "bc2ba1c529317ce1b5b661efae4707eca49c6995d6f22b04193fe7642662fed8", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4341062307357788, + "objective": 0.4341062307357788, + "error": 0.208984375, + "gradient_norm": 0.07617632299661636, + "elapsed": 31.45817995071411 + }, + { + "step": 16, + "loss": 0.5996706485748291, + "objective": 0.5996706485748291, + "error": 0.359375, + "gradient_norm": 0.05249844491481781, + "elapsed": 56.34200572967529 + }, + { + "step": 32, + "loss": 0.4388691186904907, + "objective": 0.4388691186904907, + "error": 0.2041015625, + "gradient_norm": 0.0376109778881073, + "elapsed": 67.83739852905273 + }, + { + "step": 48, + "loss": 0.5373439788818359, + "objective": 0.5373439788818359, + "error": 0.2919921875, + "gradient_norm": 0.06261218339204788, + "elapsed": 76.69065475463867 + }, + { + "step": 64, + "loss": 0.24871854484081268, + "objective": 0.24871854484081268, + "error": 0.1162109375, + "gradient_norm": 0.05284671485424042, + "elapsed": 86.3852767944336 + }, + { + "step": 80, + "loss": 0.26628297567367554, + "objective": 0.26628297567367554, + "error": 0.123046875, + "gradient_norm": 0.04054367542266846, + "elapsed": 95.77356100082397 + }, + { + "step": 96, + "loss": 0.48436349630355835, + "objective": 0.48436349630355835, + "error": 0.259765625, + "gradient_norm": 0.05399860441684723, + "elapsed": 107.06293416023254 + }, + { + "step": 112, + "loss": 0.41063767671585083, + "objective": 0.41063767671585083, + "error": 0.1943359375, + "gradient_norm": 0.043602071702480316, + "elapsed": 116.78119611740112 + }, + { + "step": 128, + "loss": 0.3990316390991211, + "objective": 0.3990316390991211, + "error": 0.1865234375, + "gradient_norm": 0.0424419641494751, + "elapsed": 125.6915397644043 + }, + { + "step": 144, + "loss": 0.5119550228118896, + "objective": 0.5119550228118896, + "error": 0.2646484375, + "gradient_norm": 0.07688591629266739, + "elapsed": 136.20711088180542 + }, + { + "step": 160, + "loss": 0.3388235569000244, + "objective": 0.3388235569000244, + "error": 0.1630859375, + "gradient_norm": 0.07015731930732727, + "elapsed": 145.3505516052246 + }, + { + "step": 176, + "loss": 0.5952156186103821, + "objective": 0.5952156186103821, + "error": 0.3369140625, + "gradient_norm": 0.039373140782117844, + "elapsed": 154.77994871139526 + }, + { + "step": 192, + "loss": 0.15157413482666016, + "objective": 0.15157413482666016, + "error": 0.0634765625, + "gradient_norm": 0.029710670933127403, + "elapsed": 164.46801733970642 + }, + { + "step": 208, + "loss": 0.3120684027671814, + "objective": 0.3120684027671814, + "error": 0.1474609375, + "gradient_norm": 0.035548821091651917, + "elapsed": 173.24825358390808 + }, + { + "step": 224, + "loss": 0.5486405491828918, + "objective": 0.5486405491828918, + "error": 0.2900390625, + "gradient_norm": 0.0503678023815155, + "elapsed": 185.29849314689636 + }, + { + "step": 240, + "loss": 0.6046283841133118, + "objective": 0.6046283841133118, + "error": 0.3349609375, + "gradient_norm": 0.05043461173772812, + "elapsed": 197.54880928993225 + }, + { + "step": 256, + "loss": 0.5926339626312256, + "objective": 0.5926339626312256, + "error": 0.3359375, + "gradient_norm": 0.051241543143987656, + "elapsed": 211.79861068725586 + }, + { + "step": 272, + "loss": 0.4018518924713135, + "objective": 0.4018518924713135, + "error": 0.1943359375, + "gradient_norm": 0.0772147998213768, + "elapsed": 222.41974115371704 + }, + { + "step": 288, + "loss": 0.13863243162631989, + "objective": 0.13863243162631989, + "error": 0.0556640625, + "gradient_norm": 0.03334609419107437, + "elapsed": 234.04247426986694 + }, + { + "step": 304, + "loss": 0.562490701675415, + "objective": 0.562490701675415, + "error": 0.337890625, + "gradient_norm": 0.04585934057831764, + "elapsed": 242.65421533584595 + }, + { + "step": 320, + "loss": 0.5352796316146851, + "objective": 0.5352796316146851, + "error": 0.294921875, + "gradient_norm": 0.0837635025382042, + "elapsed": 252.10656356811523 + }, + { + "step": 336, + "loss": 0.26082637906074524, + "objective": 0.26082637906074524, + "error": 0.1220703125, + "gradient_norm": 0.048336997628211975, + "elapsed": 262.33449625968933 + }, + { + "step": 352, + "loss": 0.5959363579750061, + "objective": 0.5959363579750061, + "error": 0.3388671875, + "gradient_norm": 0.06797357648611069, + "elapsed": 271.9942307472229 + }, + { + "step": 368, + "loss": 0.48994284868240356, + "objective": 0.48994284868240356, + "error": 0.2587890625, + "gradient_norm": 0.06296153366565704, + "elapsed": 283.0493588447571 + }, + { + "step": 384, + "loss": 0.5710494518280029, + "objective": 0.5710494518280029, + "error": 0.3134765625, + "gradient_norm": 0.045333269983530045, + "elapsed": 294.64637446403503 + }, + { + "step": 400, + "loss": 0.5957783460617065, + "objective": 0.5957783460617065, + "error": 0.349609375, + "gradient_norm": 0.03918786719441414, + "elapsed": 307.6200888156891 + }, + { + "step": 416, + "loss": 0.27521568536758423, + "objective": 0.27521568536758423, + "error": 0.1220703125, + "gradient_norm": 0.038001637905836105, + "elapsed": 317.01610231399536 + }, + { + "step": 432, + "loss": 0.02379823848605156, + "objective": 0.02379823848605156, + "error": 0.0078125, + "gradient_norm": 0.007661945186555386, + "elapsed": 326.9360330104828 + }, + { + "step": 448, + "loss": 0.56734299659729, + "objective": 0.56734299659729, + "error": 0.3271484375, + "gradient_norm": 0.057416290044784546, + "elapsed": 339.6289041042328 + }, + { + "step": 464, + "loss": 0.10715995728969574, + "objective": 0.10715995728969574, + "error": 0.0380859375, + "gradient_norm": 0.02532491274178028, + "elapsed": 349.8584108352661 + }, + { + "step": 480, + "loss": 0.6143364310264587, + "objective": 0.6143364310264587, + "error": 0.36328125, + "gradient_norm": 0.08023032546043396, + "elapsed": 360.36362075805664 + }, + { + "step": 496, + "loss": 0.44069671630859375, + "objective": 0.44069671630859375, + "error": 0.2197265625, + "gradient_norm": 0.048025116324424744, + "elapsed": 369.48225808143616 + }, + { + "step": 512, + "loss": 0.019900165498256683, + "objective": 0.019900165498256683, + "error": 0.0107421875, + "gradient_norm": 0.0038635791279375553, + "elapsed": 378.59970593452454 + }, + { + "step": 528, + "loss": 0.033316534012556076, + "objective": 0.033316534012556076, + "error": 0.009765625, + "gradient_norm": 0.009174940176308155, + "elapsed": 393.4021761417389 + }, + { + "step": 544, + "loss": 0.41130945086479187, + "objective": 0.41130945086479187, + "error": 0.20703125, + "gradient_norm": 0.04695262759923935, + "elapsed": 402.8586280345917 + }, + { + "step": 560, + "loss": 0.5885373950004578, + "objective": 0.5885373950004578, + "error": 0.3544921875, + "gradient_norm": 0.08534500002861023, + "elapsed": 416.98661041259766 + }, + { + "step": 576, + "loss": 0.3804720640182495, + "objective": 0.3804720640182495, + "error": 0.19140625, + "gradient_norm": 0.05163278803229332, + "elapsed": 427.7550480365753 + }, + { + "step": 592, + "loss": 0.6101120710372925, + "objective": 0.6101120710372925, + "error": 0.3525390625, + "gradient_norm": 0.05593184754252434, + "elapsed": 441.05026268959045 + }, + { + "step": 608, + "loss": 0.5586092472076416, + "objective": 0.5586092472076416, + "error": 0.302734375, + "gradient_norm": 0.07458740472793579, + "elapsed": 452.95383286476135 + }, + { + "step": 624, + "loss": 0.5992780923843384, + "objective": 0.5992780923843384, + "error": 0.357421875, + "gradient_norm": 0.03618372976779938, + "elapsed": 466.1582691669464 + }, + { + "step": 640, + "loss": 0.3536975383758545, + "objective": 0.3536975383758545, + "error": 0.1650390625, + "gradient_norm": 0.05353165790438652, + "elapsed": 477.166255235672 + }, + { + "step": 656, + "loss": 0.4926893711090088, + "objective": 0.4926893711090088, + "error": 0.2626953125, + "gradient_norm": 0.05201377719640732, + "elapsed": 491.1417751312256 + }, + { + "step": 672, + "loss": 0.5754991173744202, + "objective": 0.5754991173744202, + "error": 0.3271484375, + "gradient_norm": 0.08167096972465515, + "elapsed": 501.630366563797 + }, + { + "step": 688, + "loss": 0.5685014724731445, + "objective": 0.5685014724731445, + "error": 0.333984375, + "gradient_norm": 0.043775107711553574, + "elapsed": 514.2880456447601 + }, + { + "step": 704, + "loss": 0.022465089336037636, + "objective": 0.022465089336037636, + "error": 0.0068359375, + "gradient_norm": 0.010172540321946144, + "elapsed": 522.9173214435577 + }, + { + "step": 720, + "loss": 0.035460107028484344, + "objective": 0.035460107028484344, + "error": 0.0107421875, + "gradient_norm": 0.010515578091144562, + "elapsed": 532.8470129966736 + }, + { + "step": 736, + "loss": 0.44765588641166687, + "objective": 0.44765588641166687, + "error": 0.2138671875, + "gradient_norm": 0.09050357341766357, + "elapsed": 541.9488840103149 + }, + { + "step": 752, + "loss": 0.5933939218521118, + "objective": 0.5933939218521118, + "error": 0.3359375, + "gradient_norm": 0.0665116235613823, + "elapsed": 552.9967355728149 + }, + { + "step": 768, + "loss": 0.6100764870643616, + "objective": 0.6100764870643616, + "error": 0.3515625, + "gradient_norm": 0.0821211114525795, + "elapsed": 563.7709202766418 + }, + { + "step": 784, + "loss": 0.02964692935347557, + "objective": 0.02964692935347557, + "error": 0.009765625, + "gradient_norm": 0.012663272209465504, + "elapsed": 573.1517221927643 + }, + { + "step": 800, + "loss": 0.38091832399368286, + "objective": 0.38091832399368286, + "error": 0.1904296875, + "gradient_norm": 0.060622021555900574, + "elapsed": 582.5687477588654 + }, + { + "step": 816, + "loss": 0.552335262298584, + "objective": 0.552335262298584, + "error": 0.3076171875, + "gradient_norm": 0.14419035613536835, + "elapsed": 594.4292685985565 + }, + { + "step": 832, + "loss": 0.5943340063095093, + "objective": 0.5943340063095093, + "error": 0.34375, + "gradient_norm": 0.0633513554930687, + "elapsed": 605.2052299976349 + }, + { + "step": 848, + "loss": 0.6074100732803345, + "objective": 0.6074100732803345, + "error": 0.3486328125, + "gradient_norm": 0.04225531220436096, + "elapsed": 614.8996202945709 + }, + { + "step": 864, + "loss": 0.6198879480361938, + "objective": 0.6198879480361938, + "error": 0.361328125, + "gradient_norm": 0.04208856821060181, + "elapsed": 625.4266908168793 + }, + { + "step": 880, + "loss": 0.6151762008666992, + "objective": 0.6151762008666992, + "error": 0.369140625, + "gradient_norm": 0.06261089444160461, + "elapsed": 636.0696911811829 + }, + { + "step": 896, + "loss": 0.49680083990097046, + "objective": 0.49680083990097046, + "error": 0.25390625, + "gradient_norm": 0.0827067643404007, + "elapsed": 644.6893246173859 + }, + { + "step": 912, + "loss": 0.4610927402973175, + "objective": 0.4610927402973175, + "error": 0.23828125, + "gradient_norm": 0.06652095168828964, + "elapsed": 655.969132900238 + }, + { + "step": 928, + "loss": 0.5218505859375, + "objective": 0.5218505859375, + "error": 0.2685546875, + "gradient_norm": 0.07188194245100021, + "elapsed": 667.5352523326874 + }, + { + "step": 944, + "loss": 0.33009427785873413, + "objective": 0.33009427785873413, + "error": 0.1533203125, + "gradient_norm": 0.05718810483813286, + "elapsed": 677.8397319316864 + }, + { + "step": 960, + "loss": 0.5703234672546387, + "objective": 0.5703234672546387, + "error": 0.3193359375, + "gradient_norm": 0.11168288439512253, + "elapsed": 687.8742904663086 + }, + { + "step": 976, + "loss": 0.025548014789819717, + "objective": 0.025548014789819717, + "error": 0.0107421875, + "gradient_norm": 0.009453393518924713, + "elapsed": 698.294285774231 + }, + { + "step": 992, + "loss": 0.45398157835006714, + "objective": 0.45398157835006714, + "error": 0.2412109375, + "gradient_norm": 0.04607952758669853, + "elapsed": 707.903199672699 + }, + { + "step": 1008, + "loss": 0.3412189781665802, + "objective": 0.3412189781665802, + "error": 0.1513671875, + "gradient_norm": 0.0432075597345829, + "elapsed": 718.5662748813629 + }, + { + "step": 1024, + "loss": 0.4376429319381714, + "objective": 0.4376429319381714, + "error": 0.2275390625, + "gradient_norm": 0.07974351197481155, + "elapsed": 728.8954858779907 + }, + { + "step": 1040, + "loss": 0.33512815833091736, + "objective": 0.33512815833091736, + "error": 0.150390625, + "gradient_norm": 0.04476875811815262, + "elapsed": 744.0822694301605 + }, + { + "step": 1056, + "loss": 0.5214208364486694, + "objective": 0.5214208364486694, + "error": 0.283203125, + "gradient_norm": 0.08898192644119263, + "elapsed": 755.1484262943268 + }, + { + "step": 1072, + "loss": 0.13849599659442902, + "objective": 0.13849599659442902, + "error": 0.052734375, + "gradient_norm": 0.028359953314065933, + "elapsed": 764.3303108215332 + }, + { + "step": 1088, + "loss": 0.323838472366333, + "objective": 0.323838472366333, + "error": 0.1435546875, + "gradient_norm": 0.04081716760993004, + "elapsed": 773.2739362716675 + }, + { + "step": 1104, + "loss": 0.5627881288528442, + "objective": 0.5627881288528442, + "error": 0.3125, + "gradient_norm": 0.08322097361087799, + "elapsed": 784.7223973274231 + }, + { + "step": 1120, + "loss": 0.44111010432243347, + "objective": 0.44111010432243347, + "error": 0.2216796875, + "gradient_norm": 0.05700977146625519, + "elapsed": 795.085648059845 + }, + { + "step": 1136, + "loss": 0.6395992040634155, + "objective": 0.6395992040634155, + "error": 0.39453125, + "gradient_norm": 0.0744553729891777, + "elapsed": 805.7942585945129 + }, + { + "step": 1152, + "loss": 0.5433304309844971, + "objective": 0.5433304309844971, + "error": 0.287109375, + "gradient_norm": 0.04814797267317772, + "elapsed": 817.3382890224457 + }, + { + "step": 1168, + "loss": 0.5708576440811157, + "objective": 0.5708576440811157, + "error": 0.3203125, + "gradient_norm": 0.051331400871276855, + "elapsed": 829.288791179657 + }, + { + "step": 1184, + "loss": 0.5447035431861877, + "objective": 0.5447035431861877, + "error": 0.2939453125, + "gradient_norm": 0.10116687417030334, + "elapsed": 839.6822843551636 + }, + { + "step": 1200, + "loss": 0.6125671863555908, + "objective": 0.6125671863555908, + "error": 0.3642578125, + "gradient_norm": 0.04368080571293831, + "elapsed": 850.2262740135193 + }, + { + "step": 1216, + "loss": 0.5002380609512329, + "objective": 0.5002380609512329, + "error": 0.259765625, + "gradient_norm": 0.04939017817378044, + "elapsed": 862.3783452510834 + }, + { + "step": 1232, + "loss": 0.5698772668838501, + "objective": 0.5698772668838501, + "error": 0.3173828125, + "gradient_norm": 0.04916854575276375, + "elapsed": 871.4622664451599 + }, + { + "step": 1248, + "loss": 0.6046518683433533, + "objective": 0.6046518683433533, + "error": 0.341796875, + "gradient_norm": 0.04919794574379921, + "elapsed": 883.3905737400055 + }, + { + "step": 1264, + "loss": 0.5913128852844238, + "objective": 0.5913128852844238, + "error": 0.357421875, + "gradient_norm": 0.046917904168367386, + "elapsed": 892.4264807701111 + }, + { + "step": 1280, + "loss": 0.5027461051940918, + "objective": 0.5027461051940918, + "error": 0.2626953125, + "gradient_norm": 0.04705750197172165, + "elapsed": 902.5875842571259 + }, + { + "step": 1296, + "loss": 0.13519814610481262, + "objective": 0.13519814610481262, + "error": 0.052734375, + "gradient_norm": 0.02625490538775921, + "elapsed": 912.4087471961975 + }, + { + "step": 1312, + "loss": 0.5862359404563904, + "objective": 0.5862359404563904, + "error": 0.3271484375, + "gradient_norm": 0.05441493168473244, + "elapsed": 923.992555141449 + }, + { + "step": 1328, + "loss": 0.6031408309936523, + "objective": 0.6031408309936523, + "error": 0.3505859375, + "gradient_norm": 0.05901554971933365, + "elapsed": 933.3936491012573 + }, + { + "step": 1344, + "loss": 0.5823733806610107, + "objective": 0.5823733806610107, + "error": 0.3310546875, + "gradient_norm": 0.0842989832162857, + "elapsed": 941.979998588562 + }, + { + "step": 1360, + "loss": 0.6241492033004761, + "objective": 0.6241492033004761, + "error": 0.3720703125, + "gradient_norm": 0.04446673393249512, + "elapsed": 954.969649553299 + }, + { + "step": 1376, + "loss": 0.5829156637191772, + "objective": 0.5829156637191772, + "error": 0.361328125, + "gradient_norm": 0.06615480780601501, + "elapsed": 966.0245676040649 + }, + { + "step": 1392, + "loss": 0.5968320369720459, + "objective": 0.5968320369720459, + "error": 0.34765625, + "gradient_norm": 0.05093541368842125, + "elapsed": 975.1022663116455 + }, + { + "step": 1408, + "loss": 0.045559000223875046, + "objective": 0.045559000223875046, + "error": 0.01171875, + "gradient_norm": 0.02514980360865593, + "elapsed": 987.2391452789307 + }, + { + "step": 1424, + "loss": 0.22601813077926636, + "objective": 0.22601813077926636, + "error": 0.09765625, + "gradient_norm": 0.04834206402301788, + "elapsed": 996.4583384990692 + }, + { + "step": 1440, + "loss": 0.23011144995689392, + "objective": 0.23011144995689392, + "error": 0.111328125, + "gradient_norm": 0.050687842071056366, + "elapsed": 1007.1440904140472 + }, + { + "step": 1456, + "loss": 0.018240466713905334, + "objective": 0.018240466713905334, + "error": 0.0078125, + "gradient_norm": 0.005604141391813755, + "elapsed": 1016.4502851963043 + }, + { + "step": 1472, + "loss": 0.4498720169067383, + "objective": 0.4498720169067383, + "error": 0.232421875, + "gradient_norm": 0.08179625123739243, + "elapsed": 1028.8303294181824 + }, + { + "step": 1488, + "loss": 0.24151627719402313, + "objective": 0.24151627719402313, + "error": 0.107421875, + "gradient_norm": 0.03838668763637543, + "elapsed": 1037.8867321014404 + }, + { + "step": 1504, + "loss": 0.46122002601623535, + "objective": 0.46122002601623535, + "error": 0.232421875, + "gradient_norm": 0.0726623386144638, + "elapsed": 1047.7258644104004 + }, + { + "step": 1520, + "loss": 0.5085602402687073, + "objective": 0.5085602402687073, + "error": 0.2705078125, + "gradient_norm": 0.06673175096511841, + "elapsed": 1059.352120399475 + }, + { + "step": 1536, + "loss": 0.6105246543884277, + "objective": 0.6105246543884277, + "error": 0.3818359375, + "gradient_norm": 0.04271261766552925, + "elapsed": 1070.1413230895996 + }, + { + "step": 1552, + "loss": 0.4792126417160034, + "objective": 0.4792126417160034, + "error": 0.2578125, + "gradient_norm": 0.05200039595365524, + "elapsed": 1086.444006204605 + }, + { + "step": 1568, + "loss": 0.5814266204833984, + "objective": 0.5814266204833984, + "error": 0.330078125, + "gradient_norm": 0.05867309868335724, + "elapsed": 1097.2902619838715 + }, + { + "step": 1584, + "loss": 0.6321226358413696, + "objective": 0.6321226358413696, + "error": 0.3798828125, + "gradient_norm": 0.05418067052960396, + "elapsed": 1107.9767682552338 + }, + { + "step": 1600, + "loss": 0.5931253433227539, + "objective": 0.5931253433227539, + "error": 0.3603515625, + "gradient_norm": 0.06396215409040451, + "elapsed": 1121.782609462738 + }, + { + "step": 1616, + "loss": 0.6411516666412354, + "objective": 0.6411516666412354, + "error": 0.38671875, + "gradient_norm": 0.05035768821835518, + "elapsed": 1132.7197887897491 + }, + { + "step": 1632, + "loss": 0.4267754852771759, + "objective": 0.4267754852771759, + "error": 0.2080078125, + "gradient_norm": 0.09109894186258316, + "elapsed": 1139.1667578220367 + }, + { + "step": 1648, + "loss": 0.21246182918548584, + "objective": 0.21246182918548584, + "error": 0.095703125, + "gradient_norm": 0.04478950425982475, + "elapsed": 1149.1183021068573 + }, + { + "step": 1664, + "loss": 0.46360665559768677, + "objective": 0.46360665559768677, + "error": 0.251953125, + "gradient_norm": 0.07668188214302063, + "elapsed": 1161.1197745800018 + }, + { + "step": 1680, + "loss": 0.46281397342681885, + "objective": 0.46281397342681885, + "error": 0.236328125, + "gradient_norm": 0.07954126596450806, + "elapsed": 1171.8474535942078 + }, + { + "step": 1696, + "loss": 0.2484058141708374, + "objective": 0.2484058141708374, + "error": 0.12109375, + "gradient_norm": 0.047261305153369904, + "elapsed": 1185.6542596817017 + }, + { + "step": 1712, + "loss": 0.24310235679149628, + "objective": 0.24310235679149628, + "error": 0.1064453125, + "gradient_norm": 0.07262872904539108, + "elapsed": 1197.8986082077026 + }, + { + "step": 1728, + "loss": 0.009729458019137383, + "objective": 0.009729458019137383, + "error": 0.001953125, + "gradient_norm": 0.01146845705807209, + "elapsed": 1208.495581150055 + }, + { + "step": 1744, + "loss": 0.24568752944469452, + "objective": 0.24568752944469452, + "error": 0.10546875, + "gradient_norm": 0.05830742046236992, + "elapsed": 1219.9394850730896 + }, + { + "step": 1760, + "loss": 0.022546378895640373, + "objective": 0.022546378895640373, + "error": 0.0068359375, + "gradient_norm": 0.007667526602745056, + "elapsed": 1229.5703229904175 + }, + { + "step": 1776, + "loss": 0.5848401784896851, + "objective": 0.5848401784896851, + "error": 0.3271484375, + "gradient_norm": 0.061901818960905075, + "elapsed": 1238.750280380249 + }, + { + "step": 1792, + "loss": 0.6031335592269897, + "objective": 0.6031335592269897, + "error": 0.3671875, + "gradient_norm": 0.0676632970571518, + "elapsed": 1247.7468683719635 + }, + { + "step": 1808, + "loss": 0.6210961937904358, + "objective": 0.6210961937904358, + "error": 0.3603515625, + "gradient_norm": 0.0718468651175499, + "elapsed": 1256.1821897029877 + }, + { + "step": 1824, + "loss": 0.570877730846405, + "objective": 0.570877730846405, + "error": 0.3212890625, + "gradient_norm": 0.05575930327177048, + "elapsed": 1266.4091975688934 + }, + { + "step": 1840, + "loss": 0.5711429119110107, + "objective": 0.5711429119110107, + "error": 0.31640625, + "gradient_norm": 0.0691002607345581, + "elapsed": 1277.4722146987915 + }, + { + "step": 1856, + "loss": 0.36046335101127625, + "objective": 0.36046335101127625, + "error": 0.16796875, + "gradient_norm": 0.04694395884871483, + "elapsed": 1287.1420249938965 + }, + { + "step": 1872, + "loss": 0.4688999652862549, + "objective": 0.4688999652862549, + "error": 0.2216796875, + "gradient_norm": 0.07401346415281296, + "elapsed": 1297.3945078849792 + }, + { + "step": 1888, + "loss": 0.46385282278060913, + "objective": 0.46385282278060913, + "error": 0.2373046875, + "gradient_norm": 0.05608939751982689, + "elapsed": 1305.9779334068298 + }, + { + "step": 1904, + "loss": 0.60875403881073, + "objective": 0.60875403881073, + "error": 0.365234375, + "gradient_norm": 0.05085878074169159, + "elapsed": 1317.3097081184387 + }, + { + "step": 1920, + "loss": 0.12223530560731888, + "objective": 0.12223530560731888, + "error": 0.0458984375, + "gradient_norm": 0.024870412424206734, + "elapsed": 1328.6486887931824 + }, + { + "step": 1936, + "loss": 0.3486189544200897, + "objective": 0.3486189544200897, + "error": 0.16796875, + "gradient_norm": 0.04780663549900055, + "elapsed": 1336.6701011657715 + }, + { + "step": 1952, + "loss": 0.5777363777160645, + "objective": 0.5777363777160645, + "error": 0.3427734375, + "gradient_norm": 0.0571451336145401, + "elapsed": 1346.9158833026886 + }, + { + "step": 1968, + "loss": 0.39320266246795654, + "objective": 0.39320266246795654, + "error": 0.1884765625, + "gradient_norm": 0.05673858895897865, + "elapsed": 1354.9182631969452 + }, + { + "step": 1984, + "loss": 0.5900611281394958, + "objective": 0.5900611281394958, + "error": 0.3349609375, + "gradient_norm": 0.06593932211399078, + "elapsed": 1364.2754452228546 + }, + { + "step": 2000, + "loss": 0.6212430000305176, + "objective": 0.6212430000305176, + "error": 0.3857421875, + "gradient_norm": 0.040818918496370316, + "elapsed": 1374.7192046642303 + }, + { + "step": 2016, + "loss": 0.15605247020721436, + "objective": 0.15605247020721436, + "error": 0.0556640625, + "gradient_norm": 0.03108786791563034, + "elapsed": 1386.2740807533264 + }, + { + "step": 2032, + "loss": 0.22049596905708313, + "objective": 0.22049596905708313, + "error": 0.1015625, + "gradient_norm": 0.042733557522296906, + "elapsed": 1396.6422457695007 + }, + { + "step": 2048, + "loss": 0.5642613172531128, + "objective": 0.5642613172531128, + "error": 0.306640625, + "gradient_norm": 0.07527482509613037, + "elapsed": 1407.6688070297241 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 512, + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "512": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "512": { + "step": 512, + "training_samples": 524288, + "unique_training_rows_seen_in_this_phase": 324661, + "weights_sha256": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "complete": true + }, + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ff5a023ce2c18be7c29f810a3788a450e3ad3ad2237d6e9448923aa6a28c5074", + "complete": true + } + }, + "selection": "Predefined averages of the last3 or all4 saved noninitial full3_1 checkpoints; evaluate every validation condition before selecting", + "test_data_used": false, + "derivation_source_sha256": "08c498d6952b0380e001371df9a0461a483631a301f93747b821e529e72b349d" + }, + "training_source_snapshot": "training_sources/full3_swa", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23290264423076928, + "mean3": 0.2335186298076923, + "blend-mean3": 0.2325420673076923, + "mean4": 0.23326322115384618, + "blend-mean4": 0.23300781250000002 + }, + "selected": "blend-mean3" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615, + "mean3": 0.22037259615384613, + "blend-mean3": 0.22091346153846153, + "mean4": 0.2205528846153846, + "blend-mean4": 0.22100360576923078 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 491030, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18670, + "surface_code_bX_d5_r03_center_5_5": 18940, + "surface_code_bX_d5_r05_center_5_5": 19128, + "surface_code_bX_d5_r07_center_5_5": 18988, + "surface_code_bX_d5_r09_center_5_5": 18523, + "surface_code_bX_d5_r11_center_5_5": 19227, + "surface_code_bX_d5_r13_center_5_5": 18816, + "surface_code_bX_d5_r15_center_5_5": 18107, + "surface_code_bX_d5_r17_center_5_5": 18728, + "surface_code_bX_d5_r19_center_5_5": 18983, + "surface_code_bX_d5_r21_center_5_5": 18959, + "surface_code_bX_d5_r23_center_5_5": 19079, + "surface_code_bX_d5_r25_center_5_5": 19193, + "surface_code_bZ_d5_r01_center_5_5": 18828, + "surface_code_bZ_d5_r03_center_5_5": 18896, + "surface_code_bZ_d5_r05_center_5_5": 19011, + "surface_code_bZ_d5_r07_center_5_5": 18806, + "surface_code_bZ_d5_r09_center_5_5": 18268, + "surface_code_bZ_d5_r11_center_5_5": 18927, + "surface_code_bZ_d5_r13_center_5_5": 19399, + "surface_code_bZ_d5_r15_center_5_5": 19358, + "surface_code_bZ_d5_r17_center_5_5": 18634, + "surface_code_bZ_d5_r19_center_5_5": 19126, + "surface_code_bZ_d5_r21_center_5_5": 18603, + "surface_code_bZ_d5_r23_center_5_5": 18626, + "surface_code_bZ_d5_r25_center_5_5": 19207 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/fresh2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_warm/weights-512.npz", + "starting_checkpoint_sha256": "d3e3abba07693bd7fd3d17be2dd981d5b803a496e76ba230ed94afeb51f26f4f", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 325678, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 11962, + "surface_code_bX_d5_r03_center_5_5": 10232, + "surface_code_bX_d5_r05_center_5_5": 14014, + "surface_code_bX_d5_r07_center_5_5": 11594, + "surface_code_bX_d5_r09_center_5_5": 12805, + "surface_code_bX_d5_r11_center_5_5": 11644, + "surface_code_bX_d5_r13_center_5_5": 13845, + "surface_code_bX_d5_r15_center_5_5": 10703, + "surface_code_bX_d5_r17_center_5_5": 15460, + "surface_code_bX_d5_r19_center_5_5": 14156, + "surface_code_bX_d5_r21_center_5_5": 11568, + "surface_code_bX_d5_r23_center_5_5": 14156, + "surface_code_bX_d5_r25_center_5_5": 12021, + "surface_code_bZ_d5_r01_center_5_5": 10601, + "surface_code_bZ_d5_r03_center_5_5": 14135, + "surface_code_bZ_d5_r05_center_5_5": 11975, + "surface_code_bZ_d5_r07_center_5_5": 13841, + "surface_code_bZ_d5_r09_center_5_5": 12024, + "surface_code_bZ_d5_r11_center_5_5": 11151, + "surface_code_bZ_d5_r13_center_5_5": 10640, + "surface_code_bZ_d5_r15_center_5_5": 11089, + "surface_code_bZ_d5_r17_center_5_5": 13788, + "surface_code_bZ_d5_r19_center_5_5": 12350, + "surface_code_bZ_d5_r21_center_5_5": 12797, + "surface_code_bZ_d5_r23_center_5_5": 12809, + "surface_code_bZ_d5_r25_center_5_5": 14318 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261135", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6522030830383301, + "objective": 0.6522030830383301, + "error": 0.375, + "gradient_norm": 0.11649785190820694, + "elapsed": 30.089841604232788 + }, + { + "step": 16, + "loss": 0.5927819609642029, + "objective": 0.5927819609642029, + "error": 0.3466796875, + "gradient_norm": 0.07945127785205841, + "elapsed": 48.85365080833435 + }, + { + "step": 32, + "loss": 0.3115929663181305, + "objective": 0.3115929663181305, + "error": 0.13671875, + "gradient_norm": 0.039320655167102814, + "elapsed": 63.60312819480896 + }, + { + "step": 48, + "loss": 0.2456369698047638, + "objective": 0.2456369698047638, + "error": 0.1015625, + "gradient_norm": 0.029398636892437935, + "elapsed": 73.71074151992798 + }, + { + "step": 64, + "loss": 0.6231744885444641, + "objective": 0.6231744885444641, + "error": 0.3759765625, + "gradient_norm": 0.06867238879203796, + "elapsed": 83.75580954551697 + }, + { + "step": 80, + "loss": 0.3674217164516449, + "objective": 0.3674217164516449, + "error": 0.1572265625, + "gradient_norm": 0.0557992123067379, + "elapsed": 94.6383364200592 + }, + { + "step": 96, + "loss": 0.5152362585067749, + "objective": 0.5152362585067749, + "error": 0.2568359375, + "gradient_norm": 0.08284599334001541, + "elapsed": 106.90000939369202 + }, + { + "step": 112, + "loss": 0.020773420110344887, + "objective": 0.020773420110344887, + "error": 0.0048828125, + "gradient_norm": 0.008813572116196156, + "elapsed": 117.77558088302612 + }, + { + "step": 128, + "loss": 0.02593131735920906, + "objective": 0.02593131735920906, + "error": 0.0087890625, + "gradient_norm": 0.00872033555060625, + "elapsed": 128.93439435958862 + }, + { + "step": 144, + "loss": 0.5852900743484497, + "objective": 0.5852900743484497, + "error": 0.3291015625, + "gradient_norm": 0.04771002382040024, + "elapsed": 139.5588686466217 + }, + { + "step": 160, + "loss": 0.46074625849723816, + "objective": 0.46074625849723816, + "error": 0.232421875, + "gradient_norm": 0.08834747970104218, + "elapsed": 151.5595977306366 + }, + { + "step": 176, + "loss": 0.6310865879058838, + "objective": 0.6310865879058838, + "error": 0.376953125, + "gradient_norm": 0.14084596931934357, + "elapsed": 163.7892107963562 + }, + { + "step": 192, + "loss": 0.246865376830101, + "objective": 0.246865376830101, + "error": 0.1103515625, + "gradient_norm": 0.041402049362659454, + "elapsed": 174.28971648216248 + }, + { + "step": 208, + "loss": 0.3103577196598053, + "objective": 0.3103577196598053, + "error": 0.15625, + "gradient_norm": 0.04525696486234665, + "elapsed": 187.03909611701965 + }, + { + "step": 224, + "loss": 0.4523138999938965, + "objective": 0.4523138999938965, + "error": 0.208984375, + "gradient_norm": 0.09180521965026855, + "elapsed": 199.56195068359375 + }, + { + "step": 240, + "loss": 0.02241751179099083, + "objective": 0.02241751179099083, + "error": 0.009765625, + "gradient_norm": 0.009998111054301262, + "elapsed": 212.35500597953796 + }, + { + "step": 256, + "loss": 0.5487150549888611, + "objective": 0.5487150549888611, + "error": 0.294921875, + "gradient_norm": 0.12748055160045624, + "elapsed": 223.03854608535767 + }, + { + "step": 272, + "loss": 0.023057367652654648, + "objective": 0.023057367652654648, + "error": 0.0078125, + "gradient_norm": 0.006953821517527103, + "elapsed": 244.6508972644806 + }, + { + "step": 288, + "loss": 0.5845386981964111, + "objective": 0.5845386981964111, + "error": 0.330078125, + "gradient_norm": 0.06542652100324631, + "elapsed": 256.78167748451233 + }, + { + "step": 304, + "loss": 0.442532479763031, + "objective": 0.442532479763031, + "error": 0.232421875, + "gradient_norm": 0.10874580591917038, + "elapsed": 269.1364529132843 + }, + { + "step": 320, + "loss": 0.3264174163341522, + "objective": 0.3264174163341522, + "error": 0.15625, + "gradient_norm": 0.06276191771030426, + "elapsed": 282.38969564437866 + }, + { + "step": 336, + "loss": 0.386960506439209, + "objective": 0.386960506439209, + "error": 0.177734375, + "gradient_norm": 0.06561421602964401, + "elapsed": 292.9079031944275 + }, + { + "step": 352, + "loss": 0.23919886350631714, + "objective": 0.23919886350631714, + "error": 0.107421875, + "gradient_norm": 0.02755703590810299, + "elapsed": 304.16068935394287 + }, + { + "step": 368, + "loss": 0.5029175281524658, + "objective": 0.5029175281524658, + "error": 0.259765625, + "gradient_norm": 0.0378776490688324, + "elapsed": 315.11088514328003 + }, + { + "step": 384, + "loss": 0.565666675567627, + "objective": 0.565666675567627, + "error": 0.322265625, + "gradient_norm": 0.11368246376514435, + "elapsed": 324.3651068210602 + }, + { + "step": 400, + "loss": 0.5846428275108337, + "objective": 0.5846428275108337, + "error": 0.3408203125, + "gradient_norm": 0.08116643130779266, + "elapsed": 334.70786476135254 + }, + { + "step": 416, + "loss": 0.025111017748713493, + "objective": 0.025111017748713493, + "error": 0.0078125, + "gradient_norm": 0.008838560432195663, + "elapsed": 345.56963562965393 + }, + { + "step": 432, + "loss": 0.628488302230835, + "objective": 0.628488302230835, + "error": 0.3818359375, + "gradient_norm": 0.04001976177096367, + "elapsed": 355.3310384750366 + }, + { + "step": 448, + "loss": 0.4569575786590576, + "objective": 0.4569575786590576, + "error": 0.2578125, + "gradient_norm": 0.06344135850667953, + "elapsed": 367.05255675315857 + }, + { + "step": 464, + "loss": 0.49193111062049866, + "objective": 0.49193111062049866, + "error": 0.24609375, + "gradient_norm": 0.06022385507822037, + "elapsed": 377.38399291038513 + }, + { + "step": 480, + "loss": 0.5920064449310303, + "objective": 0.5920064449310303, + "error": 0.3466796875, + "gradient_norm": 0.036063045263290405, + "elapsed": 387.7266733646393 + }, + { + "step": 496, + "loss": 0.22157302498817444, + "objective": 0.22157302498817444, + "error": 0.09375, + "gradient_norm": 0.04071022942662239, + "elapsed": 397.78643012046814 + }, + { + "step": 512, + "loss": 0.39216887950897217, + "objective": 0.39216887950897217, + "error": 0.1728515625, + "gradient_norm": 0.09079446643590927, + "elapsed": 407.0137679576874 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6092928647994995, + "objective": 0.6092928647994995, + "error": 0.3583984375, + "gradient_norm": 0.08161187171936035, + "elapsed": 27.421262741088867 + }, + { + "step": 16, + "loss": 0.4709879755973816, + "objective": 0.4709879755973816, + "error": 0.2529296875, + "gradient_norm": 0.0541619211435318, + "elapsed": 48.74575757980347 + }, + { + "step": 32, + "loss": 0.5842419862747192, + "objective": 0.5842419862747192, + "error": 0.34375, + "gradient_norm": 0.09450904279947281, + "elapsed": 60.68022179603577 + }, + { + "step": 48, + "loss": 0.5840846300125122, + "objective": 0.5840846300125122, + "error": 0.32421875, + "gradient_norm": 0.04569687321782112, + "elapsed": 74.63272476196289 + }, + { + "step": 64, + "loss": 0.5139708518981934, + "objective": 0.5139708518981934, + "error": 0.2646484375, + "gradient_norm": 0.16111725568771362, + "elapsed": 91.88426613807678 + }, + { + "step": 80, + "loss": 0.49099838733673096, + "objective": 0.49099838733673096, + "error": 0.251953125, + "gradient_norm": 0.04431874305009842, + "elapsed": 105.08457684516907 + }, + { + "step": 96, + "loss": 0.30287861824035645, + "objective": 0.30287861824035645, + "error": 0.14453125, + "gradient_norm": 0.03792181238532066, + "elapsed": 118.16054177284241 + }, + { + "step": 112, + "loss": 0.6026535630226135, + "objective": 0.6026535630226135, + "error": 0.359375, + "gradient_norm": 0.043088704347610474, + "elapsed": 134.6414511203766 + }, + { + "step": 128, + "loss": 0.5983598828315735, + "objective": 0.5983598828315735, + "error": 0.328125, + "gradient_norm": 0.06492504477500916, + "elapsed": 148.38875198364258 + }, + { + "step": 144, + "loss": 0.616276204586029, + "objective": 0.616276204586029, + "error": 0.3857421875, + "gradient_norm": 0.05420554056763649, + "elapsed": 164.11315298080444 + }, + { + "step": 160, + "loss": 0.017882924526929855, + "objective": 0.017882924526929855, + "error": 0.0048828125, + "gradient_norm": 0.004682278726249933, + "elapsed": 178.31525373458862 + }, + { + "step": 176, + "loss": 0.5279660820960999, + "objective": 0.5279660820960999, + "error": 0.271484375, + "gradient_norm": 0.03895021602511406, + "elapsed": 192.20261907577515 + }, + { + "step": 192, + "loss": 0.5794406533241272, + "objective": 0.5794406533241272, + "error": 0.34375, + "gradient_norm": 0.041880734264850616, + "elapsed": 200.32051873207092 + }, + { + "step": 208, + "loss": 0.3353561758995056, + "objective": 0.3353561758995056, + "error": 0.1513671875, + "gradient_norm": 0.07022152841091156, + "elapsed": 212.5193521976471 + }, + { + "step": 224, + "loss": 0.47239983081817627, + "objective": 0.47239983081817627, + "error": 0.23828125, + "gradient_norm": 0.044771477580070496, + "elapsed": 223.36571788787842 + }, + { + "step": 240, + "loss": 0.6235381364822388, + "objective": 0.6235381364822388, + "error": 0.3779296875, + "gradient_norm": 0.047636937350034714, + "elapsed": 233.90032649040222 + }, + { + "step": 256, + "loss": 0.516319751739502, + "objective": 0.516319751739502, + "error": 0.271484375, + "gradient_norm": 0.087476447224617, + "elapsed": 245.52193427085876 + }, + { + "step": 272, + "loss": 0.23385891318321228, + "objective": 0.23385891318321228, + "error": 0.091796875, + "gradient_norm": 0.05921977758407593, + "elapsed": 254.38622951507568 + }, + { + "step": 288, + "loss": 0.31280556321144104, + "objective": 0.31280556321144104, + "error": 0.1318359375, + "gradient_norm": 0.03548427298665047, + "elapsed": 263.25871300697327 + }, + { + "step": 304, + "loss": 0.6208417415618896, + "objective": 0.6208417415618896, + "error": 0.361328125, + "gradient_norm": 0.10255666077136993, + "elapsed": 273.5115919113159 + }, + { + "step": 320, + "loss": 0.5985375642776489, + "objective": 0.5985375642776489, + "error": 0.3603515625, + "gradient_norm": 0.04024764895439148, + "elapsed": 285.4135670661926 + }, + { + "step": 336, + "loss": 0.028151696547865868, + "objective": 0.028151696547865868, + "error": 0.009765625, + "gradient_norm": 0.008847440592944622, + "elapsed": 295.0800693035126 + }, + { + "step": 352, + "loss": 0.6147637963294983, + "objective": 0.6147637963294983, + "error": 0.3603515625, + "gradient_norm": 0.05709920823574066, + "elapsed": 305.32019686698914 + }, + { + "step": 368, + "loss": 0.5955979824066162, + "objective": 0.5955979824066162, + "error": 0.3486328125, + "gradient_norm": 0.04276399686932564, + "elapsed": 316.3869025707245 + }, + { + "step": 384, + "loss": 0.23504304885864258, + "objective": 0.23504304885864258, + "error": 0.1025390625, + "gradient_norm": 0.03205326199531555, + "elapsed": 325.7849349975586 + }, + { + "step": 400, + "loss": 0.13460804522037506, + "objective": 0.13460804522037506, + "error": 0.0546875, + "gradient_norm": 0.03109711967408657, + "elapsed": 335.72691917419434 + }, + { + "step": 416, + "loss": 0.5798783302307129, + "objective": 0.5798783302307129, + "error": 0.322265625, + "gradient_norm": 0.053542010486125946, + "elapsed": 345.7052640914917 + }, + { + "step": 432, + "loss": 0.3892784118652344, + "objective": 0.3892784118652344, + "error": 0.19140625, + "gradient_norm": 0.052194178104400635, + "elapsed": 357.38475036621094 + }, + { + "step": 448, + "loss": 0.23582103848457336, + "objective": 0.23582103848457336, + "error": 0.1181640625, + "gradient_norm": 0.032037943601608276, + "elapsed": 369.5841510295868 + }, + { + "step": 464, + "loss": 0.5408849716186523, + "objective": 0.5408849716186523, + "error": 0.2900390625, + "gradient_norm": 0.07508285343647003, + "elapsed": 379.84099793434143 + }, + { + "step": 480, + "loss": 0.3894873559474945, + "objective": 0.3894873559474945, + "error": 0.19140625, + "gradient_norm": 0.03977999836206436, + "elapsed": 390.9687530994415 + }, + { + "step": 496, + "loss": 0.6059300899505615, + "objective": 0.6059300899505615, + "error": 0.361328125, + "gradient_norm": 0.06041429564356804, + "elapsed": 403.2380111217499 + }, + { + "step": 512, + "loss": 0.2117740511894226, + "objective": 0.2117740511894226, + "error": 0.0908203125, + "gradient_norm": 0.05693414434790611, + "elapsed": 414.4854781627655 + }, + { + "step": 528, + "loss": 0.4666211009025574, + "objective": 0.4666211009025574, + "error": 0.2470703125, + "gradient_norm": 0.0764947235584259, + "elapsed": 433.42368054389954 + }, + { + "step": 544, + "loss": 0.22636458277702332, + "objective": 0.22636458277702332, + "error": 0.1083984375, + "gradient_norm": 0.03683016076683998, + "elapsed": 442.92575907707214 + }, + { + "step": 560, + "loss": 0.23172692954540253, + "objective": 0.23172692954540253, + "error": 0.1083984375, + "gradient_norm": 0.034071482717990875, + "elapsed": 453.3129711151123 + }, + { + "step": 576, + "loss": 0.4768703579902649, + "objective": 0.4768703579902649, + "error": 0.2529296875, + "gradient_norm": 0.06308378279209137, + "elapsed": 462.4127457141876 + }, + { + "step": 592, + "loss": 0.5165150165557861, + "objective": 0.5165150165557861, + "error": 0.291015625, + "gradient_norm": 0.07674732059240341, + "elapsed": 473.8309862613678 + }, + { + "step": 608, + "loss": 0.5919064283370972, + "objective": 0.5919064283370972, + "error": 0.3359375, + "gradient_norm": 0.06379934400320053, + "elapsed": 484.3733870983124 + }, + { + "step": 624, + "loss": 0.01804366335272789, + "objective": 0.01804366335272789, + "error": 0.0068359375, + "gradient_norm": 0.005318541545420885, + "elapsed": 495.94076347351074 + }, + { + "step": 640, + "loss": 0.41747498512268066, + "objective": 0.41747498512268066, + "error": 0.1962890625, + "gradient_norm": 0.052116431295871735, + "elapsed": 506.73559165000916 + }, + { + "step": 656, + "loss": 0.6140056848526001, + "objective": 0.6140056848526001, + "error": 0.3896484375, + "gradient_norm": 0.05376415699720383, + "elapsed": 517.2397899627686 + }, + { + "step": 672, + "loss": 0.4098930358886719, + "objective": 0.4098930358886719, + "error": 0.197265625, + "gradient_norm": 0.04737741872668266, + "elapsed": 525.7957897186279 + }, + { + "step": 688, + "loss": 0.3499884009361267, + "objective": 0.3499884009361267, + "error": 0.1650390625, + "gradient_norm": 0.0714973583817482, + "elapsed": 534.9302124977112 + }, + { + "step": 704, + "loss": 0.552291989326477, + "objective": 0.552291989326477, + "error": 0.3095703125, + "gradient_norm": 0.10188189148902893, + "elapsed": 545.4470670223236 + }, + { + "step": 720, + "loss": 0.4040689468383789, + "objective": 0.4040689468383789, + "error": 0.1943359375, + "gradient_norm": 0.06630362570285797, + "elapsed": 554.2920794487 + }, + { + "step": 736, + "loss": 0.3191133439540863, + "objective": 0.3191133439540863, + "error": 0.15625, + "gradient_norm": 0.060587506741285324, + "elapsed": 562.335791349411 + }, + { + "step": 752, + "loss": 0.5949387550354004, + "objective": 0.5949387550354004, + "error": 0.330078125, + "gradient_norm": 0.051291145384311676, + "elapsed": 570.9363489151001 + }, + { + "step": 768, + "loss": 0.4783790409564972, + "objective": 0.4783790409564972, + "error": 0.244140625, + "gradient_norm": 0.08808670938014984, + "elapsed": 581.1555306911469 + }, + { + "step": 784, + "loss": 0.4414710998535156, + "objective": 0.4414710998535156, + "error": 0.20703125, + "gradient_norm": 0.06632383912801743, + "elapsed": 590.4109175205231 + }, + { + "step": 800, + "loss": 0.2536136507987976, + "objective": 0.2536136507987976, + "error": 0.1142578125, + "gradient_norm": 0.03191893920302391, + "elapsed": 601.43274974823 + }, + { + "step": 816, + "loss": 0.22448071837425232, + "objective": 0.22448071837425232, + "error": 0.1015625, + "gradient_norm": 0.04966023191809654, + "elapsed": 612.7252013683319 + }, + { + "step": 832, + "loss": 0.5342355966567993, + "objective": 0.5342355966567993, + "error": 0.2783203125, + "gradient_norm": 0.05757307633757591, + "elapsed": 623.6647284030914 + }, + { + "step": 848, + "loss": 0.2506354749202728, + "objective": 0.2506354749202728, + "error": 0.109375, + "gradient_norm": 0.03991081938147545, + "elapsed": 635.1636409759521 + }, + { + "step": 864, + "loss": 0.40698009729385376, + "objective": 0.40698009729385376, + "error": 0.1953125, + "gradient_norm": 0.09155476838350296, + "elapsed": 645.2128469944 + }, + { + "step": 880, + "loss": 0.563283383846283, + "objective": 0.563283383846283, + "error": 0.3134765625, + "gradient_norm": 0.11409252882003784, + "elapsed": 659.2946681976318 + }, + { + "step": 896, + "loss": 0.13591040670871735, + "objective": 0.13591040670871735, + "error": 0.064453125, + "gradient_norm": 0.02692740224301815, + "elapsed": 668.6167254447937 + }, + { + "step": 912, + "loss": 0.5798318982124329, + "objective": 0.5798318982124329, + "error": 0.3310546875, + "gradient_norm": 0.06674209237098694, + "elapsed": 680.6492185592651 + }, + { + "step": 928, + "loss": 0.6140691041946411, + "objective": 0.6140691041946411, + "error": 0.3857421875, + "gradient_norm": 0.06117575615644455, + "elapsed": 693.1704411506653 + }, + { + "step": 944, + "loss": 0.3964633643627167, + "objective": 0.3964633643627167, + "error": 0.1865234375, + "gradient_norm": 0.08617512136697769, + "elapsed": 708.2128443717957 + }, + { + "step": 960, + "loss": 0.5512299537658691, + "objective": 0.5512299537658691, + "error": 0.2861328125, + "gradient_norm": 0.05705108866095543, + "elapsed": 720.2417063713074 + }, + { + "step": 976, + "loss": 0.454137921333313, + "objective": 0.454137921333313, + "error": 0.216796875, + "gradient_norm": 0.07962293922901154, + "elapsed": 730.2567391395569 + }, + { + "step": 992, + "loss": 0.5681213140487671, + "objective": 0.5681213140487671, + "error": 0.3017578125, + "gradient_norm": 0.09802286326885223, + "elapsed": 742.7380962371826 + }, + { + "step": 1008, + "loss": 0.13060352206230164, + "objective": 0.13060352206230164, + "error": 0.0537109375, + "gradient_norm": 0.04271279275417328, + "elapsed": 750.8077793121338 + }, + { + "step": 1024, + "loss": 0.6129879355430603, + "objective": 0.6129879355430603, + "error": 0.3603515625, + "gradient_norm": 0.04127912223339081, + "elapsed": 761.0585849285126 + }, + { + "step": 1040, + "loss": 0.31361687183380127, + "objective": 0.31361687183380127, + "error": 0.1455078125, + "gradient_norm": 0.04341907799243927, + "elapsed": 776.3491418361664 + }, + { + "step": 1056, + "loss": 0.6326502561569214, + "objective": 0.6326502561569214, + "error": 0.365234375, + "gradient_norm": 0.07518075406551361, + "elapsed": 786.0424168109894 + }, + { + "step": 1072, + "loss": 0.537599503993988, + "objective": 0.537599503993988, + "error": 0.2958984375, + "gradient_norm": 0.08455493301153183, + "elapsed": 795.1607735157013 + }, + { + "step": 1088, + "loss": 0.5953108072280884, + "objective": 0.5953108072280884, + "error": 0.337890625, + "gradient_norm": 0.06973882764577866, + "elapsed": 804.0053510665894 + }, + { + "step": 1104, + "loss": 0.36860400438308716, + "objective": 0.36860400438308716, + "error": 0.1923828125, + "gradient_norm": 0.04828036576509476, + "elapsed": 813.4029138088226 + }, + { + "step": 1120, + "loss": 0.5423247218132019, + "objective": 0.5423247218132019, + "error": 0.28125, + "gradient_norm": 0.04841453209519386, + "elapsed": 823.626978635788 + }, + { + "step": 1136, + "loss": 0.4766136407852173, + "objective": 0.4766136407852173, + "error": 0.236328125, + "gradient_norm": 0.07564551383256912, + "elapsed": 832.4641265869141 + }, + { + "step": 1152, + "loss": 0.5473434925079346, + "objective": 0.5473434925079346, + "error": 0.2958984375, + "gradient_norm": 0.13677075505256653, + "elapsed": 844.9307618141174 + }, + { + "step": 1168, + "loss": 0.3040686249732971, + "objective": 0.3040686249732971, + "error": 0.150390625, + "gradient_norm": 0.045926257967948914, + "elapsed": 854.336992263794 + }, + { + "step": 1184, + "loss": 0.6298375129699707, + "objective": 0.6298375129699707, + "error": 0.3798828125, + "gradient_norm": 0.06807851791381836, + "elapsed": 864.5731596946716 + }, + { + "step": 1200, + "loss": 0.6272540092468262, + "objective": 0.6272540092468262, + "error": 0.37890625, + "gradient_norm": 0.139838308095932, + "elapsed": 877.8357374668121 + }, + { + "step": 1216, + "loss": 0.5224937200546265, + "objective": 0.5224937200546265, + "error": 0.287109375, + "gradient_norm": 0.0647057592868805, + "elapsed": 887.8107197284698 + }, + { + "step": 1232, + "loss": 0.02408422902226448, + "objective": 0.02408422902226448, + "error": 0.0107421875, + "gradient_norm": 0.007562167476862669, + "elapsed": 902.201171875 + }, + { + "step": 1248, + "loss": 0.01936865597963333, + "objective": 0.01936865597963333, + "error": 0.0048828125, + "gradient_norm": 0.006423021201044321, + "elapsed": 914.0247437953949 + }, + { + "step": 1264, + "loss": 0.47522181272506714, + "objective": 0.47522181272506714, + "error": 0.2490234375, + "gradient_norm": 0.04962826892733574, + "elapsed": 927.0462884902954 + }, + { + "step": 1280, + "loss": 0.019577551633119583, + "objective": 0.019577551633119583, + "error": 0.0068359375, + "gradient_norm": 0.008308992721140385, + "elapsed": 939.3647270202637 + }, + { + "step": 1296, + "loss": 0.5085430145263672, + "objective": 0.5085430145263672, + "error": 0.2734375, + "gradient_norm": 0.06214233115315437, + "elapsed": 949.4259700775146 + }, + { + "step": 1312, + "loss": 0.23232896625995636, + "objective": 0.23232896625995636, + "error": 0.1015625, + "gradient_norm": 0.05894213914871216, + "elapsed": 961.3636543750763 + }, + { + "step": 1328, + "loss": 0.5330536365509033, + "objective": 0.5330536365509033, + "error": 0.2861328125, + "gradient_norm": 0.11579663306474686, + "elapsed": 972.1607241630554 + }, + { + "step": 1344, + "loss": 0.019525721669197083, + "objective": 0.019525721669197083, + "error": 0.0087890625, + "gradient_norm": 0.008134250529110432, + "elapsed": 983.0828921794891 + }, + { + "step": 1360, + "loss": 0.22790294885635376, + "objective": 0.22790294885635376, + "error": 0.103515625, + "gradient_norm": 0.04187086224555969, + "elapsed": 991.3167304992676 + }, + { + "step": 1376, + "loss": 0.48713046312332153, + "objective": 0.48713046312332153, + "error": 0.2666015625, + "gradient_norm": 0.06267429888248444, + "elapsed": 1003.5033710002899 + }, + { + "step": 1392, + "loss": 0.6043434143066406, + "objective": 0.6043434143066406, + "error": 0.369140625, + "gradient_norm": 0.037880122661590576, + "elapsed": 1017.8567223548889 + }, + { + "step": 1408, + "loss": 0.034499723464250565, + "objective": 0.034499723464250565, + "error": 0.0068359375, + "gradient_norm": 0.013505477458238602, + "elapsed": 1027.3547134399414 + }, + { + "step": 1424, + "loss": 0.5320160388946533, + "objective": 0.5320160388946533, + "error": 0.306640625, + "gradient_norm": 0.07510018348693848, + "elapsed": 1036.9454221725464 + }, + { + "step": 1440, + "loss": 0.3451523780822754, + "objective": 0.3451523780822754, + "error": 0.171875, + "gradient_norm": 0.06453985720872879, + "elapsed": 1046.1805095672607 + }, + { + "step": 1456, + "loss": 0.21541815996170044, + "objective": 0.21541815996170044, + "error": 0.08984375, + "gradient_norm": 0.043503839522600174, + "elapsed": 1055.850379705429 + }, + { + "step": 1472, + "loss": 0.43667086958885193, + "objective": 0.43667086958885193, + "error": 0.22265625, + "gradient_norm": 0.07311506569385529, + "elapsed": 1066.6324400901794 + }, + { + "step": 1488, + "loss": 0.6163139939308167, + "objective": 0.6163139939308167, + "error": 0.3779296875, + "gradient_norm": 0.06406569480895996, + "elapsed": 1075.7883398532867 + }, + { + "step": 1504, + "loss": 0.23901250958442688, + "objective": 0.23901250958442688, + "error": 0.10546875, + "gradient_norm": 0.04792191833257675, + "elapsed": 1085.4756922721863 + }, + { + "step": 1520, + "loss": 0.3817014694213867, + "objective": 0.3817014694213867, + "error": 0.18359375, + "gradient_norm": 0.046061187982559204, + "elapsed": 1095.974383354187 + }, + { + "step": 1536, + "loss": 0.5593156814575195, + "objective": 0.5593156814575195, + "error": 0.3017578125, + "gradient_norm": 0.0735388696193695, + "elapsed": 1105.913155078888 + } + ] + }, + "training_source_snapshot": "training_sources/fresh2_full", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2325420673076923, + "0": 0.23359374999999996, + "blend-0": 0.23372896634615387, + "512": 0.23342848557692306, + "blend-512": 0.23329326923076926, + "1024": 0.23315805288461536, + "blend-1024": 0.23309795673076922, + "1536": 0.2326923076923077, + "blend-1536": 0.23278245192307695 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615, + "0": 0.22125901442307688, + "blend-0": 0.22125901442307694, + "512": 0.22080829326923082, + "blend-512": 0.2211838942307692, + "1024": 0.22052283653846153, + "blend-1024": 0.22031249999999997, + "1536": 0.21953124999999998, + "blend-1536": 0.21998197115384616 + }, + "selected": "1536" + } + ], + "checkpoints": { + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 491030, + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit unused intermediate logical tracking; raw neural branches also omit the unused final physical readout.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "packaged_runtime_control_cpu": { + "device": "cpu", + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "same_cpu_old_vs_new_maximum_difference": 0.0, + "old_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "new_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "cpu_vs_reconstructed_old_gpu_runtime_maximum_difference": 4.976987838745117e-05, + "original_gpu_evaluation_vs_reconstructed_gpu_runtime_maximum_difference": 7.748603820800781e-07, + "initial_failed_control": { + "comparison": "CPU runtime against original GPU evaluator", + "observed_maximum_difference": 4.971027374267578e-05, + "original_tolerance": 3e-06 + }, + "sources": { + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b" + }, + "scope": "Same-device compatibility check. Reconstructed GPU runtime removes the recorded equal physical blend; that reconstruction has floating-point rounding uncertainty.", + "status": "passed_same_device_compatibility" + }, + "cpu_probability_precision": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "validation_syndromes": 7, + "logical_labels_used": false, + "parameter_updates": 0, + "reference": "Float64 neural forward and exact contraction from the same stored weights and fixed float32 input logits, on CPU", + "cpu_float32_vs_float64_maximum_difference": 7.624897924163321e-08, + "cpu_float32_edges_float64_contraction_vs_float64_maximum_difference": 4.725248914372315e-08, + "gpu_float32_vs_float64_maximum_difference": 4.964999121059854e-05, + "cpu_vs_gpu_float32_maximum_difference": 4.971027374267578e-05, + "maximum_neural_edge_probability_difference": 2.6330936014895556e-08, + "float32_edge_values_above_one_minus_1e6": 0, + "scope": "Precision diagnostic only; the published model is unchanged. Same-device old/new packaged-code compatibility was independently exact." + }, + "priors_only_control_cpu": { + "status": "passed", + "device": "cpu", + "source_sha256": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 2.7116777896881104, + "priors_only_seconds_warm": 0.13569164276123047 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 3.557781457901001, + "priors_only_seconds_warm": 1.7711329460144043 + } + ], + "scope": "CPU numerical equivalence on supplied training syndromes; timings are not a controlled speed comparison." + } + } + }, + { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 466919, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved1_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved1_warm/weights-512.npz", + "starting_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317613, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261272", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.1412775069475174, + "objective": 0.1412775069475174, + "error": 0.0595703125, + "gradient_norm": 0.030735325068235397, + "elapsed": 28.457472801208496 + }, + { + "step": 16, + "loss": 0.6315727233886719, + "objective": 0.6315727233886719, + "error": 0.384765625, + "gradient_norm": 0.06563512235879898, + "elapsed": 47.886730670928955 + }, + { + "step": 32, + "loss": 0.5130410194396973, + "objective": 0.5130410194396973, + "error": 0.263671875, + "gradient_norm": 0.10626910626888275, + "elapsed": 60.16136598587036 + }, + { + "step": 48, + "loss": 0.6413166522979736, + "objective": 0.6413166522979736, + "error": 0.408203125, + "gradient_norm": 0.03790846839547157, + "elapsed": 70.9611382484436 + }, + { + "step": 64, + "loss": 0.5491592884063721, + "objective": 0.5491592884063721, + "error": 0.2939453125, + "gradient_norm": 0.093081034719944, + "elapsed": 81.46673464775085 + }, + { + "step": 80, + "loss": 0.6315242648124695, + "objective": 0.6315242648124695, + "error": 0.359375, + "gradient_norm": 0.0384257510304451, + "elapsed": 91.71172666549683 + }, + { + "step": 96, + "loss": 0.6311566829681396, + "objective": 0.6311566829681396, + "error": 0.3798828125, + "gradient_norm": 0.03731638938188553, + "elapsed": 100.83252763748169 + }, + { + "step": 112, + "loss": 0.5327925682067871, + "objective": 0.5327925682067871, + "error": 0.29296875, + "gradient_norm": 0.11202990263700485, + "elapsed": 111.35073852539062 + }, + { + "step": 128, + "loss": 0.6284654140472412, + "objective": 0.6284654140472412, + "error": 0.3740234375, + "gradient_norm": 0.03215613588690758, + "elapsed": 121.32994651794434 + }, + { + "step": 144, + "loss": 0.33964547514915466, + "objective": 0.33964547514915466, + "error": 0.1259765625, + "gradient_norm": 0.05133189633488655, + "elapsed": 131.2744882106781 + }, + { + "step": 160, + "loss": 0.14193454384803772, + "objective": 0.14193454384803772, + "error": 0.0478515625, + "gradient_norm": 0.03264402225613594, + "elapsed": 139.58473920822144 + }, + { + "step": 176, + "loss": 0.14203950762748718, + "objective": 0.14203950762748718, + "error": 0.0654296875, + "gradient_norm": 0.022548990324139595, + "elapsed": 148.9861602783203 + }, + { + "step": 192, + "loss": 0.6307225227355957, + "objective": 0.6307225227355957, + "error": 0.3955078125, + "gradient_norm": 0.08607082068920135, + "elapsed": 162.27514505386353 + }, + { + "step": 208, + "loss": 0.16193106770515442, + "objective": 0.16193106770515442, + "error": 0.064453125, + "gradient_norm": 0.023293493315577507, + "elapsed": 173.59824013710022 + }, + { + "step": 224, + "loss": 0.5426318049430847, + "objective": 0.5426318049430847, + "error": 0.3037109375, + "gradient_norm": 0.03944721072912216, + "elapsed": 182.70232272148132 + }, + { + "step": 240, + "loss": 0.6270365715026855, + "objective": 0.6270365715026855, + "error": 0.3896484375, + "gradient_norm": 0.14661568403244019, + "elapsed": 193.759183883667 + }, + { + "step": 256, + "loss": 0.4933152198791504, + "objective": 0.4933152198791504, + "error": 0.2724609375, + "gradient_norm": 0.1065438985824585, + "elapsed": 205.62959718704224 + }, + { + "step": 272, + "loss": 0.3671969473361969, + "objective": 0.3671969473361969, + "error": 0.177734375, + "gradient_norm": 0.05156548321247101, + "elapsed": 222.249596118927 + }, + { + "step": 288, + "loss": 0.5478869676589966, + "objective": 0.5478869676589966, + "error": 0.3203125, + "gradient_norm": 0.08357688039541245, + "elapsed": 232.2198715209961 + }, + { + "step": 304, + "loss": 0.21171918511390686, + "objective": 0.21171918511390686, + "error": 0.0849609375, + "gradient_norm": 0.06231697276234627, + "elapsed": 241.07631373405457 + }, + { + "step": 320, + "loss": 0.5333335995674133, + "objective": 0.5333335995674133, + "error": 0.2861328125, + "gradient_norm": 0.08931853622198105, + "elapsed": 251.28962755203247 + }, + { + "step": 336, + "loss": 0.12485946714878082, + "objective": 0.12485946714878082, + "error": 0.046875, + "gradient_norm": 0.018839582800865173, + "elapsed": 262.3605041503906 + }, + { + "step": 352, + "loss": 0.2334863245487213, + "objective": 0.2334863245487213, + "error": 0.09765625, + "gradient_norm": 0.03669576346874237, + "elapsed": 273.16373229026794 + }, + { + "step": 368, + "loss": 0.5818328857421875, + "objective": 0.5818328857421875, + "error": 0.3232421875, + "gradient_norm": 0.09833699464797974, + "elapsed": 282.8677294254303 + }, + { + "step": 384, + "loss": 0.6228232383728027, + "objective": 0.6228232383728027, + "error": 0.3671875, + "gradient_norm": 0.033418990671634674, + "elapsed": 295.04902839660645 + }, + { + "step": 400, + "loss": 0.5749450922012329, + "objective": 0.5749450922012329, + "error": 0.333984375, + "gradient_norm": 0.04644288495182991, + "elapsed": 306.67032837867737 + }, + { + "step": 416, + "loss": 0.46251457929611206, + "objective": 0.46251457929611206, + "error": 0.2216796875, + "gradient_norm": 0.06633804738521576, + "elapsed": 317.759464263916 + }, + { + "step": 432, + "loss": 0.5577508211135864, + "objective": 0.5577508211135864, + "error": 0.30859375, + "gradient_norm": 0.0970199704170227, + "elapsed": 327.4626543521881 + }, + { + "step": 448, + "loss": 0.11625733226537704, + "objective": 0.11625733226537704, + "error": 0.0419921875, + "gradient_norm": 0.020417485386133194, + "elapsed": 336.3522970676422 + }, + { + "step": 464, + "loss": 0.23657961189746857, + "objective": 0.23657961189746857, + "error": 0.1025390625, + "gradient_norm": 0.03908605873584747, + "elapsed": 344.3832321166992 + }, + { + "step": 480, + "loss": 0.011504358612000942, + "objective": 0.011504358612000942, + "error": 0.00390625, + "gradient_norm": 0.006708688102662563, + "elapsed": 355.18855381011963 + }, + { + "step": 496, + "loss": 0.3410624563694, + "objective": 0.3410624563694, + "error": 0.1533203125, + "gradient_norm": 0.05804387852549553, + "elapsed": 366.2978138923645 + }, + { + "step": 512, + "loss": 0.034005306661129, + "objective": 0.034005306661129, + "error": 0.0107421875, + "gradient_norm": 0.01019973959773779, + "elapsed": 375.73491764068604 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "b31e8f5ee2b5ea1b661e6bf8b5649bec45b7ab5da74fe9de46e4d06846356b87", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317613, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5523660182952881, + "objective": 0.5523660182952881, + "error": 0.30859375, + "gradient_norm": 0.05200070142745972, + "elapsed": 30.08410096168518 + }, + { + "step": 16, + "loss": 0.5380295515060425, + "objective": 0.5380295515060425, + "error": 0.306640625, + "gradient_norm": 0.0804876759648323, + "elapsed": 50.77648210525513 + }, + { + "step": 32, + "loss": 0.6359301805496216, + "objective": 0.6359301805496216, + "error": 0.3837890625, + "gradient_norm": 0.059380218386650085, + "elapsed": 59.453776836395264 + }, + { + "step": 48, + "loss": 0.2540435492992401, + "objective": 0.2540435492992401, + "error": 0.1083984375, + "gradient_norm": 0.04367281496524811, + "elapsed": 67.29314041137695 + }, + { + "step": 64, + "loss": 0.5867692232131958, + "objective": 0.5867692232131958, + "error": 0.3447265625, + "gradient_norm": 0.053885214030742645, + "elapsed": 78.74847197532654 + }, + { + "step": 80, + "loss": 0.6015321016311646, + "objective": 0.6015321016311646, + "error": 0.365234375, + "gradient_norm": 0.04807985574007034, + "elapsed": 90.48145818710327 + }, + { + "step": 96, + "loss": 0.49287766218185425, + "objective": 0.49287766218185425, + "error": 0.271484375, + "gradient_norm": 0.07899080961942673, + "elapsed": 101.65468978881836 + }, + { + "step": 112, + "loss": 0.3271353542804718, + "objective": 0.3271353542804718, + "error": 0.15234375, + "gradient_norm": 0.049542222172021866, + "elapsed": 111.14713263511658 + }, + { + "step": 128, + "loss": 0.50013667345047, + "objective": 0.50013667345047, + "error": 0.271484375, + "gradient_norm": 0.06454745680093765, + "elapsed": 121.21207547187805 + }, + { + "step": 144, + "loss": 0.028576843440532684, + "objective": 0.028576843440532684, + "error": 0.0087890625, + "gradient_norm": 0.010781333781778812, + "elapsed": 130.69302248954773 + }, + { + "step": 160, + "loss": 0.5668779015541077, + "objective": 0.5668779015541077, + "error": 0.330078125, + "gradient_norm": 0.06098390743136406, + "elapsed": 142.14290237426758 + }, + { + "step": 176, + "loss": 0.3986494839191437, + "objective": 0.3986494839191437, + "error": 0.1884765625, + "gradient_norm": 0.042795032262802124, + "elapsed": 152.75753688812256 + }, + { + "step": 192, + "loss": 0.31897079944610596, + "objective": 0.31897079944610596, + "error": 0.142578125, + "gradient_norm": 0.040675707161426544, + "elapsed": 160.04981398582458 + }, + { + "step": 208, + "loss": 0.5092275142669678, + "objective": 0.5092275142669678, + "error": 0.255859375, + "gradient_norm": 0.07929783314466476, + "elapsed": 169.85345673561096 + }, + { + "step": 224, + "loss": 0.35782667994499207, + "objective": 0.35782667994499207, + "error": 0.1748046875, + "gradient_norm": 0.05785144120454788, + "elapsed": 179.90323066711426 + }, + { + "step": 240, + "loss": 0.5660895109176636, + "objective": 0.5660895109176636, + "error": 0.3349609375, + "gradient_norm": 0.10684454441070557, + "elapsed": 191.3668942451477 + }, + { + "step": 256, + "loss": 0.6265910863876343, + "objective": 0.6265910863876343, + "error": 0.3779296875, + "gradient_norm": 0.034383758902549744, + "elapsed": 200.3055775165558 + }, + { + "step": 272, + "loss": 0.6210677623748779, + "objective": 0.6210677623748779, + "error": 0.369140625, + "gradient_norm": 0.04434216767549515, + "elapsed": 210.09376430511475 + }, + { + "step": 288, + "loss": 0.4892377257347107, + "objective": 0.4892377257347107, + "error": 0.2490234375, + "gradient_norm": 0.1040654331445694, + "elapsed": 220.45881819725037 + }, + { + "step": 304, + "loss": 0.6407739520072937, + "objective": 0.6407739520072937, + "error": 0.3916015625, + "gradient_norm": 0.07782924920320511, + "elapsed": 233.3719048500061 + }, + { + "step": 320, + "loss": 0.4752756953239441, + "objective": 0.4752756953239441, + "error": 0.263671875, + "gradient_norm": 0.051829319447278976, + "elapsed": 244.25844407081604 + }, + { + "step": 336, + "loss": 0.6482080221176147, + "objective": 0.6482080221176147, + "error": 0.41015625, + "gradient_norm": 0.04979892820119858, + "elapsed": 253.1897099018097 + }, + { + "step": 352, + "loss": 0.34022292494773865, + "objective": 0.34022292494773865, + "error": 0.1708984375, + "gradient_norm": 0.09951864182949066, + "elapsed": 264.0781395435333 + }, + { + "step": 368, + "loss": 0.3494992256164551, + "objective": 0.3494992256164551, + "error": 0.15625, + "gradient_norm": 0.10392706841230392, + "elapsed": 275.8111581802368 + }, + { + "step": 384, + "loss": 0.47191378474235535, + "objective": 0.47191378474235535, + "error": 0.25, + "gradient_norm": 0.07366786152124405, + "elapsed": 283.9459602832794 + }, + { + "step": 400, + "loss": 0.583655595779419, + "objective": 0.583655595779419, + "error": 0.3623046875, + "gradient_norm": 0.10394527018070221, + "elapsed": 294.3349726200104 + }, + { + "step": 416, + "loss": 0.6212975978851318, + "objective": 0.6212975978851318, + "error": 0.37109375, + "gradient_norm": 0.054796766489744186, + "elapsed": 304.7477548122406 + }, + { + "step": 432, + "loss": 0.4719577431678772, + "objective": 0.4719577431678772, + "error": 0.2431640625, + "gradient_norm": 0.05418012663722038, + "elapsed": 315.91914200782776 + }, + { + "step": 448, + "loss": 0.5696494579315186, + "objective": 0.5696494579315186, + "error": 0.3330078125, + "gradient_norm": 0.047046076506376266, + "elapsed": 324.96326184272766 + }, + { + "step": 464, + "loss": 0.613875687122345, + "objective": 0.613875687122345, + "error": 0.34765625, + "gradient_norm": 0.05237002298235893, + "elapsed": 334.7670781612396 + }, + { + "step": 480, + "loss": 0.28741705417633057, + "objective": 0.28741705417633057, + "error": 0.1240234375, + "gradient_norm": 0.05365394428372383, + "elapsed": 344.03080439567566 + }, + { + "step": 496, + "loss": 0.3729455769062042, + "objective": 0.3729455769062042, + "error": 0.1875, + "gradient_norm": 0.05905403569340706, + "elapsed": 356.01581716537476 + }, + { + "step": 512, + "loss": 0.38685142993927, + "objective": 0.38685142993927, + "error": 0.17578125, + "gradient_norm": 0.048455506563186646, + "elapsed": 367.7296392917633 + }, + { + "step": 528, + "loss": 0.6062720417976379, + "objective": 0.6062720417976379, + "error": 0.369140625, + "gradient_norm": 0.07544548809528351, + "elapsed": 385.4480962753296 + }, + { + "step": 544, + "loss": 0.520085871219635, + "objective": 0.520085871219635, + "error": 0.279296875, + "gradient_norm": 0.08394371718168259, + "elapsed": 397.71993708610535 + }, + { + "step": 560, + "loss": 0.5944540500640869, + "objective": 0.5944540500640869, + "error": 0.3544921875, + "gradient_norm": 0.05468091368675232, + "elapsed": 406.9417428970337 + }, + { + "step": 576, + "loss": 0.34102559089660645, + "objective": 0.34102559089660645, + "error": 0.1611328125, + "gradient_norm": 0.07333917915821075, + "elapsed": 417.0068130493164 + }, + { + "step": 592, + "loss": 0.47373664379119873, + "objective": 0.47373664379119873, + "error": 0.2412109375, + "gradient_norm": 0.05662858858704567, + "elapsed": 425.1176447868347 + }, + { + "step": 608, + "loss": 0.48517894744873047, + "objective": 0.48517894744873047, + "error": 0.25, + "gradient_norm": 0.08127480745315552, + "elapsed": 434.92080903053284 + }, + { + "step": 624, + "loss": 0.39865612983703613, + "objective": 0.39865612983703613, + "error": 0.1904296875, + "gradient_norm": 0.07332058995962143, + "elapsed": 446.6602101325989 + }, + { + "step": 640, + "loss": 0.41867297887802124, + "objective": 0.41867297887802124, + "error": 0.2177734375, + "gradient_norm": 0.07386308163404465, + "elapsed": 457.0243580341339 + }, + { + "step": 656, + "loss": 0.5108687877655029, + "objective": 0.5108687877655029, + "error": 0.2822265625, + "gradient_norm": 0.052080318331718445, + "elapsed": 469.5842761993408 + }, + { + "step": 672, + "loss": 0.5043742656707764, + "objective": 0.5043742656707764, + "error": 0.2734375, + "gradient_norm": 0.047204963862895966, + "elapsed": 479.356397151947 + }, + { + "step": 688, + "loss": 0.5550935864448547, + "objective": 0.5550935864448547, + "error": 0.30078125, + "gradient_norm": 0.04080262407660484, + "elapsed": 489.9912152290344 + }, + { + "step": 704, + "loss": 0.5698974132537842, + "objective": 0.5698974132537842, + "error": 0.322265625, + "gradient_norm": 0.10692963004112244, + "elapsed": 500.3283371925354 + }, + { + "step": 720, + "loss": 0.45870622992515564, + "objective": 0.45870622992515564, + "error": 0.2255859375, + "gradient_norm": 0.06705734878778458, + "elapsed": 509.82279753685 + }, + { + "step": 736, + "loss": 0.555386483669281, + "objective": 0.555386483669281, + "error": 0.31640625, + "gradient_norm": 0.05112688988447189, + "elapsed": 518.507036447525 + }, + { + "step": 752, + "loss": 0.14282986521720886, + "objective": 0.14282986521720886, + "error": 0.056640625, + "gradient_norm": 0.03209136053919792, + "elapsed": 529.1373023986816 + }, + { + "step": 768, + "loss": 0.5362129807472229, + "objective": 0.5362129807472229, + "error": 0.2841796875, + "gradient_norm": 0.049996186047792435, + "elapsed": 538.9186007976532 + }, + { + "step": 784, + "loss": 0.5071826577186584, + "objective": 0.5071826577186584, + "error": 0.2744140625, + "gradient_norm": 0.04826078191399574, + "elapsed": 549.5225830078125 + }, + { + "step": 800, + "loss": 0.24775367975234985, + "objective": 0.24775367975234985, + "error": 0.107421875, + "gradient_norm": 0.06889795511960983, + "elapsed": 560.7170543670654 + }, + { + "step": 816, + "loss": 0.17432856559753418, + "objective": 0.17432856559753418, + "error": 0.06640625, + "gradient_norm": 0.05147368833422661, + "elapsed": 570.7887880802155 + }, + { + "step": 832, + "loss": 0.5410823822021484, + "objective": 0.5410823822021484, + "error": 0.3115234375, + "gradient_norm": 0.11862928420305252, + "elapsed": 581.9721121788025 + }, + { + "step": 848, + "loss": 0.5555508732795715, + "objective": 0.5555508732795715, + "error": 0.296875, + "gradient_norm": 0.060369592159986496, + "elapsed": 592.2823219299316 + }, + { + "step": 864, + "loss": 0.31839215755462646, + "objective": 0.31839215755462646, + "error": 0.1552734375, + "gradient_norm": 0.063877172768116, + "elapsed": 603.1910541057587 + }, + { + "step": 880, + "loss": 0.481766939163208, + "objective": 0.481766939163208, + "error": 0.2470703125, + "gradient_norm": 0.1623816341161728, + "elapsed": 614.4277107715607 + }, + { + "step": 896, + "loss": 0.5780366659164429, + "objective": 0.5780366659164429, + "error": 0.3037109375, + "gradient_norm": 0.06694691628217697, + "elapsed": 623.9365792274475 + }, + { + "step": 912, + "loss": 0.4794909358024597, + "objective": 0.4794909358024597, + "error": 0.2314453125, + "gradient_norm": 0.07813122123479843, + "elapsed": 633.9845306873322 + }, + { + "step": 928, + "loss": 0.6279138922691345, + "objective": 0.6279138922691345, + "error": 0.380859375, + "gradient_norm": 0.047679927200078964, + "elapsed": 643.7766675949097 + }, + { + "step": 944, + "loss": 0.6401606798171997, + "objective": 0.6401606798171997, + "error": 0.3994140625, + "gradient_norm": 0.07329051941633224, + "elapsed": 655.2369928359985 + }, + { + "step": 960, + "loss": 0.4340277910232544, + "objective": 0.4340277910232544, + "error": 0.2158203125, + "gradient_norm": 0.11762503534555435, + "elapsed": 666.9884371757507 + }, + { + "step": 976, + "loss": 0.44496864080429077, + "objective": 0.44496864080429077, + "error": 0.2236328125, + "gradient_norm": 0.05260347202420235, + "elapsed": 677.3464586734772 + }, + { + "step": 992, + "loss": 0.13230293989181519, + "objective": 0.13230293989181519, + "error": 0.05078125, + "gradient_norm": 0.030240925028920174, + "elapsed": 685.7275724411011 + }, + { + "step": 1008, + "loss": 0.2971688508987427, + "objective": 0.2971688508987427, + "error": 0.1171875, + "gradient_norm": 0.05503479763865471, + "elapsed": 694.1270356178284 + }, + { + "step": 1024, + "loss": 0.5688735246658325, + "objective": 0.5688735246658325, + "error": 0.314453125, + "gradient_norm": 0.06526188552379608, + "elapsed": 703.9192817211151 + }, + { + "step": 1040, + "loss": 0.42805811762809753, + "objective": 0.42805811762809753, + "error": 0.2080078125, + "gradient_norm": 0.13000032305717468, + "elapsed": 720.145961523056 + }, + { + "step": 1056, + "loss": 0.5543602705001831, + "objective": 0.5543602705001831, + "error": 0.298828125, + "gradient_norm": 0.15922385454177856, + "elapsed": 733.5112845897675 + }, + { + "step": 1072, + "loss": 0.031130114570260048, + "objective": 0.031130114570260048, + "error": 0.013671875, + "gradient_norm": 0.008926023729145527, + "elapsed": 742.4467866420746 + }, + { + "step": 1088, + "loss": 0.14947748184204102, + "objective": 0.14947748184204102, + "error": 0.056640625, + "gradient_norm": 0.03975249081850052, + "elapsed": 751.8575854301453 + }, + { + "step": 1104, + "loss": 0.6275734901428223, + "objective": 0.6275734901428223, + "error": 0.3671875, + "gradient_norm": 0.08096148073673248, + "elapsed": 761.5625903606415 + }, + { + "step": 1120, + "loss": 0.23923414945602417, + "objective": 0.23923414945602417, + "error": 0.0966796875, + "gradient_norm": 0.03325376287102699, + "elapsed": 773.9633615016937 + }, + { + "step": 1136, + "loss": 0.570243239402771, + "objective": 0.570243239402771, + "error": 0.31640625, + "gradient_norm": 0.07534287869930267, + "elapsed": 783.1533136367798 + }, + { + "step": 1152, + "loss": 0.4264270067214966, + "objective": 0.4264270067214966, + "error": 0.2119140625, + "gradient_norm": 0.08900073170661926, + "elapsed": 792.1710996627808 + }, + { + "step": 1168, + "loss": 0.5958121418952942, + "objective": 0.5958121418952942, + "error": 0.3583984375, + "gradient_norm": 0.08239343762397766, + "elapsed": 803.1175289154053 + }, + { + "step": 1184, + "loss": 0.2909137010574341, + "objective": 0.2909137010574341, + "error": 0.1416015625, + "gradient_norm": 0.05281354859471321, + "elapsed": 812.6055159568787 + }, + { + "step": 1200, + "loss": 0.6119058728218079, + "objective": 0.6119058728218079, + "error": 0.36328125, + "gradient_norm": 0.056254416704177856, + "elapsed": 823.2276427745819 + }, + { + "step": 1216, + "loss": 0.13595536351203918, + "objective": 0.13595536351203918, + "error": 0.0556640625, + "gradient_norm": 0.04057573154568672, + "elapsed": 834.1696293354034 + }, + { + "step": 1232, + "loss": 0.5840731263160706, + "objective": 0.5840731263160706, + "error": 0.328125, + "gradient_norm": 0.054566267877817154, + "elapsed": 845.3501887321472 + }, + { + "step": 1248, + "loss": 0.3053072690963745, + "objective": 0.3053072690963745, + "error": 0.1337890625, + "gradient_norm": 0.04617297649383545, + "elapsed": 854.9564871788025 + }, + { + "step": 1264, + "loss": 0.6288673281669617, + "objective": 0.6288673281669617, + "error": 0.3994140625, + "gradient_norm": 0.08229745179414749, + "elapsed": 864.8914043903351 + }, + { + "step": 1280, + "loss": 0.5586361289024353, + "objective": 0.5586361289024353, + "error": 0.2958984375, + "gradient_norm": 0.05713959410786629, + "elapsed": 877.0349607467651 + }, + { + "step": 1296, + "loss": 0.3648858666419983, + "objective": 0.3648858666419983, + "error": 0.16796875, + "gradient_norm": 0.08502963185310364, + "elapsed": 888.5764675140381 + }, + { + "step": 1312, + "loss": 0.4747084081172943, + "objective": 0.4747084081172943, + "error": 0.244140625, + "gradient_norm": 0.08609883487224579, + "elapsed": 899.7598609924316 + }, + { + "step": 1328, + "loss": 0.15583917498588562, + "objective": 0.15583917498588562, + "error": 0.05859375, + "gradient_norm": 0.027793049812316895, + "elapsed": 909.47514295578 + }, + { + "step": 1344, + "loss": 0.47515708208084106, + "objective": 0.47515708208084106, + "error": 0.263671875, + "gradient_norm": 0.07668807357549667, + "elapsed": 919.7640328407288 + }, + { + "step": 1360, + "loss": 0.5173689126968384, + "objective": 0.5173689126968384, + "error": 0.2744140625, + "gradient_norm": 0.05054212734103203, + "elapsed": 930.6309463977814 + }, + { + "step": 1376, + "loss": 0.46629998087882996, + "objective": 0.46629998087882996, + "error": 0.24609375, + "gradient_norm": 0.051172077655792236, + "elapsed": 939.0202586650848 + }, + { + "step": 1392, + "loss": 0.11312969774007797, + "objective": 0.11312969774007797, + "error": 0.044921875, + "gradient_norm": 0.05863805115222931, + "elapsed": 949.1451416015625 + }, + { + "step": 1408, + "loss": 0.5750841498374939, + "objective": 0.5750841498374939, + "error": 0.322265625, + "gradient_norm": 0.051106806844472885, + "elapsed": 959.94162940979 + }, + { + "step": 1424, + "loss": 0.5937192440032959, + "objective": 0.5937192440032959, + "error": 0.3408203125, + "gradient_norm": 0.05014815554022789, + "elapsed": 969.5868306159973 + }, + { + "step": 1440, + "loss": 0.5292985439300537, + "objective": 0.5292985439300537, + "error": 0.2958984375, + "gradient_norm": 0.057068243622779846, + "elapsed": 982.6692054271698 + }, + { + "step": 1456, + "loss": 0.5959951877593994, + "objective": 0.5959951877593994, + "error": 0.3408203125, + "gradient_norm": 0.0703694075345993, + "elapsed": 995.0066986083984 + }, + { + "step": 1472, + "loss": 0.018453411757946014, + "objective": 0.018453411757946014, + "error": 0.00390625, + "gradient_norm": 0.012016087770462036, + "elapsed": 1004.0057821273804 + }, + { + "step": 1488, + "loss": 0.5711684823036194, + "objective": 0.5711684823036194, + "error": 0.3095703125, + "gradient_norm": 0.07746906578540802, + "elapsed": 1016.1701967716217 + }, + { + "step": 1504, + "loss": 0.3114882707595825, + "objective": 0.3114882707595825, + "error": 0.1455078125, + "gradient_norm": 0.05321609228849411, + "elapsed": 1026.6053586006165 + }, + { + "step": 1520, + "loss": 0.6433392763137817, + "objective": 0.6433392763137817, + "error": 0.4072265625, + "gradient_norm": 0.05683734640479088, + "elapsed": 1036.1535296440125 + }, + { + "step": 1536, + "loss": 0.38409170508384705, + "objective": 0.38409170508384705, + "error": 0.19140625, + "gradient_norm": 0.07577994465827942, + "elapsed": 1046.9508447647095 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "7b45252d6bb77a39c003c8f34f040d0d672e9dd1a1338a14126e1fe07a02c8c9", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 466919, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/reserved1_full", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23228665865384618, + "0": 0.2337439903846154, + "blend-0": 0.23366887019230773, + "512": 0.23284254807692306, + "blend-512": 0.23275240384615387, + "1024": 0.23356370192307693, + "blend-1024": 0.23315805288461536, + "1536": 0.23218149038461539, + "blend-1536": 0.2330378605769231 + }, + "selected": "1536" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "0": 0.2206580528846154, + "blend-0": 0.2208683894230769, + "512": 0.22100360576923078, + "blend-512": 0.2208984375, + "1024": 0.22104867788461538, + "blend-1024": 0.22019230769230771, + "1536": 0.22264122596153849, + "blend-1536": 0.22032752403846154 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 466919, + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit unused intermediate logical tracking; raw neural branches also omit the unused final physical readout.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "packaged_runtime_control_cpu": { + "device": "cpu", + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "same_cpu_old_vs_new_maximum_difference": 0.0, + "old_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "new_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "cpu_vs_reconstructed_old_gpu_runtime_maximum_difference": 4.976987838745117e-05, + "original_gpu_evaluation_vs_reconstructed_gpu_runtime_maximum_difference": 7.748603820800781e-07, + "initial_failed_control": { + "comparison": "CPU runtime against original GPU evaluator", + "observed_maximum_difference": 4.971027374267578e-05, + "original_tolerance": 3e-06 + }, + "sources": { + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee", + "d5_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b" + }, + "scope": "Same-device compatibility check. Reconstructed GPU runtime removes the recorded equal physical blend; that reconstruction has floating-point rounding uncertainty.", + "status": "passed_same_device_compatibility" + }, + "dispatcher_control_cpu": { + "status": "passed", + "device": "cpu", + "sources": { + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee" + }, + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + } + ], + "scope": "Routing and code-copy check against each direct model implementation, using training detector inputs without labels. Tiny trained temporal/history smoke weights test nonzero feature couplings; they are excluded from model selection and submission.", + "test_data_used": false + }, + "cpu_probability_precision": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "validation_syndromes": 7, + "logical_labels_used": false, + "parameter_updates": 0, + "reference": "Float64 neural forward and exact contraction from the same stored weights and fixed float32 input logits, on CPU", + "cpu_float32_vs_float64_maximum_difference": 7.624897924163321e-08, + "cpu_float32_edges_float64_contraction_vs_float64_maximum_difference": 4.725248914372315e-08, + "gpu_float32_vs_float64_maximum_difference": 4.964999121059854e-05, + "cpu_vs_gpu_float32_maximum_difference": 4.971027374267578e-05, + "maximum_neural_edge_probability_difference": 2.6330936014895556e-08, + "float32_edge_values_above_one_minus_1e6": 0, + "scope": "Precision diagnostic only; the published model is unchanged. Same-device old/new packaged-code compatibility was independently exact." + }, + "priors_only_control_cpu": { + "status": "passed", + "device": "cpu", + "source_sha256": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 2.7116777896881104, + "priors_only_seconds_warm": 0.13569164276123047 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 3.557781457901001, + "priors_only_seconds_warm": 1.7711329460144043 + } + ], + "scope": "CPU numerical equivalence on supplied training syndromes; timings are not a controlled speed comparison." + } + } + } + ], + "short_syndrome_updates": [ + { + "training": { + "initialization": "256 residual logits per condition initialized independently Normal(0,.01), seeds20261126 through20261133; optimized in this session", + "architecture": "One categorical residual per possible8-bit detection syndrome, added to an exact physical DEM logit; no sample IDs or row indices are model features", + "loss": "Binomial logical BCE sufficient statistics plus strength times cross entropy to the fixed physical prior; damped Newton optimization from random residual initialization", + "fixed_prior": "Exact full-DEM probabilities for all256 possible input syndromes, computed now from the authorized packaged even-fitted DEM plans; no external trained weights or decoder answers", + "training": "All19880 supplied training labels for each of eight d3 one-round conditions; only aggregate counts by detection syndrome enter fitting", + "data_scope": "This is a finite categorical classifier, indexed by detection events, not a per-shot answer table. Other122 conditions retain the incumbent in any candidate benchmark.", + "selection": "One common strength and optional equal probability blend for all eight geometries/bases, minimizing full validation mean; all other conditions unchanged", + "base_package": { + "package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "predictions": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/predictions", + "score": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/score.json", + "P": 0.7663217397836538 + }, + "test_data_used": false, + "training_records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 149, + "initial_seed": 20261126, + "physical_plan_sha256": "640c371577096ba08c799b70fd16d03a06a37004feaa15c85c4cb6ef87529080", + "training_arrays_sha256": "a7acd6f6e5372873cf2d34946876a791996238efdea39f7fa33f7d2eabc1c10f" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 157, + "initial_seed": 20261127, + "physical_plan_sha256": "4a0f8f630b7f34fba620a4e03bd77e14fb80149e70b7da80b6176dbd24d9ddc8", + "training_arrays_sha256": "0e2267afc5dc4e761d3b9e09288875f2077215fac2f902ce4151699c38c24531" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 152, + "initial_seed": 20261128, + "physical_plan_sha256": "de8914194be7689d70e9424540923197a5c0465fb42ec96556df97b73ba250c1", + "training_arrays_sha256": "0542609248a5d2c8b410666bb901361b60c39cb8b32b3b46fdd24a6c7913db56" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 147, + "initial_seed": 20261129, + "physical_plan_sha256": "bc1a6888cc5a854f0348cab463b8879c2d176d9509176b944b7f4265e0772ab3", + "training_arrays_sha256": "ccd43f09fba55b2138a5401e6f5c89cc7b4c4ec470a07cd037d9f715acaa1188" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 153, + "initial_seed": 20261130, + "physical_plan_sha256": "1931b5b85d0014c2a928a40c3ec502316ff30ea1632a25c5f64e2694f828434b", + "training_arrays_sha256": "aa27eee730c88b2071b5fd97f9d47a0f3ad010e29202415f786babc073d405e4" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 159, + "initial_seed": 20261131, + "physical_plan_sha256": "6d231f857bbe85040c91af1160c2dda16557a67851deaedc8092412f6abeb294", + "training_arrays_sha256": "569131ce49a2c1060ebd472c0290fc0c1de6e522cd7cd7aa92b10e17cdd1783c" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 158, + "initial_seed": 20261132, + "physical_plan_sha256": "ef285cea44ad63e0452596d4be65c8844ea8a7dcc49fb31b6a6241d367ed63eb", + "training_arrays_sha256": "6928ade685b05f76b7a3a9dc6423504d0bdce09742603c24978aa21fcf106f88" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 160, + "initial_seed": 20261133, + "physical_plan_sha256": "82bee01cf3e00079270a27cb79472322867548df5c9dc4db3252e4c6ec89e6a6", + "training_arrays_sha256": "afbc73fc5ca8e3b8e996377ab3df5a5b9397f36362e72c01feea7848ea1995f3" + } + ], + "records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261126, + "iterations": 8, + "failure": 0.0134765625, + "blended_failure": 0.013671875, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04649575086997129, + "weights_sha256": "d985985dedbe644bfae165330f4f46da14d04efbc4cad1af81c5510115380701" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261126, + "iterations": 6, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04591998541695955, + "weights_sha256": "17383d153dd1dfef62b3d4f6c5b7549c3209150faf0714e78fede09b941ecc3a" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.0458401737684183, + "weights_sha256": "f863a64ca698135f6fac6ac184d3c689db684a15d73bf0565418b240d76b5c58" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.045887733186657405, + "weights_sha256": "ded1a941e0dfc58e55ced6523720445fb70032d2d15c9929b0c93544f7c567f8" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261127, + "iterations": 8, + "failure": 0.0177734375, + "blended_failure": 0.0177734375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05532273244895745, + "weights_sha256": "02950043334a38d3e7980cc97685904338553746653bd2d6a4c9be88ae845270" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261127, + "iterations": 6, + "failure": 0.01875, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055166841080990084, + "weights_sha256": "412ee1f453695e4f3534dbe8d7eb1ca565d06fd7c718b52fe9a306b35e845d9d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261127, + "iterations": 5, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055186840974757456, + "weights_sha256": "12d8f72c2ee5cb837145aaf9a1b485d8517e4374721eebcbea9803d3bfdc8fcd" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261127, + "iterations": 4, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05544033886527203, + "weights_sha256": "d1daa90794c1c3c8cd00134d9b22a7173aee4dd9b139b86f6d3f9b8f2131056d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261128, + "iterations": 7, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.049592331750930654, + "weights_sha256": "ad21a8640e2fe7bbd550225e354dedcbad8cb70433b892f45d28fa2346ab88de" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04900882633372332, + "weights_sha256": "4664564f60149b00b1754a3f9e91c8b04b29ef819b231bf17ea7588346433a57" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04861554683295004, + "weights_sha256": "cad51322361a95020501afa64e356f2a49dd02afa0cd91294d4498f7eb0c5a8d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04843255984360956, + "weights_sha256": "5fe850e6313cb9ed6631697684afeeb7b7c5857a5c74fad66189cfcf8a08218b" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261129, + "iterations": 7, + "failure": 0.0158203125, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05156220348280275, + "weights_sha256": "56c2fd4a7c35033084020cd1f5c9dcc2ab1cf2c631d0e88cc87ac4c715c6af17" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05139675960346585, + "weights_sha256": "0bf66368e18c8d1baecaa614d4c0cec16304ac14bcd29d22d1cdb2a0ff6c0173" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05135569004239689, + "weights_sha256": "d9581a6f29f9d3ea54d482c17995a37b55e3b4253d36e1d49cfce95b398eb5c2" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05141882723288258, + "weights_sha256": "2c4e4592067fcbbe69d6ede68c4494209652a2d510e74aa2ea3b4420c3cdd741" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261130, + "iterations": 7, + "failure": 0.0173828125, + "blended_failure": 0.0173828125, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.054216247940585036, + "weights_sha256": "7b12f028f764293a9496d9fd2ddbf92ba9c23653d7889a602a9ec23f8cde3d6b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261130, + "iterations": 6, + "failure": 0.017578125, + "blended_failure": 0.0171875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05364509063427466, + "weights_sha256": "1ad2ffaafa33009129a0953d79fe2d30ad62308eb9dbf8da0b76eca018a5b55a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261130, + "iterations": 5, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05368896256105915, + "weights_sha256": "64619c9b7bd40a14651bcd056d58f5b55e79eb334a4e5105ff12cb7ff6f2400a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261130, + "iterations": 6, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05387292464104988, + "weights_sha256": "b1490702e212d7cdcc936f55186b15411ced3a8928a1a32f2d4ac1212706fabf" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261131, + "iterations": 8, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04709647994869577, + "weights_sha256": "eb56715dfc5e8c6b8866ceeb2636422acad9992dd2c625355dc21b94c25351f0" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261131, + "iterations": 6, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.046679107084477436, + "weights_sha256": "320cd10cc8cd9d13d20d9ce0ea90413ed8343587f0c77abb0e1c8c84503aa2d8" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261131, + "iterations": 5, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04621785858320204, + "weights_sha256": "c7e63309de0668bd4d5c05169ecd6af1879c88be10947d0fdb958ca37068d433" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261131, + "iterations": 4, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04577880173787941, + "weights_sha256": "494824e979e52fbf0302e706ff6786d89ce60b607afd6b376cad9700f328feda" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261132, + "iterations": 7, + "failure": 0.01484375, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.05068038016752655, + "weights_sha256": "0b4c35df1d44c9353a2ea505205f3def95bb28de0c7052ded18cf599bef2709b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049663607204405706, + "weights_sha256": "b18deed32b51a58789873a1b45718f5c40d1d9500b57e113520b700a66902f1a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261132, + "iterations": 5, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.04918133832768282, + "weights_sha256": "12e71625e223602cbc9f7ae150473a1dad2c32f2d9221a4b88ccb93babc2c41d" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049002647954447996, + "weights_sha256": "e909b83698caba60ad01e28027b28005544cd8e795f88574fc6f81bcf56b2add" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261133, + "iterations": 7, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05204562159505248, + "weights_sha256": "b03b071238dda333574a4da2d9b2bb999cf362a83b9194b1c53871e9438f9f45" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05177096705064832, + "weights_sha256": "2a4c8113ee9a1dadcfc0f1b7ff8d164e7c8771d5764b0512ee1a5de2a8aaa395" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.051861030681133645, + "weights_sha256": "f201491af84870ffa8c1b59e16dea1fea910e7fda32f0e3d82863943222b57ee" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261133, + "iterations": 6, + "failure": 0.01640625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05206536190640361, + "weights_sha256": "b7cfd76b6574457626306868e31ab5327a1950cbbca41f6384eb2c4bc759e800" + } + ], + "choices": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "blend-16": 0.015429687499999999, + "64": 0.0155029296875, + "blend-64": 0.015600585937500001, + "256": 0.0155517578125, + "blend-256": 0.015600585937500001, + "1024": 0.0156005859375, + "blend-1024": 0.015600585937500001 + }, + "selected": "16", + "expected_full_P": 0.7663245567908653, + "validation_P_gain": 2.817007211538435e-06, + "source_sha256": "7e75f14190b18b05e9af540a8ef0f75522060e78c30b05475686ea18faf0035f", + "seconds": 3.316046953201294 + }, + "packaging_selection": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "64": 0.0155029296875, + "256": 0.0155517578125, + "1024": 0.0156005859375 + }, + "selected": "16", + "selection_scope": "One common prior strength for all eight short conditions; other122 condition predictions retained", + "runtime_source_sha256": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af" + }, + { + "training": { + "initialization": "256 residual logits per condition initialized independently Normal(0,.01), seeds20261126 through20261133; optimized in this session", + "architecture": "One categorical residual per possible8-bit detection syndrome, added to an exact physical DEM logit; no sample IDs or row indices are model features", + "loss": "Binomial logical BCE sufficient statistics plus strength times cross entropy to the fixed physical prior; damped Newton optimization from random residual initialization", + "fixed_prior": "Exact full-DEM probabilities for all256 possible input syndromes, computed now from the authorized packaged even-fitted DEM plans; no external trained weights or decoder answers", + "training": "All19880 supplied training labels for each of eight d3 one-round conditions; only aggregate counts by detection syndrome enter fitting", + "data_scope": "This is a finite categorical classifier, indexed by detection events, not a per-shot answer table. Other122 conditions retain the incumbent in any candidate benchmark.", + "selection": "One common strength and optional equal probability blend for all eight geometries/bases, minimizing full validation mean; all other conditions unchanged", + "base_package": { + "package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "predictions": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/predictions", + "score": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/score.json", + "P": 0.7663217397836538 + }, + "test_data_used": false, + "training_records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 149, + "initial_seed": 20261126, + "physical_plan_sha256": "640c371577096ba08c799b70fd16d03a06a37004feaa15c85c4cb6ef87529080", + "training_arrays_sha256": "a7acd6f6e5372873cf2d34946876a791996238efdea39f7fa33f7d2eabc1c10f" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 157, + "initial_seed": 20261127, + "physical_plan_sha256": "4a0f8f630b7f34fba620a4e03bd77e14fb80149e70b7da80b6176dbd24d9ddc8", + "training_arrays_sha256": "0e2267afc5dc4e761d3b9e09288875f2077215fac2f902ce4151699c38c24531" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 152, + "initial_seed": 20261128, + "physical_plan_sha256": "de8914194be7689d70e9424540923197a5c0465fb42ec96556df97b73ba250c1", + "training_arrays_sha256": "0542609248a5d2c8b410666bb901361b60c39cb8b32b3b46fdd24a6c7913db56" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 147, + "initial_seed": 20261129, + "physical_plan_sha256": "bc1a6888cc5a854f0348cab463b8879c2d176d9509176b944b7f4265e0772ab3", + "training_arrays_sha256": "ccd43f09fba55b2138a5401e6f5c89cc7b4c4ec470a07cd037d9f715acaa1188" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 153, + "initial_seed": 20261130, + "physical_plan_sha256": "1931b5b85d0014c2a928a40c3ec502316ff30ea1632a25c5f64e2694f828434b", + "training_arrays_sha256": "aa27eee730c88b2071b5fd97f9d47a0f3ad010e29202415f786babc073d405e4" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 159, + "initial_seed": 20261131, + "physical_plan_sha256": "6d231f857bbe85040c91af1160c2dda16557a67851deaedc8092412f6abeb294", + "training_arrays_sha256": "569131ce49a2c1060ebd472c0290fc0c1de6e522cd7cd7aa92b10e17cdd1783c" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 158, + "initial_seed": 20261132, + "physical_plan_sha256": "ef285cea44ad63e0452596d4be65c8844ea8a7dcc49fb31b6a6241d367ed63eb", + "training_arrays_sha256": "6928ade685b05f76b7a3a9dc6423504d0bdce09742603c24978aa21fcf106f88" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 160, + "initial_seed": 20261133, + "physical_plan_sha256": "82bee01cf3e00079270a27cb79472322867548df5c9dc4db3252e4c6ec89e6a6", + "training_arrays_sha256": "afbc73fc5ca8e3b8e996377ab3df5a5b9397f36362e72c01feea7848ea1995f3" + } + ], + "records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261126, + "iterations": 8, + "failure": 0.0134765625, + "blended_failure": 0.013671875, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04649575086997129, + "weights_sha256": "d985985dedbe644bfae165330f4f46da14d04efbc4cad1af81c5510115380701" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261126, + "iterations": 6, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04591998541695955, + "weights_sha256": "17383d153dd1dfef62b3d4f6c5b7549c3209150faf0714e78fede09b941ecc3a" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.0458401737684183, + "weights_sha256": "f863a64ca698135f6fac6ac184d3c689db684a15d73bf0565418b240d76b5c58" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.045887733186657405, + "weights_sha256": "ded1a941e0dfc58e55ced6523720445fb70032d2d15c9929b0c93544f7c567f8" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261127, + "iterations": 8, + "failure": 0.0177734375, + "blended_failure": 0.0177734375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05532273244895745, + "weights_sha256": "02950043334a38d3e7980cc97685904338553746653bd2d6a4c9be88ae845270" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261127, + "iterations": 6, + "failure": 0.01875, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055166841080990084, + "weights_sha256": "412ee1f453695e4f3534dbe8d7eb1ca565d06fd7c718b52fe9a306b35e845d9d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261127, + "iterations": 5, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055186840974757456, + "weights_sha256": "12d8f72c2ee5cb837145aaf9a1b485d8517e4374721eebcbea9803d3bfdc8fcd" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261127, + "iterations": 4, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05544033886527203, + "weights_sha256": "d1daa90794c1c3c8cd00134d9b22a7173aee4dd9b139b86f6d3f9b8f2131056d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261128, + "iterations": 7, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.049592331750930654, + "weights_sha256": "ad21a8640e2fe7bbd550225e354dedcbad8cb70433b892f45d28fa2346ab88de" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04900882633372332, + "weights_sha256": "4664564f60149b00b1754a3f9e91c8b04b29ef819b231bf17ea7588346433a57" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04861554683295004, + "weights_sha256": "cad51322361a95020501afa64e356f2a49dd02afa0cd91294d4498f7eb0c5a8d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04843255984360956, + "weights_sha256": "5fe850e6313cb9ed6631697684afeeb7b7c5857a5c74fad66189cfcf8a08218b" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261129, + "iterations": 7, + "failure": 0.0158203125, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05156220348280275, + "weights_sha256": "56c2fd4a7c35033084020cd1f5c9dcc2ab1cf2c631d0e88cc87ac4c715c6af17" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05139675960346585, + "weights_sha256": "0bf66368e18c8d1baecaa614d4c0cec16304ac14bcd29d22d1cdb2a0ff6c0173" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05135569004239689, + "weights_sha256": "d9581a6f29f9d3ea54d482c17995a37b55e3b4253d36e1d49cfce95b398eb5c2" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05141882723288258, + "weights_sha256": "2c4e4592067fcbbe69d6ede68c4494209652a2d510e74aa2ea3b4420c3cdd741" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261130, + "iterations": 7, + "failure": 0.0173828125, + "blended_failure": 0.0173828125, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.054216247940585036, + "weights_sha256": "7b12f028f764293a9496d9fd2ddbf92ba9c23653d7889a602a9ec23f8cde3d6b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261130, + "iterations": 6, + "failure": 0.017578125, + "blended_failure": 0.0171875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05364509063427466, + "weights_sha256": "1ad2ffaafa33009129a0953d79fe2d30ad62308eb9dbf8da0b76eca018a5b55a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261130, + "iterations": 5, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05368896256105915, + "weights_sha256": "64619c9b7bd40a14651bcd056d58f5b55e79eb334a4e5105ff12cb7ff6f2400a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261130, + "iterations": 6, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05387292464104988, + "weights_sha256": "b1490702e212d7cdcc936f55186b15411ced3a8928a1a32f2d4ac1212706fabf" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261131, + "iterations": 8, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04709647994869577, + "weights_sha256": "eb56715dfc5e8c6b8866ceeb2636422acad9992dd2c625355dc21b94c25351f0" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261131, + "iterations": 6, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.046679107084477436, + "weights_sha256": "320cd10cc8cd9d13d20d9ce0ea90413ed8343587f0c77abb0e1c8c84503aa2d8" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261131, + "iterations": 5, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04621785858320204, + "weights_sha256": "c7e63309de0668bd4d5c05169ecd6af1879c88be10947d0fdb958ca37068d433" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261131, + "iterations": 4, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04577880173787941, + "weights_sha256": "494824e979e52fbf0302e706ff6786d89ce60b607afd6b376cad9700f328feda" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261132, + "iterations": 7, + "failure": 0.01484375, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.05068038016752655, + "weights_sha256": "0b4c35df1d44c9353a2ea505205f3def95bb28de0c7052ded18cf599bef2709b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049663607204405706, + "weights_sha256": "b18deed32b51a58789873a1b45718f5c40d1d9500b57e113520b700a66902f1a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261132, + "iterations": 5, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.04918133832768282, + "weights_sha256": "12e71625e223602cbc9f7ae150473a1dad2c32f2d9221a4b88ccb93babc2c41d" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049002647954447996, + "weights_sha256": "e909b83698caba60ad01e28027b28005544cd8e795f88574fc6f81bcf56b2add" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261133, + "iterations": 7, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05204562159505248, + "weights_sha256": "b03b071238dda333574a4da2d9b2bb999cf362a83b9194b1c53871e9438f9f45" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05177096705064832, + "weights_sha256": "2a4c8113ee9a1dadcfc0f1b7ff8d164e7c8771d5764b0512ee1a5de2a8aaa395" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.051861030681133645, + "weights_sha256": "f201491af84870ffa8c1b59e16dea1fea910e7fda32f0e3d82863943222b57ee" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261133, + "iterations": 6, + "failure": 0.01640625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05206536190640361, + "weights_sha256": "b7cfd76b6574457626306868e31ab5327a1950cbbca41f6384eb2c4bc759e800" + } + ], + "choices": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "blend-16": 0.015429687499999999, + "64": 0.0155029296875, + "blend-64": 0.015600585937500001, + "256": 0.0155517578125, + "blend-256": 0.015600585937500001, + "1024": 0.0156005859375, + "blend-1024": 0.015600585937500001 + }, + "selected": "16", + "expected_full_P": 0.7663245567908653, + "validation_P_gain": 2.817007211538435e-06, + "source_sha256": "7e75f14190b18b05e9af540a8ef0f75522060e78c30b05475686ea18faf0035f", + "seconds": 3.316046953201294 + }, + "packaging_selection": { + "incumbent": 0.0154296875, + "16": 0.015380859375, + "64": 0.0155029296875, + "256": 0.0155517578125, + "1024": 0.0156005859375 + }, + "selected": "16", + "new_optimizer_updates": 0, + "selection_scope": "One common prior strength for all eight short conditions; other122 condition predictions retained", + "runtime_source_sha256": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af" + }, + { + "training": { + "initialization": "256 residual logits per condition initialized independently Normal(0,.01), seeds20261126 through20261133; optimized in this session", + "architecture": "One categorical residual per possible8-bit detection syndrome, added to an exact physical DEM logit; no sample IDs or row indices are model features", + "loss": "Binomial logical BCE sufficient statistics plus strength times cross entropy to the fixed physical prior; damped Newton optimization from random residual initialization", + "fixed_prior": "Exact full-DEM probabilities for all256 possible input syndromes, computed now from the authorized packaged even-fitted DEM plans; no external trained weights or decoder answers", + "training": "All19880 supplied training labels for each of eight d3 one-round conditions; only aggregate counts by detection syndrome enter fitting", + "data_scope": "This is a finite categorical classifier, indexed by detection events, not a per-shot answer table. Other122 conditions retain the incumbent in any candidate benchmark.", + "selection": "One common strength and optional equal probability blend for all eight geometries/bases, minimizing full validation mean; all other conditions unchanged", + "base_package": { + "package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "predictions": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/predictions", + "score": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/score.json", + "P": 0.7663217397836538 + }, + "test_data_used": false, + "training_records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 149, + "initial_seed": 20261126, + "physical_plan_sha256": "640c371577096ba08c799b70fd16d03a06a37004feaa15c85c4cb6ef87529080", + "training_arrays_sha256": "a7acd6f6e5372873cf2d34946876a791996238efdea39f7fa33f7d2eabc1c10f" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 157, + "initial_seed": 20261127, + "physical_plan_sha256": "4a0f8f630b7f34fba620a4e03bd77e14fb80149e70b7da80b6176dbd24d9ddc8", + "training_arrays_sha256": "0e2267afc5dc4e761d3b9e09288875f2077215fac2f902ce4151699c38c24531" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 152, + "initial_seed": 20261128, + "physical_plan_sha256": "de8914194be7689d70e9424540923197a5c0465fb42ec96556df97b73ba250c1", + "training_arrays_sha256": "0542609248a5d2c8b410666bb901361b60c39cb8b32b3b46fdd24a6c7913db56" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 147, + "initial_seed": 20261129, + "physical_plan_sha256": "bc1a6888cc5a854f0348cab463b8879c2d176d9509176b944b7f4265e0772ab3", + "training_arrays_sha256": "ccd43f09fba55b2138a5401e6f5c89cc7b4c4ec470a07cd037d9f715acaa1188" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 153, + "initial_seed": 20261130, + "physical_plan_sha256": "1931b5b85d0014c2a928a40c3ec502316ff30ea1632a25c5f64e2694f828434b", + "training_arrays_sha256": "aa27eee730c88b2071b5fd97f9d47a0f3ad010e29202415f786babc073d405e4" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 159, + "initial_seed": 20261131, + "physical_plan_sha256": "6d231f857bbe85040c91af1160c2dda16557a67851deaedc8092412f6abeb294", + "training_arrays_sha256": "569131ce49a2c1060ebd472c0290fc0c1de6e522cd7cd7aa92b10e17cdd1783c" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 158, + "initial_seed": 20261132, + "physical_plan_sha256": "ef285cea44ad63e0452596d4be65c8844ea8a7dcc49fb31b6a6241d367ed63eb", + "training_arrays_sha256": "6928ade685b05f76b7a3a9dc6423504d0bdce09742603c24978aa21fcf106f88" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 160, + "initial_seed": 20261133, + "physical_plan_sha256": "82bee01cf3e00079270a27cb79472322867548df5c9dc4db3252e4c6ec89e6a6", + "training_arrays_sha256": "afbc73fc5ca8e3b8e996377ab3df5a5b9397f36362e72c01feea7848ea1995f3" + } + ], + "records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261126, + "iterations": 8, + "failure": 0.0134765625, + "blended_failure": 0.013671875, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04649575086997129, + "weights_sha256": "d985985dedbe644bfae165330f4f46da14d04efbc4cad1af81c5510115380701" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261126, + "iterations": 6, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04591998541695955, + "weights_sha256": "17383d153dd1dfef62b3d4f6c5b7549c3209150faf0714e78fede09b941ecc3a" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.0458401737684183, + "weights_sha256": "f863a64ca698135f6fac6ac184d3c689db684a15d73bf0565418b240d76b5c58" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.045887733186657405, + "weights_sha256": "ded1a941e0dfc58e55ced6523720445fb70032d2d15c9929b0c93544f7c567f8" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261127, + "iterations": 8, + "failure": 0.0177734375, + "blended_failure": 0.0177734375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05532273244895745, + "weights_sha256": "02950043334a38d3e7980cc97685904338553746653bd2d6a4c9be88ae845270" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261127, + "iterations": 6, + "failure": 0.01875, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055166841080990084, + "weights_sha256": "412ee1f453695e4f3534dbe8d7eb1ca565d06fd7c718b52fe9a306b35e845d9d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261127, + "iterations": 5, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055186840974757456, + "weights_sha256": "12d8f72c2ee5cb837145aaf9a1b485d8517e4374721eebcbea9803d3bfdc8fcd" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261127, + "iterations": 4, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05544033886527203, + "weights_sha256": "d1daa90794c1c3c8cd00134d9b22a7173aee4dd9b139b86f6d3f9b8f2131056d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261128, + "iterations": 7, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.049592331750930654, + "weights_sha256": "ad21a8640e2fe7bbd550225e354dedcbad8cb70433b892f45d28fa2346ab88de" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04900882633372332, + "weights_sha256": "4664564f60149b00b1754a3f9e91c8b04b29ef819b231bf17ea7588346433a57" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04861554683295004, + "weights_sha256": "cad51322361a95020501afa64e356f2a49dd02afa0cd91294d4498f7eb0c5a8d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04843255984360956, + "weights_sha256": "5fe850e6313cb9ed6631697684afeeb7b7c5857a5c74fad66189cfcf8a08218b" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261129, + "iterations": 7, + "failure": 0.0158203125, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05156220348280275, + "weights_sha256": "56c2fd4a7c35033084020cd1f5c9dcc2ab1cf2c631d0e88cc87ac4c715c6af17" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05139675960346585, + "weights_sha256": "0bf66368e18c8d1baecaa614d4c0cec16304ac14bcd29d22d1cdb2a0ff6c0173" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05135569004239689, + "weights_sha256": "d9581a6f29f9d3ea54d482c17995a37b55e3b4253d36e1d49cfce95b398eb5c2" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05141882723288258, + "weights_sha256": "2c4e4592067fcbbe69d6ede68c4494209652a2d510e74aa2ea3b4420c3cdd741" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261130, + "iterations": 7, + "failure": 0.0173828125, + "blended_failure": 0.0173828125, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.054216247940585036, + "weights_sha256": "7b12f028f764293a9496d9fd2ddbf92ba9c23653d7889a602a9ec23f8cde3d6b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261130, + "iterations": 6, + "failure": 0.017578125, + "blended_failure": 0.0171875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05364509063427466, + "weights_sha256": "1ad2ffaafa33009129a0953d79fe2d30ad62308eb9dbf8da0b76eca018a5b55a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261130, + "iterations": 5, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05368896256105915, + "weights_sha256": "64619c9b7bd40a14651bcd056d58f5b55e79eb334a4e5105ff12cb7ff6f2400a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261130, + "iterations": 6, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05387292464104988, + "weights_sha256": "b1490702e212d7cdcc936f55186b15411ced3a8928a1a32f2d4ac1212706fabf" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261131, + "iterations": 8, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04709647994869577, + "weights_sha256": "eb56715dfc5e8c6b8866ceeb2636422acad9992dd2c625355dc21b94c25351f0" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261131, + "iterations": 6, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.046679107084477436, + "weights_sha256": "320cd10cc8cd9d13d20d9ce0ea90413ed8343587f0c77abb0e1c8c84503aa2d8" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261131, + "iterations": 5, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04621785858320204, + "weights_sha256": "c7e63309de0668bd4d5c05169ecd6af1879c88be10947d0fdb958ca37068d433" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261131, + "iterations": 4, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04577880173787941, + "weights_sha256": "494824e979e52fbf0302e706ff6786d89ce60b607afd6b376cad9700f328feda" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261132, + "iterations": 7, + "failure": 0.01484375, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.05068038016752655, + "weights_sha256": "0b4c35df1d44c9353a2ea505205f3def95bb28de0c7052ded18cf599bef2709b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049663607204405706, + "weights_sha256": "b18deed32b51a58789873a1b45718f5c40d1d9500b57e113520b700a66902f1a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261132, + "iterations": 5, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.04918133832768282, + "weights_sha256": "12e71625e223602cbc9f7ae150473a1dad2c32f2d9221a4b88ccb93babc2c41d" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049002647954447996, + "weights_sha256": "e909b83698caba60ad01e28027b28005544cd8e795f88574fc6f81bcf56b2add" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261133, + "iterations": 7, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05204562159505248, + "weights_sha256": "b03b071238dda333574a4da2d9b2bb999cf362a83b9194b1c53871e9438f9f45" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05177096705064832, + "weights_sha256": "2a4c8113ee9a1dadcfc0f1b7ff8d164e7c8771d5764b0512ee1a5de2a8aaa395" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.051861030681133645, + "weights_sha256": "f201491af84870ffa8c1b59e16dea1fea910e7fda32f0e3d82863943222b57ee" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261133, + "iterations": 6, + "failure": 0.01640625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05206536190640361, + "weights_sha256": "b7cfd76b6574457626306868e31ab5327a1950cbbca41f6384eb2c4bc759e800" + } + ], + "choices": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "blend-16": 0.015429687499999999, + "64": 0.0155029296875, + "blend-64": 0.015600585937500001, + "256": 0.0155517578125, + "blend-256": 0.015600585937500001, + "1024": 0.0156005859375, + "blend-1024": 0.015600585937500001 + }, + "selected": "16", + "expected_full_P": 0.7663245567908653, + "validation_P_gain": 2.817007211538435e-06, + "source_sha256": "7e75f14190b18b05e9af540a8ef0f75522060e78c30b05475686ea18faf0035f", + "seconds": 3.316046953201294 + }, + "packaging_selection": { + "incumbent": 0.0155517578125, + "16": 0.015380859375, + "64": 0.0155029296875, + "256": 0.0155517578125, + "1024": 0.0156005859375 + }, + "selected": "16", + "new_optimizer_updates": 0, + "selection_scope": "One common prior strength for all eight short conditions; other122 condition predictions retained", + "runtime_source_sha256": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af" + } + ], + "research_selection_history": { + "path": "selection_history.json", + "sha256": "8c2a1fe6fc46032f1ba440022a6ca6488ae661798d441e382720b07077890434", + "completed_training_runs": 58, + "assembled_candidates": 59 + }, + "runtime_projection": { + "measured_full_validation_seconds_by_distance": { + "d3": 66.40283012390137, + "d5": 409.5445261001587 + }, + "validation_shots_per_condition": 5120, + "benchmark_shots_per_condition": 25000, + "workload_source": "Supplied data/README.md declares 25000 benchmark rows per condition; no benchmark examples accessed", + "linear_scale": 4.8828125, + "projected_total_seconds": 2323.9617003127933, + "limit_seconds": 3600, + "interpretation": "Projection from complete validation replays, scaling startup/compilation overhead as well as shot work. Retained-path timings are inherited; one-round categorical replacements only remove contractions. This is not a timed benchmark-split run." + }, + "neural_probability_ensemble": { + "new_optimizer_updates": 0, + "new_trainable_parameters": 0, + "initialization": "Constituents trained from random initialization in this session; this step only averages their predicted probabilities.", + "new_training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 467790, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved2_warm/weights-512.npz", + "starting_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317635, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261274", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.2600052058696747, + "objective": 0.2600052058696747, + "error": 0.1123046875, + "gradient_norm": 0.06799795478582382, + "elapsed": 27.333195447921753 + }, + { + "step": 16, + "loss": 0.0312246885150671, + "objective": 0.0312246885150671, + "error": 0.01171875, + "gradient_norm": 0.004962741397321224, + "elapsed": 48.383540868759155 + }, + { + "step": 32, + "loss": 0.22698244452476501, + "objective": 0.22698244452476501, + "error": 0.08984375, + "gradient_norm": 0.06353150308132172, + "elapsed": 57.04609966278076 + }, + { + "step": 48, + "loss": 0.5861443281173706, + "objective": 0.5861443281173706, + "error": 0.3486328125, + "gradient_norm": 0.04095375910401344, + "elapsed": 69.08654689788818 + }, + { + "step": 64, + "loss": 0.6103856563568115, + "objective": 0.6103856563568115, + "error": 0.3662109375, + "gradient_norm": 0.04155975207686424, + "elapsed": 81.63970494270325 + }, + { + "step": 80, + "loss": 0.5673234462738037, + "objective": 0.5673234462738037, + "error": 0.3125, + "gradient_norm": 0.1773851364850998, + "elapsed": 92.5357596874237 + }, + { + "step": 96, + "loss": 0.3763846755027771, + "objective": 0.3763846755027771, + "error": 0.1875, + "gradient_norm": 0.0951203852891922, + "elapsed": 103.12279391288757 + }, + { + "step": 112, + "loss": 0.45539408922195435, + "objective": 0.45539408922195435, + "error": 0.22265625, + "gradient_norm": 0.056369006633758545, + "elapsed": 112.61882042884827 + }, + { + "step": 128, + "loss": 0.015473627485334873, + "objective": 0.015473627485334873, + "error": 0.005859375, + "gradient_norm": 0.005696057807654142, + "elapsed": 125.16960310935974 + }, + { + "step": 144, + "loss": 0.03449750319123268, + "objective": 0.03449750319123268, + "error": 0.0107421875, + "gradient_norm": 0.008358650840818882, + "elapsed": 135.8080232143402 + }, + { + "step": 160, + "loss": 0.5731935501098633, + "objective": 0.5731935501098633, + "error": 0.31640625, + "gradient_norm": 0.056162577122449875, + "elapsed": 145.0349259376526 + }, + { + "step": 176, + "loss": 0.5626271963119507, + "objective": 0.5626271963119507, + "error": 0.314453125, + "gradient_norm": 0.048817526549100876, + "elapsed": 154.84093379974365 + }, + { + "step": 192, + "loss": 0.5507581233978271, + "objective": 0.5507581233978271, + "error": 0.3173828125, + "gradient_norm": 0.06503377854824066, + "elapsed": 164.7195086479187 + }, + { + "step": 208, + "loss": 0.5725968480110168, + "objective": 0.5725968480110168, + "error": 0.3251953125, + "gradient_norm": 0.047704510390758514, + "elapsed": 175.38803815841675 + }, + { + "step": 224, + "loss": 0.5249365568161011, + "objective": 0.5249365568161011, + "error": 0.2802734375, + "gradient_norm": 0.10021239519119263, + "elapsed": 187.0162854194641 + }, + { + "step": 240, + "loss": 0.2526492476463318, + "objective": 0.2526492476463318, + "error": 0.1103515625, + "gradient_norm": 0.06751289963722229, + "elapsed": 196.51696944236755 + }, + { + "step": 256, + "loss": 0.5214780569076538, + "objective": 0.5214780569076538, + "error": 0.275390625, + "gradient_norm": 0.14627203345298767, + "elapsed": 208.2405219078064 + }, + { + "step": 272, + "loss": 0.59315025806427, + "objective": 0.59315025806427, + "error": 0.341796875, + "gradient_norm": 0.03693874180316925, + "elapsed": 224.87874341011047 + }, + { + "step": 288, + "loss": 0.37350377440452576, + "objective": 0.37350377440452576, + "error": 0.169921875, + "gradient_norm": 0.05035478249192238, + "elapsed": 235.2427306175232 + }, + { + "step": 304, + "loss": 0.6201726198196411, + "objective": 0.6201726198196411, + "error": 0.3798828125, + "gradient_norm": 0.04230104014277458, + "elapsed": 244.4733214378357 + }, + { + "step": 320, + "loss": 0.5781067609786987, + "objective": 0.5781067609786987, + "error": 0.3291015625, + "gradient_norm": 0.06764703243970871, + "elapsed": 256.96991300582886 + }, + { + "step": 336, + "loss": 0.13824111223220825, + "objective": 0.13824111223220825, + "error": 0.0556640625, + "gradient_norm": 0.02330971322953701, + "elapsed": 268.097412109375 + }, + { + "step": 352, + "loss": 0.6141752004623413, + "objective": 0.6141752004623413, + "error": 0.37890625, + "gradient_norm": 0.08660273998975754, + "elapsed": 282.79302310943604 + }, + { + "step": 368, + "loss": 0.3470626473426819, + "objective": 0.3470626473426819, + "error": 0.1611328125, + "gradient_norm": 0.05711895599961281, + "elapsed": 293.79467129707336 + }, + { + "step": 384, + "loss": 0.6023644208908081, + "objective": 0.6023644208908081, + "error": 0.3466796875, + "gradient_norm": 0.08649417012929916, + "elapsed": 305.9786322116852 + }, + { + "step": 400, + "loss": 0.03022841364145279, + "objective": 0.03022841364145279, + "error": 0.0087890625, + "gradient_norm": 0.009741511195898056, + "elapsed": 315.06104922294617 + }, + { + "step": 416, + "loss": 0.23827238380908966, + "objective": 0.23827238380908966, + "error": 0.1015625, + "gradient_norm": 0.03526044636964798, + "elapsed": 325.6410942077637 + }, + { + "step": 432, + "loss": 0.43375664949417114, + "objective": 0.43375664949417114, + "error": 0.201171875, + "gradient_norm": 0.03940205276012421, + "elapsed": 336.9890570640564 + }, + { + "step": 448, + "loss": 0.5915575623512268, + "objective": 0.5915575623512268, + "error": 0.3359375, + "gradient_norm": 0.04364592209458351, + "elapsed": 346.9254243373871 + }, + { + "step": 464, + "loss": 0.5641118288040161, + "objective": 0.5641118288040161, + "error": 0.3076171875, + "gradient_norm": 0.052896615117788315, + "elapsed": 356.9816539287567 + }, + { + "step": 480, + "loss": 0.5682889223098755, + "objective": 0.5682889223098755, + "error": 0.322265625, + "gradient_norm": 0.07130409777164459, + "elapsed": 369.16103172302246 + }, + { + "step": 496, + "loss": 0.37034764885902405, + "objective": 0.37034764885902405, + "error": 0.181640625, + "gradient_norm": 0.11464523524045944, + "elapsed": 381.041054725647 + }, + { + "step": 512, + "loss": 0.5398496389389038, + "objective": 0.5398496389389038, + "error": 0.3076171875, + "gradient_norm": 0.05673467367887497, + "elapsed": 394.5030150413513 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "db182d721768f832e1c83f6258b31bef0d8bf2ded239a8ab5a45cbb76378fd30", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317635, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.30839407444000244, + "objective": 0.30839407444000244, + "error": 0.130859375, + "gradient_norm": 0.053425733000040054, + "elapsed": 28.537403345108032 + }, + { + "step": 16, + "loss": 0.021987520158290863, + "objective": 0.021987520158290863, + "error": 0.0078125, + "gradient_norm": 0.01397851575165987, + "elapsed": 48.18276286125183 + }, + { + "step": 32, + "loss": 0.5041587352752686, + "objective": 0.5041587352752686, + "error": 0.2724609375, + "gradient_norm": 0.0528741292655468, + "elapsed": 58.27348470687866 + }, + { + "step": 48, + "loss": 0.4326452612876892, + "objective": 0.4326452612876892, + "error": 0.21484375, + "gradient_norm": 0.0559566393494606, + "elapsed": 68.90473222732544 + }, + { + "step": 64, + "loss": 0.4804917275905609, + "objective": 0.4804917275905609, + "error": 0.248046875, + "gradient_norm": 0.0669105276465416, + "elapsed": 77.87249231338501 + }, + { + "step": 80, + "loss": 0.2889654338359833, + "objective": 0.2889654338359833, + "error": 0.1328125, + "gradient_norm": 0.08293467015028, + "elapsed": 86.87973022460938 + }, + { + "step": 96, + "loss": 0.5135385990142822, + "objective": 0.5135385990142822, + "error": 0.271484375, + "gradient_norm": 0.06412295252084732, + "elapsed": 95.98773431777954 + }, + { + "step": 112, + "loss": 0.31248384714126587, + "objective": 0.31248384714126587, + "error": 0.1357421875, + "gradient_norm": 0.03881710395216942, + "elapsed": 106.47444081306458 + }, + { + "step": 128, + "loss": 0.23868557810783386, + "objective": 0.23868557810783386, + "error": 0.091796875, + "gradient_norm": 0.03896595537662506, + "elapsed": 117.72143626213074 + }, + { + "step": 144, + "loss": 0.5315916538238525, + "objective": 0.5315916538238525, + "error": 0.2890625, + "gradient_norm": 0.09184520691633224, + "elapsed": 126.97882843017578 + }, + { + "step": 160, + "loss": 0.604732096195221, + "objective": 0.604732096195221, + "error": 0.3603515625, + "gradient_norm": 0.044600710272789, + "elapsed": 137.403742313385 + }, + { + "step": 176, + "loss": 0.032417282462120056, + "objective": 0.032417282462120056, + "error": 0.0107421875, + "gradient_norm": 0.010968778282403946, + "elapsed": 147.58081603050232 + }, + { + "step": 192, + "loss": 0.24050910770893097, + "objective": 0.24050910770893097, + "error": 0.087890625, + "gradient_norm": 0.052534136921167374, + "elapsed": 156.545964717865 + }, + { + "step": 208, + "loss": 0.3183761537075043, + "objective": 0.3183761537075043, + "error": 0.1435546875, + "gradient_norm": 0.05253623053431511, + "elapsed": 166.62695455551147 + }, + { + "step": 224, + "loss": 0.6407097578048706, + "objective": 0.6407097578048706, + "error": 0.3837890625, + "gradient_norm": 0.08772490173578262, + "elapsed": 174.46970582008362 + }, + { + "step": 240, + "loss": 0.597212553024292, + "objective": 0.597212553024292, + "error": 0.36328125, + "gradient_norm": 0.13039150834083557, + "elapsed": 184.2768793106079 + }, + { + "step": 256, + "loss": 0.3317721486091614, + "objective": 0.3317721486091614, + "error": 0.14453125, + "gradient_norm": 0.03749232366681099, + "elapsed": 194.6345317363739 + }, + { + "step": 272, + "loss": 0.6330116987228394, + "objective": 0.6330116987228394, + "error": 0.3955078125, + "gradient_norm": 0.06468097865581512, + "elapsed": 205.8717017173767 + }, + { + "step": 288, + "loss": 0.3141757845878601, + "objective": 0.3141757845878601, + "error": 0.138671875, + "gradient_norm": 0.046496689319610596, + "elapsed": 215.2117359638214 + }, + { + "step": 304, + "loss": 0.5782994031906128, + "objective": 0.5782994031906128, + "error": 0.345703125, + "gradient_norm": 0.06487675756216049, + "elapsed": 225.47403240203857 + }, + { + "step": 320, + "loss": 0.45729100704193115, + "objective": 0.45729100704193115, + "error": 0.2255859375, + "gradient_norm": 0.04169687256217003, + "elapsed": 233.03686332702637 + }, + { + "step": 336, + "loss": 0.49350813031196594, + "objective": 0.49350813031196594, + "error": 0.24609375, + "gradient_norm": 0.08623651415109634, + "elapsed": 244.53246903419495 + }, + { + "step": 352, + "loss": 0.25660067796707153, + "objective": 0.25660067796707153, + "error": 0.1103515625, + "gradient_norm": 0.03029652312397957, + "elapsed": 254.88137793540955 + }, + { + "step": 368, + "loss": 0.2295728325843811, + "objective": 0.2295728325843811, + "error": 0.0966796875, + "gradient_norm": 0.042884912341833115, + "elapsed": 262.7415475845337 + }, + { + "step": 384, + "loss": 0.6214326620101929, + "objective": 0.6214326620101929, + "error": 0.3759765625, + "gradient_norm": 0.08176509290933609, + "elapsed": 271.72958397865295 + }, + { + "step": 400, + "loss": 0.6463049650192261, + "objective": 0.6463049650192261, + "error": 0.3984375, + "gradient_norm": 0.08226390928030014, + "elapsed": 281.51069259643555 + }, + { + "step": 416, + "loss": 0.024987798184156418, + "objective": 0.024987798184156418, + "error": 0.0078125, + "gradient_norm": 0.0075854891911149025, + "elapsed": 291.0118627548218 + }, + { + "step": 432, + "loss": 0.5520929098129272, + "objective": 0.5520929098129272, + "error": 0.3125, + "gradient_norm": 0.09755270183086395, + "elapsed": 301.23231768608093 + }, + { + "step": 448, + "loss": 0.6077401638031006, + "objective": 0.6077401638031006, + "error": 0.361328125, + "gradient_norm": 0.04908076301217079, + "elapsed": 312.93572759628296 + }, + { + "step": 464, + "loss": 0.016434211283922195, + "objective": 0.016434211283922195, + "error": 0.005859375, + "gradient_norm": 0.007213531993329525, + "elapsed": 323.8330478668213 + }, + { + "step": 480, + "loss": 0.1582300364971161, + "objective": 0.1582300364971161, + "error": 0.064453125, + "gradient_norm": 0.028335656970739365, + "elapsed": 334.6112554073334 + }, + { + "step": 496, + "loss": 0.5916742086410522, + "objective": 0.5916742086410522, + "error": 0.35546875, + "gradient_norm": 0.08213689178228378, + "elapsed": 345.8490369319916 + }, + { + "step": 512, + "loss": 0.11447565257549286, + "objective": 0.11447565257549286, + "error": 0.04296875, + "gradient_norm": 0.028994916006922722, + "elapsed": 358.71793270111084 + }, + { + "step": 528, + "loss": 0.3011414408683777, + "objective": 0.3011414408683777, + "error": 0.1435546875, + "gradient_norm": 0.04305516928434372, + "elapsed": 373.143226146698 + }, + { + "step": 544, + "loss": 0.3099900782108307, + "objective": 0.3099900782108307, + "error": 0.130859375, + "gradient_norm": 0.06152835488319397, + "elapsed": 380.42762184143066 + }, + { + "step": 560, + "loss": 0.42917633056640625, + "objective": 0.42917633056640625, + "error": 0.203125, + "gradient_norm": 0.051812849938869476, + "elapsed": 390.78397703170776 + }, + { + "step": 576, + "loss": 0.4895544648170471, + "objective": 0.4895544648170471, + "error": 0.2451171875, + "gradient_norm": 0.059052009135484695, + "elapsed": 400.29374146461487 + }, + { + "step": 592, + "loss": 0.5950886011123657, + "objective": 0.5950886011123657, + "error": 0.328125, + "gradient_norm": 0.1449151188135147, + "elapsed": 410.06920647621155 + }, + { + "step": 608, + "loss": 0.3282078504562378, + "objective": 0.3282078504562378, + "error": 0.1484375, + "gradient_norm": 0.06495015323162079, + "elapsed": 420.5240683555603 + }, + { + "step": 624, + "loss": 0.6034166812896729, + "objective": 0.6034166812896729, + "error": 0.3388671875, + "gradient_norm": 0.05658626928925514, + "elapsed": 430.7997169494629 + }, + { + "step": 640, + "loss": 0.590431809425354, + "objective": 0.590431809425354, + "error": 0.3447265625, + "gradient_norm": 0.046094730496406555, + "elapsed": 441.8197224140167 + }, + { + "step": 656, + "loss": 0.2260439246892929, + "objective": 0.2260439246892929, + "error": 0.1015625, + "gradient_norm": 0.06323576718568802, + "elapsed": 450.76086831092834 + }, + { + "step": 672, + "loss": 0.26158156991004944, + "objective": 0.26158156991004944, + "error": 0.1162109375, + "gradient_norm": 0.08324819058179855, + "elapsed": 459.1986529827118 + }, + { + "step": 688, + "loss": 0.4871026873588562, + "objective": 0.4871026873588562, + "error": 0.244140625, + "gradient_norm": 0.051720812916755676, + "elapsed": 470.4437210559845 + }, + { + "step": 704, + "loss": 0.5861694812774658, + "objective": 0.5861694812774658, + "error": 0.341796875, + "gradient_norm": 0.05766218528151512, + "elapsed": 483.85575103759766 + }, + { + "step": 720, + "loss": 0.4168863296508789, + "objective": 0.4168863296508789, + "error": 0.21484375, + "gradient_norm": 0.05056491494178772, + "elapsed": 494.63891077041626 + }, + { + "step": 736, + "loss": 0.42054638266563416, + "objective": 0.42054638266563416, + "error": 0.21875, + "gradient_norm": 0.07021808624267578, + "elapsed": 505.4899232387543 + }, + { + "step": 752, + "loss": 0.2022928148508072, + "objective": 0.2022928148508072, + "error": 0.0849609375, + "gradient_norm": 0.0765448734164238, + "elapsed": 516.2925503253937 + }, + { + "step": 768, + "loss": 0.026398655027151108, + "objective": 0.026398655027151108, + "error": 0.0068359375, + "gradient_norm": 0.00973521638661623, + "elapsed": 524.7940125465393 + }, + { + "step": 784, + "loss": 0.5843480825424194, + "objective": 0.5843480825424194, + "error": 0.345703125, + "gradient_norm": 0.04805552959442139, + "elapsed": 535.345025062561 + }, + { + "step": 800, + "loss": 0.3102012872695923, + "objective": 0.3102012872695923, + "error": 0.134765625, + "gradient_norm": 0.09761057049036026, + "elapsed": 544.4683487415314 + }, + { + "step": 816, + "loss": 0.5332639217376709, + "objective": 0.5332639217376709, + "error": 0.30078125, + "gradient_norm": 0.10398133844137192, + "elapsed": 554.8217175006866 + }, + { + "step": 832, + "loss": 0.4870310425758362, + "objective": 0.4870310425758362, + "error": 0.2685546875, + "gradient_norm": 0.05754273384809494, + "elapsed": 564.9130115509033 + }, + { + "step": 848, + "loss": 0.1336989849805832, + "objective": 0.1336989849805832, + "error": 0.0498046875, + "gradient_norm": 0.02862304449081421, + "elapsed": 573.6143791675568 + }, + { + "step": 864, + "loss": 0.5794297456741333, + "objective": 0.5794297456741333, + "error": 0.3427734375, + "gradient_norm": 0.05002075806260109, + "elapsed": 584.2565310001373 + }, + { + "step": 880, + "loss": 0.6150081753730774, + "objective": 0.6150081753730774, + "error": 0.341796875, + "gradient_norm": 0.0605069138109684, + "elapsed": 596.845867395401 + }, + { + "step": 896, + "loss": 0.3804032504558563, + "objective": 0.3804032504558563, + "error": 0.18359375, + "gradient_norm": 0.057405781000852585, + "elapsed": 606.0786938667297 + }, + { + "step": 912, + "loss": 0.5734928846359253, + "objective": 0.5734928846359253, + "error": 0.2958984375, + "gradient_norm": 0.06807747483253479, + "elapsed": 616.9755277633667 + }, + { + "step": 928, + "loss": 0.23615539073944092, + "objective": 0.23615539073944092, + "error": 0.107421875, + "gradient_norm": 0.04033413156867027, + "elapsed": 625.9104406833649 + }, + { + "step": 944, + "loss": 0.5668450593948364, + "objective": 0.5668450593948364, + "error": 0.3134765625, + "gradient_norm": 0.04825817048549652, + "elapsed": 635.4241654872894 + }, + { + "step": 960, + "loss": 0.1369795948266983, + "objective": 0.1369795948266983, + "error": 0.0537109375, + "gradient_norm": 0.029475854709744453, + "elapsed": 646.0763671398163 + }, + { + "step": 976, + "loss": 0.026218727231025696, + "objective": 0.026218727231025696, + "error": 0.009765625, + "gradient_norm": 0.0067830472253263, + "elapsed": 656.7150173187256 + }, + { + "step": 992, + "loss": 0.6016548871994019, + "objective": 0.6016548871994019, + "error": 0.3564453125, + "gradient_norm": 0.04935981705784798, + "elapsed": 668.9989516735077 + }, + { + "step": 1008, + "loss": 0.1370980143547058, + "objective": 0.1370980143547058, + "error": 0.0546875, + "gradient_norm": 0.04418199881911278, + "elapsed": 677.3821382522583 + }, + { + "step": 1024, + "loss": 0.4085504412651062, + "objective": 0.4085504412651062, + "error": 0.19921875, + "gradient_norm": 0.07943295687437057, + "elapsed": 688.8395888805389 + }, + { + "step": 1040, + "loss": 0.34129297733306885, + "objective": 0.34129297733306885, + "error": 0.15625, + "gradient_norm": 0.04551500454545021, + "elapsed": 703.4613966941833 + }, + { + "step": 1056, + "loss": 0.5297085046768188, + "objective": 0.5297085046768188, + "error": 0.2705078125, + "gradient_norm": 0.06177444010972977, + "elapsed": 714.0862259864807 + }, + { + "step": 1072, + "loss": 0.3833361268043518, + "objective": 0.3833361268043518, + "error": 0.185546875, + "gradient_norm": 0.053057629615068436, + "elapsed": 724.1480000019073 + }, + { + "step": 1088, + "loss": 0.6497273445129395, + "objective": 0.6497273445129395, + "error": 0.421875, + "gradient_norm": 0.10790837556123734, + "elapsed": 735.8740057945251 + }, + { + "step": 1104, + "loss": 0.5393906831741333, + "objective": 0.5393906831741333, + "error": 0.2998046875, + "gradient_norm": 0.06015805900096893, + "elapsed": 743.9961709976196 + }, + { + "step": 1120, + "loss": 0.38553956151008606, + "objective": 0.38553956151008606, + "error": 0.1875, + "gradient_norm": 0.05357081815600395, + "elapsed": 753.2208635807037 + }, + { + "step": 1136, + "loss": 0.5478834509849548, + "objective": 0.5478834509849548, + "error": 0.2900390625, + "gradient_norm": 0.05761478468775749, + "elapsed": 761.3359644412994 + }, + { + "step": 1152, + "loss": 0.5732287168502808, + "objective": 0.5732287168502808, + "error": 0.341796875, + "gradient_norm": 0.07881136238574982, + "elapsed": 771.133172750473 + }, + { + "step": 1168, + "loss": 0.5174047946929932, + "objective": 0.5174047946929932, + "error": 0.29296875, + "gradient_norm": 0.07794999331235886, + "elapsed": 783.7084786891937 + }, + { + "step": 1184, + "loss": 0.5022754669189453, + "objective": 0.5022754669189453, + "error": 0.265625, + "gradient_norm": 0.05175226181745529, + "elapsed": 793.499255657196 + }, + { + "step": 1200, + "loss": 0.5698775053024292, + "objective": 0.5698775053024292, + "error": 0.34375, + "gradient_norm": 0.06385946273803711, + "elapsed": 804.970814704895 + }, + { + "step": 1216, + "loss": 0.6203033924102783, + "objective": 0.6203033924102783, + "error": 0.37109375, + "gradient_norm": 0.07393646240234375, + "elapsed": 816.1773698329926 + }, + { + "step": 1232, + "loss": 0.6154648065567017, + "objective": 0.6154648065567017, + "error": 0.3857421875, + "gradient_norm": 0.04278155043721199, + "elapsed": 827.3619928359985 + }, + { + "step": 1248, + "loss": 0.5948328971862793, + "objective": 0.5948328971862793, + "error": 0.3291015625, + "gradient_norm": 0.062024734914302826, + "elapsed": 838.8370804786682 + }, + { + "step": 1264, + "loss": 0.5644958019256592, + "objective": 0.5644958019256592, + "error": 0.3212890625, + "gradient_norm": 0.12030917406082153, + "elapsed": 849.5000331401825 + }, + { + "step": 1280, + "loss": 0.028782427310943604, + "objective": 0.028782427310943604, + "error": 0.0087890625, + "gradient_norm": 0.009096251800656319, + "elapsed": 857.8837285041809 + }, + { + "step": 1296, + "loss": 0.5129679441452026, + "objective": 0.5129679441452026, + "error": 0.2626953125, + "gradient_norm": 0.12833116948604584, + "elapsed": 868.5195860862732 + }, + { + "step": 1312, + "loss": 0.4095553159713745, + "objective": 0.4095553159713745, + "error": 0.193359375, + "gradient_norm": 0.09977155178785324, + "elapsed": 877.4712297916412 + }, + { + "step": 1328, + "loss": 0.2850862741470337, + "objective": 0.2850862741470337, + "error": 0.1240234375, + "gradient_norm": 0.05365074798464775, + "elapsed": 887.5133347511292 + }, + { + "step": 1344, + "loss": 0.41809165477752686, + "objective": 0.41809165477752686, + "error": 0.19140625, + "gradient_norm": 0.10622142255306244, + "elapsed": 895.0828025341034 + }, + { + "step": 1360, + "loss": 0.3627069890499115, + "objective": 0.3627069890499115, + "error": 0.1650390625, + "gradient_norm": 0.049557290971279144, + "elapsed": 906.2595431804657 + }, + { + "step": 1376, + "loss": 0.023341629654169083, + "objective": 0.023341629654169083, + "error": 0.0068359375, + "gradient_norm": 0.008970360271632671, + "elapsed": 916.6110022068024 + }, + { + "step": 1392, + "loss": 0.519214391708374, + "objective": 0.519214391708374, + "error": 0.26953125, + "gradient_norm": 0.052287619560956955, + "elapsed": 926.660523891449 + }, + { + "step": 1408, + "loss": 0.6152850389480591, + "objective": 0.6152850389480591, + "error": 0.3662109375, + "gradient_norm": 0.049617987126111984, + "elapsed": 936.7533056735992 + }, + { + "step": 1424, + "loss": 0.020841240882873535, + "objective": 0.020841240882873535, + "error": 0.0068359375, + "gradient_norm": 0.008459246717393398, + "elapsed": 946.8231542110443 + }, + { + "step": 1440, + "loss": 0.5963407754898071, + "objective": 0.5963407754898071, + "error": 0.3525390625, + "gradient_norm": 0.08714025467634201, + "elapsed": 956.0344398021698 + }, + { + "step": 1456, + "loss": 0.44305220246315, + "objective": 0.44305220246315, + "error": 0.2099609375, + "gradient_norm": 0.061915796250104904, + "elapsed": 967.506050825119 + }, + { + "step": 1472, + "loss": 0.5292993783950806, + "objective": 0.5292993783950806, + "error": 0.2939453125, + "gradient_norm": 0.10089804977178574, + "elapsed": 977.855934381485 + }, + { + "step": 1488, + "loss": 0.6087026596069336, + "objective": 0.6087026596069336, + "error": 0.345703125, + "gradient_norm": 0.05276322737336159, + "elapsed": 986.2705359458923 + }, + { + "step": 1504, + "loss": 0.3670162558555603, + "objective": 0.3670162558555603, + "error": 0.1796875, + "gradient_norm": 0.0575372576713562, + "elapsed": 995.2220902442932 + }, + { + "step": 1520, + "loss": 0.33479321002960205, + "objective": 0.33479321002960205, + "error": 0.1435546875, + "gradient_norm": 0.056317709386348724, + "elapsed": 1005.2168045043945 + }, + { + "step": 1536, + "loss": 0.5869293212890625, + "objective": 0.5869293212890625, + "error": 0.337890625, + "gradient_norm": 0.07419256865978241, + "elapsed": 1016.8691458702087 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "0f5926c94bb1aa83840c6d257757b80c081835affc2cb34bf9246ba18e00266a", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 467790, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "source_reference_package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "original_training_provenance": { + "training": { + "initialization": "Uniform parameter averages of checkpoints from the same session-initialized training trajectory; no external weights", + "prior_pass": 3, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "hidden_width": 64, + "training": "No new optimizer updates; all learning comes from the recorded source trajectory and its session-trained parent", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "training_source_sha256": { + "learned_d5__train.py": "b73af9da21332dee9a43f653b514695b020fbc3516604b2e721d8cf0ea876d53", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "5e9420df1f6dd56518925e910096fb9bc93bd796a5933b13bf894a1a96256cdf", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 507282, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 19592, + "surface_code_bX_d5_r03_center_5_5": 19646, + "surface_code_bX_d5_r05_center_5_5": 19513, + "surface_code_bX_d5_r07_center_5_5": 19341, + "surface_code_bX_d5_r09_center_5_5": 19211, + "surface_code_bX_d5_r11_center_5_5": 19239, + "surface_code_bX_d5_r13_center_5_5": 19679, + "surface_code_bX_d5_r15_center_5_5": 19455, + "surface_code_bX_d5_r17_center_5_5": 19479, + "surface_code_bX_d5_r19_center_5_5": 19479, + "surface_code_bX_d5_r21_center_5_5": 19551, + "surface_code_bX_d5_r23_center_5_5": 19586, + "surface_code_bX_d5_r25_center_5_5": 19526, + "surface_code_bZ_d5_r01_center_5_5": 19652, + "surface_code_bZ_d5_r03_center_5_5": 19732, + "surface_code_bZ_d5_r05_center_5_5": 19754, + "surface_code_bZ_d5_r07_center_5_5": 19194, + "surface_code_bZ_d5_r09_center_5_5": 19641, + "surface_code_bZ_d5_r11_center_5_5": 19611, + "surface_code_bZ_d5_r13_center_5_5": 19424, + "surface_code_bZ_d5_r15_center_5_5": 19380, + "surface_code_bZ_d5_r17_center_5_5": 19384, + "surface_code_bZ_d5_r19_center_5_5": 19684, + "surface_code_bZ_d5_r21_center_5_5": 19559, + "surface_code_bZ_d5_r23_center_5_5": 19524, + "surface_code_bZ_d5_r25_center_5_5": 19446 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 2048, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261113, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_d5/feedback3_pilot/rng-768.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/feedback3_pilot/weights-768.npz", + "starting_checkpoint_sha256": "bc2ba1c529317ce1b5b661efae4707eca49c6995d6f22b04193fe7642662fed8", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4341062307357788, + "objective": 0.4341062307357788, + "error": 0.208984375, + "gradient_norm": 0.07617632299661636, + "elapsed": 31.45817995071411 + }, + { + "step": 16, + "loss": 0.5996706485748291, + "objective": 0.5996706485748291, + "error": 0.359375, + "gradient_norm": 0.05249844491481781, + "elapsed": 56.34200572967529 + }, + { + "step": 32, + "loss": 0.4388691186904907, + "objective": 0.4388691186904907, + "error": 0.2041015625, + "gradient_norm": 0.0376109778881073, + "elapsed": 67.83739852905273 + }, + { + "step": 48, + "loss": 0.5373439788818359, + "objective": 0.5373439788818359, + "error": 0.2919921875, + "gradient_norm": 0.06261218339204788, + "elapsed": 76.69065475463867 + }, + { + "step": 64, + "loss": 0.24871854484081268, + "objective": 0.24871854484081268, + "error": 0.1162109375, + "gradient_norm": 0.05284671485424042, + "elapsed": 86.3852767944336 + }, + { + "step": 80, + "loss": 0.26628297567367554, + "objective": 0.26628297567367554, + "error": 0.123046875, + "gradient_norm": 0.04054367542266846, + "elapsed": 95.77356100082397 + }, + { + "step": 96, + "loss": 0.48436349630355835, + "objective": 0.48436349630355835, + "error": 0.259765625, + "gradient_norm": 0.05399860441684723, + "elapsed": 107.06293416023254 + }, + { + "step": 112, + "loss": 0.41063767671585083, + "objective": 0.41063767671585083, + "error": 0.1943359375, + "gradient_norm": 0.043602071702480316, + "elapsed": 116.78119611740112 + }, + { + "step": 128, + "loss": 0.3990316390991211, + "objective": 0.3990316390991211, + "error": 0.1865234375, + "gradient_norm": 0.0424419641494751, + "elapsed": 125.6915397644043 + }, + { + "step": 144, + "loss": 0.5119550228118896, + "objective": 0.5119550228118896, + "error": 0.2646484375, + "gradient_norm": 0.07688591629266739, + "elapsed": 136.20711088180542 + }, + { + "step": 160, + "loss": 0.3388235569000244, + "objective": 0.3388235569000244, + "error": 0.1630859375, + "gradient_norm": 0.07015731930732727, + "elapsed": 145.3505516052246 + }, + { + "step": 176, + "loss": 0.5952156186103821, + "objective": 0.5952156186103821, + "error": 0.3369140625, + "gradient_norm": 0.039373140782117844, + "elapsed": 154.77994871139526 + }, + { + "step": 192, + "loss": 0.15157413482666016, + "objective": 0.15157413482666016, + "error": 0.0634765625, + "gradient_norm": 0.029710670933127403, + "elapsed": 164.46801733970642 + }, + { + "step": 208, + "loss": 0.3120684027671814, + "objective": 0.3120684027671814, + "error": 0.1474609375, + "gradient_norm": 0.035548821091651917, + "elapsed": 173.24825358390808 + }, + { + "step": 224, + "loss": 0.5486405491828918, + "objective": 0.5486405491828918, + "error": 0.2900390625, + "gradient_norm": 0.0503678023815155, + "elapsed": 185.29849314689636 + }, + { + "step": 240, + "loss": 0.6046283841133118, + "objective": 0.6046283841133118, + "error": 0.3349609375, + "gradient_norm": 0.05043461173772812, + "elapsed": 197.54880928993225 + }, + { + "step": 256, + "loss": 0.5926339626312256, + "objective": 0.5926339626312256, + "error": 0.3359375, + "gradient_norm": 0.051241543143987656, + "elapsed": 211.79861068725586 + }, + { + "step": 272, + "loss": 0.4018518924713135, + "objective": 0.4018518924713135, + "error": 0.1943359375, + "gradient_norm": 0.0772147998213768, + "elapsed": 222.41974115371704 + }, + { + "step": 288, + "loss": 0.13863243162631989, + "objective": 0.13863243162631989, + "error": 0.0556640625, + "gradient_norm": 0.03334609419107437, + "elapsed": 234.04247426986694 + }, + { + "step": 304, + "loss": 0.562490701675415, + "objective": 0.562490701675415, + "error": 0.337890625, + "gradient_norm": 0.04585934057831764, + "elapsed": 242.65421533584595 + }, + { + "step": 320, + "loss": 0.5352796316146851, + "objective": 0.5352796316146851, + "error": 0.294921875, + "gradient_norm": 0.0837635025382042, + "elapsed": 252.10656356811523 + }, + { + "step": 336, + "loss": 0.26082637906074524, + "objective": 0.26082637906074524, + "error": 0.1220703125, + "gradient_norm": 0.048336997628211975, + "elapsed": 262.33449625968933 + }, + { + "step": 352, + "loss": 0.5959363579750061, + "objective": 0.5959363579750061, + "error": 0.3388671875, + "gradient_norm": 0.06797357648611069, + "elapsed": 271.9942307472229 + }, + { + "step": 368, + "loss": 0.48994284868240356, + "objective": 0.48994284868240356, + "error": 0.2587890625, + "gradient_norm": 0.06296153366565704, + "elapsed": 283.0493588447571 + }, + { + "step": 384, + "loss": 0.5710494518280029, + "objective": 0.5710494518280029, + "error": 0.3134765625, + "gradient_norm": 0.045333269983530045, + "elapsed": 294.64637446403503 + }, + { + "step": 400, + "loss": 0.5957783460617065, + "objective": 0.5957783460617065, + "error": 0.349609375, + "gradient_norm": 0.03918786719441414, + "elapsed": 307.6200888156891 + }, + { + "step": 416, + "loss": 0.27521568536758423, + "objective": 0.27521568536758423, + "error": 0.1220703125, + "gradient_norm": 0.038001637905836105, + "elapsed": 317.01610231399536 + }, + { + "step": 432, + "loss": 0.02379823848605156, + "objective": 0.02379823848605156, + "error": 0.0078125, + "gradient_norm": 0.007661945186555386, + "elapsed": 326.9360330104828 + }, + { + "step": 448, + "loss": 0.56734299659729, + "objective": 0.56734299659729, + "error": 0.3271484375, + "gradient_norm": 0.057416290044784546, + "elapsed": 339.6289041042328 + }, + { + "step": 464, + "loss": 0.10715995728969574, + "objective": 0.10715995728969574, + "error": 0.0380859375, + "gradient_norm": 0.02532491274178028, + "elapsed": 349.8584108352661 + }, + { + "step": 480, + "loss": 0.6143364310264587, + "objective": 0.6143364310264587, + "error": 0.36328125, + "gradient_norm": 0.08023032546043396, + "elapsed": 360.36362075805664 + }, + { + "step": 496, + "loss": 0.44069671630859375, + "objective": 0.44069671630859375, + "error": 0.2197265625, + "gradient_norm": 0.048025116324424744, + "elapsed": 369.48225808143616 + }, + { + "step": 512, + "loss": 0.019900165498256683, + "objective": 0.019900165498256683, + "error": 0.0107421875, + "gradient_norm": 0.0038635791279375553, + "elapsed": 378.59970593452454 + }, + { + "step": 528, + "loss": 0.033316534012556076, + "objective": 0.033316534012556076, + "error": 0.009765625, + "gradient_norm": 0.009174940176308155, + "elapsed": 393.4021761417389 + }, + { + "step": 544, + "loss": 0.41130945086479187, + "objective": 0.41130945086479187, + "error": 0.20703125, + "gradient_norm": 0.04695262759923935, + "elapsed": 402.8586280345917 + }, + { + "step": 560, + "loss": 0.5885373950004578, + "objective": 0.5885373950004578, + "error": 0.3544921875, + "gradient_norm": 0.08534500002861023, + "elapsed": 416.98661041259766 + }, + { + "step": 576, + "loss": 0.3804720640182495, + "objective": 0.3804720640182495, + "error": 0.19140625, + "gradient_norm": 0.05163278803229332, + "elapsed": 427.7550480365753 + }, + { + "step": 592, + "loss": 0.6101120710372925, + "objective": 0.6101120710372925, + "error": 0.3525390625, + "gradient_norm": 0.05593184754252434, + "elapsed": 441.05026268959045 + }, + { + "step": 608, + "loss": 0.5586092472076416, + "objective": 0.5586092472076416, + "error": 0.302734375, + "gradient_norm": 0.07458740472793579, + "elapsed": 452.95383286476135 + }, + { + "step": 624, + "loss": 0.5992780923843384, + "objective": 0.5992780923843384, + "error": 0.357421875, + "gradient_norm": 0.03618372976779938, + "elapsed": 466.1582691669464 + }, + { + "step": 640, + "loss": 0.3536975383758545, + "objective": 0.3536975383758545, + "error": 0.1650390625, + "gradient_norm": 0.05353165790438652, + "elapsed": 477.166255235672 + }, + { + "step": 656, + "loss": 0.4926893711090088, + "objective": 0.4926893711090088, + "error": 0.2626953125, + "gradient_norm": 0.05201377719640732, + "elapsed": 491.1417751312256 + }, + { + "step": 672, + "loss": 0.5754991173744202, + "objective": 0.5754991173744202, + "error": 0.3271484375, + "gradient_norm": 0.08167096972465515, + "elapsed": 501.630366563797 + }, + { + "step": 688, + "loss": 0.5685014724731445, + "objective": 0.5685014724731445, + "error": 0.333984375, + "gradient_norm": 0.043775107711553574, + "elapsed": 514.2880456447601 + }, + { + "step": 704, + "loss": 0.022465089336037636, + "objective": 0.022465089336037636, + "error": 0.0068359375, + "gradient_norm": 0.010172540321946144, + "elapsed": 522.9173214435577 + }, + { + "step": 720, + "loss": 0.035460107028484344, + "objective": 0.035460107028484344, + "error": 0.0107421875, + "gradient_norm": 0.010515578091144562, + "elapsed": 532.8470129966736 + }, + { + "step": 736, + "loss": 0.44765588641166687, + "objective": 0.44765588641166687, + "error": 0.2138671875, + "gradient_norm": 0.09050357341766357, + "elapsed": 541.9488840103149 + }, + { + "step": 752, + "loss": 0.5933939218521118, + "objective": 0.5933939218521118, + "error": 0.3359375, + "gradient_norm": 0.0665116235613823, + "elapsed": 552.9967355728149 + }, + { + "step": 768, + "loss": 0.6100764870643616, + "objective": 0.6100764870643616, + "error": 0.3515625, + "gradient_norm": 0.0821211114525795, + "elapsed": 563.7709202766418 + }, + { + "step": 784, + "loss": 0.02964692935347557, + "objective": 0.02964692935347557, + "error": 0.009765625, + "gradient_norm": 0.012663272209465504, + "elapsed": 573.1517221927643 + }, + { + "step": 800, + "loss": 0.38091832399368286, + "objective": 0.38091832399368286, + "error": 0.1904296875, + "gradient_norm": 0.060622021555900574, + "elapsed": 582.5687477588654 + }, + { + "step": 816, + "loss": 0.552335262298584, + "objective": 0.552335262298584, + "error": 0.3076171875, + "gradient_norm": 0.14419035613536835, + "elapsed": 594.4292685985565 + }, + { + "step": 832, + "loss": 0.5943340063095093, + "objective": 0.5943340063095093, + "error": 0.34375, + "gradient_norm": 0.0633513554930687, + "elapsed": 605.2052299976349 + }, + { + "step": 848, + "loss": 0.6074100732803345, + "objective": 0.6074100732803345, + "error": 0.3486328125, + "gradient_norm": 0.04225531220436096, + "elapsed": 614.8996202945709 + }, + { + "step": 864, + "loss": 0.6198879480361938, + "objective": 0.6198879480361938, + "error": 0.361328125, + "gradient_norm": 0.04208856821060181, + "elapsed": 625.4266908168793 + }, + { + "step": 880, + "loss": 0.6151762008666992, + "objective": 0.6151762008666992, + "error": 0.369140625, + "gradient_norm": 0.06261089444160461, + "elapsed": 636.0696911811829 + }, + { + "step": 896, + "loss": 0.49680083990097046, + "objective": 0.49680083990097046, + "error": 0.25390625, + "gradient_norm": 0.0827067643404007, + "elapsed": 644.6893246173859 + }, + { + "step": 912, + "loss": 0.4610927402973175, + "objective": 0.4610927402973175, + "error": 0.23828125, + "gradient_norm": 0.06652095168828964, + "elapsed": 655.969132900238 + }, + { + "step": 928, + "loss": 0.5218505859375, + "objective": 0.5218505859375, + "error": 0.2685546875, + "gradient_norm": 0.07188194245100021, + "elapsed": 667.5352523326874 + }, + { + "step": 944, + "loss": 0.33009427785873413, + "objective": 0.33009427785873413, + "error": 0.1533203125, + "gradient_norm": 0.05718810483813286, + "elapsed": 677.8397319316864 + }, + { + "step": 960, + "loss": 0.5703234672546387, + "objective": 0.5703234672546387, + "error": 0.3193359375, + "gradient_norm": 0.11168288439512253, + "elapsed": 687.8742904663086 + }, + { + "step": 976, + "loss": 0.025548014789819717, + "objective": 0.025548014789819717, + "error": 0.0107421875, + "gradient_norm": 0.009453393518924713, + "elapsed": 698.294285774231 + }, + { + "step": 992, + "loss": 0.45398157835006714, + "objective": 0.45398157835006714, + "error": 0.2412109375, + "gradient_norm": 0.04607952758669853, + "elapsed": 707.903199672699 + }, + { + "step": 1008, + "loss": 0.3412189781665802, + "objective": 0.3412189781665802, + "error": 0.1513671875, + "gradient_norm": 0.0432075597345829, + "elapsed": 718.5662748813629 + }, + { + "step": 1024, + "loss": 0.4376429319381714, + "objective": 0.4376429319381714, + "error": 0.2275390625, + "gradient_norm": 0.07974351197481155, + "elapsed": 728.8954858779907 + }, + { + "step": 1040, + "loss": 0.33512815833091736, + "objective": 0.33512815833091736, + "error": 0.150390625, + "gradient_norm": 0.04476875811815262, + "elapsed": 744.0822694301605 + }, + { + "step": 1056, + "loss": 0.5214208364486694, + "objective": 0.5214208364486694, + "error": 0.283203125, + "gradient_norm": 0.08898192644119263, + "elapsed": 755.1484262943268 + }, + { + "step": 1072, + "loss": 0.13849599659442902, + "objective": 0.13849599659442902, + "error": 0.052734375, + "gradient_norm": 0.028359953314065933, + "elapsed": 764.3303108215332 + }, + { + "step": 1088, + "loss": 0.323838472366333, + "objective": 0.323838472366333, + "error": 0.1435546875, + "gradient_norm": 0.04081716760993004, + "elapsed": 773.2739362716675 + }, + { + "step": 1104, + "loss": 0.5627881288528442, + "objective": 0.5627881288528442, + "error": 0.3125, + "gradient_norm": 0.08322097361087799, + "elapsed": 784.7223973274231 + }, + { + "step": 1120, + "loss": 0.44111010432243347, + "objective": 0.44111010432243347, + "error": 0.2216796875, + "gradient_norm": 0.05700977146625519, + "elapsed": 795.085648059845 + }, + { + "step": 1136, + "loss": 0.6395992040634155, + "objective": 0.6395992040634155, + "error": 0.39453125, + "gradient_norm": 0.0744553729891777, + "elapsed": 805.7942585945129 + }, + { + "step": 1152, + "loss": 0.5433304309844971, + "objective": 0.5433304309844971, + "error": 0.287109375, + "gradient_norm": 0.04814797267317772, + "elapsed": 817.3382890224457 + }, + { + "step": 1168, + "loss": 0.5708576440811157, + "objective": 0.5708576440811157, + "error": 0.3203125, + "gradient_norm": 0.051331400871276855, + "elapsed": 829.288791179657 + }, + { + "step": 1184, + "loss": 0.5447035431861877, + "objective": 0.5447035431861877, + "error": 0.2939453125, + "gradient_norm": 0.10116687417030334, + "elapsed": 839.6822843551636 + }, + { + "step": 1200, + "loss": 0.6125671863555908, + "objective": 0.6125671863555908, + "error": 0.3642578125, + "gradient_norm": 0.04368080571293831, + "elapsed": 850.2262740135193 + }, + { + "step": 1216, + "loss": 0.5002380609512329, + "objective": 0.5002380609512329, + "error": 0.259765625, + "gradient_norm": 0.04939017817378044, + "elapsed": 862.3783452510834 + }, + { + "step": 1232, + "loss": 0.5698772668838501, + "objective": 0.5698772668838501, + "error": 0.3173828125, + "gradient_norm": 0.04916854575276375, + "elapsed": 871.4622664451599 + }, + { + "step": 1248, + "loss": 0.6046518683433533, + "objective": 0.6046518683433533, + "error": 0.341796875, + "gradient_norm": 0.04919794574379921, + "elapsed": 883.3905737400055 + }, + { + "step": 1264, + "loss": 0.5913128852844238, + "objective": 0.5913128852844238, + "error": 0.357421875, + "gradient_norm": 0.046917904168367386, + "elapsed": 892.4264807701111 + }, + { + "step": 1280, + "loss": 0.5027461051940918, + "objective": 0.5027461051940918, + "error": 0.2626953125, + "gradient_norm": 0.04705750197172165, + "elapsed": 902.5875842571259 + }, + { + "step": 1296, + "loss": 0.13519814610481262, + "objective": 0.13519814610481262, + "error": 0.052734375, + "gradient_norm": 0.02625490538775921, + "elapsed": 912.4087471961975 + }, + { + "step": 1312, + "loss": 0.5862359404563904, + "objective": 0.5862359404563904, + "error": 0.3271484375, + "gradient_norm": 0.05441493168473244, + "elapsed": 923.992555141449 + }, + { + "step": 1328, + "loss": 0.6031408309936523, + "objective": 0.6031408309936523, + "error": 0.3505859375, + "gradient_norm": 0.05901554971933365, + "elapsed": 933.3936491012573 + }, + { + "step": 1344, + "loss": 0.5823733806610107, + "objective": 0.5823733806610107, + "error": 0.3310546875, + "gradient_norm": 0.0842989832162857, + "elapsed": 941.979998588562 + }, + { + "step": 1360, + "loss": 0.6241492033004761, + "objective": 0.6241492033004761, + "error": 0.3720703125, + "gradient_norm": 0.04446673393249512, + "elapsed": 954.969649553299 + }, + { + "step": 1376, + "loss": 0.5829156637191772, + "objective": 0.5829156637191772, + "error": 0.361328125, + "gradient_norm": 0.06615480780601501, + "elapsed": 966.0245676040649 + }, + { + "step": 1392, + "loss": 0.5968320369720459, + "objective": 0.5968320369720459, + "error": 0.34765625, + "gradient_norm": 0.05093541368842125, + "elapsed": 975.1022663116455 + }, + { + "step": 1408, + "loss": 0.045559000223875046, + "objective": 0.045559000223875046, + "error": 0.01171875, + "gradient_norm": 0.02514980360865593, + "elapsed": 987.2391452789307 + }, + { + "step": 1424, + "loss": 0.22601813077926636, + "objective": 0.22601813077926636, + "error": 0.09765625, + "gradient_norm": 0.04834206402301788, + "elapsed": 996.4583384990692 + }, + { + "step": 1440, + "loss": 0.23011144995689392, + "objective": 0.23011144995689392, + "error": 0.111328125, + "gradient_norm": 0.050687842071056366, + "elapsed": 1007.1440904140472 + }, + { + "step": 1456, + "loss": 0.018240466713905334, + "objective": 0.018240466713905334, + "error": 0.0078125, + "gradient_norm": 0.005604141391813755, + "elapsed": 1016.4502851963043 + }, + { + "step": 1472, + "loss": 0.4498720169067383, + "objective": 0.4498720169067383, + "error": 0.232421875, + "gradient_norm": 0.08179625123739243, + "elapsed": 1028.8303294181824 + }, + { + "step": 1488, + "loss": 0.24151627719402313, + "objective": 0.24151627719402313, + "error": 0.107421875, + "gradient_norm": 0.03838668763637543, + "elapsed": 1037.8867321014404 + }, + { + "step": 1504, + "loss": 0.46122002601623535, + "objective": 0.46122002601623535, + "error": 0.232421875, + "gradient_norm": 0.0726623386144638, + "elapsed": 1047.7258644104004 + }, + { + "step": 1520, + "loss": 0.5085602402687073, + "objective": 0.5085602402687073, + "error": 0.2705078125, + "gradient_norm": 0.06673175096511841, + "elapsed": 1059.352120399475 + }, + { + "step": 1536, + "loss": 0.6105246543884277, + "objective": 0.6105246543884277, + "error": 0.3818359375, + "gradient_norm": 0.04271261766552925, + "elapsed": 1070.1413230895996 + }, + { + "step": 1552, + "loss": 0.4792126417160034, + "objective": 0.4792126417160034, + "error": 0.2578125, + "gradient_norm": 0.05200039595365524, + "elapsed": 1086.444006204605 + }, + { + "step": 1568, + "loss": 0.5814266204833984, + "objective": 0.5814266204833984, + "error": 0.330078125, + "gradient_norm": 0.05867309868335724, + "elapsed": 1097.2902619838715 + }, + { + "step": 1584, + "loss": 0.6321226358413696, + "objective": 0.6321226358413696, + "error": 0.3798828125, + "gradient_norm": 0.05418067052960396, + "elapsed": 1107.9767682552338 + }, + { + "step": 1600, + "loss": 0.5931253433227539, + "objective": 0.5931253433227539, + "error": 0.3603515625, + "gradient_norm": 0.06396215409040451, + "elapsed": 1121.782609462738 + }, + { + "step": 1616, + "loss": 0.6411516666412354, + "objective": 0.6411516666412354, + "error": 0.38671875, + "gradient_norm": 0.05035768821835518, + "elapsed": 1132.7197887897491 + }, + { + "step": 1632, + "loss": 0.4267754852771759, + "objective": 0.4267754852771759, + "error": 0.2080078125, + "gradient_norm": 0.09109894186258316, + "elapsed": 1139.1667578220367 + }, + { + "step": 1648, + "loss": 0.21246182918548584, + "objective": 0.21246182918548584, + "error": 0.095703125, + "gradient_norm": 0.04478950425982475, + "elapsed": 1149.1183021068573 + }, + { + "step": 1664, + "loss": 0.46360665559768677, + "objective": 0.46360665559768677, + "error": 0.251953125, + "gradient_norm": 0.07668188214302063, + "elapsed": 1161.1197745800018 + }, + { + "step": 1680, + "loss": 0.46281397342681885, + "objective": 0.46281397342681885, + "error": 0.236328125, + "gradient_norm": 0.07954126596450806, + "elapsed": 1171.8474535942078 + }, + { + "step": 1696, + "loss": 0.2484058141708374, + "objective": 0.2484058141708374, + "error": 0.12109375, + "gradient_norm": 0.047261305153369904, + "elapsed": 1185.6542596817017 + }, + { + "step": 1712, + "loss": 0.24310235679149628, + "objective": 0.24310235679149628, + "error": 0.1064453125, + "gradient_norm": 0.07262872904539108, + "elapsed": 1197.8986082077026 + }, + { + "step": 1728, + "loss": 0.009729458019137383, + "objective": 0.009729458019137383, + "error": 0.001953125, + "gradient_norm": 0.01146845705807209, + "elapsed": 1208.495581150055 + }, + { + "step": 1744, + "loss": 0.24568752944469452, + "objective": 0.24568752944469452, + "error": 0.10546875, + "gradient_norm": 0.05830742046236992, + "elapsed": 1219.9394850730896 + }, + { + "step": 1760, + "loss": 0.022546378895640373, + "objective": 0.022546378895640373, + "error": 0.0068359375, + "gradient_norm": 0.007667526602745056, + "elapsed": 1229.5703229904175 + }, + { + "step": 1776, + "loss": 0.5848401784896851, + "objective": 0.5848401784896851, + "error": 0.3271484375, + "gradient_norm": 0.061901818960905075, + "elapsed": 1238.750280380249 + }, + { + "step": 1792, + "loss": 0.6031335592269897, + "objective": 0.6031335592269897, + "error": 0.3671875, + "gradient_norm": 0.0676632970571518, + "elapsed": 1247.7468683719635 + }, + { + "step": 1808, + "loss": 0.6210961937904358, + "objective": 0.6210961937904358, + "error": 0.3603515625, + "gradient_norm": 0.0718468651175499, + "elapsed": 1256.1821897029877 + }, + { + "step": 1824, + "loss": 0.570877730846405, + "objective": 0.570877730846405, + "error": 0.3212890625, + "gradient_norm": 0.05575930327177048, + "elapsed": 1266.4091975688934 + }, + { + "step": 1840, + "loss": 0.5711429119110107, + "objective": 0.5711429119110107, + "error": 0.31640625, + "gradient_norm": 0.0691002607345581, + "elapsed": 1277.4722146987915 + }, + { + "step": 1856, + "loss": 0.36046335101127625, + "objective": 0.36046335101127625, + "error": 0.16796875, + "gradient_norm": 0.04694395884871483, + "elapsed": 1287.1420249938965 + }, + { + "step": 1872, + "loss": 0.4688999652862549, + "objective": 0.4688999652862549, + "error": 0.2216796875, + "gradient_norm": 0.07401346415281296, + "elapsed": 1297.3945078849792 + }, + { + "step": 1888, + "loss": 0.46385282278060913, + "objective": 0.46385282278060913, + "error": 0.2373046875, + "gradient_norm": 0.05608939751982689, + "elapsed": 1305.9779334068298 + }, + { + "step": 1904, + "loss": 0.60875403881073, + "objective": 0.60875403881073, + "error": 0.365234375, + "gradient_norm": 0.05085878074169159, + "elapsed": 1317.3097081184387 + }, + { + "step": 1920, + "loss": 0.12223530560731888, + "objective": 0.12223530560731888, + "error": 0.0458984375, + "gradient_norm": 0.024870412424206734, + "elapsed": 1328.6486887931824 + }, + { + "step": 1936, + "loss": 0.3486189544200897, + "objective": 0.3486189544200897, + "error": 0.16796875, + "gradient_norm": 0.04780663549900055, + "elapsed": 1336.6701011657715 + }, + { + "step": 1952, + "loss": 0.5777363777160645, + "objective": 0.5777363777160645, + "error": 0.3427734375, + "gradient_norm": 0.0571451336145401, + "elapsed": 1346.9158833026886 + }, + { + "step": 1968, + "loss": 0.39320266246795654, + "objective": 0.39320266246795654, + "error": 0.1884765625, + "gradient_norm": 0.05673858895897865, + "elapsed": 1354.9182631969452 + }, + { + "step": 1984, + "loss": 0.5900611281394958, + "objective": 0.5900611281394958, + "error": 0.3349609375, + "gradient_norm": 0.06593932211399078, + "elapsed": 1364.2754452228546 + }, + { + "step": 2000, + "loss": 0.6212430000305176, + "objective": 0.6212430000305176, + "error": 0.3857421875, + "gradient_norm": 0.040818918496370316, + "elapsed": 1374.7192046642303 + }, + { + "step": 2016, + "loss": 0.15605247020721436, + "objective": 0.15605247020721436, + "error": 0.0556640625, + "gradient_norm": 0.03108786791563034, + "elapsed": 1386.2740807533264 + }, + { + "step": 2032, + "loss": 0.22049596905708313, + "objective": 0.22049596905708313, + "error": 0.1015625, + "gradient_norm": 0.042733557522296906, + "elapsed": 1396.6422457695007 + }, + { + "step": 2048, + "loss": 0.5642613172531128, + "objective": 0.5642613172531128, + "error": 0.306640625, + "gradient_norm": 0.07527482509613037, + "elapsed": 1407.6688070297241 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 512, + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "512": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "512": { + "step": 512, + "training_samples": 524288, + "unique_training_rows_seen_in_this_phase": 324661, + "weights_sha256": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "complete": true + }, + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ff5a023ce2c18be7c29f810a3788a450e3ad3ad2237d6e9448923aa6a28c5074", + "complete": true + } + }, + "selection": "Predefined averages of the last3 or all4 saved noninitial full3_1 checkpoints; evaluate every validation condition before selecting", + "test_data_used": false, + "derivation_source_sha256": "08c498d6952b0380e001371df9a0461a483631a301f93747b821e529e72b349d" + }, + "training_source_snapshot": "training_sources/full3_swa", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23290264423076928, + "mean3": 0.2335186298076923, + "blend-mean3": 0.2325420673076923, + "mean4": 0.23326322115384618, + "blend-mean4": 0.23300781250000002 + }, + "selected": "blend-mean3" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615, + "mean3": 0.22037259615384613, + "blend-mean3": 0.22091346153846153, + "mean4": 0.2205528846153846, + "blend-mean4": 0.22100360576923078 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + "checkpoints": { + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 467790, + "weights_sha256": "6ebe606c36cfd41862e589568878e67b2c2accafeb093b1fee3a0955d5948f0d", + "complete": true + } + }, + "selection": "Per-basis minimum full-validation mean over the incumbent and equal old/new neural probability averages, optionally blended with physical probability at fractions 0, .25, or .5. All 13 durations included.", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2319861778846154, + "0-physical-0": 0.23278245192307695, + "0-physical-0.25": 0.23291766826923077, + "0-physical-0.5": 0.23315805288461539, + "512-physical-0": 0.2319110576923077, + "512-physical-0.25": 0.23314302884615387, + "512-physical-0.5": 0.2329477163461538, + "1024-physical-0": 0.2325721153846154, + "1024-physical-0.25": 0.23218149038461536, + "1024-physical-0.5": 0.2329627403846154, + "1536-physical-0": 0.23186598557692306, + "1536-physical-0.25": 0.23234675480769235, + "1536-physical-0.5": 0.2330829326923077 + }, + "selected": "1536-physical-0", + "original_checkpoint": "full3_swa/mean3" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "0-physical-0": 0.22029747596153845, + "0-physical-0.25": 0.22067307692307694, + "0-physical-0.5": 0.22079326923076922, + "512-physical-0": 0.22034254807692305, + "512-physical-0.25": 0.22050781249999998, + "512-physical-0.5": 0.2203725961538462, + "1024-physical-0": 0.21998197115384613, + "1024-physical-0.25": 0.22049278846153844, + "1024-physical-0.5": 0.22031250000000002, + "1536-physical-0": 0.2204026442307692, + "1536-physical-0.25": 0.2201923076923077, + "1536-physical-0.5": 0.22061298076923078 + }, + "selected": "incumbent", + "original_checkpoint": "full3_1/1536" + } + ], + "control": { + "status": "passed", + "device": "cpu", + "source_sha256": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "reference_package": "/run-state/workspace/research/context_upgrades/short_categorical2/package", + "members": [ + { + "weights": "weights/neural-d5-neural_d5_full3_swa-mean3.npz", + "coefficient": 1.0 + }, + { + "weights": "weights/neural-d5-neural_d5_full3_1-1536.npz", + "coefficient": 3.0 + } + ], + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 1, + "single_path_exact": true, + "shared_mixture_exact": true, + "cpu_recomputed_vs_gpu_cached_prior_max_difference": null + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "single_path_exact": true, + "shared_mixture_exact": true, + "cpu_recomputed_vs_gpu_cached_prior_max_difference": 1.7881393432617188e-07 + } + ], + "seconds": 4.879673480987549, + "scope": "Runtime probability aggregation and prior reuse; no model fitting or validation selection." + }, + "test_data_used": false + }, + "neural_d5": { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 467790, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved2_warm/weights-512.npz", + "starting_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317635, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261274", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.2600052058696747, + "objective": 0.2600052058696747, + "error": 0.1123046875, + "gradient_norm": 0.06799795478582382, + "elapsed": 27.333195447921753 + }, + { + "step": 16, + "loss": 0.0312246885150671, + "objective": 0.0312246885150671, + "error": 0.01171875, + "gradient_norm": 0.004962741397321224, + "elapsed": 48.383540868759155 + }, + { + "step": 32, + "loss": 0.22698244452476501, + "objective": 0.22698244452476501, + "error": 0.08984375, + "gradient_norm": 0.06353150308132172, + "elapsed": 57.04609966278076 + }, + { + "step": 48, + "loss": 0.5861443281173706, + "objective": 0.5861443281173706, + "error": 0.3486328125, + "gradient_norm": 0.04095375910401344, + "elapsed": 69.08654689788818 + }, + { + "step": 64, + "loss": 0.6103856563568115, + "objective": 0.6103856563568115, + "error": 0.3662109375, + "gradient_norm": 0.04155975207686424, + "elapsed": 81.63970494270325 + }, + { + "step": 80, + "loss": 0.5673234462738037, + "objective": 0.5673234462738037, + "error": 0.3125, + "gradient_norm": 0.1773851364850998, + "elapsed": 92.5357596874237 + }, + { + "step": 96, + "loss": 0.3763846755027771, + "objective": 0.3763846755027771, + "error": 0.1875, + "gradient_norm": 0.0951203852891922, + "elapsed": 103.12279391288757 + }, + { + "step": 112, + "loss": 0.45539408922195435, + "objective": 0.45539408922195435, + "error": 0.22265625, + "gradient_norm": 0.056369006633758545, + "elapsed": 112.61882042884827 + }, + { + "step": 128, + "loss": 0.015473627485334873, + "objective": 0.015473627485334873, + "error": 0.005859375, + "gradient_norm": 0.005696057807654142, + "elapsed": 125.16960310935974 + }, + { + "step": 144, + "loss": 0.03449750319123268, + "objective": 0.03449750319123268, + "error": 0.0107421875, + "gradient_norm": 0.008358650840818882, + "elapsed": 135.8080232143402 + }, + { + "step": 160, + "loss": 0.5731935501098633, + "objective": 0.5731935501098633, + "error": 0.31640625, + "gradient_norm": 0.056162577122449875, + "elapsed": 145.0349259376526 + }, + { + "step": 176, + "loss": 0.5626271963119507, + "objective": 0.5626271963119507, + "error": 0.314453125, + "gradient_norm": 0.048817526549100876, + "elapsed": 154.84093379974365 + }, + { + "step": 192, + "loss": 0.5507581233978271, + "objective": 0.5507581233978271, + "error": 0.3173828125, + "gradient_norm": 0.06503377854824066, + "elapsed": 164.7195086479187 + }, + { + "step": 208, + "loss": 0.5725968480110168, + "objective": 0.5725968480110168, + "error": 0.3251953125, + "gradient_norm": 0.047704510390758514, + "elapsed": 175.38803815841675 + }, + { + "step": 224, + "loss": 0.5249365568161011, + "objective": 0.5249365568161011, + "error": 0.2802734375, + "gradient_norm": 0.10021239519119263, + "elapsed": 187.0162854194641 + }, + { + "step": 240, + "loss": 0.2526492476463318, + "objective": 0.2526492476463318, + "error": 0.1103515625, + "gradient_norm": 0.06751289963722229, + "elapsed": 196.51696944236755 + }, + { + "step": 256, + "loss": 0.5214780569076538, + "objective": 0.5214780569076538, + "error": 0.275390625, + "gradient_norm": 0.14627203345298767, + "elapsed": 208.2405219078064 + }, + { + "step": 272, + "loss": 0.59315025806427, + "objective": 0.59315025806427, + "error": 0.341796875, + "gradient_norm": 0.03693874180316925, + "elapsed": 224.87874341011047 + }, + { + "step": 288, + "loss": 0.37350377440452576, + "objective": 0.37350377440452576, + "error": 0.169921875, + "gradient_norm": 0.05035478249192238, + "elapsed": 235.2427306175232 + }, + { + "step": 304, + "loss": 0.6201726198196411, + "objective": 0.6201726198196411, + "error": 0.3798828125, + "gradient_norm": 0.04230104014277458, + "elapsed": 244.4733214378357 + }, + { + "step": 320, + "loss": 0.5781067609786987, + "objective": 0.5781067609786987, + "error": 0.3291015625, + "gradient_norm": 0.06764703243970871, + "elapsed": 256.96991300582886 + }, + { + "step": 336, + "loss": 0.13824111223220825, + "objective": 0.13824111223220825, + "error": 0.0556640625, + "gradient_norm": 0.02330971322953701, + "elapsed": 268.097412109375 + }, + { + "step": 352, + "loss": 0.6141752004623413, + "objective": 0.6141752004623413, + "error": 0.37890625, + "gradient_norm": 0.08660273998975754, + "elapsed": 282.79302310943604 + }, + { + "step": 368, + "loss": 0.3470626473426819, + "objective": 0.3470626473426819, + "error": 0.1611328125, + "gradient_norm": 0.05711895599961281, + "elapsed": 293.79467129707336 + }, + { + "step": 384, + "loss": 0.6023644208908081, + "objective": 0.6023644208908081, + "error": 0.3466796875, + "gradient_norm": 0.08649417012929916, + "elapsed": 305.9786322116852 + }, + { + "step": 400, + "loss": 0.03022841364145279, + "objective": 0.03022841364145279, + "error": 0.0087890625, + "gradient_norm": 0.009741511195898056, + "elapsed": 315.06104922294617 + }, + { + "step": 416, + "loss": 0.23827238380908966, + "objective": 0.23827238380908966, + "error": 0.1015625, + "gradient_norm": 0.03526044636964798, + "elapsed": 325.6410942077637 + }, + { + "step": 432, + "loss": 0.43375664949417114, + "objective": 0.43375664949417114, + "error": 0.201171875, + "gradient_norm": 0.03940205276012421, + "elapsed": 336.9890570640564 + }, + { + "step": 448, + "loss": 0.5915575623512268, + "objective": 0.5915575623512268, + "error": 0.3359375, + "gradient_norm": 0.04364592209458351, + "elapsed": 346.9254243373871 + }, + { + "step": 464, + "loss": 0.5641118288040161, + "objective": 0.5641118288040161, + "error": 0.3076171875, + "gradient_norm": 0.052896615117788315, + "elapsed": 356.9816539287567 + }, + { + "step": 480, + "loss": 0.5682889223098755, + "objective": 0.5682889223098755, + "error": 0.322265625, + "gradient_norm": 0.07130409777164459, + "elapsed": 369.16103172302246 + }, + { + "step": 496, + "loss": 0.37034764885902405, + "objective": 0.37034764885902405, + "error": 0.181640625, + "gradient_norm": 0.11464523524045944, + "elapsed": 381.041054725647 + }, + { + "step": 512, + "loss": 0.5398496389389038, + "objective": 0.5398496389389038, + "error": 0.3076171875, + "gradient_norm": 0.05673467367887497, + "elapsed": 394.5030150413513 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "db182d721768f832e1c83f6258b31bef0d8bf2ded239a8ab5a45cbb76378fd30", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317635, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.30839407444000244, + "objective": 0.30839407444000244, + "error": 0.130859375, + "gradient_norm": 0.053425733000040054, + "elapsed": 28.537403345108032 + }, + { + "step": 16, + "loss": 0.021987520158290863, + "objective": 0.021987520158290863, + "error": 0.0078125, + "gradient_norm": 0.01397851575165987, + "elapsed": 48.18276286125183 + }, + { + "step": 32, + "loss": 0.5041587352752686, + "objective": 0.5041587352752686, + "error": 0.2724609375, + "gradient_norm": 0.0528741292655468, + "elapsed": 58.27348470687866 + }, + { + "step": 48, + "loss": 0.4326452612876892, + "objective": 0.4326452612876892, + "error": 0.21484375, + "gradient_norm": 0.0559566393494606, + "elapsed": 68.90473222732544 + }, + { + "step": 64, + "loss": 0.4804917275905609, + "objective": 0.4804917275905609, + "error": 0.248046875, + "gradient_norm": 0.0669105276465416, + "elapsed": 77.87249231338501 + }, + { + "step": 80, + "loss": 0.2889654338359833, + "objective": 0.2889654338359833, + "error": 0.1328125, + "gradient_norm": 0.08293467015028, + "elapsed": 86.87973022460938 + }, + { + "step": 96, + "loss": 0.5135385990142822, + "objective": 0.5135385990142822, + "error": 0.271484375, + "gradient_norm": 0.06412295252084732, + "elapsed": 95.98773431777954 + }, + { + "step": 112, + "loss": 0.31248384714126587, + "objective": 0.31248384714126587, + "error": 0.1357421875, + "gradient_norm": 0.03881710395216942, + "elapsed": 106.47444081306458 + }, + { + "step": 128, + "loss": 0.23868557810783386, + "objective": 0.23868557810783386, + "error": 0.091796875, + "gradient_norm": 0.03896595537662506, + "elapsed": 117.72143626213074 + }, + { + "step": 144, + "loss": 0.5315916538238525, + "objective": 0.5315916538238525, + "error": 0.2890625, + "gradient_norm": 0.09184520691633224, + "elapsed": 126.97882843017578 + }, + { + "step": 160, + "loss": 0.604732096195221, + "objective": 0.604732096195221, + "error": 0.3603515625, + "gradient_norm": 0.044600710272789, + "elapsed": 137.403742313385 + }, + { + "step": 176, + "loss": 0.032417282462120056, + "objective": 0.032417282462120056, + "error": 0.0107421875, + "gradient_norm": 0.010968778282403946, + "elapsed": 147.58081603050232 + }, + { + "step": 192, + "loss": 0.24050910770893097, + "objective": 0.24050910770893097, + "error": 0.087890625, + "gradient_norm": 0.052534136921167374, + "elapsed": 156.545964717865 + }, + { + "step": 208, + "loss": 0.3183761537075043, + "objective": 0.3183761537075043, + "error": 0.1435546875, + "gradient_norm": 0.05253623053431511, + "elapsed": 166.62695455551147 + }, + { + "step": 224, + "loss": 0.6407097578048706, + "objective": 0.6407097578048706, + "error": 0.3837890625, + "gradient_norm": 0.08772490173578262, + "elapsed": 174.46970582008362 + }, + { + "step": 240, + "loss": 0.597212553024292, + "objective": 0.597212553024292, + "error": 0.36328125, + "gradient_norm": 0.13039150834083557, + "elapsed": 184.2768793106079 + }, + { + "step": 256, + "loss": 0.3317721486091614, + "objective": 0.3317721486091614, + "error": 0.14453125, + "gradient_norm": 0.03749232366681099, + "elapsed": 194.6345317363739 + }, + { + "step": 272, + "loss": 0.6330116987228394, + "objective": 0.6330116987228394, + "error": 0.3955078125, + "gradient_norm": 0.06468097865581512, + "elapsed": 205.8717017173767 + }, + { + "step": 288, + "loss": 0.3141757845878601, + "objective": 0.3141757845878601, + "error": 0.138671875, + "gradient_norm": 0.046496689319610596, + "elapsed": 215.2117359638214 + }, + { + "step": 304, + "loss": 0.5782994031906128, + "objective": 0.5782994031906128, + "error": 0.345703125, + "gradient_norm": 0.06487675756216049, + "elapsed": 225.47403240203857 + }, + { + "step": 320, + "loss": 0.45729100704193115, + "objective": 0.45729100704193115, + "error": 0.2255859375, + "gradient_norm": 0.04169687256217003, + "elapsed": 233.03686332702637 + }, + { + "step": 336, + "loss": 0.49350813031196594, + "objective": 0.49350813031196594, + "error": 0.24609375, + "gradient_norm": 0.08623651415109634, + "elapsed": 244.53246903419495 + }, + { + "step": 352, + "loss": 0.25660067796707153, + "objective": 0.25660067796707153, + "error": 0.1103515625, + "gradient_norm": 0.03029652312397957, + "elapsed": 254.88137793540955 + }, + { + "step": 368, + "loss": 0.2295728325843811, + "objective": 0.2295728325843811, + "error": 0.0966796875, + "gradient_norm": 0.042884912341833115, + "elapsed": 262.7415475845337 + }, + { + "step": 384, + "loss": 0.6214326620101929, + "objective": 0.6214326620101929, + "error": 0.3759765625, + "gradient_norm": 0.08176509290933609, + "elapsed": 271.72958397865295 + }, + { + "step": 400, + "loss": 0.6463049650192261, + "objective": 0.6463049650192261, + "error": 0.3984375, + "gradient_norm": 0.08226390928030014, + "elapsed": 281.51069259643555 + }, + { + "step": 416, + "loss": 0.024987798184156418, + "objective": 0.024987798184156418, + "error": 0.0078125, + "gradient_norm": 0.0075854891911149025, + "elapsed": 291.0118627548218 + }, + { + "step": 432, + "loss": 0.5520929098129272, + "objective": 0.5520929098129272, + "error": 0.3125, + "gradient_norm": 0.09755270183086395, + "elapsed": 301.23231768608093 + }, + { + "step": 448, + "loss": 0.6077401638031006, + "objective": 0.6077401638031006, + "error": 0.361328125, + "gradient_norm": 0.04908076301217079, + "elapsed": 312.93572759628296 + }, + { + "step": 464, + "loss": 0.016434211283922195, + "objective": 0.016434211283922195, + "error": 0.005859375, + "gradient_norm": 0.007213531993329525, + "elapsed": 323.8330478668213 + }, + { + "step": 480, + "loss": 0.1582300364971161, + "objective": 0.1582300364971161, + "error": 0.064453125, + "gradient_norm": 0.028335656970739365, + "elapsed": 334.6112554073334 + }, + { + "step": 496, + "loss": 0.5916742086410522, + "objective": 0.5916742086410522, + "error": 0.35546875, + "gradient_norm": 0.08213689178228378, + "elapsed": 345.8490369319916 + }, + { + "step": 512, + "loss": 0.11447565257549286, + "objective": 0.11447565257549286, + "error": 0.04296875, + "gradient_norm": 0.028994916006922722, + "elapsed": 358.71793270111084 + }, + { + "step": 528, + "loss": 0.3011414408683777, + "objective": 0.3011414408683777, + "error": 0.1435546875, + "gradient_norm": 0.04305516928434372, + "elapsed": 373.143226146698 + }, + { + "step": 544, + "loss": 0.3099900782108307, + "objective": 0.3099900782108307, + "error": 0.130859375, + "gradient_norm": 0.06152835488319397, + "elapsed": 380.42762184143066 + }, + { + "step": 560, + "loss": 0.42917633056640625, + "objective": 0.42917633056640625, + "error": 0.203125, + "gradient_norm": 0.051812849938869476, + "elapsed": 390.78397703170776 + }, + { + "step": 576, + "loss": 0.4895544648170471, + "objective": 0.4895544648170471, + "error": 0.2451171875, + "gradient_norm": 0.059052009135484695, + "elapsed": 400.29374146461487 + }, + { + "step": 592, + "loss": 0.5950886011123657, + "objective": 0.5950886011123657, + "error": 0.328125, + "gradient_norm": 0.1449151188135147, + "elapsed": 410.06920647621155 + }, + { + "step": 608, + "loss": 0.3282078504562378, + "objective": 0.3282078504562378, + "error": 0.1484375, + "gradient_norm": 0.06495015323162079, + "elapsed": 420.5240683555603 + }, + { + "step": 624, + "loss": 0.6034166812896729, + "objective": 0.6034166812896729, + "error": 0.3388671875, + "gradient_norm": 0.05658626928925514, + "elapsed": 430.7997169494629 + }, + { + "step": 640, + "loss": 0.590431809425354, + "objective": 0.590431809425354, + "error": 0.3447265625, + "gradient_norm": 0.046094730496406555, + "elapsed": 441.8197224140167 + }, + { + "step": 656, + "loss": 0.2260439246892929, + "objective": 0.2260439246892929, + "error": 0.1015625, + "gradient_norm": 0.06323576718568802, + "elapsed": 450.76086831092834 + }, + { + "step": 672, + "loss": 0.26158156991004944, + "objective": 0.26158156991004944, + "error": 0.1162109375, + "gradient_norm": 0.08324819058179855, + "elapsed": 459.1986529827118 + }, + { + "step": 688, + "loss": 0.4871026873588562, + "objective": 0.4871026873588562, + "error": 0.244140625, + "gradient_norm": 0.051720812916755676, + "elapsed": 470.4437210559845 + }, + { + "step": 704, + "loss": 0.5861694812774658, + "objective": 0.5861694812774658, + "error": 0.341796875, + "gradient_norm": 0.05766218528151512, + "elapsed": 483.85575103759766 + }, + { + "step": 720, + "loss": 0.4168863296508789, + "objective": 0.4168863296508789, + "error": 0.21484375, + "gradient_norm": 0.05056491494178772, + "elapsed": 494.63891077041626 + }, + { + "step": 736, + "loss": 0.42054638266563416, + "objective": 0.42054638266563416, + "error": 0.21875, + "gradient_norm": 0.07021808624267578, + "elapsed": 505.4899232387543 + }, + { + "step": 752, + "loss": 0.2022928148508072, + "objective": 0.2022928148508072, + "error": 0.0849609375, + "gradient_norm": 0.0765448734164238, + "elapsed": 516.2925503253937 + }, + { + "step": 768, + "loss": 0.026398655027151108, + "objective": 0.026398655027151108, + "error": 0.0068359375, + "gradient_norm": 0.00973521638661623, + "elapsed": 524.7940125465393 + }, + { + "step": 784, + "loss": 0.5843480825424194, + "objective": 0.5843480825424194, + "error": 0.345703125, + "gradient_norm": 0.04805552959442139, + "elapsed": 535.345025062561 + }, + { + "step": 800, + "loss": 0.3102012872695923, + "objective": 0.3102012872695923, + "error": 0.134765625, + "gradient_norm": 0.09761057049036026, + "elapsed": 544.4683487415314 + }, + { + "step": 816, + "loss": 0.5332639217376709, + "objective": 0.5332639217376709, + "error": 0.30078125, + "gradient_norm": 0.10398133844137192, + "elapsed": 554.8217175006866 + }, + { + "step": 832, + "loss": 0.4870310425758362, + "objective": 0.4870310425758362, + "error": 0.2685546875, + "gradient_norm": 0.05754273384809494, + "elapsed": 564.9130115509033 + }, + { + "step": 848, + "loss": 0.1336989849805832, + "objective": 0.1336989849805832, + "error": 0.0498046875, + "gradient_norm": 0.02862304449081421, + "elapsed": 573.6143791675568 + }, + { + "step": 864, + "loss": 0.5794297456741333, + "objective": 0.5794297456741333, + "error": 0.3427734375, + "gradient_norm": 0.05002075806260109, + "elapsed": 584.2565310001373 + }, + { + "step": 880, + "loss": 0.6150081753730774, + "objective": 0.6150081753730774, + "error": 0.341796875, + "gradient_norm": 0.0605069138109684, + "elapsed": 596.845867395401 + }, + { + "step": 896, + "loss": 0.3804032504558563, + "objective": 0.3804032504558563, + "error": 0.18359375, + "gradient_norm": 0.057405781000852585, + "elapsed": 606.0786938667297 + }, + { + "step": 912, + "loss": 0.5734928846359253, + "objective": 0.5734928846359253, + "error": 0.2958984375, + "gradient_norm": 0.06807747483253479, + "elapsed": 616.9755277633667 + }, + { + "step": 928, + "loss": 0.23615539073944092, + "objective": 0.23615539073944092, + "error": 0.107421875, + "gradient_norm": 0.04033413156867027, + "elapsed": 625.9104406833649 + }, + { + "step": 944, + "loss": 0.5668450593948364, + "objective": 0.5668450593948364, + "error": 0.3134765625, + "gradient_norm": 0.04825817048549652, + "elapsed": 635.4241654872894 + }, + { + "step": 960, + "loss": 0.1369795948266983, + "objective": 0.1369795948266983, + "error": 0.0537109375, + "gradient_norm": 0.029475854709744453, + "elapsed": 646.0763671398163 + }, + { + "step": 976, + "loss": 0.026218727231025696, + "objective": 0.026218727231025696, + "error": 0.009765625, + "gradient_norm": 0.0067830472253263, + "elapsed": 656.7150173187256 + }, + { + "step": 992, + "loss": 0.6016548871994019, + "objective": 0.6016548871994019, + "error": 0.3564453125, + "gradient_norm": 0.04935981705784798, + "elapsed": 668.9989516735077 + }, + { + "step": 1008, + "loss": 0.1370980143547058, + "objective": 0.1370980143547058, + "error": 0.0546875, + "gradient_norm": 0.04418199881911278, + "elapsed": 677.3821382522583 + }, + { + "step": 1024, + "loss": 0.4085504412651062, + "objective": 0.4085504412651062, + "error": 0.19921875, + "gradient_norm": 0.07943295687437057, + "elapsed": 688.8395888805389 + }, + { + "step": 1040, + "loss": 0.34129297733306885, + "objective": 0.34129297733306885, + "error": 0.15625, + "gradient_norm": 0.04551500454545021, + "elapsed": 703.4613966941833 + }, + { + "step": 1056, + "loss": 0.5297085046768188, + "objective": 0.5297085046768188, + "error": 0.2705078125, + "gradient_norm": 0.06177444010972977, + "elapsed": 714.0862259864807 + }, + { + "step": 1072, + "loss": 0.3833361268043518, + "objective": 0.3833361268043518, + "error": 0.185546875, + "gradient_norm": 0.053057629615068436, + "elapsed": 724.1480000019073 + }, + { + "step": 1088, + "loss": 0.6497273445129395, + "objective": 0.6497273445129395, + "error": 0.421875, + "gradient_norm": 0.10790837556123734, + "elapsed": 735.8740057945251 + }, + { + "step": 1104, + "loss": 0.5393906831741333, + "objective": 0.5393906831741333, + "error": 0.2998046875, + "gradient_norm": 0.06015805900096893, + "elapsed": 743.9961709976196 + }, + { + "step": 1120, + "loss": 0.38553956151008606, + "objective": 0.38553956151008606, + "error": 0.1875, + "gradient_norm": 0.05357081815600395, + "elapsed": 753.2208635807037 + }, + { + "step": 1136, + "loss": 0.5478834509849548, + "objective": 0.5478834509849548, + "error": 0.2900390625, + "gradient_norm": 0.05761478468775749, + "elapsed": 761.3359644412994 + }, + { + "step": 1152, + "loss": 0.5732287168502808, + "objective": 0.5732287168502808, + "error": 0.341796875, + "gradient_norm": 0.07881136238574982, + "elapsed": 771.133172750473 + }, + { + "step": 1168, + "loss": 0.5174047946929932, + "objective": 0.5174047946929932, + "error": 0.29296875, + "gradient_norm": 0.07794999331235886, + "elapsed": 783.7084786891937 + }, + { + "step": 1184, + "loss": 0.5022754669189453, + "objective": 0.5022754669189453, + "error": 0.265625, + "gradient_norm": 0.05175226181745529, + "elapsed": 793.499255657196 + }, + { + "step": 1200, + "loss": 0.5698775053024292, + "objective": 0.5698775053024292, + "error": 0.34375, + "gradient_norm": 0.06385946273803711, + "elapsed": 804.970814704895 + }, + { + "step": 1216, + "loss": 0.6203033924102783, + "objective": 0.6203033924102783, + "error": 0.37109375, + "gradient_norm": 0.07393646240234375, + "elapsed": 816.1773698329926 + }, + { + "step": 1232, + "loss": 0.6154648065567017, + "objective": 0.6154648065567017, + "error": 0.3857421875, + "gradient_norm": 0.04278155043721199, + "elapsed": 827.3619928359985 + }, + { + "step": 1248, + "loss": 0.5948328971862793, + "objective": 0.5948328971862793, + "error": 0.3291015625, + "gradient_norm": 0.062024734914302826, + "elapsed": 838.8370804786682 + }, + { + "step": 1264, + "loss": 0.5644958019256592, + "objective": 0.5644958019256592, + "error": 0.3212890625, + "gradient_norm": 0.12030917406082153, + "elapsed": 849.5000331401825 + }, + { + "step": 1280, + "loss": 0.028782427310943604, + "objective": 0.028782427310943604, + "error": 0.0087890625, + "gradient_norm": 0.009096251800656319, + "elapsed": 857.8837285041809 + }, + { + "step": 1296, + "loss": 0.5129679441452026, + "objective": 0.5129679441452026, + "error": 0.2626953125, + "gradient_norm": 0.12833116948604584, + "elapsed": 868.5195860862732 + }, + { + "step": 1312, + "loss": 0.4095553159713745, + "objective": 0.4095553159713745, + "error": 0.193359375, + "gradient_norm": 0.09977155178785324, + "elapsed": 877.4712297916412 + }, + { + "step": 1328, + "loss": 0.2850862741470337, + "objective": 0.2850862741470337, + "error": 0.1240234375, + "gradient_norm": 0.05365074798464775, + "elapsed": 887.5133347511292 + }, + { + "step": 1344, + "loss": 0.41809165477752686, + "objective": 0.41809165477752686, + "error": 0.19140625, + "gradient_norm": 0.10622142255306244, + "elapsed": 895.0828025341034 + }, + { + "step": 1360, + "loss": 0.3627069890499115, + "objective": 0.3627069890499115, + "error": 0.1650390625, + "gradient_norm": 0.049557290971279144, + "elapsed": 906.2595431804657 + }, + { + "step": 1376, + "loss": 0.023341629654169083, + "objective": 0.023341629654169083, + "error": 0.0068359375, + "gradient_norm": 0.008970360271632671, + "elapsed": 916.6110022068024 + }, + { + "step": 1392, + "loss": 0.519214391708374, + "objective": 0.519214391708374, + "error": 0.26953125, + "gradient_norm": 0.052287619560956955, + "elapsed": 926.660523891449 + }, + { + "step": 1408, + "loss": 0.6152850389480591, + "objective": 0.6152850389480591, + "error": 0.3662109375, + "gradient_norm": 0.049617987126111984, + "elapsed": 936.7533056735992 + }, + { + "step": 1424, + "loss": 0.020841240882873535, + "objective": 0.020841240882873535, + "error": 0.0068359375, + "gradient_norm": 0.008459246717393398, + "elapsed": 946.8231542110443 + }, + { + "step": 1440, + "loss": 0.5963407754898071, + "objective": 0.5963407754898071, + "error": 0.3525390625, + "gradient_norm": 0.08714025467634201, + "elapsed": 956.0344398021698 + }, + { + "step": 1456, + "loss": 0.44305220246315, + "objective": 0.44305220246315, + "error": 0.2099609375, + "gradient_norm": 0.061915796250104904, + "elapsed": 967.506050825119 + }, + { + "step": 1472, + "loss": 0.5292993783950806, + "objective": 0.5292993783950806, + "error": 0.2939453125, + "gradient_norm": 0.10089804977178574, + "elapsed": 977.855934381485 + }, + { + "step": 1488, + "loss": 0.6087026596069336, + "objective": 0.6087026596069336, + "error": 0.345703125, + "gradient_norm": 0.05276322737336159, + "elapsed": 986.2705359458923 + }, + { + "step": 1504, + "loss": 0.3670162558555603, + "objective": 0.3670162558555603, + "error": 0.1796875, + "gradient_norm": 0.0575372576713562, + "elapsed": 995.2220902442932 + }, + { + "step": 1520, + "loss": 0.33479321002960205, + "objective": 0.33479321002960205, + "error": 0.1435546875, + "gradient_norm": 0.056317709386348724, + "elapsed": 1005.2168045043945 + }, + { + "step": 1536, + "loss": 0.5869293212890625, + "objective": 0.5869293212890625, + "error": 0.337890625, + "gradient_norm": 0.07419256865978241, + "elapsed": 1016.8691458702087 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "0f5926c94bb1aa83840c6d257757b80c081835affc2cb34bf9246ba18e00266a", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 467790, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/reserved2_full", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23212139423076927, + "0": 0.23353365384615382, + "blend-0": 0.23306790865384613, + "512": 0.23380408653846152, + "blend-512": 0.23366887019230773, + "1024": 0.23197115384615388, + "blend-1024": 0.23299278846153842, + "1536": 0.23206129807692305, + "blend-1536": 0.2329326923076923 + }, + "selected": "1024" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "0": 0.22103365384615387, + "blend-0": 0.2211388221153846, + "512": 0.22092848557692304, + "blend-512": 0.22094350961538464, + "1024": 0.2204326923076923, + "blend-1024": 0.22046274038461539, + "1536": 0.22086838942307688, + "blend-1536": 0.22059795673076926 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 428858, + "weights_sha256": "a346f535004381e2e0b628fac8ff7c58282a2447b9704638e46232dff46e511f", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit unused intermediate logical tracking; raw neural branches also omit the unused final physical readout.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "packaged_runtime_control_cpu": { + "device": "cpu", + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "same_cpu_old_vs_new_maximum_difference": 0.0, + "old_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "new_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "cpu_vs_reconstructed_old_gpu_runtime_maximum_difference": 4.976987838745117e-05, + "original_gpu_evaluation_vs_reconstructed_gpu_runtime_maximum_difference": 7.748603820800781e-07, + "initial_failed_control": { + "comparison": "CPU runtime against original GPU evaluator", + "observed_maximum_difference": 4.971027374267578e-05, + "original_tolerance": 3e-06 + }, + "sources": { + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee", + "d5_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b" + }, + "scope": "Same-device compatibility check. Reconstructed GPU runtime removes the recorded equal physical blend; that reconstruction has floating-point rounding uncertainty.", + "status": "passed_same_device_compatibility" + }, + "dispatcher_control_cpu": { + "status": "passed", + "device": "cpu", + "sources": { + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee" + }, + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + } + ], + "scope": "Routing and code-copy check against each direct model implementation, using training detector inputs without labels. Tiny trained temporal/history smoke weights test nonzero feature couplings; they are excluded from model selection and submission.", + "test_data_used": false + }, + "cpu_probability_precision": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "validation_syndromes": 7, + "logical_labels_used": false, + "parameter_updates": 0, + "reference": "Float64 neural forward and exact contraction from the same stored weights and fixed float32 input logits, on CPU", + "cpu_float32_vs_float64_maximum_difference": 7.624897924163321e-08, + "cpu_float32_edges_float64_contraction_vs_float64_maximum_difference": 4.725248914372315e-08, + "gpu_float32_vs_float64_maximum_difference": 4.964999121059854e-05, + "cpu_vs_gpu_float32_maximum_difference": 4.971027374267578e-05, + "maximum_neural_edge_probability_difference": 2.6330936014895556e-08, + "float32_edge_values_above_one_minus_1e6": 0, + "scope": "Precision diagnostic only; the published model is unchanged. Same-device old/new packaged-code compatibility was independently exact." + }, + "priors_only_control_cpu": { + "status": "passed", + "device": "cpu", + "source_sha256": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 2.7116777896881104, + "priors_only_seconds_warm": 0.13569164276123047 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 3.557781457901001, + "priors_only_seconds_warm": 1.7711329460144043 + } + ], + "scope": "CPU numerical equivalence on supplied training syndromes; timings are not a controlled speed comparison." + } + } + }, + "reserved_data_mixture": { + "gate_training": { + "initialization": "Normal(0,.001) gate weights from independent NumPy seeds20261280(X),20261281(Z); feature center/scale fit only on gate rows", + "training": "Exactly512 reserved training-label rows per condition,6656 per basis,13312 total; both neural experts excluded these and the separate audit rows", + "training_expert_choices": [ + { + "expert": "reserved1", + "basis": "X", + "step": 1536, + "run": "reserved1_full", + "candidate_failures": { + "0": 0.2337439903846154, + "512": 0.23284254807692306, + "1024": 0.23356370192307693, + "1536": 0.23218149038461539 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved1_full-1536", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved1-X-1536" + }, + { + "expert": "reserved1", + "basis": "Z", + "step": 0, + "run": "reserved1_full", + "candidate_failures": { + "0": 0.2206580528846154, + "512": 0.22100360576923078, + "1024": 0.22104867788461538, + "1536": 0.22264122596153849 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved1_full/weights-0.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved1_full-0", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved1-Z-0" + }, + { + "expert": "reserved2", + "basis": "X", + "step": 1024, + "run": "reserved2_full", + "candidate_failures": { + "0": 0.23353365384615385, + "512": 0.23380408653846152, + "1024": 0.23197115384615388, + "1536": 0.23206129807692305 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved2_full/weights-1024.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved2_full-1024", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved2-X-1024" + }, + { + "expert": "reserved2", + "basis": "Z", + "step": 1024, + "run": "reserved2_full", + "candidate_failures": { + "0": 0.22103365384615387, + "512": 0.22092848557692304, + "1024": 0.2204326923076923, + "1536": 0.22086838942307688 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved2_full/weights-1024.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved2_full-1024", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved2-Z-1024" + } + ], + "partition": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + }, + "loss": "Mean conditional logical BCE of the three-way mixture plus .5*lambda*sum(scaled weights squared); bias penalty multiplier .01; expert probabilities clipped to[1e-7,1-1e-7] inside fitting objective only", + "optimization": "Independent full-batch scipy L-BFGS-B fits per basis/lambda from the same declared random initialization; expert parameters frozen", + "runtime": "Pure NumPy gate with49 syndrome/confidence features and100 learned logit weights; third expert is raw physical pass3", + "feature_names": [ + "site_density_0", + "site_density_1", + "site_density_2", + "site_density_3", + "site_density_4", + "site_density_5", + "site_density_6", + "site_density_7", + "site_density_8", + "site_density_9", + "site_density_10", + "site_density_11", + "site_density_12", + "site_density_13", + "site_density_14", + "site_density_15", + "site_density_16", + "site_density_17", + "site_density_18", + "site_density_19", + "site_density_20", + "site_density_21", + "site_density_22", + "site_density_23", + "lag_1_coincidence", + "lag_1_covariance", + "lag_2_coincidence", + "lag_2_covariance", + "lag_4_coincidence", + "lag_4_covariance", + "lag_8_coincidence", + "lag_8_covariance", + "density_mean", + "density_std", + "density_max", + "frame_std", + "frame_max", + "half_change", + "round_fraction", + "round_fraction_squared", + "confidence_0", + "confidence_1", + "confidence_2", + "difference_0_1", + "difference_0_2", + "difference_1_2", + "disagreement_0_1", + "disagreement_0_2", + "disagreement_1_2" + ], + "declared_plan": { + "experts": [ + "reserved1 selected raw checkpoint", + "reserved2 selected raw checkpoint", + "fixed raw physical pass3" + ], + "gate": "Per-basis linear two-logit softmax gate with physical reference logit0;49 syndrome/confidence features; normalized on gate rows only; no IDs or shot positions", + "regularization": [ + 0.0001, + 0.001, + 0.01 + ], + "initial_seeds": { + "X": 20261280, + "Z": 20261281 + }, + "optimizer": "Independent L-BFGS-B from randomNormal(0,.001) weights per basis, shared initial weights acrosslambda values;500iterations max,gtol1e-8,ftol1e-12", + "selection": "Minimum full-validation mean failure per basis among incumbent,equal-neural-two,equal-all-three,three regularization fits. All13durations; retainincumbentties", + "diagnostic": "Freeze selection before calculating any independent audit-label metrics; diagnostic rows never fit/select parameters,checkpoints orhyperparameters", + "source_sha256": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1", + "test_data_used": false + }, + "fits": [ + { + "basis": "X", + "key": "lambda-0.0001", + "initial_seed": 20261280, + "regularization": 0.0001, + "initial_state_sha256": "878291ff26617c774c101f5ba4065c012d69681e75bc62c55bfce9944af827c0", + "optimization_iterations": 120, + "objective": 0.4248998654410383, + "gradient_max_abs": 5.001357802025369e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "5f3e5ce0b61e92dd9c1bb59c6c71b2c7dad4a12052c091e5eba1a69ed75b8d21", + "training_metrics": { + "failure": 0.232421875, + "negative_log_likelihood": 0.42348933238384107 + } + }, + { + "basis": "X", + "key": "lambda-0.001", + "initial_seed": 20261280, + "regularization": 0.001, + "initial_state_sha256": "878291ff26617c774c101f5ba4065c012d69681e75bc62c55bfce9944af827c0", + "optimization_iterations": 37, + "objective": 0.42758078400573485, + "gradient_max_abs": 2.996975726990283e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "2c9122e8724571db4c82f6038cb3ad6a8ec78374e29dc1da168e8622f8992655", + "training_metrics": { + "failure": 0.23302283653846154, + "negative_log_likelihood": 0.42682438653490845 + } + }, + { + "basis": "X", + "key": "lambda-0.01", + "initial_seed": 20261280, + "regularization": 0.01, + "initial_state_sha256": "878291ff26617c774c101f5ba4065c012d69681e75bc62c55bfce9944af827c0", + "optimization_iterations": 17, + "objective": 0.4285813488382606, + "gradient_max_abs": 5.950265786385314e-09, + "message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "weights_sha256": "6e3372b4091e0a444a05e9ae07da7cbe931658d4df2962f6de4a171d20a0fa0c", + "training_metrics": { + "failure": 0.23542668269230768, + "negative_log_likelihood": 0.4283422091344372 + } + }, + { + "basis": "Z", + "key": "lambda-0.0001", + "initial_seed": 20261281, + "regularization": 0.0001, + "initial_state_sha256": "97aa4b4f38041e478074e113efc62f5bd4e247064c794816fc3a91b303ba620c", + "optimization_iterations": 150, + "objective": 0.4103952219601839, + "gradient_max_abs": 2.1201928863013187e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "90110b89e17f546d4466b09fe4ed59fcfb670abad33ce56c81ecc91af091e5c9", + "training_metrics": { + "failure": 0.21198918269230768, + "negative_log_likelihood": 0.4090808023552111 + } + }, + { + "basis": "Z", + "key": "lambda-0.001", + "initial_seed": 20261281, + "regularization": 0.001, + "initial_state_sha256": "97aa4b4f38041e478074e113efc62f5bd4e247064c794816fc3a91b303ba620c", + "optimization_iterations": 32, + "objective": 0.41281385633709833, + "gradient_max_abs": 3.589896600174553e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "ea1ec9ac44d9f54f4db84f7aacebb4b1084b02e40cd0a3e1e1710b9083f95d5a", + "training_metrics": { + "failure": 0.21484375, + "negative_log_likelihood": 0.41208742770455026 + } + }, + { + "basis": "Z", + "key": "lambda-0.01", + "initial_seed": 20261281, + "regularization": 0.01, + "initial_state_sha256": "97aa4b4f38041e478074e113efc62f5bd4e247064c794816fc3a91b303ba620c", + "optimization_iterations": 20, + "objective": 0.4138027840487606, + "gradient_max_abs": 2.384420584767991e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "b3bdafcb3e4e0ee663a6dc1512d6d0fe7a407f3d1cc0548fb06b7a3eb06463fb", + "training_metrics": { + "failure": 0.2166466346153846, + "negative_log_likelihood": 0.41358458556572203 + } + } + ], + "numerical_control": { + "status": "passed", + "finite_difference_max_error": 1.8119141603767375e-11, + "independent_autodiff_max_error": 5.551115123125783e-17, + "feature_and_prediction_permutation_subset_complement_checks": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "features": 49, + "rows": 11 + } + ], + "source_sha256": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1", + "labels_used": "Synthetic control labels only", + "test_data_used": false + }, + "reporting_control": { + "status": "passed", + "reason": "Unsigned labels converted to float before unary negation in diagnostic BCE", + "cases": [ + { + "source": "fit_reserved_gate.py", + "actual": { + "failure": 0.0, + "negative_log_likelihood": 0.16425202686327978 + }, + "expected_nll": 0.16425202686327978 + }, + { + "source": "audit_reserved_gate.py", + "actual": { + "failure": 0.0, + "negative_log_likelihood": 0.16425202686327978 + }, + "expected_nll": 0.16425202686327978 + } + ], + "test_data_used": false + }, + "selection": "Full supplied validation condition-mean failure per basis over incumbent,equal-two,equal-three,and the three declared regularization settings; ties retain incumbent", + "selection_history": [ + { + "basis": "X", + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23186598557692306, + "equal-two": 0.23185096153846155, + "equal-three": 0.23294771634615388, + "lambda-0.0001": 0.23278245192307698, + "lambda-0.001": 0.23230168269230772, + "lambda-0.01": 0.23240685096153849 + }, + "selected": "equal-two", + "selected_new_candidate_for_audit": "equal-two" + }, + { + "basis": "Z", + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "equal-two": 0.2203425480769231, + "equal-three": 0.22109374999999998, + "lambda-0.0001": 0.22137920673076922, + "lambda-0.001": 0.22077824519230765, + "lambda-0.01": 0.2204176682692308 + }, + "selected": "incumbent", + "selected_new_candidate_for_audit": "equal-two" + } + ], + "audit_labels_used": false, + "test_data_used": false, + "sources": { + "fit_reserved_gate.py": "f278d14aff60cb77c8a4de21523d9e71a7b84399122c865d27f7ddd415272086", + "reserved_gate.py": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1" + }, + "training_runtime_versions": { + "numpy": "2.3.3", + "scipy": "1.16.2" + }, + "seconds": 5.548679351806641 + }, + "selected_expert_training": { + "reserved1_full": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 466919, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved1_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved1_warm/weights-512.npz", + "starting_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317613, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261272", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.1412775069475174, + "objective": 0.1412775069475174, + "error": 0.0595703125, + "gradient_norm": 0.030735325068235397, + "elapsed": 28.457472801208496 + }, + { + "step": 16, + "loss": 0.6315727233886719, + "objective": 0.6315727233886719, + "error": 0.384765625, + "gradient_norm": 0.06563512235879898, + "elapsed": 47.886730670928955 + }, + { + "step": 32, + "loss": 0.5130410194396973, + "objective": 0.5130410194396973, + "error": 0.263671875, + "gradient_norm": 0.10626910626888275, + "elapsed": 60.16136598587036 + }, + { + "step": 48, + "loss": 0.6413166522979736, + "objective": 0.6413166522979736, + "error": 0.408203125, + "gradient_norm": 0.03790846839547157, + "elapsed": 70.9611382484436 + }, + { + "step": 64, + "loss": 0.5491592884063721, + "objective": 0.5491592884063721, + "error": 0.2939453125, + "gradient_norm": 0.093081034719944, + "elapsed": 81.46673464775085 + }, + { + "step": 80, + "loss": 0.6315242648124695, + "objective": 0.6315242648124695, + "error": 0.359375, + "gradient_norm": 0.0384257510304451, + "elapsed": 91.71172666549683 + }, + { + "step": 96, + "loss": 0.6311566829681396, + "objective": 0.6311566829681396, + "error": 0.3798828125, + "gradient_norm": 0.03731638938188553, + "elapsed": 100.83252763748169 + }, + { + "step": 112, + "loss": 0.5327925682067871, + "objective": 0.5327925682067871, + "error": 0.29296875, + "gradient_norm": 0.11202990263700485, + "elapsed": 111.35073852539062 + }, + { + "step": 128, + "loss": 0.6284654140472412, + "objective": 0.6284654140472412, + "error": 0.3740234375, + "gradient_norm": 0.03215613588690758, + "elapsed": 121.32994651794434 + }, + { + "step": 144, + "loss": 0.33964547514915466, + "objective": 0.33964547514915466, + "error": 0.1259765625, + "gradient_norm": 0.05133189633488655, + "elapsed": 131.2744882106781 + }, + { + "step": 160, + "loss": 0.14193454384803772, + "objective": 0.14193454384803772, + "error": 0.0478515625, + "gradient_norm": 0.03264402225613594, + "elapsed": 139.58473920822144 + }, + { + "step": 176, + "loss": 0.14203950762748718, + "objective": 0.14203950762748718, + "error": 0.0654296875, + "gradient_norm": 0.022548990324139595, + "elapsed": 148.9861602783203 + }, + { + "step": 192, + "loss": 0.6307225227355957, + "objective": 0.6307225227355957, + "error": 0.3955078125, + "gradient_norm": 0.08607082068920135, + "elapsed": 162.27514505386353 + }, + { + "step": 208, + "loss": 0.16193106770515442, + "objective": 0.16193106770515442, + "error": 0.064453125, + "gradient_norm": 0.023293493315577507, + "elapsed": 173.59824013710022 + }, + { + "step": 224, + "loss": 0.5426318049430847, + "objective": 0.5426318049430847, + "error": 0.3037109375, + "gradient_norm": 0.03944721072912216, + "elapsed": 182.70232272148132 + }, + { + "step": 240, + "loss": 0.6270365715026855, + "objective": 0.6270365715026855, + "error": 0.3896484375, + "gradient_norm": 0.14661568403244019, + "elapsed": 193.759183883667 + }, + { + "step": 256, + "loss": 0.4933152198791504, + "objective": 0.4933152198791504, + "error": 0.2724609375, + "gradient_norm": 0.1065438985824585, + "elapsed": 205.62959718704224 + }, + { + "step": 272, + "loss": 0.3671969473361969, + "objective": 0.3671969473361969, + "error": 0.177734375, + "gradient_norm": 0.05156548321247101, + "elapsed": 222.249596118927 + }, + { + "step": 288, + "loss": 0.5478869676589966, + "objective": 0.5478869676589966, + "error": 0.3203125, + "gradient_norm": 0.08357688039541245, + "elapsed": 232.2198715209961 + }, + { + "step": 304, + "loss": 0.21171918511390686, + "objective": 0.21171918511390686, + "error": 0.0849609375, + "gradient_norm": 0.06231697276234627, + "elapsed": 241.07631373405457 + }, + { + "step": 320, + "loss": 0.5333335995674133, + "objective": 0.5333335995674133, + "error": 0.2861328125, + "gradient_norm": 0.08931853622198105, + "elapsed": 251.28962755203247 + }, + { + "step": 336, + "loss": 0.12485946714878082, + "objective": 0.12485946714878082, + "error": 0.046875, + "gradient_norm": 0.018839582800865173, + "elapsed": 262.3605041503906 + }, + { + "step": 352, + "loss": 0.2334863245487213, + "objective": 0.2334863245487213, + "error": 0.09765625, + "gradient_norm": 0.03669576346874237, + "elapsed": 273.16373229026794 + }, + { + "step": 368, + "loss": 0.5818328857421875, + "objective": 0.5818328857421875, + "error": 0.3232421875, + "gradient_norm": 0.09833699464797974, + "elapsed": 282.8677294254303 + }, + { + "step": 384, + "loss": 0.6228232383728027, + "objective": 0.6228232383728027, + "error": 0.3671875, + "gradient_norm": 0.033418990671634674, + "elapsed": 295.04902839660645 + }, + { + "step": 400, + "loss": 0.5749450922012329, + "objective": 0.5749450922012329, + "error": 0.333984375, + "gradient_norm": 0.04644288495182991, + "elapsed": 306.67032837867737 + }, + { + "step": 416, + "loss": 0.46251457929611206, + "objective": 0.46251457929611206, + "error": 0.2216796875, + "gradient_norm": 0.06633804738521576, + "elapsed": 317.759464263916 + }, + { + "step": 432, + "loss": 0.5577508211135864, + "objective": 0.5577508211135864, + "error": 0.30859375, + "gradient_norm": 0.0970199704170227, + "elapsed": 327.4626543521881 + }, + { + "step": 448, + "loss": 0.11625733226537704, + "objective": 0.11625733226537704, + "error": 0.0419921875, + "gradient_norm": 0.020417485386133194, + "elapsed": 336.3522970676422 + }, + { + "step": 464, + "loss": 0.23657961189746857, + "objective": 0.23657961189746857, + "error": 0.1025390625, + "gradient_norm": 0.03908605873584747, + "elapsed": 344.3832321166992 + }, + { + "step": 480, + "loss": 0.011504358612000942, + "objective": 0.011504358612000942, + "error": 0.00390625, + "gradient_norm": 0.006708688102662563, + "elapsed": 355.18855381011963 + }, + { + "step": 496, + "loss": 0.3410624563694, + "objective": 0.3410624563694, + "error": 0.1533203125, + "gradient_norm": 0.05804387852549553, + "elapsed": 366.2978138923645 + }, + { + "step": 512, + "loss": 0.034005306661129, + "objective": 0.034005306661129, + "error": 0.0107421875, + "gradient_norm": 0.01019973959773779, + "elapsed": 375.73491764068604 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "b31e8f5ee2b5ea1b661e6bf8b5649bec45b7ab5da74fe9de46e4d06846356b87", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317613, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5523660182952881, + "objective": 0.5523660182952881, + "error": 0.30859375, + "gradient_norm": 0.05200070142745972, + "elapsed": 30.08410096168518 + }, + { + "step": 16, + "loss": 0.5380295515060425, + "objective": 0.5380295515060425, + "error": 0.306640625, + "gradient_norm": 0.0804876759648323, + "elapsed": 50.77648210525513 + }, + { + "step": 32, + "loss": 0.6359301805496216, + "objective": 0.6359301805496216, + "error": 0.3837890625, + "gradient_norm": 0.059380218386650085, + "elapsed": 59.453776836395264 + }, + { + "step": 48, + "loss": 0.2540435492992401, + "objective": 0.2540435492992401, + "error": 0.1083984375, + "gradient_norm": 0.04367281496524811, + "elapsed": 67.29314041137695 + }, + { + "step": 64, + "loss": 0.5867692232131958, + "objective": 0.5867692232131958, + "error": 0.3447265625, + "gradient_norm": 0.053885214030742645, + "elapsed": 78.74847197532654 + }, + { + "step": 80, + "loss": 0.6015321016311646, + "objective": 0.6015321016311646, + "error": 0.365234375, + "gradient_norm": 0.04807985574007034, + "elapsed": 90.48145818710327 + }, + { + "step": 96, + "loss": 0.49287766218185425, + "objective": 0.49287766218185425, + "error": 0.271484375, + "gradient_norm": 0.07899080961942673, + "elapsed": 101.65468978881836 + }, + { + "step": 112, + "loss": 0.3271353542804718, + "objective": 0.3271353542804718, + "error": 0.15234375, + "gradient_norm": 0.049542222172021866, + "elapsed": 111.14713263511658 + }, + { + "step": 128, + "loss": 0.50013667345047, + "objective": 0.50013667345047, + "error": 0.271484375, + "gradient_norm": 0.06454745680093765, + "elapsed": 121.21207547187805 + }, + { + "step": 144, + "loss": 0.028576843440532684, + "objective": 0.028576843440532684, + "error": 0.0087890625, + "gradient_norm": 0.010781333781778812, + "elapsed": 130.69302248954773 + }, + { + "step": 160, + "loss": 0.5668779015541077, + "objective": 0.5668779015541077, + "error": 0.330078125, + "gradient_norm": 0.06098390743136406, + "elapsed": 142.14290237426758 + }, + { + "step": 176, + "loss": 0.3986494839191437, + "objective": 0.3986494839191437, + "error": 0.1884765625, + "gradient_norm": 0.042795032262802124, + "elapsed": 152.75753688812256 + }, + { + "step": 192, + "loss": 0.31897079944610596, + "objective": 0.31897079944610596, + "error": 0.142578125, + "gradient_norm": 0.040675707161426544, + "elapsed": 160.04981398582458 + }, + { + "step": 208, + "loss": 0.5092275142669678, + "objective": 0.5092275142669678, + "error": 0.255859375, + "gradient_norm": 0.07929783314466476, + "elapsed": 169.85345673561096 + }, + { + "step": 224, + "loss": 0.35782667994499207, + "objective": 0.35782667994499207, + "error": 0.1748046875, + "gradient_norm": 0.05785144120454788, + "elapsed": 179.90323066711426 + }, + { + "step": 240, + "loss": 0.5660895109176636, + "objective": 0.5660895109176636, + "error": 0.3349609375, + "gradient_norm": 0.10684454441070557, + "elapsed": 191.3668942451477 + }, + { + "step": 256, + "loss": 0.6265910863876343, + "objective": 0.6265910863876343, + "error": 0.3779296875, + "gradient_norm": 0.034383758902549744, + "elapsed": 200.3055775165558 + }, + { + "step": 272, + "loss": 0.6210677623748779, + "objective": 0.6210677623748779, + "error": 0.369140625, + "gradient_norm": 0.04434216767549515, + "elapsed": 210.09376430511475 + }, + { + "step": 288, + "loss": 0.4892377257347107, + "objective": 0.4892377257347107, + "error": 0.2490234375, + "gradient_norm": 0.1040654331445694, + "elapsed": 220.45881819725037 + }, + { + "step": 304, + "loss": 0.6407739520072937, + "objective": 0.6407739520072937, + "error": 0.3916015625, + "gradient_norm": 0.07782924920320511, + "elapsed": 233.3719048500061 + }, + { + "step": 320, + "loss": 0.4752756953239441, + "objective": 0.4752756953239441, + "error": 0.263671875, + "gradient_norm": 0.051829319447278976, + "elapsed": 244.25844407081604 + }, + { + "step": 336, + "loss": 0.6482080221176147, + "objective": 0.6482080221176147, + "error": 0.41015625, + "gradient_norm": 0.04979892820119858, + "elapsed": 253.1897099018097 + }, + { + "step": 352, + "loss": 0.34022292494773865, + "objective": 0.34022292494773865, + "error": 0.1708984375, + "gradient_norm": 0.09951864182949066, + "elapsed": 264.0781395435333 + }, + { + "step": 368, + "loss": 0.3494992256164551, + "objective": 0.3494992256164551, + "error": 0.15625, + "gradient_norm": 0.10392706841230392, + "elapsed": 275.8111581802368 + }, + { + "step": 384, + "loss": 0.47191378474235535, + "objective": 0.47191378474235535, + "error": 0.25, + "gradient_norm": 0.07366786152124405, + "elapsed": 283.9459602832794 + }, + { + "step": 400, + "loss": 0.583655595779419, + "objective": 0.583655595779419, + "error": 0.3623046875, + "gradient_norm": 0.10394527018070221, + "elapsed": 294.3349726200104 + }, + { + "step": 416, + "loss": 0.6212975978851318, + "objective": 0.6212975978851318, + "error": 0.37109375, + "gradient_norm": 0.054796766489744186, + "elapsed": 304.7477548122406 + }, + { + "step": 432, + "loss": 0.4719577431678772, + "objective": 0.4719577431678772, + "error": 0.2431640625, + "gradient_norm": 0.05418012663722038, + "elapsed": 315.91914200782776 + }, + { + "step": 448, + "loss": 0.5696494579315186, + "objective": 0.5696494579315186, + "error": 0.3330078125, + "gradient_norm": 0.047046076506376266, + "elapsed": 324.96326184272766 + }, + { + "step": 464, + "loss": 0.613875687122345, + "objective": 0.613875687122345, + "error": 0.34765625, + "gradient_norm": 0.05237002298235893, + "elapsed": 334.7670781612396 + }, + { + "step": 480, + "loss": 0.28741705417633057, + "objective": 0.28741705417633057, + "error": 0.1240234375, + "gradient_norm": 0.05365394428372383, + "elapsed": 344.03080439567566 + }, + { + "step": 496, + "loss": 0.3729455769062042, + "objective": 0.3729455769062042, + "error": 0.1875, + "gradient_norm": 0.05905403569340706, + "elapsed": 356.01581716537476 + }, + { + "step": 512, + "loss": 0.38685142993927, + "objective": 0.38685142993927, + "error": 0.17578125, + "gradient_norm": 0.048455506563186646, + "elapsed": 367.7296392917633 + }, + { + "step": 528, + "loss": 0.6062720417976379, + "objective": 0.6062720417976379, + "error": 0.369140625, + "gradient_norm": 0.07544548809528351, + "elapsed": 385.4480962753296 + }, + { + "step": 544, + "loss": 0.520085871219635, + "objective": 0.520085871219635, + "error": 0.279296875, + "gradient_norm": 0.08394371718168259, + "elapsed": 397.71993708610535 + }, + { + "step": 560, + "loss": 0.5944540500640869, + "objective": 0.5944540500640869, + "error": 0.3544921875, + "gradient_norm": 0.05468091368675232, + "elapsed": 406.9417428970337 + }, + { + "step": 576, + "loss": 0.34102559089660645, + "objective": 0.34102559089660645, + "error": 0.1611328125, + "gradient_norm": 0.07333917915821075, + "elapsed": 417.0068130493164 + }, + { + "step": 592, + "loss": 0.47373664379119873, + "objective": 0.47373664379119873, + "error": 0.2412109375, + "gradient_norm": 0.05662858858704567, + "elapsed": 425.1176447868347 + }, + { + "step": 608, + "loss": 0.48517894744873047, + "objective": 0.48517894744873047, + "error": 0.25, + "gradient_norm": 0.08127480745315552, + "elapsed": 434.92080903053284 + }, + { + "step": 624, + "loss": 0.39865612983703613, + "objective": 0.39865612983703613, + "error": 0.1904296875, + "gradient_norm": 0.07332058995962143, + "elapsed": 446.6602101325989 + }, + { + "step": 640, + "loss": 0.41867297887802124, + "objective": 0.41867297887802124, + "error": 0.2177734375, + "gradient_norm": 0.07386308163404465, + "elapsed": 457.0243580341339 + }, + { + "step": 656, + "loss": 0.5108687877655029, + "objective": 0.5108687877655029, + "error": 0.2822265625, + "gradient_norm": 0.052080318331718445, + "elapsed": 469.5842761993408 + }, + { + "step": 672, + "loss": 0.5043742656707764, + "objective": 0.5043742656707764, + "error": 0.2734375, + "gradient_norm": 0.047204963862895966, + "elapsed": 479.356397151947 + }, + { + "step": 688, + "loss": 0.5550935864448547, + "objective": 0.5550935864448547, + "error": 0.30078125, + "gradient_norm": 0.04080262407660484, + "elapsed": 489.9912152290344 + }, + { + "step": 704, + "loss": 0.5698974132537842, + "objective": 0.5698974132537842, + "error": 0.322265625, + "gradient_norm": 0.10692963004112244, + "elapsed": 500.3283371925354 + }, + { + "step": 720, + "loss": 0.45870622992515564, + "objective": 0.45870622992515564, + "error": 0.2255859375, + "gradient_norm": 0.06705734878778458, + "elapsed": 509.82279753685 + }, + { + "step": 736, + "loss": 0.555386483669281, + "objective": 0.555386483669281, + "error": 0.31640625, + "gradient_norm": 0.05112688988447189, + "elapsed": 518.507036447525 + }, + { + "step": 752, + "loss": 0.14282986521720886, + "objective": 0.14282986521720886, + "error": 0.056640625, + "gradient_norm": 0.03209136053919792, + "elapsed": 529.1373023986816 + }, + { + "step": 768, + "loss": 0.5362129807472229, + "objective": 0.5362129807472229, + "error": 0.2841796875, + "gradient_norm": 0.049996186047792435, + "elapsed": 538.9186007976532 + }, + { + "step": 784, + "loss": 0.5071826577186584, + "objective": 0.5071826577186584, + "error": 0.2744140625, + "gradient_norm": 0.04826078191399574, + "elapsed": 549.5225830078125 + }, + { + "step": 800, + "loss": 0.24775367975234985, + "objective": 0.24775367975234985, + "error": 0.107421875, + "gradient_norm": 0.06889795511960983, + "elapsed": 560.7170543670654 + }, + { + "step": 816, + "loss": 0.17432856559753418, + "objective": 0.17432856559753418, + "error": 0.06640625, + "gradient_norm": 0.05147368833422661, + "elapsed": 570.7887880802155 + }, + { + "step": 832, + "loss": 0.5410823822021484, + "objective": 0.5410823822021484, + "error": 0.3115234375, + "gradient_norm": 0.11862928420305252, + "elapsed": 581.9721121788025 + }, + { + "step": 848, + "loss": 0.5555508732795715, + "objective": 0.5555508732795715, + "error": 0.296875, + "gradient_norm": 0.060369592159986496, + "elapsed": 592.2823219299316 + }, + { + "step": 864, + "loss": 0.31839215755462646, + "objective": 0.31839215755462646, + "error": 0.1552734375, + "gradient_norm": 0.063877172768116, + "elapsed": 603.1910541057587 + }, + { + "step": 880, + "loss": 0.481766939163208, + "objective": 0.481766939163208, + "error": 0.2470703125, + "gradient_norm": 0.1623816341161728, + "elapsed": 614.4277107715607 + }, + { + "step": 896, + "loss": 0.5780366659164429, + "objective": 0.5780366659164429, + "error": 0.3037109375, + "gradient_norm": 0.06694691628217697, + "elapsed": 623.9365792274475 + }, + { + "step": 912, + "loss": 0.4794909358024597, + "objective": 0.4794909358024597, + "error": 0.2314453125, + "gradient_norm": 0.07813122123479843, + "elapsed": 633.9845306873322 + }, + { + "step": 928, + "loss": 0.6279138922691345, + "objective": 0.6279138922691345, + "error": 0.380859375, + "gradient_norm": 0.047679927200078964, + "elapsed": 643.7766675949097 + }, + { + "step": 944, + "loss": 0.6401606798171997, + "objective": 0.6401606798171997, + "error": 0.3994140625, + "gradient_norm": 0.07329051941633224, + "elapsed": 655.2369928359985 + }, + { + "step": 960, + "loss": 0.4340277910232544, + "objective": 0.4340277910232544, + "error": 0.2158203125, + "gradient_norm": 0.11762503534555435, + "elapsed": 666.9884371757507 + }, + { + "step": 976, + "loss": 0.44496864080429077, + "objective": 0.44496864080429077, + "error": 0.2236328125, + "gradient_norm": 0.05260347202420235, + "elapsed": 677.3464586734772 + }, + { + "step": 992, + "loss": 0.13230293989181519, + "objective": 0.13230293989181519, + "error": 0.05078125, + "gradient_norm": 0.030240925028920174, + "elapsed": 685.7275724411011 + }, + { + "step": 1008, + "loss": 0.2971688508987427, + "objective": 0.2971688508987427, + "error": 0.1171875, + "gradient_norm": 0.05503479763865471, + "elapsed": 694.1270356178284 + }, + { + "step": 1024, + "loss": 0.5688735246658325, + "objective": 0.5688735246658325, + "error": 0.314453125, + "gradient_norm": 0.06526188552379608, + "elapsed": 703.9192817211151 + }, + { + "step": 1040, + "loss": 0.42805811762809753, + "objective": 0.42805811762809753, + "error": 0.2080078125, + "gradient_norm": 0.13000032305717468, + "elapsed": 720.145961523056 + }, + { + "step": 1056, + "loss": 0.5543602705001831, + "objective": 0.5543602705001831, + "error": 0.298828125, + "gradient_norm": 0.15922385454177856, + "elapsed": 733.5112845897675 + }, + { + "step": 1072, + "loss": 0.031130114570260048, + "objective": 0.031130114570260048, + "error": 0.013671875, + "gradient_norm": 0.008926023729145527, + "elapsed": 742.4467866420746 + }, + { + "step": 1088, + "loss": 0.14947748184204102, + "objective": 0.14947748184204102, + "error": 0.056640625, + "gradient_norm": 0.03975249081850052, + "elapsed": 751.8575854301453 + }, + { + "step": 1104, + "loss": 0.6275734901428223, + "objective": 0.6275734901428223, + "error": 0.3671875, + "gradient_norm": 0.08096148073673248, + "elapsed": 761.5625903606415 + }, + { + "step": 1120, + "loss": 0.23923414945602417, + "objective": 0.23923414945602417, + "error": 0.0966796875, + "gradient_norm": 0.03325376287102699, + "elapsed": 773.9633615016937 + }, + { + "step": 1136, + "loss": 0.570243239402771, + "objective": 0.570243239402771, + "error": 0.31640625, + "gradient_norm": 0.07534287869930267, + "elapsed": 783.1533136367798 + }, + { + "step": 1152, + "loss": 0.4264270067214966, + "objective": 0.4264270067214966, + "error": 0.2119140625, + "gradient_norm": 0.08900073170661926, + "elapsed": 792.1710996627808 + }, + { + "step": 1168, + "loss": 0.5958121418952942, + "objective": 0.5958121418952942, + "error": 0.3583984375, + "gradient_norm": 0.08239343762397766, + "elapsed": 803.1175289154053 + }, + { + "step": 1184, + "loss": 0.2909137010574341, + "objective": 0.2909137010574341, + "error": 0.1416015625, + "gradient_norm": 0.05281354859471321, + "elapsed": 812.6055159568787 + }, + { + "step": 1200, + "loss": 0.6119058728218079, + "objective": 0.6119058728218079, + "error": 0.36328125, + "gradient_norm": 0.056254416704177856, + "elapsed": 823.2276427745819 + }, + { + "step": 1216, + "loss": 0.13595536351203918, + "objective": 0.13595536351203918, + "error": 0.0556640625, + "gradient_norm": 0.04057573154568672, + "elapsed": 834.1696293354034 + }, + { + "step": 1232, + "loss": 0.5840731263160706, + "objective": 0.5840731263160706, + "error": 0.328125, + "gradient_norm": 0.054566267877817154, + "elapsed": 845.3501887321472 + }, + { + "step": 1248, + "loss": 0.3053072690963745, + "objective": 0.3053072690963745, + "error": 0.1337890625, + "gradient_norm": 0.04617297649383545, + "elapsed": 854.9564871788025 + }, + { + "step": 1264, + "loss": 0.6288673281669617, + "objective": 0.6288673281669617, + "error": 0.3994140625, + "gradient_norm": 0.08229745179414749, + "elapsed": 864.8914043903351 + }, + { + "step": 1280, + "loss": 0.5586361289024353, + "objective": 0.5586361289024353, + "error": 0.2958984375, + "gradient_norm": 0.05713959410786629, + "elapsed": 877.0349607467651 + }, + { + "step": 1296, + "loss": 0.3648858666419983, + "objective": 0.3648858666419983, + "error": 0.16796875, + "gradient_norm": 0.08502963185310364, + "elapsed": 888.5764675140381 + }, + { + "step": 1312, + "loss": 0.4747084081172943, + "objective": 0.4747084081172943, + "error": 0.244140625, + "gradient_norm": 0.08609883487224579, + "elapsed": 899.7598609924316 + }, + { + "step": 1328, + "loss": 0.15583917498588562, + "objective": 0.15583917498588562, + "error": 0.05859375, + "gradient_norm": 0.027793049812316895, + "elapsed": 909.47514295578 + }, + { + "step": 1344, + "loss": 0.47515708208084106, + "objective": 0.47515708208084106, + "error": 0.263671875, + "gradient_norm": 0.07668807357549667, + "elapsed": 919.7640328407288 + }, + { + "step": 1360, + "loss": 0.5173689126968384, + "objective": 0.5173689126968384, + "error": 0.2744140625, + "gradient_norm": 0.05054212734103203, + "elapsed": 930.6309463977814 + }, + { + "step": 1376, + "loss": 0.46629998087882996, + "objective": 0.46629998087882996, + "error": 0.24609375, + "gradient_norm": 0.051172077655792236, + "elapsed": 939.0202586650848 + }, + { + "step": 1392, + "loss": 0.11312969774007797, + "objective": 0.11312969774007797, + "error": 0.044921875, + "gradient_norm": 0.05863805115222931, + "elapsed": 949.1451416015625 + }, + { + "step": 1408, + "loss": 0.5750841498374939, + "objective": 0.5750841498374939, + "error": 0.322265625, + "gradient_norm": 0.051106806844472885, + "elapsed": 959.94162940979 + }, + { + "step": 1424, + "loss": 0.5937192440032959, + "objective": 0.5937192440032959, + "error": 0.3408203125, + "gradient_norm": 0.05014815554022789, + "elapsed": 969.5868306159973 + }, + { + "step": 1440, + "loss": 0.5292985439300537, + "objective": 0.5292985439300537, + "error": 0.2958984375, + "gradient_norm": 0.057068243622779846, + "elapsed": 982.6692054271698 + }, + { + "step": 1456, + "loss": 0.5959951877593994, + "objective": 0.5959951877593994, + "error": 0.3408203125, + "gradient_norm": 0.0703694075345993, + "elapsed": 995.0066986083984 + }, + { + "step": 1472, + "loss": 0.018453411757946014, + "objective": 0.018453411757946014, + "error": 0.00390625, + "gradient_norm": 0.012016087770462036, + "elapsed": 1004.0057821273804 + }, + { + "step": 1488, + "loss": 0.5711684823036194, + "objective": 0.5711684823036194, + "error": 0.3095703125, + "gradient_norm": 0.07746906578540802, + "elapsed": 1016.1701967716217 + }, + { + "step": 1504, + "loss": 0.3114882707595825, + "objective": 0.3114882707595825, + "error": 0.1455078125, + "gradient_norm": 0.05321609228849411, + "elapsed": 1026.6053586006165 + }, + { + "step": 1520, + "loss": 0.6433392763137817, + "objective": 0.6433392763137817, + "error": 0.4072265625, + "gradient_norm": 0.05683734640479088, + "elapsed": 1036.1535296440125 + }, + { + "step": 1536, + "loss": 0.38409170508384705, + "objective": 0.38409170508384705, + "error": 0.19140625, + "gradient_norm": 0.07577994465827942, + "elapsed": 1046.9508447647095 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "7b45252d6bb77a39c003c8f34f040d0d672e9dd1a1338a14126e1fe07a02c8c9", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 466919, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "reserved2_full": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 467790, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved2_warm/weights-512.npz", + "starting_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317635, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261274", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.2600052058696747, + "objective": 0.2600052058696747, + "error": 0.1123046875, + "gradient_norm": 0.06799795478582382, + "elapsed": 27.333195447921753 + }, + { + "step": 16, + "loss": 0.0312246885150671, + "objective": 0.0312246885150671, + "error": 0.01171875, + "gradient_norm": 0.004962741397321224, + "elapsed": 48.383540868759155 + }, + { + "step": 32, + "loss": 0.22698244452476501, + "objective": 0.22698244452476501, + "error": 0.08984375, + "gradient_norm": 0.06353150308132172, + "elapsed": 57.04609966278076 + }, + { + "step": 48, + "loss": 0.5861443281173706, + "objective": 0.5861443281173706, + "error": 0.3486328125, + "gradient_norm": 0.04095375910401344, + "elapsed": 69.08654689788818 + }, + { + "step": 64, + "loss": 0.6103856563568115, + "objective": 0.6103856563568115, + "error": 0.3662109375, + "gradient_norm": 0.04155975207686424, + "elapsed": 81.63970494270325 + }, + { + "step": 80, + "loss": 0.5673234462738037, + "objective": 0.5673234462738037, + "error": 0.3125, + "gradient_norm": 0.1773851364850998, + "elapsed": 92.5357596874237 + }, + { + "step": 96, + "loss": 0.3763846755027771, + "objective": 0.3763846755027771, + "error": 0.1875, + "gradient_norm": 0.0951203852891922, + "elapsed": 103.12279391288757 + }, + { + "step": 112, + "loss": 0.45539408922195435, + "objective": 0.45539408922195435, + "error": 0.22265625, + "gradient_norm": 0.056369006633758545, + "elapsed": 112.61882042884827 + }, + { + "step": 128, + "loss": 0.015473627485334873, + "objective": 0.015473627485334873, + "error": 0.005859375, + "gradient_norm": 0.005696057807654142, + "elapsed": 125.16960310935974 + }, + { + "step": 144, + "loss": 0.03449750319123268, + "objective": 0.03449750319123268, + "error": 0.0107421875, + "gradient_norm": 0.008358650840818882, + "elapsed": 135.8080232143402 + }, + { + "step": 160, + "loss": 0.5731935501098633, + "objective": 0.5731935501098633, + "error": 0.31640625, + "gradient_norm": 0.056162577122449875, + "elapsed": 145.0349259376526 + }, + { + "step": 176, + "loss": 0.5626271963119507, + "objective": 0.5626271963119507, + "error": 0.314453125, + "gradient_norm": 0.048817526549100876, + "elapsed": 154.84093379974365 + }, + { + "step": 192, + "loss": 0.5507581233978271, + "objective": 0.5507581233978271, + "error": 0.3173828125, + "gradient_norm": 0.06503377854824066, + "elapsed": 164.7195086479187 + }, + { + "step": 208, + "loss": 0.5725968480110168, + "objective": 0.5725968480110168, + "error": 0.3251953125, + "gradient_norm": 0.047704510390758514, + "elapsed": 175.38803815841675 + }, + { + "step": 224, + "loss": 0.5249365568161011, + "objective": 0.5249365568161011, + "error": 0.2802734375, + "gradient_norm": 0.10021239519119263, + "elapsed": 187.0162854194641 + }, + { + "step": 240, + "loss": 0.2526492476463318, + "objective": 0.2526492476463318, + "error": 0.1103515625, + "gradient_norm": 0.06751289963722229, + "elapsed": 196.51696944236755 + }, + { + "step": 256, + "loss": 0.5214780569076538, + "objective": 0.5214780569076538, + "error": 0.275390625, + "gradient_norm": 0.14627203345298767, + "elapsed": 208.2405219078064 + }, + { + "step": 272, + "loss": 0.59315025806427, + "objective": 0.59315025806427, + "error": 0.341796875, + "gradient_norm": 0.03693874180316925, + "elapsed": 224.87874341011047 + }, + { + "step": 288, + "loss": 0.37350377440452576, + "objective": 0.37350377440452576, + "error": 0.169921875, + "gradient_norm": 0.05035478249192238, + "elapsed": 235.2427306175232 + }, + { + "step": 304, + "loss": 0.6201726198196411, + "objective": 0.6201726198196411, + "error": 0.3798828125, + "gradient_norm": 0.04230104014277458, + "elapsed": 244.4733214378357 + }, + { + "step": 320, + "loss": 0.5781067609786987, + "objective": 0.5781067609786987, + "error": 0.3291015625, + "gradient_norm": 0.06764703243970871, + "elapsed": 256.96991300582886 + }, + { + "step": 336, + "loss": 0.13824111223220825, + "objective": 0.13824111223220825, + "error": 0.0556640625, + "gradient_norm": 0.02330971322953701, + "elapsed": 268.097412109375 + }, + { + "step": 352, + "loss": 0.6141752004623413, + "objective": 0.6141752004623413, + "error": 0.37890625, + "gradient_norm": 0.08660273998975754, + "elapsed": 282.79302310943604 + }, + { + "step": 368, + "loss": 0.3470626473426819, + "objective": 0.3470626473426819, + "error": 0.1611328125, + "gradient_norm": 0.05711895599961281, + "elapsed": 293.79467129707336 + }, + { + "step": 384, + "loss": 0.6023644208908081, + "objective": 0.6023644208908081, + "error": 0.3466796875, + "gradient_norm": 0.08649417012929916, + "elapsed": 305.9786322116852 + }, + { + "step": 400, + "loss": 0.03022841364145279, + "objective": 0.03022841364145279, + "error": 0.0087890625, + "gradient_norm": 0.009741511195898056, + "elapsed": 315.06104922294617 + }, + { + "step": 416, + "loss": 0.23827238380908966, + "objective": 0.23827238380908966, + "error": 0.1015625, + "gradient_norm": 0.03526044636964798, + "elapsed": 325.6410942077637 + }, + { + "step": 432, + "loss": 0.43375664949417114, + "objective": 0.43375664949417114, + "error": 0.201171875, + "gradient_norm": 0.03940205276012421, + "elapsed": 336.9890570640564 + }, + { + "step": 448, + "loss": 0.5915575623512268, + "objective": 0.5915575623512268, + "error": 0.3359375, + "gradient_norm": 0.04364592209458351, + "elapsed": 346.9254243373871 + }, + { + "step": 464, + "loss": 0.5641118288040161, + "objective": 0.5641118288040161, + "error": 0.3076171875, + "gradient_norm": 0.052896615117788315, + "elapsed": 356.9816539287567 + }, + { + "step": 480, + "loss": 0.5682889223098755, + "objective": 0.5682889223098755, + "error": 0.322265625, + "gradient_norm": 0.07130409777164459, + "elapsed": 369.16103172302246 + }, + { + "step": 496, + "loss": 0.37034764885902405, + "objective": 0.37034764885902405, + "error": 0.181640625, + "gradient_norm": 0.11464523524045944, + "elapsed": 381.041054725647 + }, + { + "step": 512, + "loss": 0.5398496389389038, + "objective": 0.5398496389389038, + "error": 0.3076171875, + "gradient_norm": 0.05673467367887497, + "elapsed": 394.5030150413513 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "db182d721768f832e1c83f6258b31bef0d8bf2ded239a8ab5a45cbb76378fd30", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317635, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.30839407444000244, + "objective": 0.30839407444000244, + "error": 0.130859375, + "gradient_norm": 0.053425733000040054, + "elapsed": 28.537403345108032 + }, + { + "step": 16, + "loss": 0.021987520158290863, + "objective": 0.021987520158290863, + "error": 0.0078125, + "gradient_norm": 0.01397851575165987, + "elapsed": 48.18276286125183 + }, + { + "step": 32, + "loss": 0.5041587352752686, + "objective": 0.5041587352752686, + "error": 0.2724609375, + "gradient_norm": 0.0528741292655468, + "elapsed": 58.27348470687866 + }, + { + "step": 48, + "loss": 0.4326452612876892, + "objective": 0.4326452612876892, + "error": 0.21484375, + "gradient_norm": 0.0559566393494606, + "elapsed": 68.90473222732544 + }, + { + "step": 64, + "loss": 0.4804917275905609, + "objective": 0.4804917275905609, + "error": 0.248046875, + "gradient_norm": 0.0669105276465416, + "elapsed": 77.87249231338501 + }, + { + "step": 80, + "loss": 0.2889654338359833, + "objective": 0.2889654338359833, + "error": 0.1328125, + "gradient_norm": 0.08293467015028, + "elapsed": 86.87973022460938 + }, + { + "step": 96, + "loss": 0.5135385990142822, + "objective": 0.5135385990142822, + "error": 0.271484375, + "gradient_norm": 0.06412295252084732, + "elapsed": 95.98773431777954 + }, + { + "step": 112, + "loss": 0.31248384714126587, + "objective": 0.31248384714126587, + "error": 0.1357421875, + "gradient_norm": 0.03881710395216942, + "elapsed": 106.47444081306458 + }, + { + "step": 128, + "loss": 0.23868557810783386, + "objective": 0.23868557810783386, + "error": 0.091796875, + "gradient_norm": 0.03896595537662506, + "elapsed": 117.72143626213074 + }, + { + "step": 144, + "loss": 0.5315916538238525, + "objective": 0.5315916538238525, + "error": 0.2890625, + "gradient_norm": 0.09184520691633224, + "elapsed": 126.97882843017578 + }, + { + "step": 160, + "loss": 0.604732096195221, + "objective": 0.604732096195221, + "error": 0.3603515625, + "gradient_norm": 0.044600710272789, + "elapsed": 137.403742313385 + }, + { + "step": 176, + "loss": 0.032417282462120056, + "objective": 0.032417282462120056, + "error": 0.0107421875, + "gradient_norm": 0.010968778282403946, + "elapsed": 147.58081603050232 + }, + { + "step": 192, + "loss": 0.24050910770893097, + "objective": 0.24050910770893097, + "error": 0.087890625, + "gradient_norm": 0.052534136921167374, + "elapsed": 156.545964717865 + }, + { + "step": 208, + "loss": 0.3183761537075043, + "objective": 0.3183761537075043, + "error": 0.1435546875, + "gradient_norm": 0.05253623053431511, + "elapsed": 166.62695455551147 + }, + { + "step": 224, + "loss": 0.6407097578048706, + "objective": 0.6407097578048706, + "error": 0.3837890625, + "gradient_norm": 0.08772490173578262, + "elapsed": 174.46970582008362 + }, + { + "step": 240, + "loss": 0.597212553024292, + "objective": 0.597212553024292, + "error": 0.36328125, + "gradient_norm": 0.13039150834083557, + "elapsed": 184.2768793106079 + }, + { + "step": 256, + "loss": 0.3317721486091614, + "objective": 0.3317721486091614, + "error": 0.14453125, + "gradient_norm": 0.03749232366681099, + "elapsed": 194.6345317363739 + }, + { + "step": 272, + "loss": 0.6330116987228394, + "objective": 0.6330116987228394, + "error": 0.3955078125, + "gradient_norm": 0.06468097865581512, + "elapsed": 205.8717017173767 + }, + { + "step": 288, + "loss": 0.3141757845878601, + "objective": 0.3141757845878601, + "error": 0.138671875, + "gradient_norm": 0.046496689319610596, + "elapsed": 215.2117359638214 + }, + { + "step": 304, + "loss": 0.5782994031906128, + "objective": 0.5782994031906128, + "error": 0.345703125, + "gradient_norm": 0.06487675756216049, + "elapsed": 225.47403240203857 + }, + { + "step": 320, + "loss": 0.45729100704193115, + "objective": 0.45729100704193115, + "error": 0.2255859375, + "gradient_norm": 0.04169687256217003, + "elapsed": 233.03686332702637 + }, + { + "step": 336, + "loss": 0.49350813031196594, + "objective": 0.49350813031196594, + "error": 0.24609375, + "gradient_norm": 0.08623651415109634, + "elapsed": 244.53246903419495 + }, + { + "step": 352, + "loss": 0.25660067796707153, + "objective": 0.25660067796707153, + "error": 0.1103515625, + "gradient_norm": 0.03029652312397957, + "elapsed": 254.88137793540955 + }, + { + "step": 368, + "loss": 0.2295728325843811, + "objective": 0.2295728325843811, + "error": 0.0966796875, + "gradient_norm": 0.042884912341833115, + "elapsed": 262.7415475845337 + }, + { + "step": 384, + "loss": 0.6214326620101929, + "objective": 0.6214326620101929, + "error": 0.3759765625, + "gradient_norm": 0.08176509290933609, + "elapsed": 271.72958397865295 + }, + { + "step": 400, + "loss": 0.6463049650192261, + "objective": 0.6463049650192261, + "error": 0.3984375, + "gradient_norm": 0.08226390928030014, + "elapsed": 281.51069259643555 + }, + { + "step": 416, + "loss": 0.024987798184156418, + "objective": 0.024987798184156418, + "error": 0.0078125, + "gradient_norm": 0.0075854891911149025, + "elapsed": 291.0118627548218 + }, + { + "step": 432, + "loss": 0.5520929098129272, + "objective": 0.5520929098129272, + "error": 0.3125, + "gradient_norm": 0.09755270183086395, + "elapsed": 301.23231768608093 + }, + { + "step": 448, + "loss": 0.6077401638031006, + "objective": 0.6077401638031006, + "error": 0.361328125, + "gradient_norm": 0.04908076301217079, + "elapsed": 312.93572759628296 + }, + { + "step": 464, + "loss": 0.016434211283922195, + "objective": 0.016434211283922195, + "error": 0.005859375, + "gradient_norm": 0.007213531993329525, + "elapsed": 323.8330478668213 + }, + { + "step": 480, + "loss": 0.1582300364971161, + "objective": 0.1582300364971161, + "error": 0.064453125, + "gradient_norm": 0.028335656970739365, + "elapsed": 334.6112554073334 + }, + { + "step": 496, + "loss": 0.5916742086410522, + "objective": 0.5916742086410522, + "error": 0.35546875, + "gradient_norm": 0.08213689178228378, + "elapsed": 345.8490369319916 + }, + { + "step": 512, + "loss": 0.11447565257549286, + "objective": 0.11447565257549286, + "error": 0.04296875, + "gradient_norm": 0.028994916006922722, + "elapsed": 358.71793270111084 + }, + { + "step": 528, + "loss": 0.3011414408683777, + "objective": 0.3011414408683777, + "error": 0.1435546875, + "gradient_norm": 0.04305516928434372, + "elapsed": 373.143226146698 + }, + { + "step": 544, + "loss": 0.3099900782108307, + "objective": 0.3099900782108307, + "error": 0.130859375, + "gradient_norm": 0.06152835488319397, + "elapsed": 380.42762184143066 + }, + { + "step": 560, + "loss": 0.42917633056640625, + "objective": 0.42917633056640625, + "error": 0.203125, + "gradient_norm": 0.051812849938869476, + "elapsed": 390.78397703170776 + }, + { + "step": 576, + "loss": 0.4895544648170471, + "objective": 0.4895544648170471, + "error": 0.2451171875, + "gradient_norm": 0.059052009135484695, + "elapsed": 400.29374146461487 + }, + { + "step": 592, + "loss": 0.5950886011123657, + "objective": 0.5950886011123657, + "error": 0.328125, + "gradient_norm": 0.1449151188135147, + "elapsed": 410.06920647621155 + }, + { + "step": 608, + "loss": 0.3282078504562378, + "objective": 0.3282078504562378, + "error": 0.1484375, + "gradient_norm": 0.06495015323162079, + "elapsed": 420.5240683555603 + }, + { + "step": 624, + "loss": 0.6034166812896729, + "objective": 0.6034166812896729, + "error": 0.3388671875, + "gradient_norm": 0.05658626928925514, + "elapsed": 430.7997169494629 + }, + { + "step": 640, + "loss": 0.590431809425354, + "objective": 0.590431809425354, + "error": 0.3447265625, + "gradient_norm": 0.046094730496406555, + "elapsed": 441.8197224140167 + }, + { + "step": 656, + "loss": 0.2260439246892929, + "objective": 0.2260439246892929, + "error": 0.1015625, + "gradient_norm": 0.06323576718568802, + "elapsed": 450.76086831092834 + }, + { + "step": 672, + "loss": 0.26158156991004944, + "objective": 0.26158156991004944, + "error": 0.1162109375, + "gradient_norm": 0.08324819058179855, + "elapsed": 459.1986529827118 + }, + { + "step": 688, + "loss": 0.4871026873588562, + "objective": 0.4871026873588562, + "error": 0.244140625, + "gradient_norm": 0.051720812916755676, + "elapsed": 470.4437210559845 + }, + { + "step": 704, + "loss": 0.5861694812774658, + "objective": 0.5861694812774658, + "error": 0.341796875, + "gradient_norm": 0.05766218528151512, + "elapsed": 483.85575103759766 + }, + { + "step": 720, + "loss": 0.4168863296508789, + "objective": 0.4168863296508789, + "error": 0.21484375, + "gradient_norm": 0.05056491494178772, + "elapsed": 494.63891077041626 + }, + { + "step": 736, + "loss": 0.42054638266563416, + "objective": 0.42054638266563416, + "error": 0.21875, + "gradient_norm": 0.07021808624267578, + "elapsed": 505.4899232387543 + }, + { + "step": 752, + "loss": 0.2022928148508072, + "objective": 0.2022928148508072, + "error": 0.0849609375, + "gradient_norm": 0.0765448734164238, + "elapsed": 516.2925503253937 + }, + { + "step": 768, + "loss": 0.026398655027151108, + "objective": 0.026398655027151108, + "error": 0.0068359375, + "gradient_norm": 0.00973521638661623, + "elapsed": 524.7940125465393 + }, + { + "step": 784, + "loss": 0.5843480825424194, + "objective": 0.5843480825424194, + "error": 0.345703125, + "gradient_norm": 0.04805552959442139, + "elapsed": 535.345025062561 + }, + { + "step": 800, + "loss": 0.3102012872695923, + "objective": 0.3102012872695923, + "error": 0.134765625, + "gradient_norm": 0.09761057049036026, + "elapsed": 544.4683487415314 + }, + { + "step": 816, + "loss": 0.5332639217376709, + "objective": 0.5332639217376709, + "error": 0.30078125, + "gradient_norm": 0.10398133844137192, + "elapsed": 554.8217175006866 + }, + { + "step": 832, + "loss": 0.4870310425758362, + "objective": 0.4870310425758362, + "error": 0.2685546875, + "gradient_norm": 0.05754273384809494, + "elapsed": 564.9130115509033 + }, + { + "step": 848, + "loss": 0.1336989849805832, + "objective": 0.1336989849805832, + "error": 0.0498046875, + "gradient_norm": 0.02862304449081421, + "elapsed": 573.6143791675568 + }, + { + "step": 864, + "loss": 0.5794297456741333, + "objective": 0.5794297456741333, + "error": 0.3427734375, + "gradient_norm": 0.05002075806260109, + "elapsed": 584.2565310001373 + }, + { + "step": 880, + "loss": 0.6150081753730774, + "objective": 0.6150081753730774, + "error": 0.341796875, + "gradient_norm": 0.0605069138109684, + "elapsed": 596.845867395401 + }, + { + "step": 896, + "loss": 0.3804032504558563, + "objective": 0.3804032504558563, + "error": 0.18359375, + "gradient_norm": 0.057405781000852585, + "elapsed": 606.0786938667297 + }, + { + "step": 912, + "loss": 0.5734928846359253, + "objective": 0.5734928846359253, + "error": 0.2958984375, + "gradient_norm": 0.06807747483253479, + "elapsed": 616.9755277633667 + }, + { + "step": 928, + "loss": 0.23615539073944092, + "objective": 0.23615539073944092, + "error": 0.107421875, + "gradient_norm": 0.04033413156867027, + "elapsed": 625.9104406833649 + }, + { + "step": 944, + "loss": 0.5668450593948364, + "objective": 0.5668450593948364, + "error": 0.3134765625, + "gradient_norm": 0.04825817048549652, + "elapsed": 635.4241654872894 + }, + { + "step": 960, + "loss": 0.1369795948266983, + "objective": 0.1369795948266983, + "error": 0.0537109375, + "gradient_norm": 0.029475854709744453, + "elapsed": 646.0763671398163 + }, + { + "step": 976, + "loss": 0.026218727231025696, + "objective": 0.026218727231025696, + "error": 0.009765625, + "gradient_norm": 0.0067830472253263, + "elapsed": 656.7150173187256 + }, + { + "step": 992, + "loss": 0.6016548871994019, + "objective": 0.6016548871994019, + "error": 0.3564453125, + "gradient_norm": 0.04935981705784798, + "elapsed": 668.9989516735077 + }, + { + "step": 1008, + "loss": 0.1370980143547058, + "objective": 0.1370980143547058, + "error": 0.0546875, + "gradient_norm": 0.04418199881911278, + "elapsed": 677.3821382522583 + }, + { + "step": 1024, + "loss": 0.4085504412651062, + "objective": 0.4085504412651062, + "error": 0.19921875, + "gradient_norm": 0.07943295687437057, + "elapsed": 688.8395888805389 + }, + { + "step": 1040, + "loss": 0.34129297733306885, + "objective": 0.34129297733306885, + "error": 0.15625, + "gradient_norm": 0.04551500454545021, + "elapsed": 703.4613966941833 + }, + { + "step": 1056, + "loss": 0.5297085046768188, + "objective": 0.5297085046768188, + "error": 0.2705078125, + "gradient_norm": 0.06177444010972977, + "elapsed": 714.0862259864807 + }, + { + "step": 1072, + "loss": 0.3833361268043518, + "objective": 0.3833361268043518, + "error": 0.185546875, + "gradient_norm": 0.053057629615068436, + "elapsed": 724.1480000019073 + }, + { + "step": 1088, + "loss": 0.6497273445129395, + "objective": 0.6497273445129395, + "error": 0.421875, + "gradient_norm": 0.10790837556123734, + "elapsed": 735.8740057945251 + }, + { + "step": 1104, + "loss": 0.5393906831741333, + "objective": 0.5393906831741333, + "error": 0.2998046875, + "gradient_norm": 0.06015805900096893, + "elapsed": 743.9961709976196 + }, + { + "step": 1120, + "loss": 0.38553956151008606, + "objective": 0.38553956151008606, + "error": 0.1875, + "gradient_norm": 0.05357081815600395, + "elapsed": 753.2208635807037 + }, + { + "step": 1136, + "loss": 0.5478834509849548, + "objective": 0.5478834509849548, + "error": 0.2900390625, + "gradient_norm": 0.05761478468775749, + "elapsed": 761.3359644412994 + }, + { + "step": 1152, + "loss": 0.5732287168502808, + "objective": 0.5732287168502808, + "error": 0.341796875, + "gradient_norm": 0.07881136238574982, + "elapsed": 771.133172750473 + }, + { + "step": 1168, + "loss": 0.5174047946929932, + "objective": 0.5174047946929932, + "error": 0.29296875, + "gradient_norm": 0.07794999331235886, + "elapsed": 783.7084786891937 + }, + { + "step": 1184, + "loss": 0.5022754669189453, + "objective": 0.5022754669189453, + "error": 0.265625, + "gradient_norm": 0.05175226181745529, + "elapsed": 793.499255657196 + }, + { + "step": 1200, + "loss": 0.5698775053024292, + "objective": 0.5698775053024292, + "error": 0.34375, + "gradient_norm": 0.06385946273803711, + "elapsed": 804.970814704895 + }, + { + "step": 1216, + "loss": 0.6203033924102783, + "objective": 0.6203033924102783, + "error": 0.37109375, + "gradient_norm": 0.07393646240234375, + "elapsed": 816.1773698329926 + }, + { + "step": 1232, + "loss": 0.6154648065567017, + "objective": 0.6154648065567017, + "error": 0.3857421875, + "gradient_norm": 0.04278155043721199, + "elapsed": 827.3619928359985 + }, + { + "step": 1248, + "loss": 0.5948328971862793, + "objective": 0.5948328971862793, + "error": 0.3291015625, + "gradient_norm": 0.062024734914302826, + "elapsed": 838.8370804786682 + }, + { + "step": 1264, + "loss": 0.5644958019256592, + "objective": 0.5644958019256592, + "error": 0.3212890625, + "gradient_norm": 0.12030917406082153, + "elapsed": 849.5000331401825 + }, + { + "step": 1280, + "loss": 0.028782427310943604, + "objective": 0.028782427310943604, + "error": 0.0087890625, + "gradient_norm": 0.009096251800656319, + "elapsed": 857.8837285041809 + }, + { + "step": 1296, + "loss": 0.5129679441452026, + "objective": 0.5129679441452026, + "error": 0.2626953125, + "gradient_norm": 0.12833116948604584, + "elapsed": 868.5195860862732 + }, + { + "step": 1312, + "loss": 0.4095553159713745, + "objective": 0.4095553159713745, + "error": 0.193359375, + "gradient_norm": 0.09977155178785324, + "elapsed": 877.4712297916412 + }, + { + "step": 1328, + "loss": 0.2850862741470337, + "objective": 0.2850862741470337, + "error": 0.1240234375, + "gradient_norm": 0.05365074798464775, + "elapsed": 887.5133347511292 + }, + { + "step": 1344, + "loss": 0.41809165477752686, + "objective": 0.41809165477752686, + "error": 0.19140625, + "gradient_norm": 0.10622142255306244, + "elapsed": 895.0828025341034 + }, + { + "step": 1360, + "loss": 0.3627069890499115, + "objective": 0.3627069890499115, + "error": 0.1650390625, + "gradient_norm": 0.049557290971279144, + "elapsed": 906.2595431804657 + }, + { + "step": 1376, + "loss": 0.023341629654169083, + "objective": 0.023341629654169083, + "error": 0.0068359375, + "gradient_norm": 0.008970360271632671, + "elapsed": 916.6110022068024 + }, + { + "step": 1392, + "loss": 0.519214391708374, + "objective": 0.519214391708374, + "error": 0.26953125, + "gradient_norm": 0.052287619560956955, + "elapsed": 926.660523891449 + }, + { + "step": 1408, + "loss": 0.6152850389480591, + "objective": 0.6152850389480591, + "error": 0.3662109375, + "gradient_norm": 0.049617987126111984, + "elapsed": 936.7533056735992 + }, + { + "step": 1424, + "loss": 0.020841240882873535, + "objective": 0.020841240882873535, + "error": 0.0068359375, + "gradient_norm": 0.008459246717393398, + "elapsed": 946.8231542110443 + }, + { + "step": 1440, + "loss": 0.5963407754898071, + "objective": 0.5963407754898071, + "error": 0.3525390625, + "gradient_norm": 0.08714025467634201, + "elapsed": 956.0344398021698 + }, + { + "step": 1456, + "loss": 0.44305220246315, + "objective": 0.44305220246315, + "error": 0.2099609375, + "gradient_norm": 0.061915796250104904, + "elapsed": 967.506050825119 + }, + { + "step": 1472, + "loss": 0.5292993783950806, + "objective": 0.5292993783950806, + "error": 0.2939453125, + "gradient_norm": 0.10089804977178574, + "elapsed": 977.855934381485 + }, + { + "step": 1488, + "loss": 0.6087026596069336, + "objective": 0.6087026596069336, + "error": 0.345703125, + "gradient_norm": 0.05276322737336159, + "elapsed": 986.2705359458923 + }, + { + "step": 1504, + "loss": 0.3670162558555603, + "objective": 0.3670162558555603, + "error": 0.1796875, + "gradient_norm": 0.0575372576713562, + "elapsed": 995.2220902442932 + }, + { + "step": 1520, + "loss": 0.33479321002960205, + "objective": 0.33479321002960205, + "error": 0.1435546875, + "gradient_norm": 0.056317709386348724, + "elapsed": 1005.2168045043945 + }, + { + "step": 1536, + "loss": 0.5869293212890625, + "objective": 0.5869293212890625, + "error": 0.337890625, + "gradient_norm": 0.07419256865978241, + "elapsed": 1016.8691458702087 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "0f5926c94bb1aa83840c6d257757b80c081835affc2cb34bf9246ba18e00266a", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 467790, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + } + }, + "selected_expert_checkpoints": { + "reserved1_full/1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 466919, + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "complete": true + }, + "reserved2_full/1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 428858, + "weights_sha256": "a346f535004381e2e0b628fac8ff7c58282a2447b9704638e46232dff46e511f", + "complete": true + } + }, + "changed_groups": [ + "d5_bX_center_5_5" + ], + "runtime_control": { + "status": "passed", + "device": "CPU", + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 1, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 3, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 4.0745362639427185e-09 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 4.76837158203125e-07 + } + ], + "seconds": 11.00676155090332, + "gate_parameters": "Synthetic random control state, excluded from fitting/selection/submission", + "sources": { + "contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "reserved_contextual.py": "8e3274896738f9dca23812b59676dcf3f96d15167a83702ee88a335af71ce2d1", + "reserved_gate.py": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1" + }, + "test_data_used": false + }, + "source_snapshot": "training_sources/reserved_gate1", + "selection_frozen_before_audit": true, + "independent_label_audit": { + "scope": "13312 randomly reserved supplied-training shots, excluded from both experts and the gate; all26d5 conditions", + "independence_scope": "Reserved logical labels are excluded from fitting and selection. The supplied even-fitted detector error models use all even syndromes, including these rows, as authorized by the benchmark.", + "selection_frozen_sha256": "99a5cdf3fa0258317d9dfbfeaf1ece2d9b33165968d5d82f1fdabd708fb8026d", + "selected_settings": { + "X": "equal-two", + "Z": "equal-two" + }, + "aggregate": { + "expert1": { + "failure": 0.22265625, + "negative_log_likelihood": 0.4219864913275091 + }, + "expert2": { + "failure": 0.2225060096153846, + "negative_log_likelihood": 0.42128344862713507 + }, + "physical": { + "failure": 0.22994290865384615, + "negative_log_likelihood": 0.43131594007437485 + }, + "equal-two": { + "failure": 0.22198016826923078, + "negative_log_likelihood": 0.4210906160117033 + }, + "equal-three": { + "failure": 0.22370793269230768, + "negative_log_likelihood": 0.4221742717028922 + }, + "validation-selected-new-mixture": { + "failure": 0.22198016826923078, + "negative_log_likelihood": 0.4210906160117033 + } + }, + "net_errors_saved_vs_equal_two": 0, + "paired_independent_shot_standard_error_of_failure_difference": 0.0, + "uncertainty": "Descriptive paired standard error ignores possible shot dependence; this is an independent training-period diagnostic, not benchmark test performance", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "basis": "X", + "rounds": 1, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017090894259712216 + }, + "expert2": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017530182758415357 + }, + "physical": { + "failure": 0.00390625, + "negative_log_likelihood": 0.018763942117481763 + }, + "equal-two": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017303048111761553 + }, + "equal-three": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017723361498233198 + }, + "validation-selected-new-mixture": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017303048111761553 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "basis": "X", + "rounds": 3, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.0703125, + "negative_log_likelihood": 0.16951059581112987 + }, + "expert2": { + "failure": 0.072265625, + "negative_log_likelihood": 0.17178756570474207 + }, + "physical": { + "failure": 0.076171875, + "negative_log_likelihood": 0.1798030054727182 + }, + "equal-two": { + "failure": 0.07421875, + "negative_log_likelihood": 0.17044986332352885 + }, + "equal-three": { + "failure": 0.076171875, + "negative_log_likelihood": 0.17250924829385533 + }, + "validation-selected-new-mixture": { + "failure": 0.07421875, + "negative_log_likelihood": 0.17044986332352885 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "basis": "X", + "rounds": 5, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.125, + "negative_log_likelihood": 0.26702956175276915 + }, + "expert2": { + "failure": 0.134765625, + "negative_log_likelihood": 0.2720239127120352 + }, + "physical": { + "failure": 0.12890625, + "negative_log_likelihood": 0.26716168642720345 + }, + "equal-two": { + "failure": 0.130859375, + "negative_log_likelihood": 0.2689265402494294 + }, + "equal-three": { + "failure": 0.12890625, + "negative_log_likelihood": 0.2666494803871213 + }, + "validation-selected-new-mixture": { + "failure": 0.130859375, + "negative_log_likelihood": 0.2689265402494294 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "basis": "X", + "rounds": 7, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.119140625, + "negative_log_likelihood": 0.28393399589383805 + }, + "expert2": { + "failure": 0.115234375, + "negative_log_likelihood": 0.2840000544441788 + }, + "physical": { + "failure": 0.126953125, + "negative_log_likelihood": 0.2969495620179671 + }, + "equal-two": { + "failure": 0.11328125, + "negative_log_likelihood": 0.28365364452835035 + }, + "equal-three": { + "failure": 0.115234375, + "negative_log_likelihood": 0.28484553303444526 + }, + "validation-selected-new-mixture": { + "failure": 0.11328125, + "negative_log_likelihood": 0.28365364452835035 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "basis": "X", + "rounds": 9, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.15234375, + "negative_log_likelihood": 0.3574806876617698 + }, + "expert2": { + "failure": 0.16015625, + "negative_log_likelihood": 0.36484337562384905 + }, + "physical": { + "failure": 0.154296875, + "negative_log_likelihood": 0.3773754577932747 + }, + "equal-two": { + "failure": 0.15234375, + "negative_log_likelihood": 0.36069278441676156 + }, + "equal-three": { + "failure": 0.154296875, + "negative_log_likelihood": 0.3626910613965446 + }, + "validation-selected-new-mixture": { + "failure": 0.15234375, + "negative_log_likelihood": 0.36069278441676156 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "basis": "X", + "rounds": 11, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.232421875, + "negative_log_likelihood": 0.46124590270993926 + }, + "expert2": { + "failure": 0.2265625, + "negative_log_likelihood": 0.4613963481795015 + }, + "physical": { + "failure": 0.234375, + "negative_log_likelihood": 0.4722622135305079 + }, + "equal-two": { + "failure": 0.23046875, + "negative_log_likelihood": 0.4606735958370106 + }, + "equal-three": { + "failure": 0.22265625, + "negative_log_likelihood": 0.46133910500738035 + }, + "validation-selected-new-mixture": { + "failure": 0.23046875, + "negative_log_likelihood": 0.4606735958370106 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "basis": "X", + "rounds": 13, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.265625, + "negative_log_likelihood": 0.4750318522643912 + }, + "expert2": { + "failure": 0.2578125, + "negative_log_likelihood": 0.4769788330146994 + }, + "physical": { + "failure": 0.2578125, + "negative_log_likelihood": 0.4916785267143769 + }, + "equal-two": { + "failure": 0.259765625, + "negative_log_likelihood": 0.4753582401528184 + }, + "equal-three": { + "failure": 0.259765625, + "negative_log_likelihood": 0.4764091488487066 + }, + "validation-selected-new-mixture": { + "failure": 0.259765625, + "negative_log_likelihood": 0.4753582401528184 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "basis": "X", + "rounds": 15, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.291015625, + "negative_log_likelihood": 0.5275047416665599 + }, + "expert2": { + "failure": 0.296875, + "negative_log_likelihood": 0.5308153878240705 + }, + "physical": { + "failure": 0.29296875, + "negative_log_likelihood": 0.5538887122415014 + }, + "equal-two": { + "failure": 0.287109375, + "negative_log_likelihood": 0.528540517342001 + }, + "equal-three": { + "failure": 0.28125, + "negative_log_likelihood": 0.5333872322093647 + }, + "validation-selected-new-mixture": { + "failure": 0.287109375, + "negative_log_likelihood": 0.528540517342001 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "basis": "X", + "rounds": 17, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.291015625, + "negative_log_likelihood": 0.5444426881972075 + }, + "expert2": { + "failure": 0.314453125, + "negative_log_likelihood": 0.5403884740065296 + }, + "physical": { + "failure": 0.296875, + "negative_log_likelihood": 0.5452648658851407 + }, + "equal-two": { + "failure": 0.298828125, + "negative_log_likelihood": 0.5417565948446685 + }, + "equal-three": { + "failure": 0.310546875, + "negative_log_likelihood": 0.5396094226965553 + }, + "validation-selected-new-mixture": { + "failure": 0.298828125, + "negative_log_likelihood": 0.5417565948446685 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "basis": "X", + "rounds": 19, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.3359375, + "negative_log_likelihood": 0.5948284537365178 + }, + "expert2": { + "failure": 0.3359375, + "negative_log_likelihood": 0.5892668837248777 + }, + "physical": { + "failure": 0.34375, + "negative_log_likelihood": 0.5978877763854513 + }, + "equal-two": { + "failure": 0.33203125, + "negative_log_likelihood": 0.591497491689464 + }, + "equal-three": { + "failure": 0.341796875, + "negative_log_likelihood": 0.5905302738463256 + }, + "validation-selected-new-mixture": { + "failure": 0.33203125, + "negative_log_likelihood": 0.591497491689464 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "basis": "X", + "rounds": 21, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.322265625, + "negative_log_likelihood": 0.6106869085573896 + }, + "expert2": { + "failure": 0.3046875, + "negative_log_likelihood": 0.6069554627640222 + }, + "physical": { + "failure": 0.349609375, + "negative_log_likelihood": 0.6312240521835084 + }, + "equal-two": { + "failure": 0.31640625, + "negative_log_likelihood": 0.6082673941419213 + }, + "equal-three": { + "failure": 0.33203125, + "negative_log_likelihood": 0.611988588131164 + }, + "validation-selected-new-mixture": { + "failure": 0.31640625, + "negative_log_likelihood": 0.6082673941419213 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "basis": "X", + "rounds": 23, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.373046875, + "negative_log_likelihood": 0.6185610303038827 + }, + "expert2": { + "failure": 0.359375, + "negative_log_likelihood": 0.6190691020479929 + }, + "physical": { + "failure": 0.376953125, + "negative_log_likelihood": 0.6370231759455196 + }, + "equal-two": { + "failure": 0.369140625, + "negative_log_likelihood": 0.6183673885171153 + }, + "equal-three": { + "failure": 0.365234375, + "negative_log_likelihood": 0.6215949225722667 + }, + "validation-selected-new-mixture": { + "failure": 0.369140625, + "negative_log_likelihood": 0.6183673885171153 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "basis": "X", + "rounds": 25, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.376953125, + "negative_log_likelihood": 0.6148529971657384 + }, + "expert2": { + "failure": 0.37890625, + "negative_log_likelihood": 0.6128175575654213 + }, + "physical": { + "failure": 0.39453125, + "negative_log_likelihood": 0.6214592551904651 + }, + "equal-two": { + "failure": 0.37890625, + "negative_log_likelihood": 0.6134261125432341 + }, + "equal-three": { + "failure": 0.38671875, + "negative_log_likelihood": 0.6138887320756413 + }, + "validation-selected-new-mixture": { + "failure": 0.37890625, + "negative_log_likelihood": 0.6134261125432341 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "basis": "Z", + "rounds": 1, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.009765625, + "negative_log_likelihood": 0.038550540341371745 + }, + "expert2": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03797109655241983 + }, + "physical": { + "failure": 0.009765625, + "negative_log_likelihood": 0.040172127018857376 + }, + "equal-two": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03824321962665776 + }, + "equal-three": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03878602821028987 + }, + "validation-selected-new-mixture": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03824321962665776 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "basis": "Z", + "rounds": 3, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.048828125, + "negative_log_likelihood": 0.13420470725766703 + }, + "expert2": { + "failure": 0.046875, + "negative_log_likelihood": 0.13194703132227217 + }, + "physical": { + "failure": 0.05078125, + "negative_log_likelihood": 0.1393875784610577 + }, + "equal-two": { + "failure": 0.048828125, + "negative_log_likelihood": 0.132766538296753 + }, + "equal-three": { + "failure": 0.05078125, + "negative_log_likelihood": 0.1343440297556426 + }, + "validation-selected-new-mixture": { + "failure": 0.048828125, + "negative_log_likelihood": 0.132766538296753 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "basis": "Z", + "rounds": 5, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.111328125, + "negative_log_likelihood": 0.2288585539609661 + }, + "expert2": { + "failure": 0.119140625, + "negative_log_likelihood": 0.22620558200243668 + }, + "physical": { + "failure": 0.11328125, + "negative_log_likelihood": 0.23821912848106855 + }, + "equal-two": { + "failure": 0.119140625, + "negative_log_likelihood": 0.22711330308351269 + }, + "equal-three": { + "failure": 0.11328125, + "negative_log_likelihood": 0.22935571518464187 + }, + "validation-selected-new-mixture": { + "failure": 0.119140625, + "negative_log_likelihood": 0.22711330308351269 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "basis": "Z", + "rounds": 7, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.1484375, + "negative_log_likelihood": 0.35045084350305566 + }, + "expert2": { + "failure": 0.142578125, + "negative_log_likelihood": 0.3410553629080602 + }, + "physical": { + "failure": 0.150390625, + "negative_log_likelihood": 0.3561979174511046 + }, + "equal-two": { + "failure": 0.14453125, + "negative_log_likelihood": 0.3445969625556094 + }, + "equal-three": { + "failure": 0.15234375, + "negative_log_likelihood": 0.3465247486817157 + }, + "validation-selected-new-mixture": { + "failure": 0.14453125, + "negative_log_likelihood": 0.3445969625556094 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "basis": "Z", + "rounds": 9, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.193359375, + "negative_log_likelihood": 0.3799049479130148 + }, + "expert2": { + "failure": 0.1953125, + "negative_log_likelihood": 0.3799510170481319 + }, + "physical": { + "failure": 0.205078125, + "negative_log_likelihood": 0.3858862521076333 + }, + "equal-two": { + "failure": 0.19140625, + "negative_log_likelihood": 0.37915749635591545 + }, + "equal-three": { + "failure": 0.19140625, + "negative_log_likelihood": 0.37935857276130736 + }, + "validation-selected-new-mixture": { + "failure": 0.19140625, + "negative_log_likelihood": 0.37915749635591545 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "basis": "Z", + "rounds": 11, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.228515625, + "negative_log_likelihood": 0.4795969526765531 + }, + "expert2": { + "failure": 0.234375, + "negative_log_likelihood": 0.4789140470085718 + }, + "physical": { + "failure": 0.236328125, + "negative_log_likelihood": 0.49341552659884924 + }, + "equal-two": { + "failure": 0.23828125, + "negative_log_likelihood": 0.4782844991105801 + }, + "equal-three": { + "failure": 0.234375, + "negative_log_likelihood": 0.47987928764039417 + }, + "validation-selected-new-mixture": { + "failure": 0.23828125, + "negative_log_likelihood": 0.4782844991105801 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "basis": "Z", + "rounds": 13, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.224609375, + "negative_log_likelihood": 0.43937554398477136 + }, + "expert2": { + "failure": 0.224609375, + "negative_log_likelihood": 0.4399126222895116 + }, + "physical": { + "failure": 0.236328125, + "negative_log_likelihood": 0.443789110862745 + }, + "equal-two": { + "failure": 0.2265625, + "negative_log_likelihood": 0.43901392764953234 + }, + "equal-three": { + "failure": 0.228515625, + "negative_log_likelihood": 0.43857847342118456 + }, + "validation-selected-new-mixture": { + "failure": 0.2265625, + "negative_log_likelihood": 0.43901392764953234 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "basis": "Z", + "rounds": 15, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.228515625, + "negative_log_likelihood": 0.48160554977293224 + }, + "expert2": { + "failure": 0.25, + "negative_log_likelihood": 0.4820924709840312 + }, + "physical": { + "failure": 0.234375, + "negative_log_likelihood": 0.4826623880733387 + }, + "equal-two": { + "failure": 0.24609375, + "negative_log_likelihood": 0.481233806415451 + }, + "equal-three": { + "failure": 0.2265625, + "negative_log_likelihood": 0.47960647657889843 + }, + "validation-selected-new-mixture": { + "failure": 0.24609375, + "negative_log_likelihood": 0.481233806415451 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "basis": "Z", + "rounds": 17, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.259765625, + "negative_log_likelihood": 0.5466166697019426 + }, + "expert2": { + "failure": 0.251953125, + "negative_log_likelihood": 0.5398671697628821 + }, + "physical": { + "failure": 0.294921875, + "negative_log_likelihood": 0.5660913072892866 + }, + "equal-two": { + "failure": 0.25, + "negative_log_likelihood": 0.5425301452794579 + }, + "equal-three": { + "failure": 0.275390625, + "negative_log_likelihood": 0.5478310998814211 + }, + "validation-selected-new-mixture": { + "failure": 0.25, + "negative_log_likelihood": 0.5425301452794579 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "basis": "Z", + "rounds": 19, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.30859375, + "negative_log_likelihood": 0.5655635506734258 + }, + "expert2": { + "failure": 0.310546875, + "negative_log_likelihood": 0.5681193038458382 + }, + "physical": { + "failure": 0.333984375, + "negative_log_likelihood": 0.5729767379746973 + }, + "equal-two": { + "failure": 0.30859375, + "negative_log_likelihood": 0.5661764057670509 + }, + "equal-three": { + "failure": 0.3046875, + "negative_log_likelihood": 0.5664520523054867 + }, + "validation-selected-new-mixture": { + "failure": 0.30859375, + "negative_log_likelihood": 0.5661764057670509 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "basis": "Z", + "rounds": 21, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.341796875, + "negative_log_likelihood": 0.5861600809583261 + }, + "expert2": { + "failure": 0.34375, + "negative_log_likelihood": 0.5787440828303073 + }, + "physical": { + "failure": 0.353515625, + "negative_log_likelihood": 0.6075796127135422 + }, + "equal-two": { + "failure": 0.353515625, + "negative_log_likelihood": 0.5817604918541285 + }, + "equal-three": { + "failure": 0.349609375, + "negative_log_likelihood": 0.5878103360696245 + }, + "validation-selected-new-mixture": { + "failure": 0.353515625, + "negative_log_likelihood": 0.5817604918541285 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "basis": "Z", + "rounds": 23, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.36328125, + "negative_log_likelihood": 0.5797032207789384 + }, + "expert2": { + "failure": 0.34765625, + "negative_log_likelihood": 0.5796550113024783 + }, + "physical": { + "failure": 0.3359375, + "negative_log_likelihood": 0.5773577505747061 + }, + "equal-two": { + "failure": 0.34765625, + "negative_log_likelihood": 0.5790676826897196 + }, + "equal-three": { + "failure": 0.33984375, + "negative_log_likelihood": 0.576848055206876 + }, + "validation-selected-new-mixture": { + "failure": 0.34765625, + "negative_log_likelihood": 0.5790676826897196 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "basis": "Z", + "rounds": 25, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.36328125, + "negative_log_likelihood": 0.6188573030114262 + }, + "expert2": { + "failure": 0.34765625, + "negative_log_likelihood": 0.6210617260782341 + }, + "physical": { + "failure": 0.38671875, + "negative_log_likelihood": 0.6197367724217436 + }, + "equal-two": { + "failure": 0.33984375, + "negative_log_likelihood": 0.6194983219218514 + }, + "equal-three": { + "failure": 0.361328125, + "negative_log_likelihood": 0.6179900785801107 + }, + "validation-selected-new-mixture": { + "failure": 0.33984375, + "negative_log_likelihood": 0.6194983219218514 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + } + ], + "used_for_fitting_or_selection": false, + "test_data_used": false, + "source_sha256": "7b8d03717f5fbfd28eec2cca0dd6a59ee7af63ee7bc7cc7c672022f9e96a6779" + }, + "test_data_used": false + }, + "independent_temporal_probability_mixture": { + "new_optimizer_updates": 0, + "new_trainable_parameters": 0, + "new_expert_training": { + "initialization": "Uniform averages of the same session-trained temporal trajectory; no external weights", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Fresh128-unit rich trunk NumPy seed20261300: hidden weights Normal(0,1/sqrt(fan-in)),output Normal(0,.001),zero biases. Fresh32-channel temporal encoder JAX seed20261301: variance-scaled normal input/convolution weights,zero biases; appendedinput rows Normal(0,.001).", + "initial_seed": 20261300, + "encoder_seed": 20261301, + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__fresh_temporal_train.py": "366163a0c52e537485ab92df6c217600070886c0d0f0880abda4cd55d89cef20", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__fresh_temporal_initialization.py": "5e776e118573bceb5c253d6ae58d154ca9c95a375ddcf631d46ab7b846440ffb", + "learned_exact__model.py": "bc36fa5fa0191abc8e67e4ede0d4ff87848d80e9e2fac5cd60c0ac4fcefc3088", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 1961820, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18448, + "surface_code_bX_d3_r03_center_3_5": 19003, + "surface_code_bX_d3_r05_center_3_5": 19382, + "surface_code_bX_d3_r07_center_3_5": 19124, + "surface_code_bX_d3_r09_center_3_5": 18013, + "surface_code_bX_d3_r11_center_3_5": 19371, + "surface_code_bX_d3_r13_center_3_5": 19114, + "surface_code_bX_d3_r15_center_3_5": 18157, + "surface_code_bX_d3_r17_center_3_5": 18980, + "surface_code_bX_d3_r19_center_3_5": 19142, + "surface_code_bX_d3_r21_center_3_5": 19270, + "surface_code_bX_d3_r23_center_3_5": 18297, + "surface_code_bX_d3_r25_center_3_5": 19344, + "surface_code_bX_d3_r01_center_5_3": 18996, + "surface_code_bX_d3_r03_center_5_3": 18998, + "surface_code_bX_d3_r05_center_5_3": 18970, + "surface_code_bX_d3_r07_center_5_3": 19269, + "surface_code_bX_d3_r09_center_5_3": 19119, + "surface_code_bX_d3_r11_center_5_3": 18216, + "surface_code_bX_d3_r13_center_5_3": 18649, + "surface_code_bX_d3_r15_center_5_3": 19083, + "surface_code_bX_d3_r17_center_5_3": 19330, + "surface_code_bX_d3_r19_center_5_3": 18815, + "surface_code_bX_d3_r21_center_5_3": 18877, + "surface_code_bX_d3_r23_center_5_3": 18006, + "surface_code_bX_d3_r25_center_5_3": 19331, + "surface_code_bX_d3_r01_center_5_7": 19033, + "surface_code_bX_d3_r03_center_5_7": 19053, + "surface_code_bX_d3_r05_center_5_7": 18867, + "surface_code_bX_d3_r07_center_5_7": 18867, + "surface_code_bX_d3_r09_center_5_7": 18926, + "surface_code_bX_d3_r11_center_5_7": 19184, + "surface_code_bX_d3_r13_center_5_7": 18897, + "surface_code_bX_d3_r15_center_5_7": 19188, + "surface_code_bX_d3_r17_center_5_7": 18964, + "surface_code_bX_d3_r19_center_5_7": 18341, + "surface_code_bX_d3_r21_center_5_7": 18924, + "surface_code_bX_d3_r23_center_5_7": 19313, + "surface_code_bX_d3_r25_center_5_7": 18262, + "surface_code_bX_d3_r01_center_7_5": 19036, + "surface_code_bX_d3_r03_center_7_5": 19271, + "surface_code_bX_d3_r05_center_7_5": 18958, + "surface_code_bX_d3_r07_center_7_5": 19334, + "surface_code_bX_d3_r09_center_7_5": 19013, + "surface_code_bX_d3_r11_center_7_5": 19214, + "surface_code_bX_d3_r13_center_7_5": 19546, + "surface_code_bX_d3_r15_center_7_5": 19273, + "surface_code_bX_d3_r17_center_7_5": 19005, + "surface_code_bX_d3_r19_center_7_5": 18932, + "surface_code_bX_d3_r21_center_7_5": 19116, + "surface_code_bX_d3_r23_center_7_5": 19097, + "surface_code_bX_d3_r25_center_7_5": 18679, + "surface_code_bZ_d3_r01_center_3_5": 18962, + "surface_code_bZ_d3_r03_center_3_5": 19079, + "surface_code_bZ_d3_r05_center_3_5": 18872, + "surface_code_bZ_d3_r07_center_3_5": 18313, + "surface_code_bZ_d3_r09_center_3_5": 19259, + "surface_code_bZ_d3_r11_center_3_5": 19073, + "surface_code_bZ_d3_r13_center_3_5": 19057, + "surface_code_bZ_d3_r15_center_3_5": 18234, + "surface_code_bZ_d3_r17_center_3_5": 18637, + "surface_code_bZ_d3_r19_center_3_5": 18673, + "surface_code_bZ_d3_r21_center_3_5": 17946, + "surface_code_bZ_d3_r23_center_3_5": 17080, + "surface_code_bZ_d3_r25_center_3_5": 19360, + "surface_code_bZ_d3_r01_center_5_3": 19182, + "surface_code_bZ_d3_r03_center_5_3": 18951, + "surface_code_bZ_d3_r05_center_5_3": 18101, + "surface_code_bZ_d3_r07_center_5_3": 19178, + "surface_code_bZ_d3_r09_center_5_3": 19006, + "surface_code_bZ_d3_r11_center_5_3": 18983, + "surface_code_bZ_d3_r13_center_5_3": 18389, + "surface_code_bZ_d3_r15_center_5_3": 18142, + "surface_code_bZ_d3_r17_center_5_3": 18804, + "surface_code_bZ_d3_r19_center_5_3": 19257, + "surface_code_bZ_d3_r21_center_5_3": 18353, + "surface_code_bZ_d3_r23_center_5_3": 18793, + "surface_code_bZ_d3_r25_center_5_3": 18683, + "surface_code_bZ_d3_r01_center_5_7": 18981, + "surface_code_bZ_d3_r03_center_5_7": 19012, + "surface_code_bZ_d3_r05_center_5_7": 19002, + "surface_code_bZ_d3_r07_center_5_7": 18591, + "surface_code_bZ_d3_r09_center_5_7": 18849, + "surface_code_bZ_d3_r11_center_5_7": 19149, + "surface_code_bZ_d3_r13_center_5_7": 18612, + "surface_code_bZ_d3_r15_center_5_7": 19116, + "surface_code_bZ_d3_r17_center_5_7": 18960, + "surface_code_bZ_d3_r19_center_5_7": 19218, + "surface_code_bZ_d3_r21_center_5_7": 18825, + "surface_code_bZ_d3_r23_center_5_7": 18568, + "surface_code_bZ_d3_r25_center_5_7": 18136, + "surface_code_bZ_d3_r01_center_7_5": 19121, + "surface_code_bZ_d3_r03_center_7_5": 19311, + "surface_code_bZ_d3_r05_center_7_5": 18171, + "surface_code_bZ_d3_r07_center_7_5": 18714, + "surface_code_bZ_d3_r09_center_7_5": 19122, + "surface_code_bZ_d3_r11_center_7_5": 18697, + "surface_code_bZ_d3_r13_center_7_5": 18570, + "surface_code_bZ_d3_r15_center_7_5": 18646, + "surface_code_bZ_d3_r17_center_7_5": 18711, + "surface_code_bZ_d3_r19_center_7_5": 18802, + "surface_code_bZ_d3_r21_center_7_5": 18903, + "surface_code_bZ_d3_r23_center_7_5": 19115, + "surface_code_bZ_d3_r25_center_7_5": 18954 + }, + "steps": 6144, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.0005, + "sampling_seed": 20261302, + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_exact/fresh_temporal1_warm/rng-1024.json", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/fresh_temporal1_warm/weights-1024.npz", + "starting_checkpoint_sha256": "6649ebebc4fb0161756fa7b9dbeb513179dbcb8e4f75cb59ba4261f6829ed6f1", + "starting_training_provenance": { + "initialization": "Entire rich trunk and temporal encoder initialized randomly in this session; no learned checkpoint loaded", + "original_initialization": "Fresh128-unit rich trunk NumPy seed20261300: hidden weights Normal(0,1/sqrt(fan-in)),output Normal(0,.001),zero biases. Fresh32-channel temporal encoder JAX seed20261301: variance-scaled normal input/convolution weights,zero biases; appendedinput rows Normal(0,.001).", + "initial_seed": 20261300, + "encoder_seed": 20261301, + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__fresh_temporal_train.py": "366163a0c52e537485ab92df6c217600070886c0d0f0880abda4cd55d89cef20", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__fresh_temporal_initialization.py": "5e776e118573bceb5c253d6ae58d154ca9c95a375ddcf631d46ab7b846440ffb", + "learned_exact__model.py": "bc36fa5fa0191abc8e67e4ede0d4ff87848d80e9e2fac5cd60c0ac4fcefc3088", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 805845, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 7368, + "surface_code_bX_d3_r03_center_3_5": 10180, + "surface_code_bX_d3_r05_center_3_5": 11996, + "surface_code_bX_d3_r07_center_3_5": 8612, + "surface_code_bX_d3_r09_center_3_5": 9665, + "surface_code_bX_d3_r11_center_3_5": 9130, + "surface_code_bX_d3_r13_center_3_5": 8025, + "surface_code_bX_d3_r15_center_3_5": 6058, + "surface_code_bX_d3_r17_center_3_5": 8648, + "surface_code_bX_d3_r19_center_3_5": 9138, + "surface_code_bX_d3_r21_center_3_5": 6714, + "surface_code_bX_d3_r23_center_3_5": 8607, + "surface_code_bX_d3_r25_center_3_5": 7455, + "surface_code_bX_d3_r01_center_5_3": 10671, + "surface_code_bX_d3_r03_center_5_3": 6015, + "surface_code_bX_d3_r05_center_5_3": 8634, + "surface_code_bX_d3_r07_center_5_3": 8553, + "surface_code_bX_d3_r09_center_5_3": 7391, + "surface_code_bX_d3_r11_center_5_3": 10239, + "surface_code_bX_d3_r13_center_5_3": 9776, + "surface_code_bX_d3_r15_center_5_3": 8010, + "surface_code_bX_d3_r17_center_5_3": 9174, + "surface_code_bX_d3_r19_center_5_3": 7364, + "surface_code_bX_d3_r21_center_5_3": 9761, + "surface_code_bX_d3_r23_center_5_3": 4457, + "surface_code_bX_d3_r25_center_5_3": 12037, + "surface_code_bX_d3_r01_center_5_7": 6710, + "surface_code_bX_d3_r03_center_5_7": 7365, + "surface_code_bX_d3_r05_center_5_7": 11614, + "surface_code_bX_d3_r07_center_5_7": 7387, + "surface_code_bX_d3_r09_center_5_7": 7986, + "surface_code_bX_d3_r11_center_5_7": 6744, + "surface_code_bX_d3_r13_center_5_7": 8017, + "surface_code_bX_d3_r15_center_5_7": 7315, + "surface_code_bX_d3_r17_center_5_7": 5281, + "surface_code_bX_d3_r19_center_5_7": 5271, + "surface_code_bX_d3_r21_center_5_7": 6017, + "surface_code_bX_d3_r23_center_5_7": 8021, + "surface_code_bX_d3_r25_center_5_7": 8010, + "surface_code_bX_d3_r01_center_7_5": 8608, + "surface_code_bX_d3_r03_center_7_5": 9133, + "surface_code_bX_d3_r05_center_7_5": 10756, + "surface_code_bX_d3_r07_center_7_5": 7332, + "surface_code_bX_d3_r09_center_7_5": 6726, + "surface_code_bX_d3_r11_center_7_5": 9734, + "surface_code_bX_d3_r13_center_7_5": 11169, + "surface_code_bX_d3_r15_center_7_5": 6032, + "surface_code_bX_d3_r17_center_7_5": 5287, + "surface_code_bX_d3_r19_center_7_5": 12010, + "surface_code_bX_d3_r21_center_7_5": 7993, + "surface_code_bX_d3_r23_center_7_5": 7349, + "surface_code_bX_d3_r25_center_7_5": 6723, + "surface_code_bZ_d3_r01_center_3_5": 10253, + "surface_code_bZ_d3_r03_center_3_5": 4531, + "surface_code_bZ_d3_r05_center_3_5": 9189, + "surface_code_bZ_d3_r07_center_3_5": 5303, + "surface_code_bZ_d3_r09_center_3_5": 8018, + "surface_code_bZ_d3_r11_center_3_5": 6730, + "surface_code_bZ_d3_r13_center_3_5": 4509, + "surface_code_bZ_d3_r15_center_3_5": 8555, + "surface_code_bZ_d3_r17_center_3_5": 6697, + "surface_code_bZ_d3_r19_center_3_5": 9190, + "surface_code_bZ_d3_r21_center_3_5": 6724, + "surface_code_bZ_d3_r23_center_3_5": 7373, + "surface_code_bZ_d3_r25_center_3_5": 8594, + "surface_code_bZ_d3_r01_center_5_3": 5307, + "surface_code_bZ_d3_r03_center_5_3": 10773, + "surface_code_bZ_d3_r05_center_5_3": 6016, + "surface_code_bZ_d3_r07_center_5_3": 9681, + "surface_code_bZ_d3_r09_center_5_3": 1959, + "surface_code_bZ_d3_r11_center_5_3": 5273, + "surface_code_bZ_d3_r13_center_5_3": 3723, + "surface_code_bZ_d3_r15_center_5_3": 6760, + "surface_code_bZ_d3_r17_center_5_3": 6017, + "surface_code_bZ_d3_r19_center_5_3": 5990, + "surface_code_bZ_d3_r21_center_5_3": 4521, + "surface_code_bZ_d3_r23_center_5_3": 10684, + "surface_code_bZ_d3_r25_center_5_3": 8025, + "surface_code_bZ_d3_r01_center_5_7": 8639, + "surface_code_bZ_d3_r03_center_5_7": 8601, + "surface_code_bZ_d3_r05_center_5_7": 9147, + "surface_code_bZ_d3_r07_center_5_7": 3697, + "surface_code_bZ_d3_r09_center_5_7": 8580, + "surface_code_bZ_d3_r11_center_5_7": 7403, + "surface_code_bZ_d3_r13_center_5_7": 6050, + "surface_code_bZ_d3_r15_center_5_7": 7417, + "surface_code_bZ_d3_r17_center_5_7": 9123, + "surface_code_bZ_d3_r19_center_5_7": 8018, + "surface_code_bZ_d3_r21_center_5_7": 6711, + "surface_code_bZ_d3_r23_center_5_7": 10239, + "surface_code_bZ_d3_r25_center_5_7": 4534, + "surface_code_bZ_d3_r01_center_7_5": 6724, + "surface_code_bZ_d3_r03_center_7_5": 7384, + "surface_code_bZ_d3_r05_center_7_5": 7417, + "surface_code_bZ_d3_r07_center_7_5": 6719, + "surface_code_bZ_d3_r09_center_7_5": 10697, + "surface_code_bZ_d3_r11_center_7_5": 9158, + "surface_code_bZ_d3_r13_center_7_5": 9191, + "surface_code_bZ_d3_r15_center_7_5": 7387, + "surface_code_bZ_d3_r17_center_7_5": 7952, + "surface_code_bZ_d3_r19_center_7_5": 3733, + "surface_code_bZ_d3_r21_center_7_5": 7392, + "surface_code_bZ_d3_r23_center_7_5": 8555, + "surface_code_bZ_d3_r25_center_7_5": 6714 + }, + "steps": 1024, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261302, + "optimizer_restored": false, + "rng_restored": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261302", + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.21217256784439087, + "error": 0.083984375, + "gradient_norm": 72.38723754882812, + "elapsed": 31.918910264968872 + }, + { + "step": 16, + "loss": 0.6045569181442261, + "error": 0.3603515625, + "gradient_norm": 0.028699910268187523, + "elapsed": 36.16854238510132 + }, + { + "step": 32, + "loss": 0.5565786361694336, + "error": 0.3212890625, + "gradient_norm": 0.22047482430934906, + "elapsed": 40.7435200214386 + }, + { + "step": 48, + "loss": 0.5321167707443237, + "error": 0.2822265625, + "gradient_norm": 0.09377239644527435, + "elapsed": 45.324397802352905 + }, + { + "step": 64, + "loss": 0.6348063349723816, + "error": 0.3720703125, + "gradient_norm": 0.05646984279155731, + "elapsed": 49.901334285736084 + }, + { + "step": 80, + "loss": 0.3326907157897949, + "error": 0.15625, + "gradient_norm": 0.06038638949394226, + "elapsed": 54.464093923568726 + }, + { + "step": 96, + "loss": 0.5551769733428955, + "error": 0.298828125, + "gradient_norm": 0.055739693343639374, + "elapsed": 59.01659154891968 + }, + { + "step": 112, + "loss": 0.07460369914770126, + "error": 0.01953125, + "gradient_norm": 0.030606018379330635, + "elapsed": 63.59593486785889 + }, + { + "step": 128, + "loss": 0.635905385017395, + "error": 0.3671875, + "gradient_norm": 0.04703317582607269, + "elapsed": 68.13260126113892 + }, + { + "step": 144, + "loss": 0.3003300428390503, + "error": 0.1357421875, + "gradient_norm": 0.05791902542114258, + "elapsed": 72.68314933776855 + }, + { + "step": 160, + "loss": 0.5628958940505981, + "error": 0.31640625, + "gradient_norm": 0.04959387332201004, + "elapsed": 77.23784852027893 + }, + { + "step": 176, + "loss": 0.5111046433448792, + "error": 0.2724609375, + "gradient_norm": 0.12674643099308014, + "elapsed": 81.82993626594543 + }, + { + "step": 192, + "loss": 0.4157131314277649, + "error": 0.2021484375, + "gradient_norm": 0.04782126098871231, + "elapsed": 86.42463231086731 + }, + { + "step": 208, + "loss": 0.5037418603897095, + "error": 0.2412109375, + "gradient_norm": 0.11169904470443726, + "elapsed": 91.04993081092834 + }, + { + "step": 224, + "loss": 0.6123065948486328, + "error": 0.3544921875, + "gradient_norm": 0.04985548555850983, + "elapsed": 95.6228940486908 + }, + { + "step": 240, + "loss": 0.4364244341850281, + "error": 0.2294921875, + "gradient_norm": 0.04670470952987671, + "elapsed": 100.18718242645264 + }, + { + "step": 256, + "loss": 0.5368590354919434, + "error": 0.2705078125, + "gradient_norm": 0.08144843578338623, + "elapsed": 104.73340320587158 + }, + { + "step": 272, + "loss": 0.06957712769508362, + "error": 0.0205078125, + "gradient_norm": 0.02150244265794754, + "elapsed": 109.2998673915863 + }, + { + "step": 288, + "loss": 0.4743788242340088, + "error": 0.255859375, + "gradient_norm": 0.07198309898376465, + "elapsed": 113.85788202285767 + }, + { + "step": 304, + "loss": 0.5969283580780029, + "error": 0.34375, + "gradient_norm": 0.11116421222686768, + "elapsed": 118.44765996932983 + }, + { + "step": 320, + "loss": 0.6432123184204102, + "error": 0.4013671875, + "gradient_norm": 0.03600870445370674, + "elapsed": 123.0557234287262 + }, + { + "step": 336, + "loss": 0.2727017402648926, + "error": 0.1123046875, + "gradient_norm": 0.029231661930680275, + "elapsed": 127.63300156593323 + }, + { + "step": 352, + "loss": 0.33606210350990295, + "error": 0.1611328125, + "gradient_norm": 0.07312989979982376, + "elapsed": 132.23885369300842 + }, + { + "step": 368, + "loss": 0.47369420528411865, + "error": 0.244140625, + "gradient_norm": 0.02903619036078453, + "elapsed": 136.80904459953308 + }, + { + "step": 384, + "loss": 0.4002310335636139, + "error": 0.197265625, + "gradient_norm": 0.04330601170659065, + "elapsed": 141.3804693222046 + }, + { + "step": 400, + "loss": 0.6038965582847595, + "error": 0.365234375, + "gradient_norm": 0.0767364501953125, + "elapsed": 145.98827505111694 + }, + { + "step": 416, + "loss": 0.5417855978012085, + "error": 0.29296875, + "gradient_norm": 0.039777908474206924, + "elapsed": 150.581374168396 + }, + { + "step": 432, + "loss": 0.41134020686149597, + "error": 0.2119140625, + "gradient_norm": 0.07896082103252411, + "elapsed": 155.18097972869873 + }, + { + "step": 448, + "loss": 0.453294575214386, + "error": 0.21875, + "gradient_norm": 0.13904333114624023, + "elapsed": 159.76109957695007 + }, + { + "step": 464, + "loss": 0.6003777384757996, + "error": 0.34375, + "gradient_norm": 0.0483400784432888, + "elapsed": 164.35339641571045 + }, + { + "step": 480, + "loss": 0.6074748039245605, + "error": 0.357421875, + "gradient_norm": 0.07674132287502289, + "elapsed": 169.8213918209076 + }, + { + "step": 496, + "loss": 0.4164890646934509, + "error": 0.197265625, + "gradient_norm": 0.061338409781455994, + "elapsed": 174.49940991401672 + }, + { + "step": 512, + "loss": 0.6227350234985352, + "error": 0.3505859375, + "gradient_norm": 0.05870670825242996, + "elapsed": 179.1194713115692 + }, + { + "step": 528, + "loss": 0.6169978380203247, + "error": 0.3623046875, + "gradient_norm": 0.098697230219841, + "elapsed": 196.2275745868683 + }, + { + "step": 544, + "loss": 0.2587624788284302, + "error": 0.1123046875, + "gradient_norm": 0.022135253995656967, + "elapsed": 200.9405219554901 + }, + { + "step": 560, + "loss": 0.5247371196746826, + "error": 0.29296875, + "gradient_norm": 0.06389769911766052, + "elapsed": 205.67444229125977 + }, + { + "step": 576, + "loss": 0.05718298628926277, + "error": 0.015625, + "gradient_norm": 0.021210815757513046, + "elapsed": 210.3046429157257 + }, + { + "step": 592, + "loss": 0.43722718954086304, + "error": 0.212890625, + "gradient_norm": 0.06130598857998848, + "elapsed": 215.0165765285492 + }, + { + "step": 608, + "loss": 0.5744407773017883, + "error": 0.3203125, + "gradient_norm": 0.07507859915494919, + "elapsed": 219.74542117118835 + }, + { + "step": 624, + "loss": 0.5390439033508301, + "error": 0.294921875, + "gradient_norm": 0.036382775753736496, + "elapsed": 224.4689064025879 + }, + { + "step": 640, + "loss": 0.19186168909072876, + "error": 0.076171875, + "gradient_norm": 0.024380143731832504, + "elapsed": 229.15582585334778 + }, + { + "step": 656, + "loss": 0.05277765542268753, + "error": 0.015625, + "gradient_norm": 0.006531866267323494, + "elapsed": 233.81245923042297 + }, + { + "step": 672, + "loss": 0.5513497591018677, + "error": 0.298828125, + "gradient_norm": 0.1369253545999527, + "elapsed": 238.5322244167328 + }, + { + "step": 688, + "loss": 0.3628368377685547, + "error": 0.1611328125, + "gradient_norm": 0.035758279263973236, + "elapsed": 243.25305819511414 + }, + { + "step": 704, + "loss": 0.5448720455169678, + "error": 0.2890625, + "gradient_norm": 0.08170927315950394, + "elapsed": 248.0137722492218 + }, + { + "step": 720, + "loss": 0.6215678453445435, + "error": 0.380859375, + "gradient_norm": 0.03859468176960945, + "elapsed": 252.7013487815857 + }, + { + "step": 736, + "loss": 0.05821540951728821, + "error": 0.0205078125, + "gradient_norm": 0.03346256539225578, + "elapsed": 257.3715970516205 + }, + { + "step": 752, + "loss": 0.5765384435653687, + "error": 0.330078125, + "gradient_norm": 0.053423501551151276, + "elapsed": 262.0626804828644 + }, + { + "step": 768, + "loss": 0.5890514850616455, + "error": 0.3408203125, + "gradient_norm": 0.030601002275943756, + "elapsed": 266.704386472702 + }, + { + "step": 784, + "loss": 0.17312845587730408, + "error": 0.072265625, + "gradient_norm": 0.07305414229631424, + "elapsed": 271.3879518508911 + }, + { + "step": 800, + "loss": 0.5634596347808838, + "error": 0.318359375, + "gradient_norm": 0.07817637175321579, + "elapsed": 276.0717463493347 + }, + { + "step": 816, + "loss": 0.5935904383659363, + "error": 0.3388671875, + "gradient_norm": 0.07579515874385834, + "elapsed": 280.7568049430847 + }, + { + "step": 832, + "loss": 0.6194716095924377, + "error": 0.3837890625, + "gradient_norm": 0.02388901636004448, + "elapsed": 285.4642608165741 + }, + { + "step": 848, + "loss": 0.520949125289917, + "error": 0.2724609375, + "gradient_norm": 0.03898578882217407, + "elapsed": 290.3232216835022 + }, + { + "step": 864, + "loss": 0.15686637163162231, + "error": 0.064453125, + "gradient_norm": 0.057798173278570175, + "elapsed": 294.98178148269653 + }, + { + "step": 880, + "loss": 0.19637487828731537, + "error": 0.0712890625, + "gradient_norm": 0.05533617362380028, + "elapsed": 299.6453402042389 + }, + { + "step": 896, + "loss": 0.6358869075775146, + "error": 0.3896484375, + "gradient_norm": 0.09036138653755188, + "elapsed": 304.30250573158264 + }, + { + "step": 912, + "loss": 0.27959102392196655, + "error": 0.1240234375, + "gradient_norm": 0.08433368802070618, + "elapsed": 308.9346263408661 + }, + { + "step": 928, + "loss": 0.5670071840286255, + "error": 0.306640625, + "gradient_norm": 0.10389015078544617, + "elapsed": 313.57604146003723 + }, + { + "step": 944, + "loss": 0.3012816309928894, + "error": 0.1240234375, + "gradient_norm": 0.06701963394880295, + "elapsed": 318.2669222354889 + }, + { + "step": 960, + "loss": 0.366061806678772, + "error": 0.169921875, + "gradient_norm": 0.03428084775805473, + "elapsed": 323.0082552433014 + }, + { + "step": 976, + "loss": 0.6076786518096924, + "error": 0.365234375, + "gradient_norm": 0.07815126329660416, + "elapsed": 327.6706819534302 + }, + { + "step": 992, + "loss": 0.6151949167251587, + "error": 0.3525390625, + "gradient_norm": 0.09757541865110397, + "elapsed": 332.3222963809967 + }, + { + "step": 1008, + "loss": 0.5961805582046509, + "error": 0.3505859375, + "gradient_norm": 0.05717983841896057, + "elapsed": 336.9618263244629 + }, + { + "step": 1024, + "loss": 0.6189296245574951, + "error": 0.365234375, + "gradient_norm": 0.13010352849960327, + "elapsed": 341.6393735408783 + } + ], + "sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_exact/fresh_temporal1_warm", + "sampling_replayed_checkpoints": [ + 512, + 1024 + ], + "eligible_training_rows": 2067520, + "training_draws": 1048576, + "distinct_phase_training_rows": 805845, + "distinct_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 7368, + "surface_code_bX_d3_r03_center_3_5": 10180, + "surface_code_bX_d3_r05_center_3_5": 11996, + "surface_code_bX_d3_r07_center_3_5": 8612, + "surface_code_bX_d3_r09_center_3_5": 9665, + "surface_code_bX_d3_r11_center_3_5": 9130, + "surface_code_bX_d3_r13_center_3_5": 8025, + "surface_code_bX_d3_r15_center_3_5": 6058, + "surface_code_bX_d3_r17_center_3_5": 8648, + "surface_code_bX_d3_r19_center_3_5": 9138, + "surface_code_bX_d3_r21_center_3_5": 6714, + "surface_code_bX_d3_r23_center_3_5": 8607, + "surface_code_bX_d3_r25_center_3_5": 7455, + "surface_code_bX_d3_r01_center_5_3": 10671, + "surface_code_bX_d3_r03_center_5_3": 6015, + "surface_code_bX_d3_r05_center_5_3": 8634, + "surface_code_bX_d3_r07_center_5_3": 8553, + "surface_code_bX_d3_r09_center_5_3": 7391, + "surface_code_bX_d3_r11_center_5_3": 10239, + "surface_code_bX_d3_r13_center_5_3": 9776, + "surface_code_bX_d3_r15_center_5_3": 8010, + "surface_code_bX_d3_r17_center_5_3": 9174, + "surface_code_bX_d3_r19_center_5_3": 7364, + "surface_code_bX_d3_r21_center_5_3": 9761, + "surface_code_bX_d3_r23_center_5_3": 4457, + "surface_code_bX_d3_r25_center_5_3": 12037, + "surface_code_bX_d3_r01_center_5_7": 6710, + "surface_code_bX_d3_r03_center_5_7": 7365, + "surface_code_bX_d3_r05_center_5_7": 11614, + "surface_code_bX_d3_r07_center_5_7": 7387, + "surface_code_bX_d3_r09_center_5_7": 7986, + "surface_code_bX_d3_r11_center_5_7": 6744, + "surface_code_bX_d3_r13_center_5_7": 8017, + "surface_code_bX_d3_r15_center_5_7": 7315, + "surface_code_bX_d3_r17_center_5_7": 5281, + "surface_code_bX_d3_r19_center_5_7": 5271, + "surface_code_bX_d3_r21_center_5_7": 6017, + "surface_code_bX_d3_r23_center_5_7": 8021, + "surface_code_bX_d3_r25_center_5_7": 8010, + "surface_code_bX_d3_r01_center_7_5": 8608, + "surface_code_bX_d3_r03_center_7_5": 9133, + "surface_code_bX_d3_r05_center_7_5": 10756, + "surface_code_bX_d3_r07_center_7_5": 7332, + "surface_code_bX_d3_r09_center_7_5": 6726, + "surface_code_bX_d3_r11_center_7_5": 9734, + "surface_code_bX_d3_r13_center_7_5": 11169, + "surface_code_bX_d3_r15_center_7_5": 6032, + "surface_code_bX_d3_r17_center_7_5": 5287, + "surface_code_bX_d3_r19_center_7_5": 12010, + "surface_code_bX_d3_r21_center_7_5": 7993, + "surface_code_bX_d3_r23_center_7_5": 7349, + "surface_code_bX_d3_r25_center_7_5": 6723, + "surface_code_bZ_d3_r01_center_3_5": 10253, + "surface_code_bZ_d3_r03_center_3_5": 4531, + "surface_code_bZ_d3_r05_center_3_5": 9189, + "surface_code_bZ_d3_r07_center_3_5": 5303, + "surface_code_bZ_d3_r09_center_3_5": 8018, + "surface_code_bZ_d3_r11_center_3_5": 6730, + "surface_code_bZ_d3_r13_center_3_5": 4509, + "surface_code_bZ_d3_r15_center_3_5": 8555, + "surface_code_bZ_d3_r17_center_3_5": 6697, + "surface_code_bZ_d3_r19_center_3_5": 9190, + "surface_code_bZ_d3_r21_center_3_5": 6724, + "surface_code_bZ_d3_r23_center_3_5": 7373, + "surface_code_bZ_d3_r25_center_3_5": 8594, + "surface_code_bZ_d3_r01_center_5_3": 5307, + "surface_code_bZ_d3_r03_center_5_3": 10773, + "surface_code_bZ_d3_r05_center_5_3": 6016, + "surface_code_bZ_d3_r07_center_5_3": 9681, + "surface_code_bZ_d3_r09_center_5_3": 1959, + "surface_code_bZ_d3_r11_center_5_3": 5273, + "surface_code_bZ_d3_r13_center_5_3": 3723, + "surface_code_bZ_d3_r15_center_5_3": 6760, + "surface_code_bZ_d3_r17_center_5_3": 6017, + "surface_code_bZ_d3_r19_center_5_3": 5990, + "surface_code_bZ_d3_r21_center_5_3": 4521, + "surface_code_bZ_d3_r23_center_5_3": 10684, + "surface_code_bZ_d3_r25_center_5_3": 8025, + "surface_code_bZ_d3_r01_center_5_7": 8639, + "surface_code_bZ_d3_r03_center_5_7": 8601, + "surface_code_bZ_d3_r05_center_5_7": 9147, + "surface_code_bZ_d3_r07_center_5_7": 3697, + "surface_code_bZ_d3_r09_center_5_7": 8580, + "surface_code_bZ_d3_r11_center_5_7": 7403, + "surface_code_bZ_d3_r13_center_5_7": 6050, + "surface_code_bZ_d3_r15_center_5_7": 7417, + "surface_code_bZ_d3_r17_center_5_7": 9123, + "surface_code_bZ_d3_r19_center_5_7": 8018, + "surface_code_bZ_d3_r21_center_5_7": 6711, + "surface_code_bZ_d3_r23_center_5_7": 10239, + "surface_code_bZ_d3_r25_center_5_7": 4534, + "surface_code_bZ_d3_r01_center_7_5": 6724, + "surface_code_bZ_d3_r03_center_7_5": 7384, + "surface_code_bZ_d3_r05_center_7_5": 7417, + "surface_code_bZ_d3_r07_center_7_5": 6719, + "surface_code_bZ_d3_r09_center_7_5": 10697, + "surface_code_bZ_d3_r11_center_7_5": 9158, + "surface_code_bZ_d3_r13_center_7_5": 9191, + "surface_code_bZ_d3_r15_center_7_5": 7387, + "surface_code_bZ_d3_r17_center_7_5": 7952, + "surface_code_bZ_d3_r19_center_7_5": 3733, + "surface_code_bZ_d3_r21_center_7_5": 7392, + "surface_code_bZ_d3_r23_center_7_5": 8555, + "surface_code_bZ_d3_r25_center_7_5": 6714 + }, + "initial_optimizer_count": 0, + "final_optimizer_count": 1024, + "phase_start_weights_sha256": "ac433aed92210db54462c1b43f28ef1cad6dcf440dc4fa16c36b00e46c4a1f89", + "phase_start_rng_sha256": "f0e363f38b6f09d38f93970bfe3bc1d0d3562c8fabef0de76c1cfb41c36acaff", + "parent_checkpoint_sha256": null, + "source_sha256": "9f739f4865d3596d545529edaf2fc7f129ce2ac3701aa4be8ceb0613cb608690", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "A fully independent d3 trunk/temporal initialization may provide useful accuracy or complementarity beyond continuations of the shared original seed", + "initial_seed": 20261300, + "encoder_seed": 20261301, + "sampling_seed": 20261302, + "architecture": "Existing128-unit rich trunk plus32-channel temporal encoder,177features,4*tanh corrections,exact width10 joint contraction; all neural parameters initialized fresh, no learned checkpoint used in warm initialization", + "data": "All2067520 supplied d3 training rows across104conditions eligible from first update; uniform condition/row sampling with replacement; no reserved split for this fixed-mixture study", + "schedule": "1024 updates B1024 LR.001; then6144 LR.0005 restoring own optimizer/RNG. AdamW decay1e-4/globalclip1. Original initialization code/scales retained except seeds; all temporal features present from first update", + "validation": "Full532480 d3 validation shots at main0/2048/4096/6144. Main0 is trained warm1024. Per-group raw/equal-small-contextual choices versus incumbent acrossall13durations; full replay/score/relocation/timebudget controls if better", + "fixed_ensemble": "Freeze original selected temporal components before training. Pick each group new raw checkpoint by full-validation mean failure; compare incumbent with equal old/new temporal average and that mixture averaged equally with fixed small-contextual reference. No mixture weights fitted. Recheck existing categorical1 short heads afterward", + "interpretation": "Tests an independent direct-training recipe; not an isolated causal ablation of initialization because the historical original used staged rich/temporal training", + "gpu": "One H100, serialized afterfour_seed_finished", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "device": "CPU", + "initial_seed": 20261300, + "encoder_seed": 20261301, + "sampling_seed": 20261302, + "fresh_initialization_exact": true, + "independent_seed_effects_checked": true, + "audits": [ + { + "run": "/run-state/workspace/research/learned_exact/fresh_temporal_smoke1", + "optimizer_end_count": 1, + "sampling_replay_exact": true, + "all104_condition_screens_passed": true, + "eligible_training_rows": 2067520 + }, + { + "run": "/run-state/workspace/research/learned_exact/fresh_temporal_smoke2", + "optimizer_end_count": 2, + "sampling_replay_exact": true, + "all104_condition_screens_passed": true, + "eligible_training_rows": 2067520 + } + ], + "training_source_sha256": { + "learned_exact__fresh_temporal_train.py": "366163a0c52e537485ab92df6c217600070886c0d0f0880abda4cd55d89cef20", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__fresh_temporal_initialization.py": "5e776e118573bceb5c253d6ae58d154ca9c95a375ddcf631d46ab7b846440ffb", + "learned_exact__model.py": "bc36fa5fa0191abc8e67e4ede0d4ff87848d80e9e2fac5cd60c0ac4fcefc3088", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "source_sha256": "3087fc1f9870dea649b73049a011cd2ce1198599f5cbc63b1fd0ba8da8ea6035", + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6341909170150757, + "error": 0.4013671875, + "gradient_norm": 0.05585212633013725, + "elapsed": 32.28317856788635 + }, + { + "step": 16, + "loss": 0.456127405166626, + "error": 0.2255859375, + "gradient_norm": 0.046588145196437836, + "elapsed": 36.59702777862549 + }, + { + "step": 32, + "loss": 0.04657192528247833, + "error": 0.0126953125, + "gradient_norm": 0.033088602125644684, + "elapsed": 41.29656410217285 + }, + { + "step": 48, + "loss": 0.6189465522766113, + "error": 0.375, + "gradient_norm": 0.03974652290344238, + "elapsed": 45.95187759399414 + }, + { + "step": 64, + "loss": 0.5583971738815308, + "error": 0.3056640625, + "gradient_norm": 0.03700100630521774, + "elapsed": 50.5803005695343 + }, + { + "step": 80, + "loss": 0.03466007858514786, + "error": 0.0126953125, + "gradient_norm": 0.019406599923968315, + "elapsed": 55.25237274169922 + }, + { + "step": 96, + "loss": 0.5516310930252075, + "error": 0.2958984375, + "gradient_norm": 0.04349132254719734, + "elapsed": 59.85644865036011 + }, + { + "step": 112, + "loss": 0.5548046231269836, + "error": 0.298828125, + "gradient_norm": 0.04338373616337776, + "elapsed": 64.55351972579956 + }, + { + "step": 128, + "loss": 0.46574971079826355, + "error": 0.234375, + "gradient_norm": 0.08960820734500885, + "elapsed": 69.1681661605835 + }, + { + "step": 144, + "loss": 0.05429682508111, + "error": 0.0185546875, + "gradient_norm": 0.011900621466338634, + "elapsed": 73.7904441356659 + }, + { + "step": 160, + "loss": 0.35522276163101196, + "error": 0.1669921875, + "gradient_norm": 0.044266730546951294, + "elapsed": 78.53880095481873 + }, + { + "step": 176, + "loss": 0.5386976599693298, + "error": 0.3056640625, + "gradient_norm": 0.07917412370443344, + "elapsed": 83.28840517997742 + }, + { + "step": 192, + "loss": 0.2644604742527008, + "error": 0.1181640625, + "gradient_norm": 0.025316553190350533, + "elapsed": 87.95155954360962 + }, + { + "step": 208, + "loss": 0.4947037696838379, + "error": 0.2509765625, + "gradient_norm": 0.06943541020154953, + "elapsed": 92.61985993385315 + }, + { + "step": 224, + "loss": 0.615615725517273, + "error": 0.3408203125, + "gradient_norm": 0.07630990445613861, + "elapsed": 97.2170205116272 + }, + { + "step": 240, + "loss": 0.5095486044883728, + "error": 0.2744140625, + "gradient_norm": 0.07120614498853683, + "elapsed": 101.91877818107605 + }, + { + "step": 256, + "loss": 0.5333108901977539, + "error": 0.310546875, + "gradient_norm": 0.07515383511781693, + "elapsed": 106.49094939231873 + }, + { + "step": 272, + "loss": 0.5162908434867859, + "error": 0.2744140625, + "gradient_norm": 0.05129021033644676, + "elapsed": 111.15040564537048 + }, + { + "step": 288, + "loss": 0.5398142337799072, + "error": 0.31640625, + "gradient_norm": 0.06806779652833939, + "elapsed": 115.6865484714508 + }, + { + "step": 304, + "loss": 0.3107696771621704, + "error": 0.1455078125, + "gradient_norm": 0.09763714671134949, + "elapsed": 120.31649327278137 + }, + { + "step": 320, + "loss": 0.04630197584629059, + "error": 0.0146484375, + "gradient_norm": 0.01098143495619297, + "elapsed": 124.94930696487427 + }, + { + "step": 336, + "loss": 0.6275073885917664, + "error": 0.3759765625, + "gradient_norm": 0.05482485517859459, + "elapsed": 129.56086540222168 + }, + { + "step": 352, + "loss": 0.6060937643051147, + "error": 0.3369140625, + "gradient_norm": 0.07023993134498596, + "elapsed": 134.28360033035278 + }, + { + "step": 368, + "loss": 0.5901987552642822, + "error": 0.35546875, + "gradient_norm": 0.06627754122018814, + "elapsed": 138.81673049926758 + }, + { + "step": 384, + "loss": 0.6594040393829346, + "error": 0.400390625, + "gradient_norm": 0.1026342362165451, + "elapsed": 143.42880535125732 + }, + { + "step": 400, + "loss": 0.3803889751434326, + "error": 0.1796875, + "gradient_norm": 0.03560839965939522, + "elapsed": 148.03747177124023 + }, + { + "step": 416, + "loss": 0.6085200309753418, + "error": 0.369140625, + "gradient_norm": 0.030336299911141396, + "elapsed": 152.65069365501404 + }, + { + "step": 432, + "loss": 0.36734795570373535, + "error": 0.1708984375, + "gradient_norm": 0.03496645390987396, + "elapsed": 157.23520922660828 + }, + { + "step": 448, + "loss": 0.3846629559993744, + "error": 0.1728515625, + "gradient_norm": 0.11889868229627609, + "elapsed": 161.93284916877747 + }, + { + "step": 464, + "loss": 0.23870262503623962, + "error": 0.1064453125, + "gradient_norm": 0.0607006661593914, + "elapsed": 166.58285808563232 + }, + { + "step": 480, + "loss": 0.4664641320705414, + "error": 0.2236328125, + "gradient_norm": 0.05872314050793648, + "elapsed": 171.21521162986755 + }, + { + "step": 496, + "loss": 0.3944041430950165, + "error": 0.1796875, + "gradient_norm": 0.050601981580257416, + "elapsed": 175.85764479637146 + }, + { + "step": 512, + "loss": 0.5885912775993347, + "error": 0.328125, + "gradient_norm": 0.046007562428712845, + "elapsed": 180.53591585159302 + }, + { + "step": 528, + "loss": 0.43844735622406006, + "error": 0.2099609375, + "gradient_norm": 0.1198468953371048, + "elapsed": 185.25590872764587 + }, + { + "step": 544, + "loss": 0.6136760115623474, + "error": 0.359375, + "gradient_norm": 0.0467623770236969, + "elapsed": 189.82663464546204 + }, + { + "step": 560, + "loss": 0.5299022197723389, + "error": 0.28515625, + "gradient_norm": 0.10448995977640152, + "elapsed": 194.53549695014954 + }, + { + "step": 576, + "loss": 0.6356092691421509, + "error": 0.37890625, + "gradient_norm": 0.02995666302740574, + "elapsed": 199.08422470092773 + }, + { + "step": 592, + "loss": 0.6018321514129639, + "error": 0.35546875, + "gradient_norm": 0.0668799951672554, + "elapsed": 203.73297691345215 + }, + { + "step": 608, + "loss": 0.6308359503746033, + "error": 0.3662109375, + "gradient_norm": 0.03168797865509987, + "elapsed": 208.34401726722717 + }, + { + "step": 624, + "loss": 0.5222915410995483, + "error": 0.2822265625, + "gradient_norm": 0.1146664246916771, + "elapsed": 212.99023914337158 + }, + { + "step": 640, + "loss": 0.4680047333240509, + "error": 0.228515625, + "gradient_norm": 0.04169515147805214, + "elapsed": 217.72008228302002 + }, + { + "step": 656, + "loss": 0.6042362451553345, + "error": 0.3466796875, + "gradient_norm": 0.0828205868601799, + "elapsed": 222.3381130695343 + }, + { + "step": 672, + "loss": 0.6178575158119202, + "error": 0.375, + "gradient_norm": 0.03251202031970024, + "elapsed": 226.88199996948242 + }, + { + "step": 688, + "loss": 0.42640379071235657, + "error": 0.208984375, + "gradient_norm": 0.07412807643413544, + "elapsed": 231.63267493247986 + }, + { + "step": 704, + "loss": 0.3711197078227997, + "error": 0.1748046875, + "gradient_norm": 0.044139791280031204, + "elapsed": 236.23333978652954 + }, + { + "step": 720, + "loss": 0.5284324288368225, + "error": 0.2841796875, + "gradient_norm": 0.03873316943645477, + "elapsed": 240.83383870124817 + }, + { + "step": 736, + "loss": 0.16025343537330627, + "error": 0.060546875, + "gradient_norm": 0.05114922299981117, + "elapsed": 245.5975468158722 + }, + { + "step": 752, + "loss": 0.6351460218429565, + "error": 0.3916015625, + "gradient_norm": 0.04426570236682892, + "elapsed": 250.25391268730164 + }, + { + "step": 768, + "loss": 0.5509989857673645, + "error": 0.30078125, + "gradient_norm": 0.10688307136297226, + "elapsed": 254.902690410614 + }, + { + "step": 784, + "loss": 0.6286169290542603, + "error": 0.3662109375, + "gradient_norm": 0.07505354285240173, + "elapsed": 259.5052902698517 + }, + { + "step": 800, + "loss": 0.5576198697090149, + "error": 0.2919921875, + "gradient_norm": 0.06140255555510521, + "elapsed": 264.1623592376709 + }, + { + "step": 816, + "loss": 0.05915779992938042, + "error": 0.017578125, + "gradient_norm": 0.01805649697780609, + "elapsed": 268.80254578590393 + }, + { + "step": 832, + "loss": 0.38657045364379883, + "error": 0.1767578125, + "gradient_norm": 0.12654690444469452, + "elapsed": 273.38897037506104 + }, + { + "step": 848, + "loss": 0.28410667181015015, + "error": 0.115234375, + "gradient_norm": 0.038617584854364395, + "elapsed": 278.1598415374756 + }, + { + "step": 864, + "loss": 0.47303736209869385, + "error": 0.248046875, + "gradient_norm": 0.03542777895927429, + "elapsed": 282.80416107177734 + }, + { + "step": 880, + "loss": 0.5891786813735962, + "error": 0.3642578125, + "gradient_norm": 0.12498646974563599, + "elapsed": 287.4678556919098 + }, + { + "step": 896, + "loss": 0.3116525411605835, + "error": 0.1298828125, + "gradient_norm": 0.047197770327329636, + "elapsed": 292.16887307167053 + }, + { + "step": 912, + "loss": 0.42549118399620056, + "error": 0.2080078125, + "gradient_norm": 0.05146906524896622, + "elapsed": 296.8276309967041 + }, + { + "step": 928, + "loss": 0.0634768158197403, + "error": 0.0224609375, + "gradient_norm": 0.03060089610517025, + "elapsed": 301.50970005989075 + }, + { + "step": 944, + "loss": 0.6288316249847412, + "error": 0.373046875, + "gradient_norm": 0.06184377148747444, + "elapsed": 306.39040327072144 + }, + { + "step": 960, + "loss": 0.6475993990898132, + "error": 0.3994140625, + "gradient_norm": 0.07131482660770416, + "elapsed": 311.18965768814087 + }, + { + "step": 976, + "loss": 0.59993577003479, + "error": 0.3642578125, + "gradient_norm": 0.06932099908590317, + "elapsed": 315.96173071861267 + }, + { + "step": 992, + "loss": 0.6319019794464111, + "error": 0.3994140625, + "gradient_norm": 0.06504041701555252, + "elapsed": 320.6668322086334 + }, + { + "step": 1008, + "loss": 0.4708365797996521, + "error": 0.2373046875, + "gradient_norm": 0.04225744679570198, + "elapsed": 325.415559053421 + }, + { + "step": 1024, + "loss": 0.6430202722549438, + "error": 0.408203125, + "gradient_norm": 0.06004021316766739, + "elapsed": 330.17973923683167 + }, + { + "step": 1040, + "loss": 0.15643015503883362, + "error": 0.0576171875, + "gradient_norm": 0.03150030970573425, + "elapsed": 334.8280999660492 + }, + { + "step": 1056, + "loss": 0.48963552713394165, + "error": 0.263671875, + "gradient_norm": 0.10803613066673279, + "elapsed": 339.5090026855469 + }, + { + "step": 1072, + "loss": 0.6405315399169922, + "error": 0.3857421875, + "gradient_norm": 0.047702908515930176, + "elapsed": 344.17492485046387 + }, + { + "step": 1088, + "loss": 0.3234683871269226, + "error": 0.1572265625, + "gradient_norm": 0.049128271639347076, + "elapsed": 348.84293127059937 + }, + { + "step": 1104, + "loss": 0.619228720664978, + "error": 0.392578125, + "gradient_norm": 0.05446392297744751, + "elapsed": 353.5684473514557 + }, + { + "step": 1120, + "loss": 0.6581277251243591, + "error": 0.4013671875, + "gradient_norm": 0.07903233915567398, + "elapsed": 358.2885591983795 + }, + { + "step": 1136, + "loss": 0.5328423380851746, + "error": 0.2890625, + "gradient_norm": 0.10206863284111023, + "elapsed": 362.99575638771057 + }, + { + "step": 1152, + "loss": 0.6385581493377686, + "error": 0.408203125, + "gradient_norm": 0.04808427765965462, + "elapsed": 367.7000253200531 + }, + { + "step": 1168, + "loss": 0.06468203663825989, + "error": 0.0224609375, + "gradient_norm": 0.047940801829099655, + "elapsed": 372.4194619655609 + }, + { + "step": 1184, + "loss": 0.06591373682022095, + "error": 0.0244140625, + "gradient_norm": 0.009472771547734737, + "elapsed": 377.16490364074707 + }, + { + "step": 1200, + "loss": 0.6552315950393677, + "error": 0.4091796875, + "gradient_norm": 0.05334237962961197, + "elapsed": 381.86866331100464 + }, + { + "step": 1216, + "loss": 0.16547518968582153, + "error": 0.0673828125, + "gradient_norm": 0.04886999353766441, + "elapsed": 386.49158549308777 + }, + { + "step": 1232, + "loss": 0.34151381254196167, + "error": 0.177734375, + "gradient_norm": 0.03777805343270302, + "elapsed": 391.30346608161926 + }, + { + "step": 1248, + "loss": 0.17612549662590027, + "error": 0.0810546875, + "gradient_norm": 0.034834422171115875, + "elapsed": 396.0469307899475 + }, + { + "step": 1264, + "loss": 0.6107323169708252, + "error": 0.357421875, + "gradient_norm": 0.03001052513718605, + "elapsed": 400.90507769584656 + }, + { + "step": 1280, + "loss": 0.37743276357650757, + "error": 0.1806640625, + "gradient_norm": 0.051271237432956696, + "elapsed": 405.717068195343 + }, + { + "step": 1296, + "loss": 0.20403912663459778, + "error": 0.078125, + "gradient_norm": 0.05912303179502487, + "elapsed": 410.3923969268799 + }, + { + "step": 1312, + "loss": 0.1675759255886078, + "error": 0.06640625, + "gradient_norm": 0.08029310405254364, + "elapsed": 415.10699820518494 + }, + { + "step": 1328, + "loss": 0.6141129732131958, + "error": 0.361328125, + "gradient_norm": 0.07506722211837769, + "elapsed": 419.8230435848236 + }, + { + "step": 1344, + "loss": 0.18071675300598145, + "error": 0.0751953125, + "gradient_norm": 0.021455086767673492, + "elapsed": 424.5374264717102 + }, + { + "step": 1360, + "loss": 0.6552559733390808, + "error": 0.431640625, + "gradient_norm": 0.05407087877392769, + "elapsed": 429.2148015499115 + }, + { + "step": 1376, + "loss": 0.618600606918335, + "error": 0.3564453125, + "gradient_norm": 0.042265623807907104, + "elapsed": 433.92309975624084 + }, + { + "step": 1392, + "loss": 0.6499584913253784, + "error": 0.4072265625, + "gradient_norm": 0.1180991604924202, + "elapsed": 438.78556871414185 + }, + { + "step": 1408, + "loss": 0.6095918416976929, + "error": 0.3720703125, + "gradient_norm": 0.03585854172706604, + "elapsed": 443.46277475357056 + }, + { + "step": 1424, + "loss": 0.6362854838371277, + "error": 0.384765625, + "gradient_norm": 0.0688432827591896, + "elapsed": 448.2213034629822 + }, + { + "step": 1440, + "loss": 0.30842864513397217, + "error": 0.15234375, + "gradient_norm": 0.09746919572353363, + "elapsed": 452.9967062473297 + }, + { + "step": 1456, + "loss": 0.6272240877151489, + "error": 0.3916015625, + "gradient_norm": 0.03176156431436539, + "elapsed": 457.80520462989807 + }, + { + "step": 1472, + "loss": 0.46614566445350647, + "error": 0.224609375, + "gradient_norm": 0.06449230015277863, + "elapsed": 462.4930462837219 + }, + { + "step": 1488, + "loss": 0.5790297985076904, + "error": 0.33203125, + "gradient_norm": 0.05202231928706169, + "elapsed": 467.40463280677795 + }, + { + "step": 1504, + "loss": 0.5788902044296265, + "error": 0.3310546875, + "gradient_norm": 0.03769056499004364, + "elapsed": 472.248553276062 + }, + { + "step": 1520, + "loss": 0.39975684881210327, + "error": 0.1904296875, + "gradient_norm": 0.04010908678174019, + "elapsed": 477.0461850166321 + }, + { + "step": 1536, + "loss": 0.17822569608688354, + "error": 0.0712890625, + "gradient_norm": 0.07238694280385971, + "elapsed": 481.7407524585724 + }, + { + "step": 1552, + "loss": 0.5427708029747009, + "error": 0.2958984375, + "gradient_norm": 0.07285252213478088, + "elapsed": 486.53775358200073 + }, + { + "step": 1568, + "loss": 0.42445769906044006, + "error": 0.205078125, + "gradient_norm": 0.1447010487318039, + "elapsed": 491.21664571762085 + }, + { + "step": 1584, + "loss": 0.5689634084701538, + "error": 0.3046875, + "gradient_norm": 0.035228826105594635, + "elapsed": 495.95153307914734 + }, + { + "step": 1600, + "loss": 0.16538125276565552, + "error": 0.0595703125, + "gradient_norm": 0.046762529760599136, + "elapsed": 500.59500527381897 + }, + { + "step": 1616, + "loss": 0.48107683658599854, + "error": 0.267578125, + "gradient_norm": 0.0425315760076046, + "elapsed": 505.408282995224 + }, + { + "step": 1632, + "loss": 0.49956071376800537, + "error": 0.2607421875, + "gradient_norm": 0.049997735768556595, + "elapsed": 510.2778625488281 + }, + { + "step": 1648, + "loss": 0.4562152624130249, + "error": 0.23046875, + "gradient_norm": 0.08852462470531464, + "elapsed": 515.2828216552734 + }, + { + "step": 1664, + "loss": 0.304529070854187, + "error": 0.13671875, + "gradient_norm": 0.036250144243240356, + "elapsed": 519.9940991401672 + }, + { + "step": 1680, + "loss": 0.5833057165145874, + "error": 0.310546875, + "gradient_norm": 0.045563891530036926, + "elapsed": 524.785187959671 + }, + { + "step": 1696, + "loss": 0.5309747457504272, + "error": 0.28125, + "gradient_norm": 0.07198496907949448, + "elapsed": 529.5726261138916 + }, + { + "step": 1712, + "loss": 0.27641019225120544, + "error": 0.1220703125, + "gradient_norm": 0.05701657384634018, + "elapsed": 534.3710963726044 + }, + { + "step": 1728, + "loss": 0.3296618163585663, + "error": 0.1484375, + "gradient_norm": 0.052221205085515976, + "elapsed": 539.1172955036163 + }, + { + "step": 1744, + "loss": 0.5601730346679688, + "error": 0.3251953125, + "gradient_norm": 0.051884688436985016, + "elapsed": 543.97318983078 + }, + { + "step": 1760, + "loss": 0.6139429807662964, + "error": 0.357421875, + "gradient_norm": 0.05166471004486084, + "elapsed": 548.742434501648 + }, + { + "step": 1776, + "loss": 0.2092965543270111, + "error": 0.0791015625, + "gradient_norm": 0.04677150025963783, + "elapsed": 553.4552154541016 + }, + { + "step": 1792, + "loss": 0.6146889925003052, + "error": 0.3779296875, + "gradient_norm": 0.058625478297472, + "elapsed": 558.2058596611023 + }, + { + "step": 1808, + "loss": 0.6289598941802979, + "error": 0.3642578125, + "gradient_norm": 0.03946023806929588, + "elapsed": 562.9514946937561 + }, + { + "step": 1824, + "loss": 0.39613020420074463, + "error": 0.2080078125, + "gradient_norm": 0.06473295390605927, + "elapsed": 567.66179728508 + }, + { + "step": 1840, + "loss": 0.03428482264280319, + "error": 0.01171875, + "gradient_norm": 0.025456221774220467, + "elapsed": 572.3990049362183 + }, + { + "step": 1856, + "loss": 0.41345760226249695, + "error": 0.203125, + "gradient_norm": 0.04492348060011864, + "elapsed": 577.1865518093109 + }, + { + "step": 1872, + "loss": 0.654647707939148, + "error": 0.392578125, + "gradient_norm": 0.11777105927467346, + "elapsed": 582.062207698822 + }, + { + "step": 1888, + "loss": 0.6227863430976868, + "error": 0.376953125, + "gradient_norm": 0.0900707021355629, + "elapsed": 586.7429945468903 + }, + { + "step": 1904, + "loss": 0.49292421340942383, + "error": 0.2587890625, + "gradient_norm": 0.047608889639377594, + "elapsed": 591.4822914600372 + }, + { + "step": 1920, + "loss": 0.22034738957881927, + "error": 0.08984375, + "gradient_norm": 0.08454853296279907, + "elapsed": 596.2034058570862 + }, + { + "step": 1936, + "loss": 0.051317501813173294, + "error": 0.017578125, + "gradient_norm": 0.013038767501711845, + "elapsed": 600.8624582290649 + }, + { + "step": 1952, + "loss": 0.5136944055557251, + "error": 0.2626953125, + "gradient_norm": 0.09549390524625778, + "elapsed": 605.5240256786346 + }, + { + "step": 1968, + "loss": 0.6111668944358826, + "error": 0.3515625, + "gradient_norm": 0.034260354936122894, + "elapsed": 610.3351051807404 + }, + { + "step": 1984, + "loss": 0.472719669342041, + "error": 0.26171875, + "gradient_norm": 0.12456662952899933, + "elapsed": 615.0500724315643 + }, + { + "step": 2000, + "loss": 0.6162117719650269, + "error": 0.353515625, + "gradient_norm": 0.030650220811367035, + "elapsed": 619.7509381771088 + }, + { + "step": 2016, + "loss": 0.27654582262039185, + "error": 0.1279296875, + "gradient_norm": 0.04047423601150513, + "elapsed": 624.4685935974121 + }, + { + "step": 2032, + "loss": 0.5032722353935242, + "error": 0.2587890625, + "gradient_norm": 0.045484982430934906, + "elapsed": 629.2459764480591 + }, + { + "step": 2048, + "loss": 0.055038534104824066, + "error": 0.0185546875, + "gradient_norm": 0.01552350539714098, + "elapsed": 633.9705281257629 + }, + { + "step": 2064, + "loss": 0.2254418432712555, + "error": 0.0986328125, + "gradient_norm": 0.07971645146608353, + "elapsed": 650.0332264900208 + }, + { + "step": 2080, + "loss": 0.5926885604858398, + "error": 0.3388671875, + "gradient_norm": 0.04898345470428467, + "elapsed": 654.7273683547974 + }, + { + "step": 2096, + "loss": 0.4063616991043091, + "error": 0.1826171875, + "gradient_norm": 0.03498317301273346, + "elapsed": 659.4939618110657 + }, + { + "step": 2112, + "loss": 0.22919878363609314, + "error": 0.1015625, + "gradient_norm": 0.08031623065471649, + "elapsed": 664.2422962188721 + }, + { + "step": 2128, + "loss": 0.6161428689956665, + "error": 0.3564453125, + "gradient_norm": 0.052767764776945114, + "elapsed": 668.8916397094727 + }, + { + "step": 2144, + "loss": 0.6014909744262695, + "error": 0.361328125, + "gradient_norm": 0.060356494039297104, + "elapsed": 673.6013762950897 + }, + { + "step": 2160, + "loss": 0.5150203108787537, + "error": 0.29296875, + "gradient_norm": 0.04678260535001755, + "elapsed": 678.3040428161621 + }, + { + "step": 2176, + "loss": 0.6039552688598633, + "error": 0.333984375, + "gradient_norm": 0.04778292402625084, + "elapsed": 683.0881252288818 + }, + { + "step": 2192, + "loss": 0.6009731292724609, + "error": 0.3623046875, + "gradient_norm": 0.05769297108054161, + "elapsed": 687.8723254203796 + }, + { + "step": 2208, + "loss": 0.4049401879310608, + "error": 0.189453125, + "gradient_norm": 0.0663701593875885, + "elapsed": 692.6133396625519 + }, + { + "step": 2224, + "loss": 0.05646701157093048, + "error": 0.017578125, + "gradient_norm": 0.03609362244606018, + "elapsed": 697.364550113678 + }, + { + "step": 2240, + "loss": 0.48992472887039185, + "error": 0.2646484375, + "gradient_norm": 0.0424848236143589, + "elapsed": 702.0832378864288 + }, + { + "step": 2256, + "loss": 0.19377350807189941, + "error": 0.08203125, + "gradient_norm": 0.03500033915042877, + "elapsed": 706.8569564819336 + }, + { + "step": 2272, + "loss": 0.1980733573436737, + "error": 0.0869140625, + "gradient_norm": 0.045778438448905945, + "elapsed": 711.5871696472168 + }, + { + "step": 2288, + "loss": 0.29163089394569397, + "error": 0.1328125, + "gradient_norm": 0.10073326528072357, + "elapsed": 716.2904229164124 + }, + { + "step": 2304, + "loss": 0.5809526443481445, + "error": 0.3466796875, + "gradient_norm": 0.06220729276537895, + "elapsed": 721.0387332439423 + }, + { + "step": 2320, + "loss": 0.27267956733703613, + "error": 0.1181640625, + "gradient_norm": 0.06212710589170456, + "elapsed": 725.8135886192322 + }, + { + "step": 2336, + "loss": 0.29143351316452026, + "error": 0.1181640625, + "gradient_norm": 0.035241350531578064, + "elapsed": 730.5655705928802 + }, + { + "step": 2352, + "loss": 0.4917527437210083, + "error": 0.2666015625, + "gradient_norm": 0.08863461017608643, + "elapsed": 735.3855311870575 + }, + { + "step": 2368, + "loss": 0.5735359191894531, + "error": 0.3037109375, + "gradient_norm": 0.0414167158305645, + "elapsed": 740.0458054542542 + }, + { + "step": 2384, + "loss": 0.44610151648521423, + "error": 0.2265625, + "gradient_norm": 0.032321102917194366, + "elapsed": 744.7695000171661 + }, + { + "step": 2400, + "loss": 0.5107525587081909, + "error": 0.2646484375, + "gradient_norm": 0.05750737339258194, + "elapsed": 749.5549652576447 + }, + { + "step": 2416, + "loss": 0.6260479688644409, + "error": 0.3662109375, + "gradient_norm": 0.07954186946153641, + "elapsed": 754.2598557472229 + }, + { + "step": 2432, + "loss": 0.42416834831237793, + "error": 0.216796875, + "gradient_norm": 0.07007592916488647, + "elapsed": 759.0757219791412 + }, + { + "step": 2448, + "loss": 0.616998016834259, + "error": 0.3544921875, + "gradient_norm": 0.04369773343205452, + "elapsed": 763.889315366745 + }, + { + "step": 2464, + "loss": 0.6189758777618408, + "error": 0.3779296875, + "gradient_norm": 0.0861201360821724, + "elapsed": 768.643075466156 + }, + { + "step": 2480, + "loss": 0.534727931022644, + "error": 0.2763671875, + "gradient_norm": 0.11949768662452698, + "elapsed": 773.3234212398529 + }, + { + "step": 2496, + "loss": 0.2642596662044525, + "error": 0.1123046875, + "gradient_norm": 0.04401363804936409, + "elapsed": 777.99835729599 + }, + { + "step": 2512, + "loss": 0.316694051027298, + "error": 0.154296875, + "gradient_norm": 0.05544165521860123, + "elapsed": 782.7598814964294 + }, + { + "step": 2528, + "loss": 0.6133518815040588, + "error": 0.3701171875, + "gradient_norm": 0.04883045330643654, + "elapsed": 787.4722270965576 + }, + { + "step": 2544, + "loss": 0.46383893489837646, + "error": 0.2265625, + "gradient_norm": 0.10961318016052246, + "elapsed": 792.1515769958496 + }, + { + "step": 2560, + "loss": 0.6395339965820312, + "error": 0.3896484375, + "gradient_norm": 0.060653287917375565, + "elapsed": 796.8980717658997 + }, + { + "step": 2576, + "loss": 0.5954150557518005, + "error": 0.3486328125, + "gradient_norm": 0.0639895349740982, + "elapsed": 801.6126036643982 + }, + { + "step": 2592, + "loss": 0.5673046112060547, + "error": 0.3251953125, + "gradient_norm": 0.09414395689964294, + "elapsed": 806.2902829647064 + }, + { + "step": 2608, + "loss": 0.543382465839386, + "error": 0.28515625, + "gradient_norm": 0.09926929324865341, + "elapsed": 810.9966278076172 + }, + { + "step": 2624, + "loss": 0.6365521550178528, + "error": 0.4052734375, + "gradient_norm": 0.04898317530751228, + "elapsed": 815.7470283508301 + }, + { + "step": 2640, + "loss": 0.1537156105041504, + "error": 0.0576171875, + "gradient_norm": 0.0357561893761158, + "elapsed": 820.582780122757 + }, + { + "step": 2656, + "loss": 0.3075976073741913, + "error": 0.1435546875, + "gradient_norm": 0.043708425015211105, + "elapsed": 825.2876286506653 + }, + { + "step": 2672, + "loss": 0.4743073284626007, + "error": 0.2568359375, + "gradient_norm": 0.0841125100851059, + "elapsed": 830.0087203979492 + }, + { + "step": 2688, + "loss": 0.5830615758895874, + "error": 0.326171875, + "gradient_norm": 0.1030748263001442, + "elapsed": 834.7422065734863 + }, + { + "step": 2704, + "loss": 0.22131001949310303, + "error": 0.08984375, + "gradient_norm": 0.13081751763820648, + "elapsed": 839.4776856899261 + }, + { + "step": 2720, + "loss": 0.6323255896568298, + "error": 0.3759765625, + "gradient_norm": 0.07800226658582687, + "elapsed": 844.2346675395966 + }, + { + "step": 2736, + "loss": 0.49441713094711304, + "error": 0.2412109375, + "gradient_norm": 0.07211968302726746, + "elapsed": 848.982759475708 + }, + { + "step": 2752, + "loss": 0.6579408645629883, + "error": 0.4189453125, + "gradient_norm": 0.08874426782131195, + "elapsed": 853.8351457118988 + }, + { + "step": 2768, + "loss": 0.6155497431755066, + "error": 0.357421875, + "gradient_norm": 0.033903054893016815, + "elapsed": 858.5420045852661 + }, + { + "step": 2784, + "loss": 0.041317712515592575, + "error": 0.0107421875, + "gradient_norm": 0.026763662695884705, + "elapsed": 863.2441916465759 + }, + { + "step": 2800, + "loss": 0.5675083994865417, + "error": 0.3017578125, + "gradient_norm": 0.045707687735557556, + "elapsed": 868.0290188789368 + }, + { + "step": 2816, + "loss": 0.5619531869888306, + "error": 0.3056640625, + "gradient_norm": 0.06082772836089134, + "elapsed": 872.8060805797577 + }, + { + "step": 2832, + "loss": 0.17957276105880737, + "error": 0.0732421875, + "gradient_norm": 0.04258417710661888, + "elapsed": 877.5140509605408 + }, + { + "step": 2848, + "loss": 0.05909765511751175, + "error": 0.0234375, + "gradient_norm": 0.02091357111930847, + "elapsed": 882.2372331619263 + }, + { + "step": 2864, + "loss": 0.5285354852676392, + "error": 0.267578125, + "gradient_norm": 0.0801018625497818, + "elapsed": 886.9495780467987 + }, + { + "step": 2880, + "loss": 0.5334465503692627, + "error": 0.283203125, + "gradient_norm": 0.056470923125743866, + "elapsed": 891.667802810669 + }, + { + "step": 2896, + "loss": 0.5272667407989502, + "error": 0.28125, + "gradient_norm": 0.0509747713804245, + "elapsed": 896.4548943042755 + }, + { + "step": 2912, + "loss": 0.1782023012638092, + "error": 0.08203125, + "gradient_norm": 0.028406014665961266, + "elapsed": 901.1290113925934 + }, + { + "step": 2928, + "loss": 0.4651077389717102, + "error": 0.2373046875, + "gradient_norm": 0.052196353673934937, + "elapsed": 905.8575649261475 + }, + { + "step": 2944, + "loss": 0.37636104226112366, + "error": 0.18359375, + "gradient_norm": 0.0456317663192749, + "elapsed": 910.6105432510376 + }, + { + "step": 2960, + "loss": 0.5737433433532715, + "error": 0.33203125, + "gradient_norm": 0.08177118748426437, + "elapsed": 915.3165609836578 + }, + { + "step": 2976, + "loss": 0.40313419699668884, + "error": 0.205078125, + "gradient_norm": 0.05348942428827286, + "elapsed": 920.004273891449 + }, + { + "step": 2992, + "loss": 0.1772809773683548, + "error": 0.0654296875, + "gradient_norm": 0.05808376148343086, + "elapsed": 924.7744464874268 + }, + { + "step": 3008, + "loss": 0.30725544691085815, + "error": 0.1455078125, + "gradient_norm": 0.041266828775405884, + "elapsed": 929.617283821106 + }, + { + "step": 3024, + "loss": 0.626629650592804, + "error": 0.3564453125, + "gradient_norm": 0.0891014114022255, + "elapsed": 934.3082222938538 + }, + { + "step": 3040, + "loss": 0.5634793043136597, + "error": 0.3212890625, + "gradient_norm": 0.06226632371544838, + "elapsed": 939.0874574184418 + }, + { + "step": 3056, + "loss": 0.06251340359449387, + "error": 0.0185546875, + "gradient_norm": 0.02397671900689602, + "elapsed": 943.8014359474182 + }, + { + "step": 3072, + "loss": 0.18658950924873352, + "error": 0.0771484375, + "gradient_norm": 0.07920258492231369, + "elapsed": 948.5135896205902 + }, + { + "step": 3088, + "loss": 0.3031911551952362, + "error": 0.1259765625, + "gradient_norm": 0.03369392454624176, + "elapsed": 953.2707180976868 + }, + { + "step": 3104, + "loss": 0.3030065596103668, + "error": 0.14453125, + "gradient_norm": 0.04456803947687149, + "elapsed": 958.0335760116577 + }, + { + "step": 3120, + "loss": 0.557148814201355, + "error": 0.31640625, + "gradient_norm": 0.03235454857349396, + "elapsed": 962.8526875972748 + }, + { + "step": 3136, + "loss": 0.6249847412109375, + "error": 0.388671875, + "gradient_norm": 0.06489194184541702, + "elapsed": 967.5544240474701 + }, + { + "step": 3152, + "loss": 0.1873442828655243, + "error": 0.0908203125, + "gradient_norm": 0.04301583394408226, + "elapsed": 972.305330991745 + }, + { + "step": 3168, + "loss": 0.19983062148094177, + "error": 0.0791015625, + "gradient_norm": 0.0379863865673542, + "elapsed": 977.0770401954651 + }, + { + "step": 3184, + "loss": 0.6072715520858765, + "error": 0.3525390625, + "gradient_norm": 0.0466255284845829, + "elapsed": 981.7965779304504 + }, + { + "step": 3200, + "loss": 0.050029754638671875, + "error": 0.017578125, + "gradient_norm": 0.034418798983097076, + "elapsed": 986.5760538578033 + }, + { + "step": 3216, + "loss": 0.04948887228965759, + "error": 0.0146484375, + "gradient_norm": 0.016658855602145195, + "elapsed": 991.249969959259 + }, + { + "step": 3232, + "loss": 0.6093300580978394, + "error": 0.34765625, + "gradient_norm": 0.07778333872556686, + "elapsed": 996.0119123458862 + }, + { + "step": 3248, + "loss": 0.03380893915891647, + "error": 0.009765625, + "gradient_norm": 0.03597341850399971, + "elapsed": 1000.6593194007874 + }, + { + "step": 3264, + "loss": 0.43469762802124023, + "error": 0.21484375, + "gradient_norm": 0.08311209082603455, + "elapsed": 1005.5569305419922 + }, + { + "step": 3280, + "loss": 0.4485730826854706, + "error": 0.2197265625, + "gradient_norm": 0.10675796121358871, + "elapsed": 1010.2802982330322 + }, + { + "step": 3296, + "loss": 0.5881931781768799, + "error": 0.33203125, + "gradient_norm": 0.08826471865177155, + "elapsed": 1014.9988231658936 + }, + { + "step": 3312, + "loss": 0.41637876629829407, + "error": 0.205078125, + "gradient_norm": 0.09034381061792374, + "elapsed": 1019.6731984615326 + }, + { + "step": 3328, + "loss": 0.47191768884658813, + "error": 0.2333984375, + "gradient_norm": 0.07124290615320206, + "elapsed": 1024.4120223522186 + }, + { + "step": 3344, + "loss": 0.5093030333518982, + "error": 0.2783203125, + "gradient_norm": 0.1023976281285286, + "elapsed": 1029.1239948272705 + }, + { + "step": 3360, + "loss": 0.6033403873443604, + "error": 0.3603515625, + "gradient_norm": 0.08227833360433578, + "elapsed": 1033.8450770378113 + }, + { + "step": 3376, + "loss": 0.31789714097976685, + "error": 0.1435546875, + "gradient_norm": 0.09183549880981445, + "elapsed": 1038.5324323177338 + }, + { + "step": 3392, + "loss": 0.6236000657081604, + "error": 0.3544921875, + "gradient_norm": 0.04741818085312843, + "elapsed": 1043.2271883487701 + }, + { + "step": 3408, + "loss": 0.6300849318504333, + "error": 0.37109375, + "gradient_norm": 0.07712595164775848, + "elapsed": 1047.9210381507874 + }, + { + "step": 3424, + "loss": 0.058983251452445984, + "error": 0.017578125, + "gradient_norm": 0.032344426959753036, + "elapsed": 1052.6261167526245 + }, + { + "step": 3440, + "loss": 0.517595648765564, + "error": 0.2939453125, + "gradient_norm": 0.07201747596263885, + "elapsed": 1057.3074805736542 + }, + { + "step": 3456, + "loss": 0.07246165722608566, + "error": 0.025390625, + "gradient_norm": 0.03035593219101429, + "elapsed": 1061.943410873413 + }, + { + "step": 3472, + "loss": 0.1748662143945694, + "error": 0.078125, + "gradient_norm": 0.05368956923484802, + "elapsed": 1066.5797038078308 + }, + { + "step": 3488, + "loss": 0.38555675745010376, + "error": 0.1748046875, + "gradient_norm": 0.03985214978456497, + "elapsed": 1071.1816670894623 + }, + { + "step": 3504, + "loss": 0.2063349187374115, + "error": 0.0849609375, + "gradient_norm": 0.058749184012413025, + "elapsed": 1075.8610808849335 + }, + { + "step": 3520, + "loss": 0.6017230153083801, + "error": 0.3447265625, + "gradient_norm": 0.03499629348516464, + "elapsed": 1080.507141828537 + }, + { + "step": 3536, + "loss": 0.4236711859703064, + "error": 0.2216796875, + "gradient_norm": 0.05795566365122795, + "elapsed": 1085.1633596420288 + }, + { + "step": 3552, + "loss": 0.5309401154518127, + "error": 0.2939453125, + "gradient_norm": 0.04649072512984276, + "elapsed": 1089.8401250839233 + }, + { + "step": 3568, + "loss": 0.6494846343994141, + "error": 0.396484375, + "gradient_norm": 0.05490654334425926, + "elapsed": 1094.471025466919 + }, + { + "step": 3584, + "loss": 0.5967869758605957, + "error": 0.3662109375, + "gradient_norm": 0.05458279326558113, + "elapsed": 1099.2145318984985 + }, + { + "step": 3600, + "loss": 0.6222071647644043, + "error": 0.361328125, + "gradient_norm": 0.061278004199266434, + "elapsed": 1103.8185014724731 + }, + { + "step": 3616, + "loss": 0.5805465579032898, + "error": 0.3525390625, + "gradient_norm": 0.07839810103178024, + "elapsed": 1108.4894144535065 + }, + { + "step": 3632, + "loss": 0.5115002393722534, + "error": 0.275390625, + "gradient_norm": 0.07274686545133591, + "elapsed": 1113.2734687328339 + }, + { + "step": 3648, + "loss": 0.04651213809847832, + "error": 0.015625, + "gradient_norm": 0.022988688200712204, + "elapsed": 1117.8917963504791 + }, + { + "step": 3664, + "loss": 0.5013625621795654, + "error": 0.251953125, + "gradient_norm": 0.0996033251285553, + "elapsed": 1122.5265882015228 + }, + { + "step": 3680, + "loss": 0.33896803855895996, + "error": 0.15625, + "gradient_norm": 0.06938805431127548, + "elapsed": 1127.197154045105 + }, + { + "step": 3696, + "loss": 0.6099933385848999, + "error": 0.369140625, + "gradient_norm": 0.058700986206531525, + "elapsed": 1131.8557970523834 + }, + { + "step": 3712, + "loss": 0.5707046389579773, + "error": 0.2998046875, + "gradient_norm": 0.06556673347949982, + "elapsed": 1136.5313811302185 + }, + { + "step": 3728, + "loss": 0.4975113868713379, + "error": 0.263671875, + "gradient_norm": 0.09731130301952362, + "elapsed": 1141.0708763599396 + }, + { + "step": 3744, + "loss": 0.6402406692504883, + "error": 0.40625, + "gradient_norm": 0.07527488470077515, + "elapsed": 1145.7058799266815 + }, + { + "step": 3760, + "loss": 0.6236486434936523, + "error": 0.3837890625, + "gradient_norm": 0.06121816113591194, + "elapsed": 1150.3756635189056 + }, + { + "step": 3776, + "loss": 0.5979301929473877, + "error": 0.3525390625, + "gradient_norm": 0.04808397591114044, + "elapsed": 1154.916062116623 + }, + { + "step": 3792, + "loss": 0.5584561824798584, + "error": 0.3359375, + "gradient_norm": 0.05791031941771507, + "elapsed": 1159.6203849315643 + }, + { + "step": 3808, + "loss": 0.5935126543045044, + "error": 0.3232421875, + "gradient_norm": 0.11438889056444168, + "elapsed": 1164.359097957611 + }, + { + "step": 3824, + "loss": 0.511176347732544, + "error": 0.2578125, + "gradient_norm": 0.041369739919900894, + "elapsed": 1169.0432605743408 + }, + { + "step": 3840, + "loss": 0.4501517117023468, + "error": 0.2119140625, + "gradient_norm": 0.041493434458971024, + "elapsed": 1173.5720834732056 + }, + { + "step": 3856, + "loss": 0.4055243730545044, + "error": 0.1962890625, + "gradient_norm": 0.0759967565536499, + "elapsed": 1178.3082933425903 + }, + { + "step": 3872, + "loss": 0.6019216775894165, + "error": 0.35546875, + "gradient_norm": 0.04394691810011864, + "elapsed": 1182.9946217536926 + }, + { + "step": 3888, + "loss": 0.6305254697799683, + "error": 0.3857421875, + "gradient_norm": 0.05652457848191261, + "elapsed": 1187.6875178813934 + }, + { + "step": 3904, + "loss": 0.32350921630859375, + "error": 0.1494140625, + "gradient_norm": 0.045912157744169235, + "elapsed": 1192.32435297966 + }, + { + "step": 3920, + "loss": 0.5068554282188416, + "error": 0.263671875, + "gradient_norm": 0.0917363092303276, + "elapsed": 1196.9963824748993 + }, + { + "step": 3936, + "loss": 0.44839972257614136, + "error": 0.2177734375, + "gradient_norm": 0.06843690574169159, + "elapsed": 1201.7578427791595 + }, + { + "step": 3952, + "loss": 0.6215605735778809, + "error": 0.36328125, + "gradient_norm": 0.06534510850906372, + "elapsed": 1206.3578810691833 + }, + { + "step": 3968, + "loss": 0.5917477607727051, + "error": 0.3310546875, + "gradient_norm": 0.0793910101056099, + "elapsed": 1211.0181884765625 + }, + { + "step": 3984, + "loss": 0.33365708589553833, + "error": 0.154296875, + "gradient_norm": 0.03340807557106018, + "elapsed": 1215.63885140419 + }, + { + "step": 4000, + "loss": 0.5914261341094971, + "error": 0.369140625, + "gradient_norm": 0.07922345399856567, + "elapsed": 1220.208690404892 + }, + { + "step": 4016, + "loss": 0.5981358885765076, + "error": 0.3564453125, + "gradient_norm": 0.07050825655460358, + "elapsed": 1224.8173997402191 + }, + { + "step": 4032, + "loss": 0.04007252678275108, + "error": 0.0107421875, + "gradient_norm": 0.03843256086111069, + "elapsed": 1229.585652589798 + }, + { + "step": 4048, + "loss": 0.47372734546661377, + "error": 0.24609375, + "gradient_norm": 0.05560925230383873, + "elapsed": 1234.2027080059052 + }, + { + "step": 4064, + "loss": 0.6212053298950195, + "error": 0.34765625, + "gradient_norm": 0.05192152410745621, + "elapsed": 1238.737244606018 + }, + { + "step": 4080, + "loss": 0.24424059689044952, + "error": 0.115234375, + "gradient_norm": 0.026631340384483337, + "elapsed": 1243.360303401947 + }, + { + "step": 4096, + "loss": 0.6526628732681274, + "error": 0.4072265625, + "gradient_norm": 0.06860450655221939, + "elapsed": 1247.978857755661 + }, + { + "step": 4112, + "loss": 0.5761024355888367, + "error": 0.3359375, + "gradient_norm": 0.07407928258180618, + "elapsed": 1264.393461227417 + }, + { + "step": 4128, + "loss": 0.5166171789169312, + "error": 0.2802734375, + "gradient_norm": 0.06744228303432465, + "elapsed": 1269.0376110076904 + }, + { + "step": 4144, + "loss": 0.5645991563796997, + "error": 0.326171875, + "gradient_norm": 0.03917548060417175, + "elapsed": 1273.686464548111 + }, + { + "step": 4160, + "loss": 0.6148834824562073, + "error": 0.3525390625, + "gradient_norm": 0.03788543865084648, + "elapsed": 1278.3614382743835 + }, + { + "step": 4176, + "loss": 0.38742372393608093, + "error": 0.17578125, + "gradient_norm": 0.11304378509521484, + "elapsed": 1283.042144536972 + }, + { + "step": 4192, + "loss": 0.4484878182411194, + "error": 0.220703125, + "gradient_norm": 0.062344007194042206, + "elapsed": 1287.8987758159637 + }, + { + "step": 4208, + "loss": 0.6396719813346863, + "error": 0.3994140625, + "gradient_norm": 0.053262919187545776, + "elapsed": 1292.6689438819885 + }, + { + "step": 4224, + "loss": 0.5463206171989441, + "error": 0.3017578125, + "gradient_norm": 0.05004372447729111, + "elapsed": 1297.3772320747375 + }, + { + "step": 4240, + "loss": 0.48288077116012573, + "error": 0.25, + "gradient_norm": 0.05564543604850769, + "elapsed": 1301.9836349487305 + }, + { + "step": 4256, + "loss": 0.20926299691200256, + "error": 0.0859375, + "gradient_norm": 0.06971064954996109, + "elapsed": 1306.834755897522 + }, + { + "step": 4272, + "loss": 0.47696030139923096, + "error": 0.234375, + "gradient_norm": 0.12384538352489471, + "elapsed": 1311.646653175354 + }, + { + "step": 4288, + "loss": 0.5193263292312622, + "error": 0.2861328125, + "gradient_norm": 0.05921286344528198, + "elapsed": 1316.3805680274963 + }, + { + "step": 4304, + "loss": 0.3344917297363281, + "error": 0.1552734375, + "gradient_norm": 0.10160133242607117, + "elapsed": 1321.0748929977417 + }, + { + "step": 4320, + "loss": 0.20546990633010864, + "error": 0.091796875, + "gradient_norm": 0.04286832734942436, + "elapsed": 1325.869520187378 + }, + { + "step": 4336, + "loss": 0.5865575075149536, + "error": 0.322265625, + "gradient_norm": 0.059941042214632034, + "elapsed": 1330.5581436157227 + }, + { + "step": 4352, + "loss": 0.5839159488677979, + "error": 0.326171875, + "gradient_norm": 0.09038978815078735, + "elapsed": 1335.2654139995575 + }, + { + "step": 4368, + "loss": 0.1601221263408661, + "error": 0.068359375, + "gradient_norm": 0.027884116396307945, + "elapsed": 1339.9681899547577 + }, + { + "step": 4384, + "loss": 0.6295274496078491, + "error": 0.3916015625, + "gradient_norm": 0.04954860359430313, + "elapsed": 1344.701804637909 + }, + { + "step": 4400, + "loss": 0.6132400035858154, + "error": 0.3486328125, + "gradient_norm": 0.05869123712182045, + "elapsed": 1349.3857884407043 + }, + { + "step": 4416, + "loss": 0.5693196058273315, + "error": 0.3154296875, + "gradient_norm": 0.060945332050323486, + "elapsed": 1354.064118385315 + }, + { + "step": 4432, + "loss": 0.557330846786499, + "error": 0.328125, + "gradient_norm": 0.07243285328149796, + "elapsed": 1358.7812778949738 + }, + { + "step": 4448, + "loss": 0.6019461750984192, + "error": 0.3642578125, + "gradient_norm": 0.07621297240257263, + "elapsed": 1363.392904996872 + }, + { + "step": 4464, + "loss": 0.6193596124649048, + "error": 0.3662109375, + "gradient_norm": 0.049303628504276276, + "elapsed": 1368.0786435604095 + }, + { + "step": 4480, + "loss": 0.34808024764060974, + "error": 0.1435546875, + "gradient_norm": 0.05277419835329056, + "elapsed": 1372.8036375045776 + }, + { + "step": 4496, + "loss": 0.48142746090888977, + "error": 0.2451171875, + "gradient_norm": 0.05646621808409691, + "elapsed": 1377.4322249889374 + }, + { + "step": 4512, + "loss": 0.5625322461128235, + "error": 0.30859375, + "gradient_norm": 0.05744464695453644, + "elapsed": 1382.1681711673737 + }, + { + "step": 4528, + "loss": 0.5011025667190552, + "error": 0.275390625, + "gradient_norm": 0.05424647405743599, + "elapsed": 1386.8768243789673 + }, + { + "step": 4544, + "loss": 0.3645602762699127, + "error": 0.17578125, + "gradient_norm": 0.1261216402053833, + "elapsed": 1391.5531268119812 + }, + { + "step": 4560, + "loss": 0.37884730100631714, + "error": 0.1748046875, + "gradient_norm": 0.08905667066574097, + "elapsed": 1396.244924068451 + }, + { + "step": 4576, + "loss": 0.05790906772017479, + "error": 0.01953125, + "gradient_norm": 0.010587184689939022, + "elapsed": 1400.9877717494965 + }, + { + "step": 4592, + "loss": 0.42857348918914795, + "error": 0.2119140625, + "gradient_norm": 0.08209489285945892, + "elapsed": 1405.7844474315643 + }, + { + "step": 4608, + "loss": 0.4945109784603119, + "error": 0.2578125, + "gradient_norm": 0.11491527408361435, + "elapsed": 1410.4819538593292 + }, + { + "step": 4624, + "loss": 0.47680938243865967, + "error": 0.2392578125, + "gradient_norm": 0.1649855226278305, + "elapsed": 1415.215947151184 + }, + { + "step": 4640, + "loss": 0.5226103067398071, + "error": 0.28125, + "gradient_norm": 0.05748652666807175, + "elapsed": 1419.839337348938 + }, + { + "step": 4656, + "loss": 0.5830262899398804, + "error": 0.3466796875, + "gradient_norm": 0.048594679683446884, + "elapsed": 1424.5045154094696 + }, + { + "step": 4672, + "loss": 0.57396399974823, + "error": 0.322265625, + "gradient_norm": 0.0767059177160263, + "elapsed": 1429.224693775177 + }, + { + "step": 4688, + "loss": 0.4198788106441498, + "error": 0.203125, + "gradient_norm": 0.07652491331100464, + "elapsed": 1433.8387713432312 + }, + { + "step": 4704, + "loss": 0.5139726400375366, + "error": 0.2705078125, + "gradient_norm": 0.0505719855427742, + "elapsed": 1438.48521900177 + }, + { + "step": 4720, + "loss": 0.5912825465202332, + "error": 0.328125, + "gradient_norm": 0.08162372559309006, + "elapsed": 1443.0052802562714 + }, + { + "step": 4736, + "loss": 0.6137335300445557, + "error": 0.365234375, + "gradient_norm": 0.0734722763299942, + "elapsed": 1447.4597647190094 + }, + { + "step": 4752, + "loss": 0.43783271312713623, + "error": 0.2060546875, + "gradient_norm": 0.05513913929462433, + "elapsed": 1451.922340631485 + }, + { + "step": 4768, + "loss": 0.43194594979286194, + "error": 0.212890625, + "gradient_norm": 0.08512216061353683, + "elapsed": 1456.3923630714417 + }, + { + "step": 4784, + "loss": 0.6215378046035767, + "error": 0.373046875, + "gradient_norm": 0.05207977443933487, + "elapsed": 1460.856211423874 + }, + { + "step": 4800, + "loss": 0.18088676035404205, + "error": 0.072265625, + "gradient_norm": 0.050699349492788315, + "elapsed": 1465.329612493515 + }, + { + "step": 4816, + "loss": 0.2701481580734253, + "error": 0.1298828125, + "gradient_norm": 0.05318280681967735, + "elapsed": 1469.830040693283 + }, + { + "step": 4832, + "loss": 0.28028005361557007, + "error": 0.115234375, + "gradient_norm": 0.04486237093806267, + "elapsed": 1474.3076000213623 + }, + { + "step": 4848, + "loss": 0.6162897348403931, + "error": 0.375, + "gradient_norm": 0.05334438383579254, + "elapsed": 1478.731589794159 + }, + { + "step": 4864, + "loss": 0.6238194108009338, + "error": 0.3779296875, + "gradient_norm": 0.05142930522561073, + "elapsed": 1483.191822528839 + }, + { + "step": 4880, + "loss": 0.3980584144592285, + "error": 0.1953125, + "gradient_norm": 0.10477422922849655, + "elapsed": 1487.6553945541382 + }, + { + "step": 4896, + "loss": 0.2566850185394287, + "error": 0.107421875, + "gradient_norm": 0.05446404591202736, + "elapsed": 1492.1622877120972 + }, + { + "step": 4912, + "loss": 0.5394806861877441, + "error": 0.2958984375, + "gradient_norm": 0.07185973972082138, + "elapsed": 1496.5938274860382 + }, + { + "step": 4928, + "loss": 0.4947931468486786, + "error": 0.251953125, + "gradient_norm": 0.07238363474607468, + "elapsed": 1501.0154280662537 + }, + { + "step": 4944, + "loss": 0.6341207027435303, + "error": 0.4052734375, + "gradient_norm": 0.047372668981552124, + "elapsed": 1505.437273979187 + }, + { + "step": 4960, + "loss": 0.4993705451488495, + "error": 0.2744140625, + "gradient_norm": 0.04635903984308243, + "elapsed": 1509.8514697551727 + }, + { + "step": 4976, + "loss": 0.432881236076355, + "error": 0.21875, + "gradient_norm": 0.0631718635559082, + "elapsed": 1514.2631776332855 + }, + { + "step": 4992, + "loss": 0.18214640021324158, + "error": 0.08203125, + "gradient_norm": 0.05178966745734215, + "elapsed": 1519.5081050395966 + }, + { + "step": 5008, + "loss": 0.4984126091003418, + "error": 0.25, + "gradient_norm": 0.07836251705884933, + "elapsed": 1524.5841388702393 + }, + { + "step": 5024, + "loss": 0.05249527096748352, + "error": 0.017578125, + "gradient_norm": 0.02651856280863285, + "elapsed": 1529.240351676941 + }, + { + "step": 5040, + "loss": 0.4939548373222351, + "error": 0.2373046875, + "gradient_norm": 0.060112640261650085, + "elapsed": 1533.8897178173065 + }, + { + "step": 5056, + "loss": 0.16190454363822937, + "error": 0.0712890625, + "gradient_norm": 0.03779817000031471, + "elapsed": 1538.5146584510803 + }, + { + "step": 5072, + "loss": 0.45463526248931885, + "error": 0.236328125, + "gradient_norm": 0.13458263874053955, + "elapsed": 1543.1737053394318 + }, + { + "step": 5088, + "loss": 0.617259681224823, + "error": 0.369140625, + "gradient_norm": 0.052028730511665344, + "elapsed": 1547.8037762641907 + }, + { + "step": 5104, + "loss": 0.30152660608291626, + "error": 0.125, + "gradient_norm": 0.04300975427031517, + "elapsed": 1552.4862880706787 + }, + { + "step": 5120, + "loss": 0.48556357622146606, + "error": 0.23828125, + "gradient_norm": 0.05779493972659111, + "elapsed": 1557.2229101657867 + }, + { + "step": 5136, + "loss": 0.4014429450035095, + "error": 0.19921875, + "gradient_norm": 0.08999034762382507, + "elapsed": 1561.962744474411 + }, + { + "step": 5152, + "loss": 0.578102707862854, + "error": 0.3271484375, + "gradient_norm": 0.12180052697658539, + "elapsed": 1566.6184146404266 + }, + { + "step": 5168, + "loss": 0.24735845625400543, + "error": 0.107421875, + "gradient_norm": 0.030847609043121338, + "elapsed": 1571.3131284713745 + }, + { + "step": 5184, + "loss": 0.38058868050575256, + "error": 0.181640625, + "gradient_norm": 0.0744214877486229, + "elapsed": 1576.0601680278778 + }, + { + "step": 5200, + "loss": 0.514634370803833, + "error": 0.2685546875, + "gradient_norm": 0.08947030454874039, + "elapsed": 1580.875714302063 + }, + { + "step": 5216, + "loss": 0.5485725402832031, + "error": 0.2939453125, + "gradient_norm": 0.06839033961296082, + "elapsed": 1585.5921566486359 + }, + { + "step": 5232, + "loss": 0.2656717598438263, + "error": 0.1201171875, + "gradient_norm": 0.03527694195508957, + "elapsed": 1590.2943966388702 + }, + { + "step": 5248, + "loss": 0.3308545649051666, + "error": 0.154296875, + "gradient_norm": 0.04951170086860657, + "elapsed": 1594.9975476264954 + }, + { + "step": 5264, + "loss": 0.6104298830032349, + "error": 0.375, + "gradient_norm": 0.05209710821509361, + "elapsed": 1599.7427837848663 + }, + { + "step": 5280, + "loss": 0.42328497767448425, + "error": 0.20703125, + "gradient_norm": 0.09504231065511703, + "elapsed": 1604.4435935020447 + }, + { + "step": 5296, + "loss": 0.37444841861724854, + "error": 0.1806640625, + "gradient_norm": 0.06107482686638832, + "elapsed": 1609.3319079875946 + }, + { + "step": 5312, + "loss": 0.36695098876953125, + "error": 0.16796875, + "gradient_norm": 0.049629129469394684, + "elapsed": 1614.161862373352 + }, + { + "step": 5328, + "loss": 0.4492221772670746, + "error": 0.224609375, + "gradient_norm": 0.053409330546855927, + "elapsed": 1618.9367620944977 + }, + { + "step": 5344, + "loss": 0.16757890582084656, + "error": 0.064453125, + "gradient_norm": 0.060587745159864426, + "elapsed": 1623.8760237693787 + }, + { + "step": 5360, + "loss": 0.4249769151210785, + "error": 0.2080078125, + "gradient_norm": 0.07827810198068619, + "elapsed": 1628.6694304943085 + }, + { + "step": 5376, + "loss": 0.6309441328048706, + "error": 0.3818359375, + "gradient_norm": 0.07540460675954819, + "elapsed": 1633.4637587070465 + }, + { + "step": 5392, + "loss": 0.41754695773124695, + "error": 0.1875, + "gradient_norm": 0.08009897172451019, + "elapsed": 1638.2030646800995 + }, + { + "step": 5408, + "loss": 0.4239472448825836, + "error": 0.208984375, + "gradient_norm": 0.05904799699783325, + "elapsed": 1642.933852672577 + }, + { + "step": 5424, + "loss": 0.5784460306167603, + "error": 0.328125, + "gradient_norm": 0.04107591509819031, + "elapsed": 1647.656967639923 + }, + { + "step": 5440, + "loss": 0.6290242671966553, + "error": 0.37109375, + "gradient_norm": 0.04049605131149292, + "elapsed": 1652.153727054596 + }, + { + "step": 5456, + "loss": 0.5803163051605225, + "error": 0.33203125, + "gradient_norm": 0.061554644256830215, + "elapsed": 1656.652997970581 + }, + { + "step": 5472, + "loss": 0.5243433713912964, + "error": 0.279296875, + "gradient_norm": 0.09093347936868668, + "elapsed": 1661.195220708847 + }, + { + "step": 5488, + "loss": 0.4119020700454712, + "error": 0.185546875, + "gradient_norm": 0.06426703184843063, + "elapsed": 1665.7626667022705 + }, + { + "step": 5504, + "loss": 0.28233158588409424, + "error": 0.1171875, + "gradient_norm": 0.08238283544778824, + "elapsed": 1670.3415977954865 + }, + { + "step": 5520, + "loss": 0.6059034466743469, + "error": 0.3701171875, + "gradient_norm": 0.06656079739332199, + "elapsed": 1674.9189352989197 + }, + { + "step": 5536, + "loss": 0.5930617451667786, + "error": 0.3408203125, + "gradient_norm": 0.06556613743305206, + "elapsed": 1679.4890670776367 + }, + { + "step": 5552, + "loss": 0.04271071404218674, + "error": 0.013671875, + "gradient_norm": 0.04291592165827751, + "elapsed": 1684.0378658771515 + }, + { + "step": 5568, + "loss": 0.6180589199066162, + "error": 0.3740234375, + "gradient_norm": 0.055495720356702805, + "elapsed": 1688.6700294017792 + }, + { + "step": 5584, + "loss": 0.046329472213983536, + "error": 0.0166015625, + "gradient_norm": 0.011987456120550632, + "elapsed": 1693.2615530490875 + }, + { + "step": 5600, + "loss": 0.05479501187801361, + "error": 0.015625, + "gradient_norm": 0.014028024859726429, + "elapsed": 1698.4896109104156 + }, + { + "step": 5616, + "loss": 0.5754356384277344, + "error": 0.3427734375, + "gradient_norm": 0.05570944771170616, + "elapsed": 1703.658574104309 + }, + { + "step": 5632, + "loss": 0.4972821772098541, + "error": 0.2509765625, + "gradient_norm": 0.04249020293354988, + "elapsed": 1708.4251554012299 + }, + { + "step": 5648, + "loss": 0.5383155345916748, + "error": 0.3115234375, + "gradient_norm": 0.053966403007507324, + "elapsed": 1713.445968389511 + }, + { + "step": 5664, + "loss": 0.5762629508972168, + "error": 0.3291015625, + "gradient_norm": 0.10626781731843948, + "elapsed": 1718.3027453422546 + }, + { + "step": 5680, + "loss": 0.6408096551895142, + "error": 0.4052734375, + "gradient_norm": 0.04247480630874634, + "elapsed": 1722.8394570350647 + }, + { + "step": 5696, + "loss": 0.3656284213066101, + "error": 0.169921875, + "gradient_norm": 0.05658752843737602, + "elapsed": 1727.3735871315002 + }, + { + "step": 5712, + "loss": 0.3235703110694885, + "error": 0.146484375, + "gradient_norm": 0.05783833563327789, + "elapsed": 1731.9118783473969 + }, + { + "step": 5728, + "loss": 0.14865577220916748, + "error": 0.05078125, + "gradient_norm": 0.0706363096833229, + "elapsed": 1736.4581689834595 + }, + { + "step": 5744, + "loss": 0.49052801728248596, + "error": 0.2587890625, + "gradient_norm": 0.08640129864215851, + "elapsed": 1740.9975123405457 + }, + { + "step": 5760, + "loss": 0.44304293394088745, + "error": 0.21484375, + "gradient_norm": 0.0928334891796112, + "elapsed": 1745.5292134284973 + }, + { + "step": 5776, + "loss": 0.4967482089996338, + "error": 0.251953125, + "gradient_norm": 0.06011670455336571, + "elapsed": 1750.067622423172 + }, + { + "step": 5792, + "loss": 0.590355396270752, + "error": 0.326171875, + "gradient_norm": 0.05878058448433876, + "elapsed": 1754.6381838321686 + }, + { + "step": 5808, + "loss": 0.5593898892402649, + "error": 0.2998046875, + "gradient_norm": 0.040362726897001266, + "elapsed": 1759.1546795368195 + }, + { + "step": 5824, + "loss": 0.6377438902854919, + "error": 0.3828125, + "gradient_norm": 0.052781522274017334, + "elapsed": 1763.6587569713593 + }, + { + "step": 5840, + "loss": 0.272918164730072, + "error": 0.111328125, + "gradient_norm": 0.07445411384105682, + "elapsed": 1768.1953632831573 + }, + { + "step": 5856, + "loss": 0.5704550743103027, + "error": 0.33203125, + "gradient_norm": 0.10547811537981033, + "elapsed": 1772.7153923511505 + }, + { + "step": 5872, + "loss": 0.5762985944747925, + "error": 0.341796875, + "gradient_norm": 0.1778271198272705, + "elapsed": 1777.243012189865 + }, + { + "step": 5888, + "loss": 0.45416349172592163, + "error": 0.224609375, + "gradient_norm": 0.05864866450428963, + "elapsed": 1781.7705314159393 + }, + { + "step": 5904, + "loss": 0.5562437176704407, + "error": 0.306640625, + "gradient_norm": 0.04777278006076813, + "elapsed": 1786.6631784439087 + }, + { + "step": 5920, + "loss": 0.526985764503479, + "error": 0.27734375, + "gradient_norm": 0.055270250886678696, + "elapsed": 1791.9018635749817 + }, + { + "step": 5936, + "loss": 0.5961519479751587, + "error": 0.3515625, + "gradient_norm": 0.07846691459417343, + "elapsed": 1796.6179265975952 + }, + { + "step": 5952, + "loss": 0.44196125864982605, + "error": 0.22265625, + "gradient_norm": 0.057364918291568756, + "elapsed": 1801.4435884952545 + }, + { + "step": 5968, + "loss": 0.5679805278778076, + "error": 0.3037109375, + "gradient_norm": 0.05788804590702057, + "elapsed": 1806.227722644806 + }, + { + "step": 5984, + "loss": 0.5429763793945312, + "error": 0.28515625, + "gradient_norm": 0.06170782819390297, + "elapsed": 1810.807425737381 + }, + { + "step": 6000, + "loss": 0.5886402726173401, + "error": 0.3505859375, + "gradient_norm": 0.05652701109647751, + "elapsed": 1815.3398168087006 + }, + { + "step": 6016, + "loss": 0.6090047359466553, + "error": 0.3603515625, + "gradient_norm": 0.04130059480667114, + "elapsed": 1819.9101192951202 + }, + { + "step": 6032, + "loss": 0.3294444680213928, + "error": 0.1416015625, + "gradient_norm": 0.06110445037484169, + "elapsed": 1824.441204547882 + }, + { + "step": 6048, + "loss": 0.5077170729637146, + "error": 0.2822265625, + "gradient_norm": 0.08827364444732666, + "elapsed": 1828.9702234268188 + }, + { + "step": 6064, + "loss": 0.5033767223358154, + "error": 0.2568359375, + "gradient_norm": 0.09457007795572281, + "elapsed": 1833.4984192848206 + }, + { + "step": 6080, + "loss": 0.2741691470146179, + "error": 0.1201171875, + "gradient_norm": 0.05828089639544487, + "elapsed": 1838.0743029117584 + }, + { + "step": 6096, + "loss": 0.6021703481674194, + "error": 0.359375, + "gradient_norm": 0.07145720720291138, + "elapsed": 1842.5840139389038 + }, + { + "step": 6112, + "loss": 0.053208574652671814, + "error": 0.0166015625, + "gradient_norm": 0.017794840037822723, + "elapsed": 1847.0917072296143 + }, + { + "step": 6128, + "loss": 0.559947669506073, + "error": 0.333984375, + "gradient_norm": 0.06314288079738617, + "elapsed": 1851.6441400051117 + }, + { + "step": 6144, + "loss": 0.17558954656124115, + "error": 0.0732421875, + "gradient_norm": 0.03998808562755585, + "elapsed": 1856.1631665229797 + } + ], + "sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_exact/fresh_temporal1_full", + "sampling_replayed_checkpoints": [ + 2048, + 4096, + 6144 + ], + "eligible_training_rows": 2067520, + "training_draws": 6291456, + "distinct_phase_training_rows": 1961820, + "distinct_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18448, + "surface_code_bX_d3_r03_center_3_5": 19003, + "surface_code_bX_d3_r05_center_3_5": 19382, + "surface_code_bX_d3_r07_center_3_5": 19124, + "surface_code_bX_d3_r09_center_3_5": 18013, + "surface_code_bX_d3_r11_center_3_5": 19371, + "surface_code_bX_d3_r13_center_3_5": 19114, + "surface_code_bX_d3_r15_center_3_5": 18157, + "surface_code_bX_d3_r17_center_3_5": 18980, + "surface_code_bX_d3_r19_center_3_5": 19142, + "surface_code_bX_d3_r21_center_3_5": 19270, + "surface_code_bX_d3_r23_center_3_5": 18297, + "surface_code_bX_d3_r25_center_3_5": 19344, + "surface_code_bX_d3_r01_center_5_3": 18996, + "surface_code_bX_d3_r03_center_5_3": 18998, + "surface_code_bX_d3_r05_center_5_3": 18970, + "surface_code_bX_d3_r07_center_5_3": 19269, + "surface_code_bX_d3_r09_center_5_3": 19119, + "surface_code_bX_d3_r11_center_5_3": 18216, + "surface_code_bX_d3_r13_center_5_3": 18649, + "surface_code_bX_d3_r15_center_5_3": 19083, + "surface_code_bX_d3_r17_center_5_3": 19330, + "surface_code_bX_d3_r19_center_5_3": 18815, + "surface_code_bX_d3_r21_center_5_3": 18877, + "surface_code_bX_d3_r23_center_5_3": 18006, + "surface_code_bX_d3_r25_center_5_3": 19331, + "surface_code_bX_d3_r01_center_5_7": 19033, + "surface_code_bX_d3_r03_center_5_7": 19053, + "surface_code_bX_d3_r05_center_5_7": 18867, + "surface_code_bX_d3_r07_center_5_7": 18867, + "surface_code_bX_d3_r09_center_5_7": 18926, + "surface_code_bX_d3_r11_center_5_7": 19184, + "surface_code_bX_d3_r13_center_5_7": 18897, + "surface_code_bX_d3_r15_center_5_7": 19188, + "surface_code_bX_d3_r17_center_5_7": 18964, + "surface_code_bX_d3_r19_center_5_7": 18341, + "surface_code_bX_d3_r21_center_5_7": 18924, + "surface_code_bX_d3_r23_center_5_7": 19313, + "surface_code_bX_d3_r25_center_5_7": 18262, + "surface_code_bX_d3_r01_center_7_5": 19036, + "surface_code_bX_d3_r03_center_7_5": 19271, + "surface_code_bX_d3_r05_center_7_5": 18958, + "surface_code_bX_d3_r07_center_7_5": 19334, + "surface_code_bX_d3_r09_center_7_5": 19013, + "surface_code_bX_d3_r11_center_7_5": 19214, + "surface_code_bX_d3_r13_center_7_5": 19546, + "surface_code_bX_d3_r15_center_7_5": 19273, + "surface_code_bX_d3_r17_center_7_5": 19005, + "surface_code_bX_d3_r19_center_7_5": 18932, + "surface_code_bX_d3_r21_center_7_5": 19116, + "surface_code_bX_d3_r23_center_7_5": 19097, + "surface_code_bX_d3_r25_center_7_5": 18679, + "surface_code_bZ_d3_r01_center_3_5": 18962, + "surface_code_bZ_d3_r03_center_3_5": 19079, + "surface_code_bZ_d3_r05_center_3_5": 18872, + "surface_code_bZ_d3_r07_center_3_5": 18313, + "surface_code_bZ_d3_r09_center_3_5": 19259, + "surface_code_bZ_d3_r11_center_3_5": 19073, + "surface_code_bZ_d3_r13_center_3_5": 19057, + "surface_code_bZ_d3_r15_center_3_5": 18234, + "surface_code_bZ_d3_r17_center_3_5": 18637, + "surface_code_bZ_d3_r19_center_3_5": 18673, + "surface_code_bZ_d3_r21_center_3_5": 17946, + "surface_code_bZ_d3_r23_center_3_5": 17080, + "surface_code_bZ_d3_r25_center_3_5": 19360, + "surface_code_bZ_d3_r01_center_5_3": 19182, + "surface_code_bZ_d3_r03_center_5_3": 18951, + "surface_code_bZ_d3_r05_center_5_3": 18101, + "surface_code_bZ_d3_r07_center_5_3": 19178, + "surface_code_bZ_d3_r09_center_5_3": 19006, + "surface_code_bZ_d3_r11_center_5_3": 18983, + "surface_code_bZ_d3_r13_center_5_3": 18389, + "surface_code_bZ_d3_r15_center_5_3": 18142, + "surface_code_bZ_d3_r17_center_5_3": 18804, + "surface_code_bZ_d3_r19_center_5_3": 19257, + "surface_code_bZ_d3_r21_center_5_3": 18353, + "surface_code_bZ_d3_r23_center_5_3": 18793, + "surface_code_bZ_d3_r25_center_5_3": 18683, + "surface_code_bZ_d3_r01_center_5_7": 18981, + "surface_code_bZ_d3_r03_center_5_7": 19012, + "surface_code_bZ_d3_r05_center_5_7": 19002, + "surface_code_bZ_d3_r07_center_5_7": 18591, + "surface_code_bZ_d3_r09_center_5_7": 18849, + "surface_code_bZ_d3_r11_center_5_7": 19149, + "surface_code_bZ_d3_r13_center_5_7": 18612, + "surface_code_bZ_d3_r15_center_5_7": 19116, + "surface_code_bZ_d3_r17_center_5_7": 18960, + "surface_code_bZ_d3_r19_center_5_7": 19218, + "surface_code_bZ_d3_r21_center_5_7": 18825, + "surface_code_bZ_d3_r23_center_5_7": 18568, + "surface_code_bZ_d3_r25_center_5_7": 18136, + "surface_code_bZ_d3_r01_center_7_5": 19121, + "surface_code_bZ_d3_r03_center_7_5": 19311, + "surface_code_bZ_d3_r05_center_7_5": 18171, + "surface_code_bZ_d3_r07_center_7_5": 18714, + "surface_code_bZ_d3_r09_center_7_5": 19122, + "surface_code_bZ_d3_r11_center_7_5": 18697, + "surface_code_bZ_d3_r13_center_7_5": 18570, + "surface_code_bZ_d3_r15_center_7_5": 18646, + "surface_code_bZ_d3_r17_center_7_5": 18711, + "surface_code_bZ_d3_r19_center_7_5": 18802, + "surface_code_bZ_d3_r21_center_7_5": 18903, + "surface_code_bZ_d3_r23_center_7_5": 19115, + "surface_code_bZ_d3_r25_center_7_5": 18954 + }, + "initial_optimizer_count": 1024, + "final_optimizer_count": 7168, + "phase_start_weights_sha256": "6649ebebc4fb0161756fa7b9dbeb513179dbcb8e4f75cb59ba4261f6829ed6f1", + "phase_start_rng_sha256": "e2bfbd75d7881f0344c7533f23b06739281ec10be7b45484c8f0f065d3fdea6c", + "parent_checkpoint_sha256": "6649ebebc4fb0161756fa7b9dbeb513179dbcb8e4f75cb59ba4261f6829ed6f1", + "source_sha256": "9f739f4865d3596d545529edaf2fc7f129ce2ac3701aa4be8ceb0613cb608690", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "A fully independent d3 trunk/temporal initialization may provide useful accuracy or complementarity beyond continuations of the shared original seed", + "initial_seed": 20261300, + "encoder_seed": 20261301, + "sampling_seed": 20261302, + "architecture": "Existing128-unit rich trunk plus32-channel temporal encoder,177features,4*tanh corrections,exact width10 joint contraction; all neural parameters initialized fresh, no learned checkpoint used in warm initialization", + "data": "All2067520 supplied d3 training rows across104conditions eligible from first update; uniform condition/row sampling with replacement; no reserved split for this fixed-mixture study", + "schedule": "1024 updates B1024 LR.001; then6144 LR.0005 restoring own optimizer/RNG. AdamW decay1e-4/globalclip1. Original initialization code/scales retained except seeds; all temporal features present from first update", + "validation": "Full532480 d3 validation shots at main0/2048/4096/6144. Main0 is trained warm1024. Per-group raw/equal-small-contextual choices versus incumbent acrossall13durations; full replay/score/relocation/timebudget controls if better", + "fixed_ensemble": "Freeze original selected temporal components before training. Pick each group new raw checkpoint by full-validation mean failure; compare incumbent with equal old/new temporal average and that mixture averaged equally with fixed small-contextual reference. No mixture weights fitted. Recheck existing categorical1 short heads afterward", + "interpretation": "Tests an independent direct-training recipe; not an isolated causal ablation of initialization because the historical original used staged rich/temporal training", + "gpu": "One H100, serialized afterfour_seed_finished", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "device": "CPU", + "initial_seed": 20261300, + "encoder_seed": 20261301, + "sampling_seed": 20261302, + "fresh_initialization_exact": true, + "independent_seed_effects_checked": true, + "audits": [ + { + "run": "/run-state/workspace/research/learned_exact/fresh_temporal_smoke1", + "optimizer_end_count": 1, + "sampling_replay_exact": true, + "all104_condition_screens_passed": true, + "eligible_training_rows": 2067520 + }, + { + "run": "/run-state/workspace/research/learned_exact/fresh_temporal_smoke2", + "optimizer_end_count": 2, + "sampling_replay_exact": true, + "all104_condition_screens_passed": true, + "eligible_training_rows": 2067520 + } + ], + "training_source_sha256": { + "learned_exact__fresh_temporal_train.py": "366163a0c52e537485ab92df6c217600070886c0d0f0880abda4cd55d89cef20", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__fresh_temporal_initialization.py": "5e776e118573bceb5c253d6ae58d154ca9c95a375ddcf631d46ab7b846440ffb", + "learned_exact__model.py": "bc36fa5fa0191abc8e67e4ede0d4ff87848d80e9e2fac5cd60c0ac4fcefc3088", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "source_sha256": "3087fc1f9870dea649b73049a011cd2ce1198599f5cbc63b1fd0ba8da8ea6035", + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "derived_checkpoints": { + "mean2": { + "checkpoint_label": "mean2", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 4096, + 6144 + ], + "source_training_run": "fresh_temporal1_full", + "source_weights_sha256": { + "4096": "21c156629b081965bd0856e5292951ef793277fcac2b72657e89d64e59cdcb1f", + "6144": "08718ad705a9b35495054ffa65e35ac29445fe5ef610620778964a4413901d10" + }, + "source_checkpoint_records": { + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1780972, + "weights": "weights-4096.npz", + "weights_sha256": "21c156629b081965bd0856e5292951ef793277fcac2b72657e89d64e59cdcb1f", + "validation": "validation-4096.json", + "complete": true + }, + "6144": { + "step": 6144, + "new_training_shots": 6291456, + "unique_training_rows_seen_in_this_phase": 1961820, + "weights": "weights-6144.npz", + "weights_sha256": "08718ad705a9b35495054ffa65e35ac29445fe5ef610620778964a4413901d10", + "validation": "validation-6144.json", + "complete": true + } + }, + "weights_sha256": "9f56d54ae6f2bf3996b647027e798f4933b982e98351a9e0a67a325d2ffe4b7e", + "complete": true + }, + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 4096, + 6144 + ], + "source_training_run": "fresh_temporal1_full", + "source_weights_sha256": { + "2048": "841f3989d6ba86b179109e2d80cea037ba38a28446f962f9104651e4f4504322", + "4096": "21c156629b081965bd0856e5292951ef793277fcac2b72657e89d64e59cdcb1f", + "6144": "08718ad705a9b35495054ffa65e35ac29445fe5ef610620778964a4413901d10" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1301127, + "weights": "weights-2048.npz", + "weights_sha256": "841f3989d6ba86b179109e2d80cea037ba38a28446f962f9104651e4f4504322", + "validation": "validation-2048.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1780972, + "weights": "weights-4096.npz", + "weights_sha256": "21c156629b081965bd0856e5292951ef793277fcac2b72657e89d64e59cdcb1f", + "validation": "validation-4096.json", + "complete": true + }, + "6144": { + "step": 6144, + "new_training_shots": 6291456, + "unique_training_rows_seen_in_this_phase": 1961820, + "weights": "weights-6144.npz", + "weights_sha256": "08718ad705a9b35495054ffa65e35ac29445fe5ef610620778964a4413901d10", + "validation": "validation-6144.json", + "complete": true + } + }, + "weights_sha256": "e3f13efc5e5af11a8591a90b3176b224c892a91c98925cde79d20d3f3de8f184", + "complete": true + } + }, + "declared_plan": { + "hypothesis": "Fixed trajectory weight averages may reduce optimization fluctuations without extra inference passes; earlier d3 temporal averaging helped slightly", + "source_run": "fresh_temporal1_full", + "specifications": { + "mean2": [ + 4096, + 6144 + ], + "mean3": [ + 2048, + 4096, + 6144 + ] + }, + "initialization": "Weights derive only from the same in-session fresh trunk/encoder seeds20261300/20261301 trajectory; no new random parameters", + "new_optimizer_updates": 0, + "selection": "Full104condition validation for both averages, pergroup raw or equal-small-context versus incumbent over all13durations. Then choose best raw average pergroup and compare equal-average/original-temporal and optional outer equal-small-context mixtures against incumbent. Existing one-round categorical models rechecked without refitting", + "reference": "Frozen fresh_temporal1_reference.json original components and validation-fresh_temporal1-reference, not changed to a newer selected ensemble", + "declaration": "Fixed before fresh_temporal1 main4096/6144 checkpoints completed; neither future checkpoint nor fullvalidation results inspected", + "runtime": "No extra pass for raw parameter average; at most two temporal passes for fixed original/new probability ensemble. Full assembled replay, scoring, relocated subsets and workload projection required", + "serial_after": "learned_d5/robust_loss1_finished.json", + "test_data_used": false + }, + "selection": "Predefined last-two and last-three noninitial fresh_temporal1_full checkpoint means, declared before later checkpoints completed; all104conditions evaluated before group selection", + "test_data_used": false, + "derivation_source_sha256": "f89c4aedba3dabd17e330390ed6763467eb8fec1aa6e24d0a1fd41e4611283a5" + }, + "new_selected_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 4096, + 6144 + ], + "source_training_run": "fresh_temporal1_full", + "source_weights_sha256": { + "2048": "841f3989d6ba86b179109e2d80cea037ba38a28446f962f9104651e4f4504322", + "4096": "21c156629b081965bd0856e5292951ef793277fcac2b72657e89d64e59cdcb1f", + "6144": "08718ad705a9b35495054ffa65e35ac29445fe5ef610620778964a4413901d10" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1301127, + "weights": "weights-2048.npz", + "weights_sha256": "841f3989d6ba86b179109e2d80cea037ba38a28446f962f9104651e4f4504322", + "validation": "validation-2048.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1780972, + "weights": "weights-4096.npz", + "weights_sha256": "21c156629b081965bd0856e5292951ef793277fcac2b72657e89d64e59cdcb1f", + "validation": "validation-4096.json", + "complete": true + }, + "6144": { + "step": 6144, + "new_training_shots": 6291456, + "unique_training_rows_seen_in_this_phase": 1961820, + "weights": "weights-6144.npz", + "weights_sha256": "08718ad705a9b35495054ffa65e35ac29445fe5ef610620778964a4413901d10", + "validation": "validation-6144.json", + "complete": true + } + }, + "weights_sha256": "e3f13efc5e5af11a8591a90b3176b224c892a91c98925cde79d20d3f3de8f184", + "complete": true + } + }, + "original_reference_package": "/run-state/workspace/research/context_upgrades/reserved_gate1/package", + "original_temporal_settings": { + "d3_bX_center_3_5": { + "weights": "weights/specialized-group_specialize1-d3_bX_center_3_5-128.npz", + "training_checkpoint": "group_specialize1/d3_bX_center_3_5/128" + }, + "d3_bX_center_5_3": { + "weights": "weights/contextual-condition_same1-1024.npz", + "training_checkpoint": "condition_same1/1024" + }, + "d3_bX_center_5_7": { + "weights": "weights/specialized-group_specialize1-d3_bX_center_5_7-256.npz", + "training_checkpoint": "group_specialize1/d3_bX_center_5_7/256" + }, + "d3_bX_center_7_5": { + "weights": "weights/specialized-group_specialize1-d3_bX_center_7_5-128.npz", + "training_checkpoint": "group_specialize1/d3_bX_center_7_5/128", + "blend_contextual": true + }, + "d3_bZ_center_3_5": { + "weights": "weights/contextual-condition_same1-512.npz", + "training_checkpoint": "condition_same1/512" + }, + "d3_bZ_center_5_3": { + "weights": "weights/contextual-temporal2-2048.npz", + "training_checkpoint": "temporal2/2048" + }, + "d3_bZ_center_5_7": { + "weights": "weights/contextual-temporal2-4096.npz", + "training_checkpoint": "temporal2/4096" + }, + "d3_bZ_center_7_5": { + "weights": "weights/specialized-group_specialize1-d3_bZ_center_7_5-128.npz", + "training_checkpoint": "group_specialize1/d3_bZ_center_7_5/128" + } + }, + "original_reference_provenance": { + "initialization": { + "distribution": "Normal(0,0.01)", + "seed": 20261021, + "pretrained_weights": false + }, + "training_data": "all 19880 supplied training shots per condition; all 130 conditions", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1", + "calibration_exception": "Supplied even-fitted DEMs include validation syndromes but no logical labels or test data.", + "optimizer": "L-BFGS-B binary cross entropy plus 1e-5 L2, maximum 300 iterations", + "selection": "First trained candidate; validation reported without parameter fitting or hyperparameter selection", + "test_data_used": false, + "released_per_shot_predictions_used": false, + "history": [ + { + "group": "d3_bX_center_3_5", + "train_loss": 0.49244210477855016, + "iterations": 88, + "failure": 0.26941105769230766, + "plain_failure": 0.2847205528846154, + "correlated_failure": 0.2704326923076923, + "coset_failure": 0.2847205528846154, + "optimizer_success": true + }, + { + "group": "d3_bX_center_5_3", + "train_loss": 0.4947914557869911, + "iterations": 85, + "failure": 0.2706430288461538, + "plain_failure": 0.29103064903846154, + "correlated_failure": 0.27076322115384616, + "coset_failure": 0.29103064903846154, + "optimizer_success": true + }, + { + "group": "d3_bX_center_5_7", + "train_loss": 0.4786369068642458, + "iterations": 79, + "failure": 0.25964543269230766, + "plain_failure": 0.2741887019230769, + "correlated_failure": 0.2598106971153846, + "coset_failure": 0.2741887019230769, + "optimizer_success": true + }, + { + "group": "d3_bX_center_7_5", + "train_loss": 0.48299120621578956, + "iterations": 81, + "failure": 0.26062199519230766, + "plain_failure": 0.2762920673076923, + "correlated_failure": 0.2615234375, + "coset_failure": 0.2762920673076923, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_3_5", + "train_loss": 0.4903180822446507, + "iterations": 62, + "failure": 0.2718299278846154, + "plain_failure": 0.2878605769230769, + "correlated_failure": 0.2736778846153846, + "coset_failure": 0.2878605769230769, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_5_3", + "train_loss": 0.4886621962442568, + "iterations": 90, + "failure": 0.25896935096153845, + "plain_failure": 0.27548076923076925, + "correlated_failure": 0.2588942307692308, + "coset_failure": 0.27548076923076925, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_5_7", + "train_loss": 0.4822654448634678, + "iterations": 71, + "failure": 0.2594200721153846, + "plain_failure": 0.2823016826923077, + "correlated_failure": 0.25961538461538464, + "coset_failure": 0.2823016826923077, + "optimizer_success": true + }, + { + "group": "d3_bZ_center_7_5", + "train_loss": 0.47379411844328495, + "iterations": 69, + "failure": 0.2542067307692308, + "plain_failure": 0.27393329326923077, + "correlated_failure": 0.2547776442307692, + "coset_failure": 0.27393329326923077, + "optimizer_success": true + }, + { + "group": "d5_bX_center_5_5", + "train_loss": 0.4801955727360068, + "iterations": 85, + "failure": 0.2616887019230769, + "plain_failure": 0.293359375, + "correlated_failure": 0.2609375, + "coset_failure": 0.293359375, + "optimizer_success": true + }, + { + "group": "d5_bZ_center_5_5", + "train_loss": 0.4661361209861219, + "iterations": 87, + "failure": 0.2465294471153846, + "plain_failure": 0.2799729567307692, + "correlated_failure": 0.24618389423076922, + "coset_failure": 0.2799729567307692, + "optimizer_success": true + } + ], + "elapsed_seconds": 30.247901678085327, + "experiment_2": { + "method": "Exact contraction of supplied DEM for d3; learned logistic mixture with matching features", + "initialization": { + "distribution": "Normal(0,0.01)", + "seed": 20261022, + "pretrained_weights": false + }, + "selection": "Minimum validation condition-mean failure per group among raw exact, calibrated exact, exact plus matching ensemble", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "exact_raw": { + "failure": 0.253125 + }, + "exact_calibrated": { + "failure": 0.25378605769230766, + "train_loss": 0.46127817271552574, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2522686298076923, + "train_loss": 0.459112999306209, + "iterations": 115 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "exact_raw": { + "failure": 0.2569711538461538 + }, + "exact_calibrated": { + "failure": 0.25790264423076925, + "train_loss": 0.46654812103904, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.257421875, + "train_loss": 0.4647701206688181, + "iterations": 80 + } + }, + "selected": "exact_raw" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "exact_raw": { + "failure": 0.23622295673076923 + }, + "exact_calibrated": { + "failure": 0.23608774038461539, + "train_loss": 0.43883548729746, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2357421875, + "train_loss": 0.43779428254411507, + "iterations": 82 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "exact_raw": { + "failure": 0.24507211538461537 + }, + "exact_calibrated": { + "failure": 0.24541766826923078, + "train_loss": 0.4551514021617466, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.24453125, + "train_loss": 0.4531701181347552, + "iterations": 87 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "exact_raw": { + "failure": 0.25402644230769234 + }, + "exact_calibrated": { + "failure": 0.2541316105769231, + "train_loss": 0.4629309494609537, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.25310997596153845, + "train_loss": 0.45978815429050657, + "iterations": 96 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "exact_raw": { + "failure": 0.24298377403846153 + }, + "exact_calibrated": { + "failure": 0.24182692307692308, + "train_loss": 0.4539302799880139, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2408203125, + "train_loss": 0.45299183982324187, + "iterations": 100 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "exact_raw": { + "failure": 0.24226262019230768 + }, + "exact_calibrated": { + "failure": 0.24166165865384615, + "train_loss": 0.4465993958308988, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.24064002403846155, + "train_loss": 0.4446921891727968, + "iterations": 121 + } + }, + "selected": "exact_ensemble" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "exact_raw": { + "failure": 0.23793569711538462 + }, + "exact_calibrated": { + "failure": 0.2377253605769231, + "train_loss": 0.43773570264641537, + "iterations": 8 + }, + "exact_ensemble": { + "failure": 0.2367638221153846, + "train_loss": 0.4363258121838859, + "iterations": 103 + } + }, + "selected": "exact_ensemble" + } + ], + "numerical_check": "r01 all syndromes agrees with exhaustive enumeration to 1.2e-7" + }, + "experiment_3": { + "method": "Exact complementary CSS edge posterior marginals reweight joint error probabilities before relevant CSS exact contraction; induced correlations are factorized", + "initialization": { + "distribution": "Normal(0,0.01)", + "seed": 20261024, + "pretrained_weights": false + }, + "training": "4096 training shots sampled without replacement from each of all 26 d5 conditions, RNG seed 20261023; original matching components retain their all-training-shot fit", + "selection": "Minimum full-validation condition-mean failure per group among previous matching, raw conditional (strength 1), calibrated conditional, and learned combination of strengths 0/.5/1 with matching", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "matching": { + "failure": 0.2616887019230769 + }, + "conditional_raw": { + "failure": 0.24053485576923078 + }, + "conditional_calibrated": { + "failure": 0.24064002403846155, + "train_loss": 0.4375296643032495, + "iterations": 8 + }, + "conditional_ensemble": { + "failure": 0.24024939903846154, + "train_loss": 0.43518462432711086, + "iterations": 107 + } + }, + "selected": "conditional_ensemble" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "matching": { + "failure": 0.2465294471153846 + }, + "conditional_raw": { + "failure": 0.229296875 + }, + "conditional_calibrated": { + "failure": 0.22944711538461537, + "train_loss": 0.42155058672043744, + "iterations": 9 + }, + "conditional_ensemble": { + "failure": 0.22627704326923076, + "train_loss": 0.4183033939719488, + "iterations": 150 + } + }, + "selected": "conditional_ensemble" + } + ], + "approximation": "Complementary-check conditioning induces error dependencies. This candidate uses their marginal probabilities independently; d5 contraction is therefore approximate." + }, + "contextual_d3_pilot": { + "training": { + "initialization": "Random variance-scaled normal first two layers, random Normal(0,.001) output; zero biases; seed 20261025", + "architecture": "Two 32-unit SiLU layers, output 2*tanh correction to original hyperedge logit; 40 local detection bits and 57 static error/geometry features", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 512, + "batch_size": 128, + "optimizer": "AdamW 1e-3, weight decay 1e-4, global gradient norm clip 1", + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 512, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.5264908075332642, + "error": 0.2578125, + "gradient_norm": 0.06699763983488083, + "elapsed": 432.866411447525 + }, + { + "step": 16, + "loss": 0.3703196942806244, + "error": 0.1484375, + "gradient_norm": 0.030896008014678955, + "elapsed": 437.98383259773254 + }, + { + "step": 32, + "loss": 0.5410848259925842, + "error": 0.3125, + "gradient_norm": 0.023287978023290634, + "elapsed": 443.36136960983276 + }, + { + "step": 48, + "loss": 0.6548658609390259, + "error": 0.3984375, + "gradient_norm": 0.08600008487701416, + "elapsed": 448.5753285884857 + }, + { + "step": 64, + "loss": 0.3396199345588684, + "error": 0.1875, + "gradient_norm": 0.09408964961767197, + "elapsed": 453.55865502357483 + }, + { + "step": 80, + "loss": 0.22403547167778015, + "error": 0.09375, + "gradient_norm": 0.11353142559528351, + "elapsed": 458.8852906227112 + }, + { + "step": 96, + "loss": 0.5754531621932983, + "error": 0.34375, + "gradient_norm": 0.10487920045852661, + "elapsed": 466.05401706695557 + }, + { + "step": 112, + "loss": 0.6411566734313965, + "error": 0.4609375, + "gradient_norm": 0.0897318571805954, + "elapsed": 472.25429010391235 + }, + { + "step": 128, + "loss": 0.4312451481819153, + "error": 0.1875, + "gradient_norm": 0.024307778105139732, + "elapsed": 477.15532541275024 + }, + { + "step": 144, + "loss": 0.18217915296554565, + "error": 0.0625, + "gradient_norm": 0.02471880242228508, + "elapsed": 481.5596089363098 + }, + { + "step": 160, + "loss": 0.3044101595878601, + "error": 0.140625, + "gradient_norm": 0.11279744654893875, + "elapsed": 485.47020196914673 + }, + { + "step": 176, + "loss": 0.6485109329223633, + "error": 0.421875, + "gradient_norm": 0.09296684712171555, + "elapsed": 489.5691695213318 + }, + { + "step": 192, + "loss": 0.2566836178302765, + "error": 0.09375, + "gradient_norm": 0.03372751921415329, + "elapsed": 493.5000331401825 + }, + { + "step": 208, + "loss": 0.5453524589538574, + "error": 0.296875, + "gradient_norm": 0.09404441714286804, + "elapsed": 497.62110686302185 + }, + { + "step": 224, + "loss": 0.19316628575325012, + "error": 0.0859375, + "gradient_norm": 0.03877737745642662, + "elapsed": 501.7119605541229 + }, + { + "step": 240, + "loss": 0.5537517070770264, + "error": 0.328125, + "gradient_norm": 0.030214278027415276, + "elapsed": 505.71154594421387 + }, + { + "step": 256, + "loss": 0.5224764347076416, + "error": 0.2734375, + "gradient_norm": 0.13780595362186432, + "elapsed": 509.65054631233215 + }, + { + "step": 272, + "loss": 0.5350009202957153, + "error": 0.3046875, + "gradient_norm": 0.08942794054746628, + "elapsed": 553.2619364261627 + }, + { + "step": 288, + "loss": 0.4561898112297058, + "error": 0.21875, + "gradient_norm": 0.02774384245276451, + "elapsed": 557.1897430419922 + }, + { + "step": 304, + "loss": 0.6102809309959412, + "error": 0.390625, + "gradient_norm": 0.04374801740050316, + "elapsed": 561.1394822597504 + }, + { + "step": 320, + "loss": 0.37536823749542236, + "error": 0.171875, + "gradient_norm": 0.10325513035058975, + "elapsed": 565.0790395736694 + }, + { + "step": 336, + "loss": 0.419940710067749, + "error": 0.2265625, + "gradient_norm": 0.04723379388451576, + "elapsed": 569.050211429596 + }, + { + "step": 352, + "loss": 0.6458156108856201, + "error": 0.4609375, + "gradient_norm": 0.04816316068172455, + "elapsed": 573.0114912986755 + }, + { + "step": 368, + "loss": 0.5628451108932495, + "error": 0.328125, + "gradient_norm": 0.09256711602210999, + "elapsed": 576.9429559707642 + }, + { + "step": 384, + "loss": 0.5773618221282959, + "error": 0.359375, + "gradient_norm": 0.16693103313446045, + "elapsed": 580.8791544437408 + }, + { + "step": 400, + "loss": 0.12261693179607391, + "error": 0.046875, + "gradient_norm": 0.06734084337949753, + "elapsed": 584.8116250038147 + }, + { + "step": 416, + "loss": 0.33368560671806335, + "error": 0.125, + "gradient_norm": 0.04156317561864853, + "elapsed": 588.7308163642883 + }, + { + "step": 432, + "loss": 0.2161063849925995, + "error": 0.109375, + "gradient_norm": 0.06895668804645538, + "elapsed": 592.6584475040436 + }, + { + "step": 448, + "loss": 0.6331151723861694, + "error": 0.3828125, + "gradient_norm": 0.12380247563123703, + "elapsed": 596.5997920036316 + }, + { + "step": 464, + "loss": 0.28776052594184875, + "error": 0.1484375, + "gradient_norm": 0.03920985758304596, + "elapsed": 600.5359675884247 + }, + { + "step": 480, + "loss": 0.639541745185852, + "error": 0.421875, + "gradient_norm": 0.029632505029439926, + "elapsed": 604.4547488689423 + }, + { + "step": 496, + "loss": 0.5919073820114136, + "error": 0.359375, + "gradient_norm": 0.11676646769046783, + "elapsed": 608.3825929164886 + }, + { + "step": 512, + "loss": 0.5479233264923096, + "error": 0.265625, + "gradient_norm": 0.03692208230495453, + "elapsed": 612.3190803527832 + } + ] + }, + "selection": "Per-group minimum failure among previous decoder and pilot steps 256 and 512, using all 532480 d3 validation shots", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "previous": 0.25226862980769227, + "256": 0.2515625, + "512": 0.2510216346153846 + }, + "selected": "512" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "previous": 0.2569711538461539, + "256": 0.2557542067307692, + "512": 0.256640625 + }, + "selected": "256" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "previous": 0.23574218750000003, + "256": 0.2356820913461538, + "512": 0.23511117788461539 + }, + "selected": "512" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "previous": 0.24453125000000003, + "256": 0.24275841346153845, + "512": 0.24224759615384617 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "previous": 0.25310997596153845, + "256": 0.2524188701923077, + "512": 0.2513822115384615 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "previous": 0.24082031250000002, + "256": 0.2387469951923077, + "512": 0.23933293269230768 + }, + "selected": "256" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "previous": 0.24064002403846155, + "256": 0.24053485576923073, + "512": 0.24002403846153844 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "previous": 0.2367638221153846, + "256": 0.23635817307692306, + "512": 0.23584735576923077 + }, + "selected": "512" + } + ], + "initial_validation_subset": "First 512 validation rows/condition; then both trained checkpoints evaluated on full validation", + "features": "40 detection bits within five frames and 57 static error/geometry features; detector indices come from the ideal geometry/DEM; sample IDs are not features", + "derivative_check": "Relative error 1.16e-7 versus automatic differentiation on a small d3 example" + }, + "previous_package_validation": { + "performance": 0.7672400841346154, + "failure_by_distance": { + "d3": 0.2398212139423077, + "d5": 0.22569861778846154 + }, + "scorer": "Supplied qecbench.scoring on all 130 validation conditions and 665600 shots", + "contract_checks": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "shots": 1, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r25_center_5_3", + "shots": 37, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r13_center_5_7", + "shots": 1025, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 7, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 257, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 17, + "maximum_probability_difference": 0.0 + } + ], + "prediction_generation": "All26 d5 conditions replayed from the assembled package; unchanged d3 predictions retained. Full trusted scoring and relocated arbitrary-ID/subset checks.", + "runtime_evidence": "Full133120-shot d5 replay took 322.10s on one H100; d3 paths unchanged from the recorded incumbent.", + "d5_validation_runtime_seconds": 322.1027355194092, + "runtime_vs_cached": { + "scope": "Assembled runtime versus cached candidate predictions, including physical-prior recomputation and compilation/batching differences; descriptive, not a causal precision attribution", + "maximum_probability_difference": 4.285573959350586e-05, + "decision_differences": 0, + "source_sha256": "2e3e81d122f9d626d486d050c38d86bfd3e55bc6cd8e0e270b9e8eabbf69539a" + }, + "contract_execution": { + "requested_verifier_uid": 10001, + "effective_uid": 1000, + "effective_gid": 1000, + "supplementary_groups": [], + "identity_status": "Development process is already unprivileged and cannot change UID; verifier UID10001 was not executed", + "model_and_input_copy": "Owned by development UID 1000,directories0555,files0444,relocated under a fresh accessible temporary parent", + "output_directory": "Owned by execution UID 1000,mode0700", + "PYTHONPATH": "", + "backend": "Runtime default; full selected subset cases", + "scope": "Local contract check; not a Docker/network/mount-isolation test" + } + }, + "previous_model_manifest_sha256": "d8bed57d4619a87ad756d2347796e396b3169d4146f69ab426f99f9934ef1a8f", + "contextual_updates": [ + { + "name": "large512", + "training": { + "initialization": "This session's pilot checkpoint 512; original random initialization seed 20261025", + "run_config": { + "steps": 2048, + "batch": 2048, + "output": "/run-state/workspace/research/learned_exact/continuation1", + "validation_shots": 1024, + "init_weights": "/workspace/research/learned_exact/pilot/weights-512.npz", + "learning_rate": 0.001, + "eval_every": 512, + "seed": 20261028, + "validation_batch": 1024, + "uniform_validation": true, + "original_random_seed": 20261025, + "starting_checkpoint_sha256": "b14f7bf663b0484b9a79a759455ad09aca456f83a7cc29ed2e9e1d210683c180", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1" + }, + "completed_checkpoint_steps": 512, + "new_sampled_training_shots": 1048576, + "optimizer": "AdamW 1e-3, weight decay 1e-4, global norm clip 1; optimizer reset at phase start", + "data": "Uniform sampling over all 104 d3 training conditions; training rows only", + "selection": "Checkpoint 512 evaluated on all 532480 d3 validation shots", + "full_validation_failure": 0.2428973858173077, + "termination": "Saved checkpoint 512, then stopped to restart with corrected validation NLL reporting. Any later in-flight updates were discarded.", + "reporting_correction": "Recomputed with float labels from the full checkpoint predictions; original in-flight diagnostic negated uint8 labels. Training loss and failure metrics were unaffected.", + "test_data_used": false + }, + "selection": "Minimum full validation mean failure per group between the incumbent and this trained checkpoint", + "history": [ + { + "group": "d3_bX_center_3_5", + "previous_failure": 0.2510216346153846, + "candidate_failure": 0.2491436298076923, + "selected_new": true + }, + { + "group": "d3_bX_center_5_3", + "previous_failure": 0.2557542067307692, + "candidate_failure": 0.256640625, + "selected_new": false + }, + { + "group": "d3_bX_center_5_7", + "previous_failure": 0.23511117788461539, + "candidate_failure": 0.23515625, + "selected_new": false + }, + { + "group": "d3_bX_center_7_5", + "previous_failure": 0.24224759615384617, + "candidate_failure": 0.2403996394230769, + "selected_new": true + }, + { + "group": "d3_bZ_center_3_5", + "previous_failure": 0.2513822115384615, + "candidate_failure": 0.24893329326923078, + "selected_new": true + }, + { + "group": "d3_bZ_center_5_3", + "previous_failure": 0.2387469951923077, + "candidate_failure": 0.23925781249999997, + "selected_new": false + }, + { + "group": "d3_bZ_center_5_7", + "previous_failure": 0.24002403846153844, + "candidate_failure": 0.23885216346153845, + "selected_new": true + }, + { + "group": "d3_bZ_center_7_5", + "previous_failure": 0.23584735576923077, + "candidate_failure": 0.23479567307692306, + "selected_new": true + }, + { + "group": "d5_bX_center_5_5", + "previous_failure": 0.24024939903846157, + "candidate_failure": 0.24024939903846157, + "selected_new": false + }, + { + "group": "d5_bZ_center_5_5", + "previous_failure": 0.22627704326923076, + "candidate_failure": 0.22627704326923076, + "selected_new": false + } + ], + "source_checkpoint_sha256": "7a7579b1bded95bcea7b1d26b2cf26de333c1a0f417fac6a0143eeb3a0c93aa2" + }, + { + "name": "continuation2", + "training_run": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Random variance-scaled normal first two layers, random Normal(0,.001) output; zero biases; seed 20261025", + "architecture": "Two 32-unit SiLU layers, output 2*tanh correction to original hyperedge logit; 40 local detection bits and 57 static error/geometry features", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 1536, + "batch_size": 2048, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261028, + "optimizer_restored": true, + "rng_restored": true, + "session_trained_starting_checkpoint": "/workspace/research/learned_exact/continuation1/weights-512.npz", + "starting_checkpoint_sha256": "7a7579b1bded95bcea7b1d26b2cf26de333c1a0f417fac6a0143eeb3a0c93aa2", + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.05675870552659035, + "error": 0.0166015625, + "gradient_norm": 0.007466103881597519, + "elapsed": 30.636001586914062 + }, + { + "step": 16, + "loss": 0.44421544671058655, + "error": 0.22412109375, + "gradient_norm": 0.029868461191654205, + "elapsed": 35.424378871917725 + }, + { + "step": 32, + "loss": 0.46525052189826965, + "error": 0.23681640625, + "gradient_norm": 0.022205814719200134, + "elapsed": 40.526121854782104 + }, + { + "step": 48, + "loss": 0.6177924871444702, + "error": 0.3544921875, + "gradient_norm": 0.022866439074277878, + "elapsed": 45.67929220199585 + }, + { + "step": 64, + "loss": 0.5046484470367432, + "error": 0.2666015625, + "gradient_norm": 0.0222865492105484, + "elapsed": 50.80926203727722 + }, + { + "step": 80, + "loss": 0.638379693031311, + "error": 0.41064453125, + "gradient_norm": 0.012645655311644077, + "elapsed": 55.93321657180786 + }, + { + "step": 96, + "loss": 0.18619170784950256, + "error": 0.0732421875, + "gradient_norm": 0.012208878062665462, + "elapsed": 61.002137899398804 + }, + { + "step": 112, + "loss": 0.4269826412200928, + "error": 0.2109375, + "gradient_norm": 0.021279584616422653, + "elapsed": 66.13066720962524 + }, + { + "step": 128, + "loss": 0.47232550382614136, + "error": 0.25244140625, + "gradient_norm": 0.03405005484819412, + "elapsed": 85.5297167301178 + }, + { + "step": 144, + "loss": 0.2528073787689209, + "error": 0.11279296875, + "gradient_norm": 0.013145577162504196, + "elapsed": 90.68786001205444 + }, + { + "step": 160, + "loss": 0.5877531170845032, + "error": 0.35595703125, + "gradient_norm": 0.019021881744265556, + "elapsed": 95.76396131515503 + }, + { + "step": 176, + "loss": 0.45082807540893555, + "error": 0.2314453125, + "gradient_norm": 0.023904386907815933, + "elapsed": 100.9375216960907 + }, + { + "step": 192, + "loss": 0.4175146222114563, + "error": 0.19921875, + "gradient_norm": 0.021031895652413368, + "elapsed": 105.98947334289551 + }, + { + "step": 208, + "loss": 0.5424385070800781, + "error": 0.30078125, + "gradient_norm": 0.01396750845015049, + "elapsed": 111.17936706542969 + }, + { + "step": 224, + "loss": 0.29304587841033936, + "error": 0.1259765625, + "gradient_norm": 0.014725692570209503, + "elapsed": 116.36282753944397 + }, + { + "step": 240, + "loss": 0.056691475212574005, + "error": 0.015625, + "gradient_norm": 0.002859376836568117, + "elapsed": 121.54807162284851 + }, + { + "step": 256, + "loss": 0.17413178086280823, + "error": 0.06689453125, + "gradient_norm": 0.02666049636900425, + "elapsed": 126.718514919281 + }, + { + "step": 272, + "loss": 0.6115483641624451, + "error": 0.3466796875, + "gradient_norm": 0.03685307130217552, + "elapsed": 131.77990794181824 + }, + { + "step": 288, + "loss": 0.5973552465438843, + "error": 0.3349609375, + "gradient_norm": 0.02574622817337513, + "elapsed": 138.0202260017395 + }, + { + "step": 304, + "loss": 0.18595321476459503, + "error": 0.0732421875, + "gradient_norm": 0.012303492985665798, + "elapsed": 144.16412949562073 + }, + { + "step": 320, + "loss": 0.5418114066123962, + "error": 0.30126953125, + "gradient_norm": 0.018640751019120216, + "elapsed": 150.969500541687 + }, + { + "step": 336, + "loss": 0.5024716258049011, + "error": 0.26708984375, + "gradient_norm": 0.011490182019770145, + "elapsed": 158.32421374320984 + }, + { + "step": 352, + "loss": 0.5002061128616333, + "error": 0.255859375, + "gradient_norm": 0.03905056416988373, + "elapsed": 165.20316648483276 + }, + { + "step": 368, + "loss": 0.5892350077629089, + "error": 0.33837890625, + "gradient_norm": 0.046964384615421295, + "elapsed": 171.98852562904358 + }, + { + "step": 384, + "loss": 0.526427149772644, + "error": 0.2900390625, + "gradient_norm": 0.021478066220879555, + "elapsed": 178.02048754692078 + }, + { + "step": 400, + "loss": 0.5563177466392517, + "error": 0.306640625, + "gradient_norm": 0.024061864241957664, + "elapsed": 184.09671759605408 + }, + { + "step": 416, + "loss": 0.060019996017217636, + "error": 0.0205078125, + "gradient_norm": 0.006343841087073088, + "elapsed": 190.31260657310486 + }, + { + "step": 432, + "loss": 0.5484405755996704, + "error": 0.3115234375, + "gradient_norm": 0.020139696076512337, + "elapsed": 195.41702342033386 + }, + { + "step": 448, + "loss": 0.6163954138755798, + "error": 0.37646484375, + "gradient_norm": 0.011381164193153381, + "elapsed": 200.53582382202148 + }, + { + "step": 464, + "loss": 0.47678378224372864, + "error": 0.25927734375, + "gradient_norm": 0.03807748854160309, + "elapsed": 205.69636607170105 + }, + { + "step": 480, + "loss": 0.5176759362220764, + "error": 0.2705078125, + "gradient_norm": 0.017451826483011246, + "elapsed": 210.7581787109375 + }, + { + "step": 496, + "loss": 0.3626214563846588, + "error": 0.16455078125, + "gradient_norm": 0.019456032663583755, + "elapsed": 215.82069444656372 + }, + { + "step": 512, + "loss": 0.6202600598335266, + "error": 0.35302734375, + "gradient_norm": 0.013814727775752544, + "elapsed": 220.93863129615784 + }, + { + "step": 528, + "loss": 0.5610182285308838, + "error": 0.29833984375, + "gradient_norm": 0.03955027833580971, + "elapsed": 238.0407817363739 + }, + { + "step": 544, + "loss": 0.332148015499115, + "error": 0.15380859375, + "gradient_norm": 0.013710199855268002, + "elapsed": 243.12822461128235 + }, + { + "step": 560, + "loss": 0.4678276777267456, + "error": 0.23974609375, + "gradient_norm": 0.016155347228050232, + "elapsed": 248.3209776878357 + }, + { + "step": 576, + "loss": 0.6166238784790039, + "error": 0.3740234375, + "gradient_norm": 0.017382115125656128, + "elapsed": 253.49981307983398 + }, + { + "step": 592, + "loss": 0.6137416362762451, + "error": 0.373046875, + "gradient_norm": 0.007819767110049725, + "elapsed": 258.68269968032837 + }, + { + "step": 608, + "loss": 0.2780998647212982, + "error": 0.126953125, + "gradient_norm": 0.03436559438705444, + "elapsed": 263.82615661621094 + }, + { + "step": 624, + "loss": 0.6059691309928894, + "error": 0.3623046875, + "gradient_norm": 0.010842837393283844, + "elapsed": 268.9659583568573 + }, + { + "step": 640, + "loss": 0.058036163449287415, + "error": 0.02001953125, + "gradient_norm": 0.004723707213997841, + "elapsed": 274.09823632240295 + }, + { + "step": 656, + "loss": 0.6149133443832397, + "error": 0.37255859375, + "gradient_norm": 0.008533184416592121, + "elapsed": 279.26951336860657 + }, + { + "step": 672, + "loss": 0.3015868663787842, + "error": 0.1318359375, + "gradient_norm": 0.012536457739770412, + "elapsed": 284.41987442970276 + }, + { + "step": 688, + "loss": 0.16231489181518555, + "error": 0.06494140625, + "gradient_norm": 0.0067833056673407555, + "elapsed": 289.56297039985657 + }, + { + "step": 704, + "loss": 0.04929213970899582, + "error": 0.015625, + "gradient_norm": 0.005747381132096052, + "elapsed": 294.6839826107025 + }, + { + "step": 720, + "loss": 0.5615487098693848, + "error": 0.31689453125, + "gradient_norm": 0.02115021087229252, + "elapsed": 299.8546531200409 + }, + { + "step": 736, + "loss": 0.6306260228157043, + "error": 0.3759765625, + "gradient_norm": 0.02629203163087368, + "elapsed": 305.0923271179199 + }, + { + "step": 752, + "loss": 0.03828414902091026, + "error": 0.0126953125, + "gradient_norm": 0.008905005641281605, + "elapsed": 310.5417342185974 + }, + { + "step": 768, + "loss": 0.48764050006866455, + "error": 0.2626953125, + "gradient_norm": 0.024667929857969284, + "elapsed": 316.01200103759766 + }, + { + "step": 784, + "loss": 0.5836235284805298, + "error": 0.3505859375, + "gradient_norm": 0.023319393396377563, + "elapsed": 321.33294105529785 + }, + { + "step": 800, + "loss": 0.5693534016609192, + "error": 0.31396484375, + "gradient_norm": 0.048126742243766785, + "elapsed": 326.52227997779846 + }, + { + "step": 816, + "loss": 0.5710973739624023, + "error": 0.33349609375, + "gradient_norm": 0.022565416991710663, + "elapsed": 331.62225437164307 + }, + { + "step": 832, + "loss": 0.2818760275840759, + "error": 0.11865234375, + "gradient_norm": 0.025756066665053368, + "elapsed": 336.7874104976654 + }, + { + "step": 848, + "loss": 0.6127357482910156, + "error": 0.3583984375, + "gradient_norm": 0.020077377557754517, + "elapsed": 341.92783546447754 + }, + { + "step": 864, + "loss": 0.5109728574752808, + "error": 0.26171875, + "gradient_norm": 0.022484255954623222, + "elapsed": 347.0137662887573 + }, + { + "step": 880, + "loss": 0.16892661154270172, + "error": 0.06103515625, + "gradient_norm": 0.01363676693290472, + "elapsed": 352.0768094062805 + }, + { + "step": 896, + "loss": 0.593660831451416, + "error": 0.34423828125, + "gradient_norm": 0.01379447989165783, + "elapsed": 357.1796865463257 + }, + { + "step": 912, + "loss": 0.635499119758606, + "error": 0.39306640625, + "gradient_norm": 0.012278803624212742, + "elapsed": 362.29547691345215 + }, + { + "step": 928, + "loss": 0.3966389000415802, + "error": 0.19482421875, + "gradient_norm": 0.019856182858347893, + "elapsed": 367.3532474040985 + }, + { + "step": 944, + "loss": 0.05235423520207405, + "error": 0.01611328125, + "gradient_norm": 0.005415339022874832, + "elapsed": 372.4516806602478 + }, + { + "step": 960, + "loss": 0.5913074612617493, + "error": 0.3330078125, + "gradient_norm": 0.021171825006604195, + "elapsed": 377.5324194431305 + }, + { + "step": 976, + "loss": 0.6479356288909912, + "error": 0.41650390625, + "gradient_norm": 0.02845155820250511, + "elapsed": 382.5862877368927 + }, + { + "step": 992, + "loss": 0.5470497608184814, + "error": 0.30908203125, + "gradient_norm": 0.02726798877120018, + "elapsed": 387.6820628643036 + }, + { + "step": 1008, + "loss": 0.5729615688323975, + "error": 0.32861328125, + "gradient_norm": 0.011548872105777264, + "elapsed": 392.7741017341614 + }, + { + "step": 1024, + "loss": 0.0691118910908699, + "error": 0.0205078125, + "gradient_norm": 0.009204022586345673, + "elapsed": 397.8671176433563 + }, + { + "step": 1040, + "loss": 0.5171630382537842, + "error": 0.2685546875, + "gradient_norm": 0.015718232840299606, + "elapsed": 415.6616735458374 + }, + { + "step": 1056, + "loss": 0.6505192518234253, + "error": 0.39990234375, + "gradient_norm": 0.023937702178955078, + "elapsed": 420.7646098136902 + }, + { + "step": 1072, + "loss": 0.5660485625267029, + "error": 0.32666015625, + "gradient_norm": 0.026201115921139717, + "elapsed": 426.09313225746155 + }, + { + "step": 1088, + "loss": 0.4945259094238281, + "error": 0.25048828125, + "gradient_norm": 0.014495921321213245, + "elapsed": 431.2104251384735 + }, + { + "step": 1104, + "loss": 0.5695121884346008, + "error": 0.33837890625, + "gradient_norm": 0.029924258589744568, + "elapsed": 436.3099756240845 + }, + { + "step": 1120, + "loss": 0.3591366112232208, + "error": 0.16015625, + "gradient_norm": 0.017803259193897247, + "elapsed": 441.4024531841278 + }, + { + "step": 1136, + "loss": 0.3302019536495209, + "error": 0.1572265625, + "gradient_norm": 0.01632549799978733, + "elapsed": 446.55403757095337 + }, + { + "step": 1152, + "loss": 0.6093119382858276, + "error": 0.35107421875, + "gradient_norm": 0.014888457022607327, + "elapsed": 451.6241090297699 + }, + { + "step": 1168, + "loss": 0.3500004708766937, + "error": 0.1650390625, + "gradient_norm": 0.011492405086755753, + "elapsed": 456.7753965854645 + }, + { + "step": 1184, + "loss": 0.3738429844379425, + "error": 0.1845703125, + "gradient_norm": 0.015336514450609684, + "elapsed": 461.90868854522705 + }, + { + "step": 1200, + "loss": 0.2892451882362366, + "error": 0.12890625, + "gradient_norm": 0.010124214924871922, + "elapsed": 467.1151931285858 + }, + { + "step": 1216, + "loss": 0.45089617371559143, + "error": 0.23046875, + "gradient_norm": 0.03627275303006172, + "elapsed": 472.30455207824707 + }, + { + "step": 1232, + "loss": 0.6207081079483032, + "error": 0.36376953125, + "gradient_norm": 0.028164058923721313, + "elapsed": 477.4041998386383 + }, + { + "step": 1248, + "loss": 0.6022387742996216, + "error": 0.32470703125, + "gradient_norm": 0.05243176594376564, + "elapsed": 482.5445365905762 + }, + { + "step": 1264, + "loss": 0.6383136510848999, + "error": 0.38818359375, + "gradient_norm": 0.021598732098937035, + "elapsed": 488.21457719802856 + }, + { + "step": 1280, + "loss": 0.28611207008361816, + "error": 0.13037109375, + "gradient_norm": 0.010211448185145855, + "elapsed": 494.3161232471466 + }, + { + "step": 1296, + "loss": 0.5970274209976196, + "error": 0.35009765625, + "gradient_norm": 0.025076791644096375, + "elapsed": 500.2585813999176 + }, + { + "step": 1312, + "loss": 0.48383909463882446, + "error": 0.2529296875, + "gradient_norm": 0.02830139547586441, + "elapsed": 505.9930474758148 + }, + { + "step": 1328, + "loss": 0.6087884902954102, + "error": 0.365234375, + "gradient_norm": 0.01881619170308113, + "elapsed": 512.0680301189423 + }, + { + "step": 1344, + "loss": 0.49332645535469055, + "error": 0.25634765625, + "gradient_norm": 0.02215457707643509, + "elapsed": 517.9840953350067 + }, + { + "step": 1360, + "loss": 0.6202782392501831, + "error": 0.36767578125, + "gradient_norm": 0.018839120864868164, + "elapsed": 524.07217669487 + }, + { + "step": 1376, + "loss": 0.5857731699943542, + "error": 0.3330078125, + "gradient_norm": 0.015682006254792213, + "elapsed": 529.8370056152344 + }, + { + "step": 1392, + "loss": 0.52056485414505, + "error": 0.263671875, + "gradient_norm": 0.02431550808250904, + "elapsed": 535.9721219539642 + }, + { + "step": 1408, + "loss": 0.6433448791503906, + "error": 0.40625, + "gradient_norm": 0.016954610124230385, + "elapsed": 542.0041825771332 + }, + { + "step": 1424, + "loss": 0.6105660200119019, + "error": 0.35107421875, + "gradient_norm": 0.007737957406789064, + "elapsed": 547.4241607189178 + }, + { + "step": 1440, + "loss": 0.27237576246261597, + "error": 0.12451171875, + "gradient_norm": 0.01314462162554264, + "elapsed": 553.5436873435974 + }, + { + "step": 1456, + "loss": 0.5954712629318237, + "error": 0.3623046875, + "gradient_norm": 0.03746134042739868, + "elapsed": 558.7123465538025 + }, + { + "step": 1472, + "loss": 0.4519508481025696, + "error": 0.2255859375, + "gradient_norm": 0.010652865283191204, + "elapsed": 563.8585436344147 + }, + { + "step": 1488, + "loss": 0.41647869348526, + "error": 0.212890625, + "gradient_norm": 0.028575479984283447, + "elapsed": 569.0573513507843 + }, + { + "step": 1504, + "loss": 0.4384400248527527, + "error": 0.21337890625, + "gradient_norm": 0.017627721652388573, + "elapsed": 574.296462059021 + }, + { + "step": 1520, + "loss": 0.6105232238769531, + "error": 0.37109375, + "gradient_norm": 0.016302449628710747, + "elapsed": 579.4641361236572 + }, + { + "step": 1536, + "loss": 0.6215546131134033, + "error": 0.39013671875, + "gradient_norm": 0.032154034823179245, + "elapsed": 584.5684258937836 + } + ] + }, + "selected_checkpoint_steps": [ + 512, + 1024, + 1536 + ], + "checkpoint_records": { + "1536": { + "step": 1536, + "new_training_shots": 3145728, + "weights": "weights-1536.npz", + "weights_sha256": "785132032c12fa38abbb1103774d91b41828fdc5027e1fe4d42053476eb28199", + "validation": "validation-1536.json", + "complete": true + }, + "512": { + "step": 512, + "new_training_shots": 1048576, + "weights": "weights-512.npz", + "weights_sha256": "e9ebeb958eec680c5458b3a5c39aecf0a21c926aee816517b5f9d3bac5815d7f", + "validation": "validation-512.json", + "complete": true + }, + "1024": { + "step": 1024, + "new_training_shots": 2097152, + "weights": "weights-1024.npz", + "weights_sha256": "f45c568b13c92eb4e768146debbc8c50a8ad51882523938932ba26f4afde66f2", + "validation": "validation-1024.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.2491436298076923, + "512": 0.2478215144230769, + "1024": 0.24774639423076922, + "1536": 0.2476862980769231 + }, + "selected": "1536" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2557542067307692, + "512": 0.2544320913461538, + "1024": 0.2548527644230769, + "1536": 0.2545673076923076 + }, + "selected": "512" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23511117788461539, + "512": 0.23602764423076927, + "1024": 0.23553185096153847, + "1536": 0.2345402644230769 + }, + "selected": "1536" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.2403996394230769, + "512": 0.23999399038461539, + "1024": 0.24008413461538464, + "1536": 0.2401141826923077 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24893329326923078, + "512": 0.24894831730769235, + "1024": 0.24735576923076924, + "1536": 0.24664963942307694 + }, + "selected": "1536" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.2387469951923077, + "512": 0.23849158653846156, + "1024": 0.23789062500000002, + "1536": 0.2381610576923077 + }, + "selected": "1024" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23885216346153845, + "512": 0.23807091346153844, + "1024": 0.2377704326923077, + "1536": 0.23733473557692303 + }, + "selected": "1536" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23479567307692306, + "512": 0.2340895432692308, + "1024": 0.2340444711538461, + "1536": 0.23431490384615386 + }, + "selected": "1024" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.24024939903846157 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22627704326923076 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "rich1", + "training_run": { + "initialization": "Random initialization in this session", + "original_initialization": "Random variance-scaled normal first two layers, random Normal(0,.001) output; zero biases; seed 20261030", + "architecture": "Two 128-unit SiLU layers, output 4*tanh correction to original hyperedge logit; 40 local events, 40 reconstructed measurements, 8 per-stabilizer full-shot densities and 57 static features", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 1024, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261030, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.1747799664735794, + "error": 0.068359375, + "gradient_norm": 0.03163275867700577, + "elapsed": 30.666016340255737 + }, + { + "step": 16, + "loss": 0.5729950666427612, + "error": 0.30859375, + "gradient_norm": 0.03532477840781212, + "elapsed": 34.992138385772705 + }, + { + "step": 32, + "loss": 0.33759093284606934, + "error": 0.1435546875, + "gradient_norm": 0.03938521817326546, + "elapsed": 40.51379442214966 + }, + { + "step": 48, + "loss": 0.574704647064209, + "error": 0.3212890625, + "gradient_norm": 0.03584429249167442, + "elapsed": 46.82174754142761 + }, + { + "step": 64, + "loss": 0.6351712942123413, + "error": 0.4072265625, + "gradient_norm": 0.027485841885209084, + "elapsed": 52.75151348114014 + }, + { + "step": 80, + "loss": 0.36342084407806396, + "error": 0.1708984375, + "gradient_norm": 0.040388718247413635, + "elapsed": 58.42134428024292 + }, + { + "step": 96, + "loss": 0.613252580165863, + "error": 0.3525390625, + "gradient_norm": 0.035148631781339645, + "elapsed": 64.40935254096985 + }, + { + "step": 112, + "loss": 0.6042842864990234, + "error": 0.3564453125, + "gradient_norm": 0.06634438037872314, + "elapsed": 70.4053041934967 + }, + { + "step": 128, + "loss": 0.4366868734359741, + "error": 0.20703125, + "gradient_norm": 0.040233220905065536, + "elapsed": 76.10137701034546 + }, + { + "step": 144, + "loss": 0.340861976146698, + "error": 0.154296875, + "gradient_norm": 0.03881179168820381, + "elapsed": 81.10126686096191 + }, + { + "step": 160, + "loss": 0.5801218748092651, + "error": 0.32421875, + "gradient_norm": 0.06090407446026802, + "elapsed": 86.1252555847168 + }, + { + "step": 176, + "loss": 0.37582841515541077, + "error": 0.19140625, + "gradient_norm": 0.06935373693704605, + "elapsed": 91.53376078605652 + }, + { + "step": 192, + "loss": 0.5213879346847534, + "error": 0.291015625, + "gradient_norm": 0.038788966834545135, + "elapsed": 96.78960609436035 + }, + { + "step": 208, + "loss": 0.26441627740859985, + "error": 0.115234375, + "gradient_norm": 0.04845435172319412, + "elapsed": 101.85743975639343 + }, + { + "step": 224, + "loss": 0.4369240701198578, + "error": 0.2119140625, + "gradient_norm": 0.098305843770504, + "elapsed": 106.94148802757263 + }, + { + "step": 240, + "loss": 0.5520763397216797, + "error": 0.3037109375, + "gradient_norm": 0.04845161736011505, + "elapsed": 112.27297902107239 + }, + { + "step": 256, + "loss": 0.595374345779419, + "error": 0.3369140625, + "gradient_norm": 0.03840416297316551, + "elapsed": 117.4812536239624 + }, + { + "step": 272, + "loss": 0.2569020390510559, + "error": 0.103515625, + "gradient_norm": 0.050126779824495316, + "elapsed": 137.86142945289612 + }, + { + "step": 288, + "loss": 0.32830360531806946, + "error": 0.1455078125, + "gradient_norm": 0.035532038658857346, + "elapsed": 142.83670139312744 + }, + { + "step": 304, + "loss": 0.6040379405021667, + "error": 0.36328125, + "gradient_norm": 0.0313950814306736, + "elapsed": 148.05078554153442 + }, + { + "step": 320, + "loss": 0.35434311628341675, + "error": 0.1748046875, + "gradient_norm": 0.03184249624609947, + "elapsed": 153.22213292121887 + }, + { + "step": 336, + "loss": 0.2326659858226776, + "error": 0.099609375, + "gradient_norm": 0.06624855101108551, + "elapsed": 158.455664396286 + }, + { + "step": 352, + "loss": 0.06233043968677521, + "error": 0.017578125, + "gradient_norm": 0.02635284699499607, + "elapsed": 163.10541248321533 + }, + { + "step": 368, + "loss": 0.31427502632141113, + "error": 0.1435546875, + "gradient_norm": 0.04170582816004753, + "elapsed": 167.78928112983704 + }, + { + "step": 384, + "loss": 0.41268765926361084, + "error": 0.19921875, + "gradient_norm": 0.10103361308574677, + "elapsed": 172.34387755393982 + }, + { + "step": 400, + "loss": 0.42649346590042114, + "error": 0.2119140625, + "gradient_norm": 0.03481302782893181, + "elapsed": 176.83626103401184 + }, + { + "step": 416, + "loss": 0.6373635530471802, + "error": 0.4013671875, + "gradient_norm": 0.06979350745677948, + "elapsed": 181.35168766975403 + }, + { + "step": 432, + "loss": 0.17961856722831726, + "error": 0.072265625, + "gradient_norm": 0.018565824255347252, + "elapsed": 185.80416321754456 + }, + { + "step": 448, + "loss": 0.5501771569252014, + "error": 0.287109375, + "gradient_norm": 0.04828835278749466, + "elapsed": 190.30530858039856 + }, + { + "step": 464, + "loss": 0.5648394823074341, + "error": 0.2978515625, + "gradient_norm": 0.07398489862680435, + "elapsed": 194.7985327243805 + }, + { + "step": 480, + "loss": 0.5675262212753296, + "error": 0.3125, + "gradient_norm": 0.036255236715078354, + "elapsed": 199.30496096611023 + }, + { + "step": 496, + "loss": 0.6156162023544312, + "error": 0.3779296875, + "gradient_norm": 0.02318546548485756, + "elapsed": 203.8355917930603 + }, + { + "step": 512, + "loss": 0.0660151019692421, + "error": 0.021484375, + "gradient_norm": 0.020883027464151382, + "elapsed": 208.32652711868286 + }, + { + "step": 528, + "loss": 0.6096083521842957, + "error": 0.37890625, + "gradient_norm": 0.04742306470870972, + "elapsed": 225.1866319179535 + }, + { + "step": 544, + "loss": 0.3829265236854553, + "error": 0.18359375, + "gradient_norm": 0.05981605872511864, + "elapsed": 229.68251276016235 + }, + { + "step": 560, + "loss": 0.537099301815033, + "error": 0.2900390625, + "gradient_norm": 0.0949595719575882, + "elapsed": 234.20215129852295 + }, + { + "step": 576, + "loss": 0.5903713703155518, + "error": 0.3447265625, + "gradient_norm": 0.06430540233850479, + "elapsed": 238.70998644828796 + }, + { + "step": 592, + "loss": 0.5619152188301086, + "error": 0.298828125, + "gradient_norm": 0.03404757007956505, + "elapsed": 243.21307158470154 + }, + { + "step": 608, + "loss": 0.5997255444526672, + "error": 0.3623046875, + "gradient_norm": 0.03946321830153465, + "elapsed": 247.7153992652893 + }, + { + "step": 624, + "loss": 0.5695509910583496, + "error": 0.310546875, + "gradient_norm": 0.02815800905227661, + "elapsed": 252.3102250099182 + }, + { + "step": 640, + "loss": 0.5901973247528076, + "error": 0.34765625, + "gradient_norm": 0.04673359915614128, + "elapsed": 256.89224338531494 + }, + { + "step": 656, + "loss": 0.621924877166748, + "error": 0.37890625, + "gradient_norm": 0.04227908328175545, + "elapsed": 261.43869185447693 + }, + { + "step": 672, + "loss": 0.610299825668335, + "error": 0.35546875, + "gradient_norm": 0.036825064569711685, + "elapsed": 265.97225284576416 + }, + { + "step": 688, + "loss": 0.5249245166778564, + "error": 0.2841796875, + "gradient_norm": 0.0948338434100151, + "elapsed": 270.4997045993805 + }, + { + "step": 704, + "loss": 0.2573642134666443, + "error": 0.111328125, + "gradient_norm": 0.055987801402807236, + "elapsed": 275.0399034023285 + }, + { + "step": 720, + "loss": 0.04867870360612869, + "error": 0.0146484375, + "gradient_norm": 0.03132430091500282, + "elapsed": 279.55093908309937 + }, + { + "step": 736, + "loss": 0.24808242917060852, + "error": 0.1015625, + "gradient_norm": 0.051910530775785446, + "elapsed": 284.08127522468567 + }, + { + "step": 752, + "loss": 0.4981001615524292, + "error": 0.2529296875, + "gradient_norm": 0.06427812576293945, + "elapsed": 288.70672821998596 + }, + { + "step": 768, + "loss": 0.5241370797157288, + "error": 0.28125, + "gradient_norm": 0.10227487236261368, + "elapsed": 293.331086397171 + }, + { + "step": 784, + "loss": 0.6427845358848572, + "error": 0.400390625, + "gradient_norm": 0.08984753489494324, + "elapsed": 311.0226716995239 + }, + { + "step": 800, + "loss": 0.5990085601806641, + "error": 0.3544921875, + "gradient_norm": 0.08950027078390121, + "elapsed": 315.6725699901581 + }, + { + "step": 816, + "loss": 0.5930870771408081, + "error": 0.353515625, + "gradient_norm": 0.03096434287726879, + "elapsed": 320.38578844070435 + }, + { + "step": 832, + "loss": 0.5945324897766113, + "error": 0.359375, + "gradient_norm": 0.052297625690698624, + "elapsed": 325.3292770385742 + }, + { + "step": 848, + "loss": 0.6031227111816406, + "error": 0.3642578125, + "gradient_norm": 0.032976675778627396, + "elapsed": 330.2292652130127 + }, + { + "step": 864, + "loss": 0.3953525125980377, + "error": 0.1748046875, + "gradient_norm": 0.07015999406576157, + "elapsed": 335.1212799549103 + }, + { + "step": 880, + "loss": 0.4324202835559845, + "error": 0.2080078125, + "gradient_norm": 0.1018647849559784, + "elapsed": 339.9696366786957 + }, + { + "step": 896, + "loss": 0.5024446249008179, + "error": 0.265625, + "gradient_norm": 0.03973893076181412, + "elapsed": 344.8794775009155 + }, + { + "step": 912, + "loss": 0.5731178522109985, + "error": 0.33203125, + "gradient_norm": 0.047838907688856125, + "elapsed": 349.57729148864746 + }, + { + "step": 928, + "loss": 0.6279090642929077, + "error": 0.412109375, + "gradient_norm": 0.030738679692149162, + "elapsed": 354.4736604690552 + }, + { + "step": 944, + "loss": 0.6028326153755188, + "error": 0.341796875, + "gradient_norm": 0.04459983482956886, + "elapsed": 359.2764792442322 + }, + { + "step": 960, + "loss": 0.19082097709178925, + "error": 0.0791015625, + "gradient_norm": 0.02478513866662979, + "elapsed": 364.1252644062042 + }, + { + "step": 976, + "loss": 0.443341463804245, + "error": 0.2197265625, + "gradient_norm": 0.14411240816116333, + "elapsed": 368.8472623825073 + }, + { + "step": 992, + "loss": 0.5665505528450012, + "error": 0.3125, + "gradient_norm": 0.06498897075653076, + "elapsed": 373.6812598705292 + }, + { + "step": 1008, + "loss": 0.4306175112724304, + "error": 0.1875, + "gradient_norm": 0.04873151704668999, + "elapsed": 378.56014752388 + }, + { + "step": 1024, + "loss": 0.46258389949798584, + "error": 0.244140625, + "gradient_norm": 0.09452047199010849, + "elapsed": 383.46526074409485 + } + ] + }, + "selected_checkpoint_steps": [ + 1024 + ], + "checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "weights": "weights-1024.npz", + "weights_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "validation": "validation-1024.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average incumbent and new probabilities equally", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.2476862980769231, + "512": 0.24981971153846153, + "1024": 0.24861778846153845, + "blend-512": 0.24816706730769234, + "blend-1024": 0.24764122596153845 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2544320913461538, + "512": 0.25530348557692306, + "1024": 0.2538461538461539, + "blend-512": 0.2550330528846154, + "blend-1024": 0.25369591346153847 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.2345402644230769, + "512": 0.2346905048076923, + "1024": 0.23502103365384613, + "blend-512": 0.23520132211538458, + "blend-1024": 0.23484074519230771 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23999399038461539, + "512": 0.24036959134615385, + "1024": 0.23987379807692305, + "blend-512": 0.240234375, + "blend-1024": 0.24008413461538464 + }, + "selected": "1024" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24664963942307694, + "512": 0.24878305288461539, + "1024": 0.24810697115384614, + "blend-512": 0.2468900240384615, + "blend-1024": 0.24661959134615385 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23789062500000002, + "512": 0.23919771634615386, + "1024": 0.23847656250000002, + "blend-512": 0.23802584134615382, + "blend-1024": 0.2378155048076923 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23733473557692303, + "512": 0.23939302884615382, + "1024": 0.2384465144230769, + "blend-512": 0.23829627403846151, + "blend-1024": 0.23727463942307694 + }, + "selected": "blend-1024" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.2340444711538461, + "512": 0.23482572115384615, + "1024": 0.23378906249999998, + "blend-512": 0.23434495192307692, + "blend-1024": 0.23345853365384614 + }, + "selected": "blend-1024" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.24024939903846157 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22627704326923076 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "temporal1", + "training_run": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "selected_checkpoint_steps": [ + 1024, + 1536, + 2048 + ], + "checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "weights": "weights-2048.npz", + "weights_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "validation": "validation-2048.json", + "complete": true + }, + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "weights": "weights-1024.npz", + "weights_sha256": "6ab63cf2443420bfa5f2a817a90432dfc969348a8b23b0e6ccf3ffad3c381672", + "validation": "validation-1024.json", + "complete": true + }, + "1536": { + "step": 1536, + "new_training_shots": 1572864, + "weights": "weights-1536.npz", + "weights_sha256": "a4c6152c3b8f2f8ab8cdda41e92045ebc7eb944f9931a7937bf49c404bf96668", + "validation": "validation-1536.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24764122596153845, + "512": 0.24836237980769232, + "1024": 0.24783653846153847, + "1536": 0.24682992788461539, + "2048": 0.246875, + "blend-512": 0.24767127403846154, + "blend-1024": 0.24747596153846155, + "blend-1536": 0.24684495192307693, + "blend-2048": 0.24672475961538465 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.25369591346153847, + "512": 0.25387620192307697, + "1024": 0.25365084134615384, + "1536": 0.25392127403846154, + "2048": 0.2531550480769231, + "blend-512": 0.25429687500000003, + "blend-1024": 0.25419170673076924, + "blend-1536": 0.25338040865384615, + "blend-2048": 0.2532301682692308 + }, + "selected": "2048" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.2345402644230769, + "512": 0.23535156250000003, + "1024": 0.23467548076923078, + "1536": 0.23575721153846152, + "2048": 0.23529146634615386, + "blend-512": 0.23494591346153842, + "blend-1024": 0.2351862980769231, + "blend-1536": 0.23535156249999997, + "blend-2048": 0.23446514423076925 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23987379807692305, + "512": 0.2393028846153846, + "1024": 0.2391676682692308, + "1536": 0.2397686298076923, + "2048": 0.23969350961538463, + "blend-512": 0.23972355769230771, + "blend-1024": 0.23967848557692312, + "blend-1536": 0.24044471153846153, + "blend-2048": 0.24048978365384613 + }, + "selected": "1024" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24661959134615385, + "512": 0.24767127403846156, + "1024": 0.24747596153846155, + "1536": 0.24658954326923077, + "2048": 0.2467397836538462, + "blend-512": 0.24634915865384613, + "blend-1024": 0.24684495192307693, + "blend-1536": 0.24640925480769232, + "blend-2048": 0.24625901442307693 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.2378155048076923, + "512": 0.23912259615384615, + "1024": 0.23805588942307693, + "1536": 0.2381610576923077, + "2048": 0.2376802884615385, + "blend-512": 0.2378155048076923, + "blend-1024": 0.23765024038461538, + "blend-1536": 0.23783052884615388, + "blend-2048": 0.23760516826923078 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23727463942307694, + "512": 0.23766526442307695, + "1024": 0.23789062500000005, + "1536": 0.23713942307692307, + "2048": 0.23778545673076923, + "blend-512": 0.2376201923076923, + "blend-1024": 0.23743990384615382, + "blend-1536": 0.2375, + "blend-2048": 0.2376201923076923 + }, + "selected": "1536" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23345853365384614, + "512": 0.2344200721153846, + "1024": 0.23431490384615386, + "1536": 0.23435997596153843, + "2048": 0.23390925480769229, + "blend-512": 0.23448016826923074, + "blend-1024": 0.2340895432692308, + "blend-1536": 0.23360877403846156, + "blend-2048": 0.2338792067307692 + }, + "selected": "incumbent" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2338341346153846 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22182992788461542 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "temporal2", + "training_run": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_train.py": "7d48d2fc7f62d0bec3023b3df1c2ac28537d0417966131ae3a156697a34cda5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 1778773, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18357, + "surface_code_bX_d3_r03_center_3_5": 16816, + "surface_code_bX_d3_r05_center_3_5": 17999, + "surface_code_bX_d3_r07_center_3_5": 15225, + "surface_code_bX_d3_r09_center_3_5": 16132, + "surface_code_bX_d3_r11_center_3_5": 17041, + "surface_code_bX_d3_r13_center_3_5": 18477, + "surface_code_bX_d3_r15_center_3_5": 18214, + "surface_code_bX_d3_r17_center_3_5": 16505, + "surface_code_bX_d3_r19_center_3_5": 17120, + "surface_code_bX_d3_r21_center_3_5": 17563, + "surface_code_bX_d3_r23_center_3_5": 16681, + "surface_code_bX_d3_r25_center_3_5": 18379, + "surface_code_bX_d3_r01_center_5_3": 17450, + "surface_code_bX_d3_r03_center_5_3": 17161, + "surface_code_bX_d3_r05_center_5_3": 15797, + "surface_code_bX_d3_r07_center_5_3": 17800, + "surface_code_bX_d3_r09_center_5_3": 17190, + "surface_code_bX_d3_r11_center_5_3": 15840, + "surface_code_bX_d3_r13_center_5_3": 15178, + "surface_code_bX_d3_r15_center_5_3": 14897, + "surface_code_bX_d3_r17_center_5_3": 18252, + "surface_code_bX_d3_r19_center_5_3": 17083, + "surface_code_bX_d3_r21_center_5_3": 17229, + "surface_code_bX_d3_r23_center_5_3": 14735, + "surface_code_bX_d3_r25_center_5_3": 17949, + "surface_code_bX_d3_r01_center_5_7": 17431, + "surface_code_bX_d3_r03_center_5_7": 16583, + "surface_code_bX_d3_r05_center_5_7": 16891, + "surface_code_bX_d3_r07_center_5_7": 17969, + "surface_code_bX_d3_r09_center_5_7": 17966, + "surface_code_bX_d3_r11_center_5_7": 14424, + "surface_code_bX_d3_r13_center_5_7": 16930, + "surface_code_bX_d3_r15_center_5_7": 15205, + "surface_code_bX_d3_r17_center_5_7": 18252, + "surface_code_bX_d3_r19_center_5_7": 17077, + "surface_code_bX_d3_r21_center_5_7": 16770, + "surface_code_bX_d3_r23_center_5_7": 17308, + "surface_code_bX_d3_r25_center_5_7": 17481, + "surface_code_bX_d3_r01_center_7_5": 16630, + "surface_code_bX_d3_r03_center_7_5": 17439, + "surface_code_bX_d3_r05_center_7_5": 15811, + "surface_code_bX_d3_r07_center_7_5": 16637, + "surface_code_bX_d3_r09_center_7_5": 18306, + "surface_code_bX_d3_r11_center_7_5": 18327, + "surface_code_bX_d3_r13_center_7_5": 17974, + "surface_code_bX_d3_r15_center_7_5": 16106, + "surface_code_bX_d3_r17_center_7_5": 15834, + "surface_code_bX_d3_r19_center_7_5": 17242, + "surface_code_bX_d3_r21_center_7_5": 17889, + "surface_code_bX_d3_r23_center_7_5": 17440, + "surface_code_bX_d3_r25_center_7_5": 17087, + "surface_code_bZ_d3_r01_center_3_5": 16236, + "surface_code_bZ_d3_r03_center_3_5": 17278, + "surface_code_bZ_d3_r05_center_3_5": 16577, + "surface_code_bZ_d3_r07_center_3_5": 17376, + "surface_code_bZ_d3_r09_center_3_5": 16000, + "surface_code_bZ_d3_r11_center_3_5": 15634, + "surface_code_bZ_d3_r13_center_3_5": 14950, + "surface_code_bZ_d3_r15_center_3_5": 16600, + "surface_code_bZ_d3_r17_center_3_5": 15381, + "surface_code_bZ_d3_r19_center_3_5": 16823, + "surface_code_bZ_d3_r21_center_3_5": 18789, + "surface_code_bZ_d3_r23_center_3_5": 15616, + "surface_code_bZ_d3_r25_center_3_5": 17088, + "surface_code_bZ_d3_r01_center_5_3": 17935, + "surface_code_bZ_d3_r03_center_5_3": 16256, + "surface_code_bZ_d3_r05_center_5_3": 17959, + "surface_code_bZ_d3_r07_center_5_3": 18401, + "surface_code_bZ_d3_r09_center_5_3": 16405, + "surface_code_bZ_d3_r11_center_5_3": 17274, + "surface_code_bZ_d3_r13_center_5_3": 18172, + "surface_code_bZ_d3_r15_center_5_3": 17525, + "surface_code_bZ_d3_r17_center_5_3": 18643, + "surface_code_bZ_d3_r19_center_5_3": 17816, + "surface_code_bZ_d3_r21_center_5_3": 17404, + "surface_code_bZ_d3_r23_center_5_3": 17253, + "surface_code_bZ_d3_r25_center_5_3": 17667, + "surface_code_bZ_d3_r01_center_5_7": 16203, + "surface_code_bZ_d3_r03_center_5_7": 17214, + "surface_code_bZ_d3_r05_center_5_7": 16799, + "surface_code_bZ_d3_r07_center_5_7": 17896, + "surface_code_bZ_d3_r09_center_5_7": 16411, + "surface_code_bZ_d3_r11_center_5_7": 17726, + "surface_code_bZ_d3_r13_center_5_7": 16313, + "surface_code_bZ_d3_r15_center_5_7": 17824, + "surface_code_bZ_d3_r17_center_5_7": 15656, + "surface_code_bZ_d3_r19_center_5_7": 17169, + "surface_code_bZ_d3_r21_center_5_7": 17194, + "surface_code_bZ_d3_r23_center_5_7": 16779, + "surface_code_bZ_d3_r25_center_5_7": 16970, + "surface_code_bZ_d3_r01_center_7_5": 16762, + "surface_code_bZ_d3_r03_center_7_5": 17320, + "surface_code_bZ_d3_r05_center_7_5": 17522, + "surface_code_bZ_d3_r07_center_7_5": 17914, + "surface_code_bZ_d3_r09_center_7_5": 18439, + "surface_code_bZ_d3_r11_center_7_5": 18218, + "surface_code_bZ_d3_r13_center_7_5": 17907, + "surface_code_bZ_d3_r15_center_7_5": 17597, + "surface_code_bZ_d3_r17_center_7_5": 18252, + "surface_code_bZ_d3_r19_center_7_5": 18379, + "surface_code_bZ_d3_r21_center_7_5": 16818, + "surface_code_bZ_d3_r23_center_7_5": 18430, + "surface_code_bZ_d3_r25_center_7_5": 17924 + }, + "steps": 4096, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.0005, + "sampling_seed": 20261121, + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_exact/temporal1/rng-2048.json", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal1/weights-2048.npz", + "starting_checkpoint_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "starting_training_provenance": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.250907301902771, + "error": 0.1083984375, + "gradient_norm": 0.07171476632356644, + "elapsed": 44.811134576797485 + }, + { + "step": 16, + "loss": 0.5958679914474487, + "error": 0.3662109375, + "gradient_norm": 0.07673005014657974, + "elapsed": 49.90856671333313 + }, + { + "step": 32, + "loss": 0.47648972272872925, + "error": 0.2421875, + "gradient_norm": 0.08561501652002335, + "elapsed": 55.179388761520386 + }, + { + "step": 48, + "loss": 0.06145006790757179, + "error": 0.0234375, + "gradient_norm": 0.01556467730551958, + "elapsed": 61.0339195728302 + }, + { + "step": 64, + "loss": 0.3687053918838501, + "error": 0.1884765625, + "gradient_norm": 0.08752371370792389, + "elapsed": 65.95811891555786 + }, + { + "step": 80, + "loss": 0.6481984853744507, + "error": 0.4140625, + "gradient_norm": 0.05311283841729164, + "elapsed": 70.56021332740784 + }, + { + "step": 96, + "loss": 0.42319929599761963, + "error": 0.2138671875, + "gradient_norm": 0.05047478526830673, + "elapsed": 75.11613631248474 + }, + { + "step": 112, + "loss": 0.47527259588241577, + "error": 0.24609375, + "gradient_norm": 0.038366906344890594, + "elapsed": 79.53446984291077 + }, + { + "step": 128, + "loss": 0.5996723175048828, + "error": 0.3369140625, + "gradient_norm": 0.1213272362947464, + "elapsed": 83.97515749931335 + }, + { + "step": 144, + "loss": 0.04971993714570999, + "error": 0.0146484375, + "gradient_norm": 0.008080735802650452, + "elapsed": 88.44039463996887 + }, + { + "step": 160, + "loss": 0.35900360345840454, + "error": 0.162109375, + "gradient_norm": 0.03359593451023102, + "elapsed": 92.89548206329346 + }, + { + "step": 176, + "loss": 0.5342063903808594, + "error": 0.2978515625, + "gradient_norm": 0.04794691130518913, + "elapsed": 97.35658049583435 + }, + { + "step": 192, + "loss": 0.6300076246261597, + "error": 0.369140625, + "gradient_norm": 0.081769198179245, + "elapsed": 101.81493759155273 + }, + { + "step": 208, + "loss": 0.6191903948783875, + "error": 0.3828125, + "gradient_norm": 0.07145775109529495, + "elapsed": 106.2480263710022 + }, + { + "step": 224, + "loss": 0.5155678391456604, + "error": 0.28515625, + "gradient_norm": 0.06772179156541824, + "elapsed": 110.71284222602844 + }, + { + "step": 240, + "loss": 0.634708046913147, + "error": 0.3857421875, + "gradient_norm": 0.09493093192577362, + "elapsed": 115.14978742599487 + }, + { + "step": 256, + "loss": 0.1840895414352417, + "error": 0.0751953125, + "gradient_norm": 0.025586696341633797, + "elapsed": 119.61202120780945 + }, + { + "step": 272, + "loss": 0.2775103449821472, + "error": 0.12890625, + "gradient_norm": 0.06913147866725922, + "elapsed": 124.02584528923035 + }, + { + "step": 288, + "loss": 0.6163080334663391, + "error": 0.3642578125, + "gradient_norm": 0.05895426496863365, + "elapsed": 128.46512532234192 + }, + { + "step": 304, + "loss": 0.5276986360549927, + "error": 0.287109375, + "gradient_norm": 0.06955187022686005, + "elapsed": 132.89240765571594 + }, + { + "step": 320, + "loss": 0.44859516620635986, + "error": 0.22265625, + "gradient_norm": 0.07272452116012573, + "elapsed": 137.32864713668823 + }, + { + "step": 336, + "loss": 0.48315611481666565, + "error": 0.2626953125, + "gradient_norm": 0.03321139141917229, + "elapsed": 141.80009770393372 + }, + { + "step": 352, + "loss": 0.6107717752456665, + "error": 0.3544921875, + "gradient_norm": 0.05243214592337608, + "elapsed": 146.36439752578735 + }, + { + "step": 368, + "loss": 0.6215153932571411, + "error": 0.357421875, + "gradient_norm": 0.04383325204253197, + "elapsed": 150.99996852874756 + }, + { + "step": 384, + "loss": 0.6130329966545105, + "error": 0.35546875, + "gradient_norm": 0.04113119840621948, + "elapsed": 155.62374639511108 + }, + { + "step": 400, + "loss": 0.30471885204315186, + "error": 0.142578125, + "gradient_norm": 0.04447556659579277, + "elapsed": 160.17594957351685 + }, + { + "step": 416, + "loss": 0.6154489517211914, + "error": 0.37109375, + "gradient_norm": 0.04456057772040367, + "elapsed": 164.7639675140381 + }, + { + "step": 432, + "loss": 0.6134694218635559, + "error": 0.337890625, + "gradient_norm": 0.04219559207558632, + "elapsed": 169.32792139053345 + }, + { + "step": 448, + "loss": 0.5463185906410217, + "error": 0.2939453125, + "gradient_norm": 0.07746092975139618, + "elapsed": 173.88445162773132 + }, + { + "step": 464, + "loss": 0.06016772612929344, + "error": 0.01953125, + "gradient_norm": 0.01364185381680727, + "elapsed": 178.42725706100464 + }, + { + "step": 480, + "loss": 0.388141393661499, + "error": 0.18359375, + "gradient_norm": 0.04870256036520004, + "elapsed": 182.99062085151672 + }, + { + "step": 496, + "loss": 0.44524821639060974, + "error": 0.2216796875, + "gradient_norm": 0.03453445807099342, + "elapsed": 187.56396961212158 + }, + { + "step": 512, + "loss": 0.34312355518341064, + "error": 0.154296875, + "gradient_norm": 0.06794509291648865, + "elapsed": 192.27511191368103 + }, + { + "step": 528, + "loss": 0.19467462599277496, + "error": 0.0771484375, + "gradient_norm": 0.042381469160318375, + "elapsed": 197.7108268737793 + }, + { + "step": 544, + "loss": 0.46226584911346436, + "error": 0.2421875, + "gradient_norm": 0.06073570251464844, + "elapsed": 202.97405791282654 + }, + { + "step": 560, + "loss": 0.525318443775177, + "error": 0.2822265625, + "gradient_norm": 0.06954885274171829, + "elapsed": 208.69676971435547 + }, + { + "step": 576, + "loss": 0.6158387064933777, + "error": 0.349609375, + "gradient_norm": 0.07587578892707825, + "elapsed": 214.80397653579712 + }, + { + "step": 592, + "loss": 0.5515886545181274, + "error": 0.298828125, + "gradient_norm": 0.04969338700175285, + "elapsed": 220.27399611473083 + }, + { + "step": 608, + "loss": 0.18365338444709778, + "error": 0.0654296875, + "gradient_norm": 0.08657706528902054, + "elapsed": 224.81246256828308 + }, + { + "step": 624, + "loss": 0.4578855633735657, + "error": 0.2421875, + "gradient_norm": 0.04942100867629051, + "elapsed": 229.45902252197266 + }, + { + "step": 640, + "loss": 0.37826013565063477, + "error": 0.1865234375, + "gradient_norm": 0.047499872744083405, + "elapsed": 233.9695644378662 + }, + { + "step": 656, + "loss": 0.40863412618637085, + "error": 0.2001953125, + "gradient_norm": 0.07845330238342285, + "elapsed": 238.584894657135 + }, + { + "step": 672, + "loss": 0.5640332698822021, + "error": 0.2880859375, + "gradient_norm": 0.057469289749860764, + "elapsed": 243.0929844379425 + }, + { + "step": 688, + "loss": 0.030216243118047714, + "error": 0.0078125, + "gradient_norm": 0.04682641476392746, + "elapsed": 247.581125497818 + }, + { + "step": 704, + "loss": 0.375002384185791, + "error": 0.1826171875, + "gradient_norm": 0.04864194989204407, + "elapsed": 252.1564691066742 + }, + { + "step": 720, + "loss": 0.5145515203475952, + "error": 0.2744140625, + "gradient_norm": 0.052671682089567184, + "elapsed": 256.6466488838196 + }, + { + "step": 736, + "loss": 0.067174531519413, + "error": 0.0224609375, + "gradient_norm": 0.019299577921628952, + "elapsed": 261.1185076236725 + }, + { + "step": 752, + "loss": 0.24909992516040802, + "error": 0.111328125, + "gradient_norm": 0.06907463818788528, + "elapsed": 265.61960339546204 + }, + { + "step": 768, + "loss": 0.5088074207305908, + "error": 0.2744140625, + "gradient_norm": 0.06963017582893372, + "elapsed": 270.07474064826965 + }, + { + "step": 784, + "loss": 0.3783387839794159, + "error": 0.1826171875, + "gradient_norm": 0.05537794530391693, + "elapsed": 274.52722239494324 + }, + { + "step": 800, + "loss": 0.6107200980186462, + "error": 0.3623046875, + "gradient_norm": 0.0470259003341198, + "elapsed": 279.0401859283447 + }, + { + "step": 816, + "loss": 0.5778236389160156, + "error": 0.3212890625, + "gradient_norm": 0.10146680474281311, + "elapsed": 283.5114622116089 + }, + { + "step": 832, + "loss": 0.576002299785614, + "error": 0.3076171875, + "gradient_norm": 0.07760787010192871, + "elapsed": 288.04797434806824 + }, + { + "step": 848, + "loss": 0.6179666519165039, + "error": 0.3740234375, + "gradient_norm": 0.07383852452039719, + "elapsed": 292.60600209236145 + }, + { + "step": 864, + "loss": 0.3105512857437134, + "error": 0.1455078125, + "gradient_norm": 0.052953749895095825, + "elapsed": 297.12180352211 + }, + { + "step": 880, + "loss": 0.4802623987197876, + "error": 0.2548828125, + "gradient_norm": 0.07736275345087051, + "elapsed": 301.6091134548187 + }, + { + "step": 896, + "loss": 0.5572722554206848, + "error": 0.318359375, + "gradient_norm": 0.053303152322769165, + "elapsed": 306.1978073120117 + }, + { + "step": 912, + "loss": 0.34814420342445374, + "error": 0.1669921875, + "gradient_norm": 0.037726350128650665, + "elapsed": 310.78571581840515 + }, + { + "step": 928, + "loss": 0.41743016242980957, + "error": 0.21875, + "gradient_norm": 0.05238872766494751, + "elapsed": 315.24156188964844 + }, + { + "step": 944, + "loss": 0.5757850408554077, + "error": 0.3173828125, + "gradient_norm": 0.05837905779480934, + "elapsed": 319.78475165367126 + }, + { + "step": 960, + "loss": 0.40727972984313965, + "error": 0.197265625, + "gradient_norm": 0.059294261038303375, + "elapsed": 324.2090265750885 + }, + { + "step": 976, + "loss": 0.32715001702308655, + "error": 0.1533203125, + "gradient_norm": 0.11543179303407669, + "elapsed": 328.6462152004242 + }, + { + "step": 992, + "loss": 0.5578742623329163, + "error": 0.314453125, + "gradient_norm": 0.06282714009284973, + "elapsed": 333.0712504386902 + }, + { + "step": 1008, + "loss": 0.5052692294120789, + "error": 0.265625, + "gradient_norm": 0.04039420187473297, + "elapsed": 337.5182821750641 + }, + { + "step": 1024, + "loss": 0.18790806829929352, + "error": 0.08203125, + "gradient_norm": 0.028905188664793968, + "elapsed": 342.08340406417847 + }, + { + "step": 1040, + "loss": 0.6317684650421143, + "error": 0.3681640625, + "gradient_norm": 0.03441835194826126, + "elapsed": 358.8279616832733 + }, + { + "step": 1056, + "loss": 0.40474164485931396, + "error": 0.2021484375, + "gradient_norm": 0.036449309438467026, + "elapsed": 363.30218267440796 + }, + { + "step": 1072, + "loss": 0.518299400806427, + "error": 0.2666015625, + "gradient_norm": 0.0886964276432991, + "elapsed": 367.87997555732727 + }, + { + "step": 1088, + "loss": 0.2522922158241272, + "error": 0.099609375, + "gradient_norm": 0.07553310692310333, + "elapsed": 372.4414882659912 + }, + { + "step": 1104, + "loss": 0.6214810609817505, + "error": 0.3701171875, + "gradient_norm": 0.10188957303762436, + "elapsed": 376.9120502471924 + }, + { + "step": 1120, + "loss": 0.6307054162025452, + "error": 0.3720703125, + "gradient_norm": 0.07353860139846802, + "elapsed": 381.3824534416199 + }, + { + "step": 1136, + "loss": 0.5259381532669067, + "error": 0.2763671875, + "gradient_norm": 0.05779678374528885, + "elapsed": 385.8413143157959 + }, + { + "step": 1152, + "loss": 0.4995541572570801, + "error": 0.259765625, + "gradient_norm": 0.046648140996694565, + "elapsed": 390.28326058387756 + }, + { + "step": 1168, + "loss": 0.6075694561004639, + "error": 0.3701171875, + "gradient_norm": 0.10612073540687561, + "elapsed": 394.8162364959717 + }, + { + "step": 1184, + "loss": 0.2105136513710022, + "error": 0.080078125, + "gradient_norm": 0.0716402605175972, + "elapsed": 399.2960283756256 + }, + { + "step": 1200, + "loss": 0.6371631026268005, + "error": 0.3857421875, + "gradient_norm": 0.0549108125269413, + "elapsed": 403.7899103164673 + }, + { + "step": 1216, + "loss": 0.5450670719146729, + "error": 0.2939453125, + "gradient_norm": 0.11688558012247086, + "elapsed": 408.34677600860596 + }, + { + "step": 1232, + "loss": 0.035783201456069946, + "error": 0.01171875, + "gradient_norm": 0.02951689623296261, + "elapsed": 412.8558337688446 + }, + { + "step": 1248, + "loss": 0.5582903623580933, + "error": 0.3046875, + "gradient_norm": 0.055107031017541885, + "elapsed": 417.29854226112366 + }, + { + "step": 1264, + "loss": 0.5154441595077515, + "error": 0.27734375, + "gradient_norm": 0.04474929720163345, + "elapsed": 421.7792055606842 + }, + { + "step": 1280, + "loss": 0.35227546095848083, + "error": 0.16015625, + "gradient_norm": 0.05024837702512741, + "elapsed": 426.54427456855774 + }, + { + "step": 1296, + "loss": 0.19417589902877808, + "error": 0.0830078125, + "gradient_norm": 0.026926057413220406, + "elapsed": 431.320588350296 + }, + { + "step": 1312, + "loss": 0.4768218398094177, + "error": 0.248046875, + "gradient_norm": 0.15099607408046722, + "elapsed": 435.96817326545715 + }, + { + "step": 1328, + "loss": 0.48580923676490784, + "error": 0.2509765625, + "gradient_norm": 0.08925126492977142, + "elapsed": 440.64917039871216 + }, + { + "step": 1344, + "loss": 0.42041274905204773, + "error": 0.1982421875, + "gradient_norm": 0.08321093022823334, + "elapsed": 445.34370946884155 + }, + { + "step": 1360, + "loss": 0.06403929740190506, + "error": 0.0185546875, + "gradient_norm": 0.03817005455493927, + "elapsed": 449.98669385910034 + }, + { + "step": 1376, + "loss": 0.463126003742218, + "error": 0.2275390625, + "gradient_norm": 0.08894515782594681, + "elapsed": 454.6478977203369 + }, + { + "step": 1392, + "loss": 0.5995306968688965, + "error": 0.373046875, + "gradient_norm": 0.06733685731887817, + "elapsed": 459.35924530029297 + }, + { + "step": 1408, + "loss": 0.49053263664245605, + "error": 0.25, + "gradient_norm": 0.10475508868694305, + "elapsed": 464.100093126297 + }, + { + "step": 1424, + "loss": 0.6220744848251343, + "error": 0.3818359375, + "gradient_norm": 0.03653963655233383, + "elapsed": 468.89601135253906 + }, + { + "step": 1440, + "loss": 0.39706122875213623, + "error": 0.2021484375, + "gradient_norm": 0.04344598576426506, + "elapsed": 474.03999519348145 + }, + { + "step": 1456, + "loss": 0.5386708974838257, + "error": 0.3095703125, + "gradient_norm": 0.12589037418365479, + "elapsed": 478.8600504398346 + }, + { + "step": 1472, + "loss": 0.49776726961135864, + "error": 0.271484375, + "gradient_norm": 0.058137863874435425, + "elapsed": 483.5920066833496 + }, + { + "step": 1488, + "loss": 0.4757428765296936, + "error": 0.2412109375, + "gradient_norm": 0.050453316420316696, + "elapsed": 488.4611999988556 + }, + { + "step": 1504, + "loss": 0.5694847702980042, + "error": 0.337890625, + "gradient_norm": 0.052419569343328476, + "elapsed": 493.26151037216187 + }, + { + "step": 1520, + "loss": 0.5997745990753174, + "error": 0.3603515625, + "gradient_norm": 0.04338108375668526, + "elapsed": 498.0421245098114 + }, + { + "step": 1536, + "loss": 0.6195274591445923, + "error": 0.3876953125, + "gradient_norm": 0.04848463833332062, + "elapsed": 502.8808298110962 + }, + { + "step": 1552, + "loss": 0.46315908432006836, + "error": 0.2353515625, + "gradient_norm": 0.06380566209554672, + "elapsed": 507.5519721508026 + }, + { + "step": 1568, + "loss": 0.605262041091919, + "error": 0.36328125, + "gradient_norm": 0.05077619478106499, + "elapsed": 512.457685470581 + }, + { + "step": 1584, + "loss": 0.48782041668891907, + "error": 0.232421875, + "gradient_norm": 0.09017211943864822, + "elapsed": 517.2960062026978 + }, + { + "step": 1600, + "loss": 0.3881351947784424, + "error": 0.1875, + "gradient_norm": 0.07205695658922195, + "elapsed": 522.0911631584167 + }, + { + "step": 1616, + "loss": 0.4966873526573181, + "error": 0.24609375, + "gradient_norm": 0.0582038015127182, + "elapsed": 526.8861901760101 + }, + { + "step": 1632, + "loss": 0.5844199657440186, + "error": 0.33203125, + "gradient_norm": 0.05101500824093819, + "elapsed": 531.6640138626099 + }, + { + "step": 1648, + "loss": 0.31010180711746216, + "error": 0.1318359375, + "gradient_norm": 0.053135693073272705, + "elapsed": 536.4960391521454 + }, + { + "step": 1664, + "loss": 0.6174807548522949, + "error": 0.3779296875, + "gradient_norm": 0.04161194711923599, + "elapsed": 541.2560484409332 + }, + { + "step": 1680, + "loss": 0.18213607370853424, + "error": 0.0751953125, + "gradient_norm": 0.07171957194805145, + "elapsed": 546.0000085830688 + }, + { + "step": 1696, + "loss": 0.5445692539215088, + "error": 0.2998046875, + "gradient_norm": 0.054499462246894836, + "elapsed": 551.1221191883087 + }, + { + "step": 1712, + "loss": 0.05744167044758797, + "error": 0.017578125, + "gradient_norm": 0.013108699582517147, + "elapsed": 556.5286149978638 + }, + { + "step": 1728, + "loss": 0.6381571292877197, + "error": 0.3896484375, + "gradient_norm": 0.05157556012272835, + "elapsed": 561.8000066280365 + }, + { + "step": 1744, + "loss": 0.5301004648208618, + "error": 0.28125, + "gradient_norm": 0.04218568280339241, + "elapsed": 567.2760035991669 + }, + { + "step": 1760, + "loss": 0.5275102257728577, + "error": 0.26953125, + "gradient_norm": 0.06798839569091797, + "elapsed": 572.5601994991302 + }, + { + "step": 1776, + "loss": 0.6443773508071899, + "error": 0.4091796875, + "gradient_norm": 0.07035460323095322, + "elapsed": 577.9789206981659 + }, + { + "step": 1792, + "loss": 0.6012362241744995, + "error": 0.337890625, + "gradient_norm": 0.05189951881766319, + "elapsed": 583.028017282486 + }, + { + "step": 1808, + "loss": 0.2939091920852661, + "error": 0.12109375, + "gradient_norm": 0.05555355176329613, + "elapsed": 588.0501506328583 + }, + { + "step": 1824, + "loss": 0.2059091478586197, + "error": 0.08984375, + "gradient_norm": 0.045679714530706406, + "elapsed": 593.2120039463043 + }, + { + "step": 1840, + "loss": 0.6289581060409546, + "error": 0.349609375, + "gradient_norm": 0.04742642492055893, + "elapsed": 598.7767763137817 + }, + { + "step": 1856, + "loss": 0.5532636642456055, + "error": 0.294921875, + "gradient_norm": 0.05997413396835327, + "elapsed": 604.0475382804871 + }, + { + "step": 1872, + "loss": 0.45995670557022095, + "error": 0.228515625, + "gradient_norm": 0.05674462765455246, + "elapsed": 609.292379617691 + }, + { + "step": 1888, + "loss": 0.6178656816482544, + "error": 0.359375, + "gradient_norm": 0.08857566863298416, + "elapsed": 614.5639882087708 + }, + { + "step": 1904, + "loss": 0.5531284213066101, + "error": 0.287109375, + "gradient_norm": 0.10257937759160995, + "elapsed": 619.5600035190582 + }, + { + "step": 1920, + "loss": 0.04184349626302719, + "error": 0.013671875, + "gradient_norm": 0.04087059944868088, + "elapsed": 624.6679775714874 + }, + { + "step": 1936, + "loss": 0.5924860239028931, + "error": 0.3505859375, + "gradient_norm": 0.036822713911533356, + "elapsed": 629.936680316925 + }, + { + "step": 1952, + "loss": 0.46996980905532837, + "error": 0.2421875, + "gradient_norm": 0.034442272037267685, + "elapsed": 635.1109762191772 + }, + { + "step": 1968, + "loss": 0.17859068512916565, + "error": 0.0712890625, + "gradient_norm": 0.03440066799521446, + "elapsed": 640.32000207901 + }, + { + "step": 1984, + "loss": 0.6192275285720825, + "error": 0.3701171875, + "gradient_norm": 0.04386439174413681, + "elapsed": 645.6040184497833 + }, + { + "step": 2000, + "loss": 0.6160917282104492, + "error": 0.35546875, + "gradient_norm": 0.06268990784883499, + "elapsed": 650.7723731994629 + }, + { + "step": 2016, + "loss": 0.6343611478805542, + "error": 0.388671875, + "gradient_norm": 0.04243326932191849, + "elapsed": 655.972663640976 + }, + { + "step": 2032, + "loss": 0.062292590737342834, + "error": 0.021484375, + "gradient_norm": 0.016680095344781876, + "elapsed": 660.8079733848572 + }, + { + "step": 2048, + "loss": 0.5316072702407837, + "error": 0.26953125, + "gradient_norm": 0.057860780507326126, + "elapsed": 665.5760209560394 + }, + { + "step": 2064, + "loss": 0.605312705039978, + "error": 0.3623046875, + "gradient_norm": 0.04028146713972092, + "elapsed": 682.7294294834137 + }, + { + "step": 2080, + "loss": 0.56633460521698, + "error": 0.3330078125, + "gradient_norm": 0.09528280049562454, + "elapsed": 687.4644649028778 + }, + { + "step": 2096, + "loss": 0.3905397057533264, + "error": 0.1943359375, + "gradient_norm": 0.049456462264060974, + "elapsed": 692.1492264270782 + }, + { + "step": 2112, + "loss": 0.28124868869781494, + "error": 0.1259765625, + "gradient_norm": 0.059239838272333145, + "elapsed": 696.8701393604279 + }, + { + "step": 2128, + "loss": 0.6364338994026184, + "error": 0.392578125, + "gradient_norm": 0.08667811006307602, + "elapsed": 701.683988571167 + }, + { + "step": 2144, + "loss": 0.20683243870735168, + "error": 0.07421875, + "gradient_norm": 0.1100710779428482, + "elapsed": 706.4000360965729 + }, + { + "step": 2160, + "loss": 0.5912737250328064, + "error": 0.341796875, + "gradient_norm": 0.05641854554414749, + "elapsed": 711.2359964847565 + }, + { + "step": 2176, + "loss": 0.27793264389038086, + "error": 0.12109375, + "gradient_norm": 0.0893034040927887, + "elapsed": 715.9508004188538 + }, + { + "step": 2192, + "loss": 0.6474133133888245, + "error": 0.4072265625, + "gradient_norm": 0.06980258971452713, + "elapsed": 720.651974439621 + }, + { + "step": 2208, + "loss": 0.5961858630180359, + "error": 0.35546875, + "gradient_norm": 0.06530112773180008, + "elapsed": 725.496098279953 + }, + { + "step": 2224, + "loss": 0.47581571340560913, + "error": 0.263671875, + "gradient_norm": 0.04470043256878853, + "elapsed": 730.2880010604858 + }, + { + "step": 2240, + "loss": 0.577988862991333, + "error": 0.318359375, + "gradient_norm": 0.07201159745454788, + "elapsed": 735.006133556366 + }, + { + "step": 2256, + "loss": 0.28444671630859375, + "error": 0.1181640625, + "gradient_norm": 0.048656050115823746, + "elapsed": 739.6868116855621 + }, + { + "step": 2272, + "loss": 0.2776409089565277, + "error": 0.1201171875, + "gradient_norm": 0.05783981829881668, + "elapsed": 744.3517308235168 + }, + { + "step": 2288, + "loss": 0.621599555015564, + "error": 0.37109375, + "gradient_norm": 0.09731200337409973, + "elapsed": 749.0351710319519 + }, + { + "step": 2304, + "loss": 0.3333754539489746, + "error": 0.1513671875, + "gradient_norm": 0.07069239765405655, + "elapsed": 753.7588081359863 + }, + { + "step": 2320, + "loss": 0.4687051773071289, + "error": 0.2490234375, + "gradient_norm": 0.044891707599163055, + "elapsed": 758.4588432312012 + }, + { + "step": 2336, + "loss": 0.19801637530326843, + "error": 0.078125, + "gradient_norm": 0.10036595165729523, + "elapsed": 763.256409406662 + }, + { + "step": 2352, + "loss": 0.6186277866363525, + "error": 0.388671875, + "gradient_norm": 0.09069584310054779, + "elapsed": 767.9986386299133 + }, + { + "step": 2368, + "loss": 0.6177258491516113, + "error": 0.373046875, + "gradient_norm": 0.049019571393728256, + "elapsed": 772.730831861496 + }, + { + "step": 2384, + "loss": 0.17707547545433044, + "error": 0.0673828125, + "gradient_norm": 0.045190781354904175, + "elapsed": 777.4072704315186 + }, + { + "step": 2400, + "loss": 0.20144733786582947, + "error": 0.08203125, + "gradient_norm": 0.04537162929773331, + "elapsed": 782.0841658115387 + }, + { + "step": 2416, + "loss": 0.6151775121688843, + "error": 0.365234375, + "gradient_norm": 0.050534047186374664, + "elapsed": 786.762966632843 + }, + { + "step": 2432, + "loss": 0.5533859133720398, + "error": 0.314453125, + "gradient_norm": 0.06006559729576111, + "elapsed": 791.4656012058258 + }, + { + "step": 2448, + "loss": 0.5329082012176514, + "error": 0.2880859375, + "gradient_norm": 0.04018115997314453, + "elapsed": 796.1704161167145 + }, + { + "step": 2464, + "loss": 0.6338047981262207, + "error": 0.4140625, + "gradient_norm": 0.06069163978099823, + "elapsed": 800.9180119037628 + }, + { + "step": 2480, + "loss": 0.1603008508682251, + "error": 0.0673828125, + "gradient_norm": 0.040350593626499176, + "elapsed": 805.6127603054047 + }, + { + "step": 2496, + "loss": 0.505940318107605, + "error": 0.2568359375, + "gradient_norm": 0.05209952965378761, + "elapsed": 810.3740313053131 + }, + { + "step": 2512, + "loss": 0.5528728365898132, + "error": 0.298828125, + "gradient_norm": 0.11757992953062057, + "elapsed": 815.1708807945251 + }, + { + "step": 2528, + "loss": 0.5028313994407654, + "error": 0.2666015625, + "gradient_norm": 0.08823780715465546, + "elapsed": 819.8585045337677 + }, + { + "step": 2544, + "loss": 0.5002262592315674, + "error": 0.2783203125, + "gradient_norm": 0.04888603836297989, + "elapsed": 824.5714073181152 + }, + { + "step": 2560, + "loss": 0.6007894277572632, + "error": 0.328125, + "gradient_norm": 0.05186954140663147, + "elapsed": 829.3080432415009 + }, + { + "step": 2576, + "loss": 0.18641480803489685, + "error": 0.076171875, + "gradient_norm": 0.03799928352236748, + "elapsed": 834.044020652771 + }, + { + "step": 2592, + "loss": 0.3050769865512848, + "error": 0.1396484375, + "gradient_norm": 0.10119257122278214, + "elapsed": 838.8401296138763 + }, + { + "step": 2608, + "loss": 0.6063439846038818, + "error": 0.361328125, + "gradient_norm": 0.04979367554187775, + "elapsed": 844.3572654724121 + }, + { + "step": 2624, + "loss": 0.5751967430114746, + "error": 0.3369140625, + "gradient_norm": 0.04269539937376976, + "elapsed": 849.0660374164581 + }, + { + "step": 2640, + "loss": 0.3902108669281006, + "error": 0.193359375, + "gradient_norm": 0.10029696673154831, + "elapsed": 853.8638062477112 + }, + { + "step": 2656, + "loss": 0.15081660449504852, + "error": 0.0625, + "gradient_norm": 0.0303852129727602, + "elapsed": 858.9793758392334 + }, + { + "step": 2672, + "loss": 0.6503090858459473, + "error": 0.400390625, + "gradient_norm": 0.12611964344978333, + "elapsed": 863.9151141643524 + }, + { + "step": 2688, + "loss": 0.5587317943572998, + "error": 0.31640625, + "gradient_norm": 0.10028114914894104, + "elapsed": 868.7600305080414 + }, + { + "step": 2704, + "loss": 0.4399867355823517, + "error": 0.21484375, + "gradient_norm": 0.06889455020427704, + "elapsed": 873.4544236660004 + }, + { + "step": 2720, + "loss": 0.5865127444267273, + "error": 0.337890625, + "gradient_norm": 0.03671631962060928, + "elapsed": 878.0982644557953 + }, + { + "step": 2736, + "loss": 0.6078637838363647, + "error": 0.3701171875, + "gradient_norm": 0.04679318517446518, + "elapsed": 883.0424642562866 + }, + { + "step": 2752, + "loss": 0.5825340151786804, + "error": 0.337890625, + "gradient_norm": 0.05619681254029274, + "elapsed": 887.908124923706 + }, + { + "step": 2768, + "loss": 0.5970422029495239, + "error": 0.3369140625, + "gradient_norm": 0.041302867233753204, + "elapsed": 892.6760206222534 + }, + { + "step": 2784, + "loss": 0.3870226740837097, + "error": 0.1826171875, + "gradient_norm": 0.05731065198779106, + "elapsed": 897.6246056556702 + }, + { + "step": 2800, + "loss": 0.38130277395248413, + "error": 0.1943359375, + "gradient_norm": 0.059244755655527115, + "elapsed": 902.3360238075256 + }, + { + "step": 2816, + "loss": 0.2617901563644409, + "error": 0.1064453125, + "gradient_norm": 0.041736964136362076, + "elapsed": 907.1600468158722 + }, + { + "step": 2832, + "loss": 0.5819337368011475, + "error": 0.314453125, + "gradient_norm": 0.04097156226634979, + "elapsed": 912.0244295597076 + }, + { + "step": 2848, + "loss": 0.41393283009529114, + "error": 0.2001953125, + "gradient_norm": 0.10456771403551102, + "elapsed": 916.8225846290588 + }, + { + "step": 2864, + "loss": 0.5019145011901855, + "error": 0.2548828125, + "gradient_norm": 0.04843736067414284, + "elapsed": 921.538754940033 + }, + { + "step": 2880, + "loss": 0.04561338573694229, + "error": 0.0146484375, + "gradient_norm": 0.025407327339053154, + "elapsed": 926.2588667869568 + }, + { + "step": 2896, + "loss": 0.4338858723640442, + "error": 0.205078125, + "gradient_norm": 0.09900517761707306, + "elapsed": 930.9781975746155 + }, + { + "step": 2912, + "loss": 0.33922863006591797, + "error": 0.162109375, + "gradient_norm": 0.10189604014158249, + "elapsed": 935.6816267967224 + }, + { + "step": 2928, + "loss": 0.5294322967529297, + "error": 0.2822265625, + "gradient_norm": 0.09060791879892349, + "elapsed": 940.4373068809509 + }, + { + "step": 2944, + "loss": 0.037007369101047516, + "error": 0.01171875, + "gradient_norm": 0.05506489425897598, + "elapsed": 945.1270468235016 + }, + { + "step": 2960, + "loss": 0.6096771359443665, + "error": 0.349609375, + "gradient_norm": 0.04987221211194992, + "elapsed": 949.8300130367279 + }, + { + "step": 2976, + "loss": 0.6157823801040649, + "error": 0.373046875, + "gradient_norm": 0.03614233434200287, + "elapsed": 954.5701997280121 + }, + { + "step": 2992, + "loss": 0.1978239268064499, + "error": 0.080078125, + "gradient_norm": 0.05847112461924553, + "elapsed": 959.2756471633911 + }, + { + "step": 3008, + "loss": 0.5237340927124023, + "error": 0.2841796875, + "gradient_norm": 0.06993591040372849, + "elapsed": 963.9875864982605 + }, + { + "step": 3024, + "loss": 0.4559935927391052, + "error": 0.2373046875, + "gradient_norm": 0.05698448419570923, + "elapsed": 968.7997305393219 + }, + { + "step": 3040, + "loss": 0.5025208592414856, + "error": 0.259765625, + "gradient_norm": 0.14909739792346954, + "elapsed": 973.6042547225952 + }, + { + "step": 3056, + "loss": 0.3223109245300293, + "error": 0.1416015625, + "gradient_norm": 0.032974764704704285, + "elapsed": 978.4760546684265 + }, + { + "step": 3072, + "loss": 0.06682582199573517, + "error": 0.021484375, + "gradient_norm": 0.04433188587427139, + "elapsed": 983.2894048690796 + }, + { + "step": 3088, + "loss": 0.5919550061225891, + "error": 0.34765625, + "gradient_norm": 0.06721373647451401, + "elapsed": 1000.9520287513733 + }, + { + "step": 3104, + "loss": 0.5988063812255859, + "error": 0.3642578125, + "gradient_norm": 0.05654948577284813, + "elapsed": 1005.7442932128906 + }, + { + "step": 3120, + "loss": 0.4922299385070801, + "error": 0.2470703125, + "gradient_norm": 0.07545466721057892, + "elapsed": 1010.4616096019745 + }, + { + "step": 3136, + "loss": 0.4533671736717224, + "error": 0.236328125, + "gradient_norm": 0.06288722902536392, + "elapsed": 1015.3559956550598 + }, + { + "step": 3152, + "loss": 0.5070517063140869, + "error": 0.2666015625, + "gradient_norm": 0.07274917513132095, + "elapsed": 1020.0764343738556 + }, + { + "step": 3168, + "loss": 0.5999464988708496, + "error": 0.3408203125, + "gradient_norm": 0.05777016654610634, + "elapsed": 1024.9410600662231 + }, + { + "step": 3184, + "loss": 0.5758363008499146, + "error": 0.3427734375, + "gradient_norm": 0.051027461886405945, + "elapsed": 1029.7082171440125 + }, + { + "step": 3200, + "loss": 0.05016190931200981, + "error": 0.017578125, + "gradient_norm": 0.009175656363368034, + "elapsed": 1034.3982915878296 + }, + { + "step": 3216, + "loss": 0.5471057295799255, + "error": 0.318359375, + "gradient_norm": 0.07572721689939499, + "elapsed": 1039.117841243744 + }, + { + "step": 3232, + "loss": 0.4141446352005005, + "error": 0.193359375, + "gradient_norm": 0.10056859254837036, + "elapsed": 1043.880026102066 + }, + { + "step": 3248, + "loss": 0.5812438726425171, + "error": 0.3212890625, + "gradient_norm": 0.05781616270542145, + "elapsed": 1048.6406455039978 + }, + { + "step": 3264, + "loss": 0.19184701144695282, + "error": 0.078125, + "gradient_norm": 0.05367236211895943, + "elapsed": 1053.5672237873077 + }, + { + "step": 3280, + "loss": 0.5420833826065063, + "error": 0.28515625, + "gradient_norm": 0.052405405789613724, + "elapsed": 1058.3841104507446 + }, + { + "step": 3296, + "loss": 0.4419598877429962, + "error": 0.2177734375, + "gradient_norm": 0.05814693495631218, + "elapsed": 1063.1880333423615 + }, + { + "step": 3312, + "loss": 0.4525642991065979, + "error": 0.208984375, + "gradient_norm": 0.1061021164059639, + "elapsed": 1068.1370933055878 + }, + { + "step": 3328, + "loss": 0.32664671540260315, + "error": 0.154296875, + "gradient_norm": 0.05649850144982338, + "elapsed": 1073.1963467597961 + }, + { + "step": 3344, + "loss": 0.2655770182609558, + "error": 0.1220703125, + "gradient_norm": 0.04070372134447098, + "elapsed": 1078.2698318958282 + }, + { + "step": 3360, + "loss": 0.5894330739974976, + "error": 0.3544921875, + "gradient_norm": 0.0643400028347969, + "elapsed": 1083.0184152126312 + }, + { + "step": 3376, + "loss": 0.6118791103363037, + "error": 0.361328125, + "gradient_norm": 0.08537904173135757, + "elapsed": 1087.834038734436 + }, + { + "step": 3392, + "loss": 0.40694907307624817, + "error": 0.19921875, + "gradient_norm": 0.11411692947149277, + "elapsed": 1092.8119947910309 + }, + { + "step": 3408, + "loss": 0.04629015550017357, + "error": 0.0146484375, + "gradient_norm": 0.017204072326421738, + "elapsed": 1097.5751783847809 + }, + { + "step": 3424, + "loss": 0.20639702677726746, + "error": 0.0849609375, + "gradient_norm": 0.04801144450902939, + "elapsed": 1102.2970931529999 + }, + { + "step": 3440, + "loss": 0.6051071286201477, + "error": 0.33984375, + "gradient_norm": 0.045392412692308426, + "elapsed": 1107.1080610752106 + }, + { + "step": 3456, + "loss": 0.6553700566291809, + "error": 0.40625, + "gradient_norm": 0.05593863129615784, + "elapsed": 1111.8409752845764 + }, + { + "step": 3472, + "loss": 0.591402530670166, + "error": 0.3515625, + "gradient_norm": 0.051181379705667496, + "elapsed": 1116.5800333023071 + }, + { + "step": 3488, + "loss": 0.30494624376296997, + "error": 0.12109375, + "gradient_norm": 0.05175542086362839, + "elapsed": 1121.276373386383 + }, + { + "step": 3504, + "loss": 0.5065370798110962, + "error": 0.279296875, + "gradient_norm": 0.10419930517673492, + "elapsed": 1125.9883344173431 + }, + { + "step": 3520, + "loss": 0.3915700614452362, + "error": 0.1953125, + "gradient_norm": 0.060416825115680695, + "elapsed": 1130.7958455085754 + }, + { + "step": 3536, + "loss": 0.624374270439148, + "error": 0.3759765625, + "gradient_norm": 0.06069556251168251, + "elapsed": 1135.5360939502716 + }, + { + "step": 3552, + "loss": 0.5830206274986267, + "error": 0.3359375, + "gradient_norm": 0.046013280749320984, + "elapsed": 1140.312029838562 + }, + { + "step": 3568, + "loss": 0.4201379716396332, + "error": 0.2119140625, + "gradient_norm": 0.06909621506929398, + "elapsed": 1145.0904593467712 + }, + { + "step": 3584, + "loss": 0.28215405344963074, + "error": 0.1181640625, + "gradient_norm": 0.07625982910394669, + "elapsed": 1149.8156151771545 + }, + { + "step": 3600, + "loss": 0.5229164361953735, + "error": 0.275390625, + "gradient_norm": 0.055048178881406784, + "elapsed": 1154.5280592441559 + }, + { + "step": 3616, + "loss": 0.47238075733184814, + "error": 0.2314453125, + "gradient_norm": 0.06473162025213242, + "elapsed": 1159.2720873355865 + }, + { + "step": 3632, + "loss": 0.46245503425598145, + "error": 0.228515625, + "gradient_norm": 0.07382887601852417, + "elapsed": 1164.0119998455048 + }, + { + "step": 3648, + "loss": 0.37509745359420776, + "error": 0.171875, + "gradient_norm": 0.051260266453027725, + "elapsed": 1168.7440350055695 + }, + { + "step": 3664, + "loss": 0.1948484629392624, + "error": 0.080078125, + "gradient_norm": 0.059623416513204575, + "elapsed": 1173.3906588554382 + }, + { + "step": 3680, + "loss": 0.5552756786346436, + "error": 0.3115234375, + "gradient_norm": 0.08073585480451584, + "elapsed": 1178.0645008087158 + }, + { + "step": 3696, + "loss": 0.6405904293060303, + "error": 0.39453125, + "gradient_norm": 0.05899551138281822, + "elapsed": 1182.730489730835 + }, + { + "step": 3712, + "loss": 0.2767012119293213, + "error": 0.119140625, + "gradient_norm": 0.06593579798936844, + "elapsed": 1187.377315044403 + }, + { + "step": 3728, + "loss": 0.315812885761261, + "error": 0.134765625, + "gradient_norm": 0.035905495285987854, + "elapsed": 1192.0582301616669 + }, + { + "step": 3744, + "loss": 0.6033951640129089, + "error": 0.3544921875, + "gradient_norm": 0.05226197466254234, + "elapsed": 1196.7101175785065 + }, + { + "step": 3760, + "loss": 0.5202592611312866, + "error": 0.275390625, + "gradient_norm": 0.06367512047290802, + "elapsed": 1201.3543090820312 + }, + { + "step": 3776, + "loss": 0.24639368057250977, + "error": 0.1083984375, + "gradient_norm": 0.09370873868465424, + "elapsed": 1206.0717165470123 + }, + { + "step": 3792, + "loss": 0.6175658702850342, + "error": 0.375, + "gradient_norm": 0.06221585348248482, + "elapsed": 1210.754029750824 + }, + { + "step": 3808, + "loss": 0.41153696179389954, + "error": 0.2119140625, + "gradient_norm": 0.05355365574359894, + "elapsed": 1215.4374370574951 + }, + { + "step": 3824, + "loss": 0.28002214431762695, + "error": 0.1123046875, + "gradient_norm": 0.03846330568194389, + "elapsed": 1220.1207013130188 + }, + { + "step": 3840, + "loss": 0.0484195351600647, + "error": 0.013671875, + "gradient_norm": 0.03470242768526077, + "elapsed": 1224.8153104782104 + }, + { + "step": 3856, + "loss": 0.1407160609960556, + "error": 0.0458984375, + "gradient_norm": 0.04061700031161308, + "elapsed": 1229.5512235164642 + }, + { + "step": 3872, + "loss": 0.5881794691085815, + "error": 0.3427734375, + "gradient_norm": 0.062013477087020874, + "elapsed": 1234.3750183582306 + }, + { + "step": 3888, + "loss": 0.17833612859249115, + "error": 0.06640625, + "gradient_norm": 0.038856204599142075, + "elapsed": 1239.110375881195 + }, + { + "step": 3904, + "loss": 0.06211477518081665, + "error": 0.0224609375, + "gradient_norm": 0.02150108851492405, + "elapsed": 1243.800644159317 + }, + { + "step": 3920, + "loss": 0.06039723381400108, + "error": 0.01953125, + "gradient_norm": 0.019367367029190063, + "elapsed": 1248.4831748008728 + }, + { + "step": 3936, + "loss": 0.6010214686393738, + "error": 0.3525390625, + "gradient_norm": 0.051659151911735535, + "elapsed": 1253.1423478126526 + }, + { + "step": 3952, + "loss": 0.5867137312889099, + "error": 0.3388671875, + "gradient_norm": 0.058528851717710495, + "elapsed": 1257.9799931049347 + }, + { + "step": 3968, + "loss": 0.5231834650039673, + "error": 0.2578125, + "gradient_norm": 0.10128334909677505, + "elapsed": 1262.6990082263947 + }, + { + "step": 3984, + "loss": 0.6251651644706726, + "error": 0.353515625, + "gradient_norm": 0.06211795285344124, + "elapsed": 1267.4289934635162 + }, + { + "step": 4000, + "loss": 0.06667037308216095, + "error": 0.01953125, + "gradient_norm": 0.048018258064985275, + "elapsed": 1272.132089138031 + }, + { + "step": 4016, + "loss": 0.5286938548088074, + "error": 0.2744140625, + "gradient_norm": 0.05509360507130623, + "elapsed": 1276.8878977298737 + }, + { + "step": 4032, + "loss": 0.34016552567481995, + "error": 0.1591796875, + "gradient_norm": 0.07597329467535019, + "elapsed": 1281.7364926338196 + }, + { + "step": 4048, + "loss": 0.17750494182109833, + "error": 0.078125, + "gradient_norm": 0.06314503401517868, + "elapsed": 1286.5033600330353 + }, + { + "step": 4064, + "loss": 0.5882893800735474, + "error": 0.34375, + "gradient_norm": 0.10986580699682236, + "elapsed": 1291.1944887638092 + }, + { + "step": 4080, + "loss": 0.4923543930053711, + "error": 0.2568359375, + "gradient_norm": 0.050325747579336166, + "elapsed": 1295.9372322559357 + }, + { + "step": 4096, + "loss": 0.44146978855133057, + "error": 0.2236328125, + "gradient_norm": 0.06535191088914871, + "elapsed": 1300.641023159027 + } + ] + }, + "training_source_snapshot": "training_sources/temporal2", + "selected_checkpoint_steps": [ + "1024", + "2048", + "4096" + ], + "checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 804757, + "weights": "weights-1024.npz", + "weights_sha256": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "validation": "validation-1024.json", + "complete": true + }, + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24672475961538465, + "1024": 0.24571814903846154, + "2048": 0.24504206730769232, + "3072": 0.2456129807692308, + "4096": 0.2445763221153846, + "blend-1024": 0.2469501201923077, + "blend-2048": 0.24583834134615387, + "blend-3072": 0.2458984375, + "blend-4096": 0.2456580528846154 + }, + "selected": "4096" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2530348557692308, + "1024": 0.2528545673076923, + "2048": 0.25342548076923077, + "3072": 0.25369591346153847, + "4096": 0.25446213942307694, + "blend-1024": 0.2531550480769231, + "blend-2048": 0.2536658653846154, + "blend-3072": 0.25329026442307695, + "blend-4096": 0.2540264423076923 + }, + "selected": "1024" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23442007211538465, + "1024": 0.23445012019230768, + "2048": 0.2340895432692308, + "3072": 0.23431490384615383, + "4096": 0.23366887019230773, + "blend-1024": 0.23440504807692308, + "blend-2048": 0.2341496394230769, + "blend-3072": 0.23416466346153844, + "blend-4096": 0.23413461538461536 + }, + "selected": "4096" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.2392427884615385, + "1024": 0.23949819711538464, + "2048": 0.23907752403846155, + "3072": 0.24014423076923078, + "4096": 0.24064002403846152, + "blend-1024": 0.23916766826923075, + "blend-2048": 0.23886718750000002, + "blend-3072": 0.2392578125, + "blend-4096": 0.23900240384615387 + }, + "selected": "blend-2048" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24630408653846156, + "1024": 0.24649939903846152, + "2048": 0.2460486778846154, + "3072": 0.24523737980769228, + "4096": 0.24463641826923077, + "blend-1024": 0.24615384615384614, + "blend-2048": 0.2456580528846154, + "blend-3072": 0.24583834134615384, + "blend-4096": 0.24576322115384613 + }, + "selected": "4096" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23760516826923078, + "1024": 0.23733473557692308, + "2048": 0.23652343749999996, + "3072": 0.23795072115384613, + "4096": 0.2379807692307692, + "blend-1024": 0.23713942307692307, + "blend-2048": 0.23740985576923077, + "blend-3072": 0.23811598557692307, + "blend-4096": 0.23780048076923077 + }, + "selected": "2048" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.2371694711538461, + "1024": 0.23689903846153845, + "2048": 0.2371243990384615, + "3072": 0.2371844951923077, + "4096": 0.23562199519230764, + "blend-1024": 0.23715444711538464, + "blend-2048": 0.23662860576923078, + "blend-3072": 0.23712439903846153, + "blend-4096": 0.23643329326923077 + }, + "selected": "4096" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23342848557692306, + "1024": 0.23353365384615385, + "2048": 0.23429987980769232, + "3072": 0.2335637019230769, + "4096": 0.2329627403846154, + "blend-1024": 0.23350360576923074, + "blend-2048": 0.23383413461538463, + "blend-3072": 0.23357872596153847, + "blend-4096": 0.2333533653846154 + }, + "selected": "4096" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2325420673076923 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "temporal2_swa", + "training_run": { + "initialization": "Uniform averages of the same session-trained temporal trajectory; no external weights", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_train.py": "7d48d2fc7f62d0bec3023b3df1c2ac28537d0417966131ae3a156697a34cda5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 1778773, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18357, + "surface_code_bX_d3_r03_center_3_5": 16816, + "surface_code_bX_d3_r05_center_3_5": 17999, + "surface_code_bX_d3_r07_center_3_5": 15225, + "surface_code_bX_d3_r09_center_3_5": 16132, + "surface_code_bX_d3_r11_center_3_5": 17041, + "surface_code_bX_d3_r13_center_3_5": 18477, + "surface_code_bX_d3_r15_center_3_5": 18214, + "surface_code_bX_d3_r17_center_3_5": 16505, + "surface_code_bX_d3_r19_center_3_5": 17120, + "surface_code_bX_d3_r21_center_3_5": 17563, + "surface_code_bX_d3_r23_center_3_5": 16681, + "surface_code_bX_d3_r25_center_3_5": 18379, + "surface_code_bX_d3_r01_center_5_3": 17450, + "surface_code_bX_d3_r03_center_5_3": 17161, + "surface_code_bX_d3_r05_center_5_3": 15797, + "surface_code_bX_d3_r07_center_5_3": 17800, + "surface_code_bX_d3_r09_center_5_3": 17190, + "surface_code_bX_d3_r11_center_5_3": 15840, + "surface_code_bX_d3_r13_center_5_3": 15178, + "surface_code_bX_d3_r15_center_5_3": 14897, + "surface_code_bX_d3_r17_center_5_3": 18252, + "surface_code_bX_d3_r19_center_5_3": 17083, + "surface_code_bX_d3_r21_center_5_3": 17229, + "surface_code_bX_d3_r23_center_5_3": 14735, + "surface_code_bX_d3_r25_center_5_3": 17949, + "surface_code_bX_d3_r01_center_5_7": 17431, + "surface_code_bX_d3_r03_center_5_7": 16583, + "surface_code_bX_d3_r05_center_5_7": 16891, + "surface_code_bX_d3_r07_center_5_7": 17969, + "surface_code_bX_d3_r09_center_5_7": 17966, + "surface_code_bX_d3_r11_center_5_7": 14424, + "surface_code_bX_d3_r13_center_5_7": 16930, + "surface_code_bX_d3_r15_center_5_7": 15205, + "surface_code_bX_d3_r17_center_5_7": 18252, + "surface_code_bX_d3_r19_center_5_7": 17077, + "surface_code_bX_d3_r21_center_5_7": 16770, + "surface_code_bX_d3_r23_center_5_7": 17308, + "surface_code_bX_d3_r25_center_5_7": 17481, + "surface_code_bX_d3_r01_center_7_5": 16630, + "surface_code_bX_d3_r03_center_7_5": 17439, + "surface_code_bX_d3_r05_center_7_5": 15811, + "surface_code_bX_d3_r07_center_7_5": 16637, + "surface_code_bX_d3_r09_center_7_5": 18306, + "surface_code_bX_d3_r11_center_7_5": 18327, + "surface_code_bX_d3_r13_center_7_5": 17974, + "surface_code_bX_d3_r15_center_7_5": 16106, + "surface_code_bX_d3_r17_center_7_5": 15834, + "surface_code_bX_d3_r19_center_7_5": 17242, + "surface_code_bX_d3_r21_center_7_5": 17889, + "surface_code_bX_d3_r23_center_7_5": 17440, + "surface_code_bX_d3_r25_center_7_5": 17087, + "surface_code_bZ_d3_r01_center_3_5": 16236, + "surface_code_bZ_d3_r03_center_3_5": 17278, + "surface_code_bZ_d3_r05_center_3_5": 16577, + "surface_code_bZ_d3_r07_center_3_5": 17376, + "surface_code_bZ_d3_r09_center_3_5": 16000, + "surface_code_bZ_d3_r11_center_3_5": 15634, + "surface_code_bZ_d3_r13_center_3_5": 14950, + "surface_code_bZ_d3_r15_center_3_5": 16600, + "surface_code_bZ_d3_r17_center_3_5": 15381, + "surface_code_bZ_d3_r19_center_3_5": 16823, + "surface_code_bZ_d3_r21_center_3_5": 18789, + "surface_code_bZ_d3_r23_center_3_5": 15616, + "surface_code_bZ_d3_r25_center_3_5": 17088, + "surface_code_bZ_d3_r01_center_5_3": 17935, + "surface_code_bZ_d3_r03_center_5_3": 16256, + "surface_code_bZ_d3_r05_center_5_3": 17959, + "surface_code_bZ_d3_r07_center_5_3": 18401, + "surface_code_bZ_d3_r09_center_5_3": 16405, + "surface_code_bZ_d3_r11_center_5_3": 17274, + "surface_code_bZ_d3_r13_center_5_3": 18172, + "surface_code_bZ_d3_r15_center_5_3": 17525, + "surface_code_bZ_d3_r17_center_5_3": 18643, + "surface_code_bZ_d3_r19_center_5_3": 17816, + "surface_code_bZ_d3_r21_center_5_3": 17404, + "surface_code_bZ_d3_r23_center_5_3": 17253, + "surface_code_bZ_d3_r25_center_5_3": 17667, + "surface_code_bZ_d3_r01_center_5_7": 16203, + "surface_code_bZ_d3_r03_center_5_7": 17214, + "surface_code_bZ_d3_r05_center_5_7": 16799, + "surface_code_bZ_d3_r07_center_5_7": 17896, + "surface_code_bZ_d3_r09_center_5_7": 16411, + "surface_code_bZ_d3_r11_center_5_7": 17726, + "surface_code_bZ_d3_r13_center_5_7": 16313, + "surface_code_bZ_d3_r15_center_5_7": 17824, + "surface_code_bZ_d3_r17_center_5_7": 15656, + "surface_code_bZ_d3_r19_center_5_7": 17169, + "surface_code_bZ_d3_r21_center_5_7": 17194, + "surface_code_bZ_d3_r23_center_5_7": 16779, + "surface_code_bZ_d3_r25_center_5_7": 16970, + "surface_code_bZ_d3_r01_center_7_5": 16762, + "surface_code_bZ_d3_r03_center_7_5": 17320, + "surface_code_bZ_d3_r05_center_7_5": 17522, + "surface_code_bZ_d3_r07_center_7_5": 17914, + "surface_code_bZ_d3_r09_center_7_5": 18439, + "surface_code_bZ_d3_r11_center_7_5": 18218, + "surface_code_bZ_d3_r13_center_7_5": 17907, + "surface_code_bZ_d3_r15_center_7_5": 17597, + "surface_code_bZ_d3_r17_center_7_5": 18252, + "surface_code_bZ_d3_r19_center_7_5": 18379, + "surface_code_bZ_d3_r21_center_7_5": 16818, + "surface_code_bZ_d3_r23_center_7_5": 18430, + "surface_code_bZ_d3_r25_center_7_5": 17924 + }, + "steps": 4096, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.0005, + "sampling_seed": 20261121, + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_exact/temporal1/rng-2048.json", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal1/weights-2048.npz", + "starting_checkpoint_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "starting_training_provenance": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.250907301902771, + "error": 0.1083984375, + "gradient_norm": 0.07171476632356644, + "elapsed": 44.811134576797485 + }, + { + "step": 16, + "loss": 0.5958679914474487, + "error": 0.3662109375, + "gradient_norm": 0.07673005014657974, + "elapsed": 49.90856671333313 + }, + { + "step": 32, + "loss": 0.47648972272872925, + "error": 0.2421875, + "gradient_norm": 0.08561501652002335, + "elapsed": 55.179388761520386 + }, + { + "step": 48, + "loss": 0.06145006790757179, + "error": 0.0234375, + "gradient_norm": 0.01556467730551958, + "elapsed": 61.0339195728302 + }, + { + "step": 64, + "loss": 0.3687053918838501, + "error": 0.1884765625, + "gradient_norm": 0.08752371370792389, + "elapsed": 65.95811891555786 + }, + { + "step": 80, + "loss": 0.6481984853744507, + "error": 0.4140625, + "gradient_norm": 0.05311283841729164, + "elapsed": 70.56021332740784 + }, + { + "step": 96, + "loss": 0.42319929599761963, + "error": 0.2138671875, + "gradient_norm": 0.05047478526830673, + "elapsed": 75.11613631248474 + }, + { + "step": 112, + "loss": 0.47527259588241577, + "error": 0.24609375, + "gradient_norm": 0.038366906344890594, + "elapsed": 79.53446984291077 + }, + { + "step": 128, + "loss": 0.5996723175048828, + "error": 0.3369140625, + "gradient_norm": 0.1213272362947464, + "elapsed": 83.97515749931335 + }, + { + "step": 144, + "loss": 0.04971993714570999, + "error": 0.0146484375, + "gradient_norm": 0.008080735802650452, + "elapsed": 88.44039463996887 + }, + { + "step": 160, + "loss": 0.35900360345840454, + "error": 0.162109375, + "gradient_norm": 0.03359593451023102, + "elapsed": 92.89548206329346 + }, + { + "step": 176, + "loss": 0.5342063903808594, + "error": 0.2978515625, + "gradient_norm": 0.04794691130518913, + "elapsed": 97.35658049583435 + }, + { + "step": 192, + "loss": 0.6300076246261597, + "error": 0.369140625, + "gradient_norm": 0.081769198179245, + "elapsed": 101.81493759155273 + }, + { + "step": 208, + "loss": 0.6191903948783875, + "error": 0.3828125, + "gradient_norm": 0.07145775109529495, + "elapsed": 106.2480263710022 + }, + { + "step": 224, + "loss": 0.5155678391456604, + "error": 0.28515625, + "gradient_norm": 0.06772179156541824, + "elapsed": 110.71284222602844 + }, + { + "step": 240, + "loss": 0.634708046913147, + "error": 0.3857421875, + "gradient_norm": 0.09493093192577362, + "elapsed": 115.14978742599487 + }, + { + "step": 256, + "loss": 0.1840895414352417, + "error": 0.0751953125, + "gradient_norm": 0.025586696341633797, + "elapsed": 119.61202120780945 + }, + { + "step": 272, + "loss": 0.2775103449821472, + "error": 0.12890625, + "gradient_norm": 0.06913147866725922, + "elapsed": 124.02584528923035 + }, + { + "step": 288, + "loss": 0.6163080334663391, + "error": 0.3642578125, + "gradient_norm": 0.05895426496863365, + "elapsed": 128.46512532234192 + }, + { + "step": 304, + "loss": 0.5276986360549927, + "error": 0.287109375, + "gradient_norm": 0.06955187022686005, + "elapsed": 132.89240765571594 + }, + { + "step": 320, + "loss": 0.44859516620635986, + "error": 0.22265625, + "gradient_norm": 0.07272452116012573, + "elapsed": 137.32864713668823 + }, + { + "step": 336, + "loss": 0.48315611481666565, + "error": 0.2626953125, + "gradient_norm": 0.03321139141917229, + "elapsed": 141.80009770393372 + }, + { + "step": 352, + "loss": 0.6107717752456665, + "error": 0.3544921875, + "gradient_norm": 0.05243214592337608, + "elapsed": 146.36439752578735 + }, + { + "step": 368, + "loss": 0.6215153932571411, + "error": 0.357421875, + "gradient_norm": 0.04383325204253197, + "elapsed": 150.99996852874756 + }, + { + "step": 384, + "loss": 0.6130329966545105, + "error": 0.35546875, + "gradient_norm": 0.04113119840621948, + "elapsed": 155.62374639511108 + }, + { + "step": 400, + "loss": 0.30471885204315186, + "error": 0.142578125, + "gradient_norm": 0.04447556659579277, + "elapsed": 160.17594957351685 + }, + { + "step": 416, + "loss": 0.6154489517211914, + "error": 0.37109375, + "gradient_norm": 0.04456057772040367, + "elapsed": 164.7639675140381 + }, + { + "step": 432, + "loss": 0.6134694218635559, + "error": 0.337890625, + "gradient_norm": 0.04219559207558632, + "elapsed": 169.32792139053345 + }, + { + "step": 448, + "loss": 0.5463185906410217, + "error": 0.2939453125, + "gradient_norm": 0.07746092975139618, + "elapsed": 173.88445162773132 + }, + { + "step": 464, + "loss": 0.06016772612929344, + "error": 0.01953125, + "gradient_norm": 0.01364185381680727, + "elapsed": 178.42725706100464 + }, + { + "step": 480, + "loss": 0.388141393661499, + "error": 0.18359375, + "gradient_norm": 0.04870256036520004, + "elapsed": 182.99062085151672 + }, + { + "step": 496, + "loss": 0.44524821639060974, + "error": 0.2216796875, + "gradient_norm": 0.03453445807099342, + "elapsed": 187.56396961212158 + }, + { + "step": 512, + "loss": 0.34312355518341064, + "error": 0.154296875, + "gradient_norm": 0.06794509291648865, + "elapsed": 192.27511191368103 + }, + { + "step": 528, + "loss": 0.19467462599277496, + "error": 0.0771484375, + "gradient_norm": 0.042381469160318375, + "elapsed": 197.7108268737793 + }, + { + "step": 544, + "loss": 0.46226584911346436, + "error": 0.2421875, + "gradient_norm": 0.06073570251464844, + "elapsed": 202.97405791282654 + }, + { + "step": 560, + "loss": 0.525318443775177, + "error": 0.2822265625, + "gradient_norm": 0.06954885274171829, + "elapsed": 208.69676971435547 + }, + { + "step": 576, + "loss": 0.6158387064933777, + "error": 0.349609375, + "gradient_norm": 0.07587578892707825, + "elapsed": 214.80397653579712 + }, + { + "step": 592, + "loss": 0.5515886545181274, + "error": 0.298828125, + "gradient_norm": 0.04969338700175285, + "elapsed": 220.27399611473083 + }, + { + "step": 608, + "loss": 0.18365338444709778, + "error": 0.0654296875, + "gradient_norm": 0.08657706528902054, + "elapsed": 224.81246256828308 + }, + { + "step": 624, + "loss": 0.4578855633735657, + "error": 0.2421875, + "gradient_norm": 0.04942100867629051, + "elapsed": 229.45902252197266 + }, + { + "step": 640, + "loss": 0.37826013565063477, + "error": 0.1865234375, + "gradient_norm": 0.047499872744083405, + "elapsed": 233.9695644378662 + }, + { + "step": 656, + "loss": 0.40863412618637085, + "error": 0.2001953125, + "gradient_norm": 0.07845330238342285, + "elapsed": 238.584894657135 + }, + { + "step": 672, + "loss": 0.5640332698822021, + "error": 0.2880859375, + "gradient_norm": 0.057469289749860764, + "elapsed": 243.0929844379425 + }, + { + "step": 688, + "loss": 0.030216243118047714, + "error": 0.0078125, + "gradient_norm": 0.04682641476392746, + "elapsed": 247.581125497818 + }, + { + "step": 704, + "loss": 0.375002384185791, + "error": 0.1826171875, + "gradient_norm": 0.04864194989204407, + "elapsed": 252.1564691066742 + }, + { + "step": 720, + "loss": 0.5145515203475952, + "error": 0.2744140625, + "gradient_norm": 0.052671682089567184, + "elapsed": 256.6466488838196 + }, + { + "step": 736, + "loss": 0.067174531519413, + "error": 0.0224609375, + "gradient_norm": 0.019299577921628952, + "elapsed": 261.1185076236725 + }, + { + "step": 752, + "loss": 0.24909992516040802, + "error": 0.111328125, + "gradient_norm": 0.06907463818788528, + "elapsed": 265.61960339546204 + }, + { + "step": 768, + "loss": 0.5088074207305908, + "error": 0.2744140625, + "gradient_norm": 0.06963017582893372, + "elapsed": 270.07474064826965 + }, + { + "step": 784, + "loss": 0.3783387839794159, + "error": 0.1826171875, + "gradient_norm": 0.05537794530391693, + "elapsed": 274.52722239494324 + }, + { + "step": 800, + "loss": 0.6107200980186462, + "error": 0.3623046875, + "gradient_norm": 0.0470259003341198, + "elapsed": 279.0401859283447 + }, + { + "step": 816, + "loss": 0.5778236389160156, + "error": 0.3212890625, + "gradient_norm": 0.10146680474281311, + "elapsed": 283.5114622116089 + }, + { + "step": 832, + "loss": 0.576002299785614, + "error": 0.3076171875, + "gradient_norm": 0.07760787010192871, + "elapsed": 288.04797434806824 + }, + { + "step": 848, + "loss": 0.6179666519165039, + "error": 0.3740234375, + "gradient_norm": 0.07383852452039719, + "elapsed": 292.60600209236145 + }, + { + "step": 864, + "loss": 0.3105512857437134, + "error": 0.1455078125, + "gradient_norm": 0.052953749895095825, + "elapsed": 297.12180352211 + }, + { + "step": 880, + "loss": 0.4802623987197876, + "error": 0.2548828125, + "gradient_norm": 0.07736275345087051, + "elapsed": 301.6091134548187 + }, + { + "step": 896, + "loss": 0.5572722554206848, + "error": 0.318359375, + "gradient_norm": 0.053303152322769165, + "elapsed": 306.1978073120117 + }, + { + "step": 912, + "loss": 0.34814420342445374, + "error": 0.1669921875, + "gradient_norm": 0.037726350128650665, + "elapsed": 310.78571581840515 + }, + { + "step": 928, + "loss": 0.41743016242980957, + "error": 0.21875, + "gradient_norm": 0.05238872766494751, + "elapsed": 315.24156188964844 + }, + { + "step": 944, + "loss": 0.5757850408554077, + "error": 0.3173828125, + "gradient_norm": 0.05837905779480934, + "elapsed": 319.78475165367126 + }, + { + "step": 960, + "loss": 0.40727972984313965, + "error": 0.197265625, + "gradient_norm": 0.059294261038303375, + "elapsed": 324.2090265750885 + }, + { + "step": 976, + "loss": 0.32715001702308655, + "error": 0.1533203125, + "gradient_norm": 0.11543179303407669, + "elapsed": 328.6462152004242 + }, + { + "step": 992, + "loss": 0.5578742623329163, + "error": 0.314453125, + "gradient_norm": 0.06282714009284973, + "elapsed": 333.0712504386902 + }, + { + "step": 1008, + "loss": 0.5052692294120789, + "error": 0.265625, + "gradient_norm": 0.04039420187473297, + "elapsed": 337.5182821750641 + }, + { + "step": 1024, + "loss": 0.18790806829929352, + "error": 0.08203125, + "gradient_norm": 0.028905188664793968, + "elapsed": 342.08340406417847 + }, + { + "step": 1040, + "loss": 0.6317684650421143, + "error": 0.3681640625, + "gradient_norm": 0.03441835194826126, + "elapsed": 358.8279616832733 + }, + { + "step": 1056, + "loss": 0.40474164485931396, + "error": 0.2021484375, + "gradient_norm": 0.036449309438467026, + "elapsed": 363.30218267440796 + }, + { + "step": 1072, + "loss": 0.518299400806427, + "error": 0.2666015625, + "gradient_norm": 0.0886964276432991, + "elapsed": 367.87997555732727 + }, + { + "step": 1088, + "loss": 0.2522922158241272, + "error": 0.099609375, + "gradient_norm": 0.07553310692310333, + "elapsed": 372.4414882659912 + }, + { + "step": 1104, + "loss": 0.6214810609817505, + "error": 0.3701171875, + "gradient_norm": 0.10188957303762436, + "elapsed": 376.9120502471924 + }, + { + "step": 1120, + "loss": 0.6307054162025452, + "error": 0.3720703125, + "gradient_norm": 0.07353860139846802, + "elapsed": 381.3824534416199 + }, + { + "step": 1136, + "loss": 0.5259381532669067, + "error": 0.2763671875, + "gradient_norm": 0.05779678374528885, + "elapsed": 385.8413143157959 + }, + { + "step": 1152, + "loss": 0.4995541572570801, + "error": 0.259765625, + "gradient_norm": 0.046648140996694565, + "elapsed": 390.28326058387756 + }, + { + "step": 1168, + "loss": 0.6075694561004639, + "error": 0.3701171875, + "gradient_norm": 0.10612073540687561, + "elapsed": 394.8162364959717 + }, + { + "step": 1184, + "loss": 0.2105136513710022, + "error": 0.080078125, + "gradient_norm": 0.0716402605175972, + "elapsed": 399.2960283756256 + }, + { + "step": 1200, + "loss": 0.6371631026268005, + "error": 0.3857421875, + "gradient_norm": 0.0549108125269413, + "elapsed": 403.7899103164673 + }, + { + "step": 1216, + "loss": 0.5450670719146729, + "error": 0.2939453125, + "gradient_norm": 0.11688558012247086, + "elapsed": 408.34677600860596 + }, + { + "step": 1232, + "loss": 0.035783201456069946, + "error": 0.01171875, + "gradient_norm": 0.02951689623296261, + "elapsed": 412.8558337688446 + }, + { + "step": 1248, + "loss": 0.5582903623580933, + "error": 0.3046875, + "gradient_norm": 0.055107031017541885, + "elapsed": 417.29854226112366 + }, + { + "step": 1264, + "loss": 0.5154441595077515, + "error": 0.27734375, + "gradient_norm": 0.04474929720163345, + "elapsed": 421.7792055606842 + }, + { + "step": 1280, + "loss": 0.35227546095848083, + "error": 0.16015625, + "gradient_norm": 0.05024837702512741, + "elapsed": 426.54427456855774 + }, + { + "step": 1296, + "loss": 0.19417589902877808, + "error": 0.0830078125, + "gradient_norm": 0.026926057413220406, + "elapsed": 431.320588350296 + }, + { + "step": 1312, + "loss": 0.4768218398094177, + "error": 0.248046875, + "gradient_norm": 0.15099607408046722, + "elapsed": 435.96817326545715 + }, + { + "step": 1328, + "loss": 0.48580923676490784, + "error": 0.2509765625, + "gradient_norm": 0.08925126492977142, + "elapsed": 440.64917039871216 + }, + { + "step": 1344, + "loss": 0.42041274905204773, + "error": 0.1982421875, + "gradient_norm": 0.08321093022823334, + "elapsed": 445.34370946884155 + }, + { + "step": 1360, + "loss": 0.06403929740190506, + "error": 0.0185546875, + "gradient_norm": 0.03817005455493927, + "elapsed": 449.98669385910034 + }, + { + "step": 1376, + "loss": 0.463126003742218, + "error": 0.2275390625, + "gradient_norm": 0.08894515782594681, + "elapsed": 454.6478977203369 + }, + { + "step": 1392, + "loss": 0.5995306968688965, + "error": 0.373046875, + "gradient_norm": 0.06733685731887817, + "elapsed": 459.35924530029297 + }, + { + "step": 1408, + "loss": 0.49053263664245605, + "error": 0.25, + "gradient_norm": 0.10475508868694305, + "elapsed": 464.100093126297 + }, + { + "step": 1424, + "loss": 0.6220744848251343, + "error": 0.3818359375, + "gradient_norm": 0.03653963655233383, + "elapsed": 468.89601135253906 + }, + { + "step": 1440, + "loss": 0.39706122875213623, + "error": 0.2021484375, + "gradient_norm": 0.04344598576426506, + "elapsed": 474.03999519348145 + }, + { + "step": 1456, + "loss": 0.5386708974838257, + "error": 0.3095703125, + "gradient_norm": 0.12589037418365479, + "elapsed": 478.8600504398346 + }, + { + "step": 1472, + "loss": 0.49776726961135864, + "error": 0.271484375, + "gradient_norm": 0.058137863874435425, + "elapsed": 483.5920066833496 + }, + { + "step": 1488, + "loss": 0.4757428765296936, + "error": 0.2412109375, + "gradient_norm": 0.050453316420316696, + "elapsed": 488.4611999988556 + }, + { + "step": 1504, + "loss": 0.5694847702980042, + "error": 0.337890625, + "gradient_norm": 0.052419569343328476, + "elapsed": 493.26151037216187 + }, + { + "step": 1520, + "loss": 0.5997745990753174, + "error": 0.3603515625, + "gradient_norm": 0.04338108375668526, + "elapsed": 498.0421245098114 + }, + { + "step": 1536, + "loss": 0.6195274591445923, + "error": 0.3876953125, + "gradient_norm": 0.04848463833332062, + "elapsed": 502.8808298110962 + }, + { + "step": 1552, + "loss": 0.46315908432006836, + "error": 0.2353515625, + "gradient_norm": 0.06380566209554672, + "elapsed": 507.5519721508026 + }, + { + "step": 1568, + "loss": 0.605262041091919, + "error": 0.36328125, + "gradient_norm": 0.05077619478106499, + "elapsed": 512.457685470581 + }, + { + "step": 1584, + "loss": 0.48782041668891907, + "error": 0.232421875, + "gradient_norm": 0.09017211943864822, + "elapsed": 517.2960062026978 + }, + { + "step": 1600, + "loss": 0.3881351947784424, + "error": 0.1875, + "gradient_norm": 0.07205695658922195, + "elapsed": 522.0911631584167 + }, + { + "step": 1616, + "loss": 0.4966873526573181, + "error": 0.24609375, + "gradient_norm": 0.0582038015127182, + "elapsed": 526.8861901760101 + }, + { + "step": 1632, + "loss": 0.5844199657440186, + "error": 0.33203125, + "gradient_norm": 0.05101500824093819, + "elapsed": 531.6640138626099 + }, + { + "step": 1648, + "loss": 0.31010180711746216, + "error": 0.1318359375, + "gradient_norm": 0.053135693073272705, + "elapsed": 536.4960391521454 + }, + { + "step": 1664, + "loss": 0.6174807548522949, + "error": 0.3779296875, + "gradient_norm": 0.04161194711923599, + "elapsed": 541.2560484409332 + }, + { + "step": 1680, + "loss": 0.18213607370853424, + "error": 0.0751953125, + "gradient_norm": 0.07171957194805145, + "elapsed": 546.0000085830688 + }, + { + "step": 1696, + "loss": 0.5445692539215088, + "error": 0.2998046875, + "gradient_norm": 0.054499462246894836, + "elapsed": 551.1221191883087 + }, + { + "step": 1712, + "loss": 0.05744167044758797, + "error": 0.017578125, + "gradient_norm": 0.013108699582517147, + "elapsed": 556.5286149978638 + }, + { + "step": 1728, + "loss": 0.6381571292877197, + "error": 0.3896484375, + "gradient_norm": 0.05157556012272835, + "elapsed": 561.8000066280365 + }, + { + "step": 1744, + "loss": 0.5301004648208618, + "error": 0.28125, + "gradient_norm": 0.04218568280339241, + "elapsed": 567.2760035991669 + }, + { + "step": 1760, + "loss": 0.5275102257728577, + "error": 0.26953125, + "gradient_norm": 0.06798839569091797, + "elapsed": 572.5601994991302 + }, + { + "step": 1776, + "loss": 0.6443773508071899, + "error": 0.4091796875, + "gradient_norm": 0.07035460323095322, + "elapsed": 577.9789206981659 + }, + { + "step": 1792, + "loss": 0.6012362241744995, + "error": 0.337890625, + "gradient_norm": 0.05189951881766319, + "elapsed": 583.028017282486 + }, + { + "step": 1808, + "loss": 0.2939091920852661, + "error": 0.12109375, + "gradient_norm": 0.05555355176329613, + "elapsed": 588.0501506328583 + }, + { + "step": 1824, + "loss": 0.2059091478586197, + "error": 0.08984375, + "gradient_norm": 0.045679714530706406, + "elapsed": 593.2120039463043 + }, + { + "step": 1840, + "loss": 0.6289581060409546, + "error": 0.349609375, + "gradient_norm": 0.04742642492055893, + "elapsed": 598.7767763137817 + }, + { + "step": 1856, + "loss": 0.5532636642456055, + "error": 0.294921875, + "gradient_norm": 0.05997413396835327, + "elapsed": 604.0475382804871 + }, + { + "step": 1872, + "loss": 0.45995670557022095, + "error": 0.228515625, + "gradient_norm": 0.05674462765455246, + "elapsed": 609.292379617691 + }, + { + "step": 1888, + "loss": 0.6178656816482544, + "error": 0.359375, + "gradient_norm": 0.08857566863298416, + "elapsed": 614.5639882087708 + }, + { + "step": 1904, + "loss": 0.5531284213066101, + "error": 0.287109375, + "gradient_norm": 0.10257937759160995, + "elapsed": 619.5600035190582 + }, + { + "step": 1920, + "loss": 0.04184349626302719, + "error": 0.013671875, + "gradient_norm": 0.04087059944868088, + "elapsed": 624.6679775714874 + }, + { + "step": 1936, + "loss": 0.5924860239028931, + "error": 0.3505859375, + "gradient_norm": 0.036822713911533356, + "elapsed": 629.936680316925 + }, + { + "step": 1952, + "loss": 0.46996980905532837, + "error": 0.2421875, + "gradient_norm": 0.034442272037267685, + "elapsed": 635.1109762191772 + }, + { + "step": 1968, + "loss": 0.17859068512916565, + "error": 0.0712890625, + "gradient_norm": 0.03440066799521446, + "elapsed": 640.32000207901 + }, + { + "step": 1984, + "loss": 0.6192275285720825, + "error": 0.3701171875, + "gradient_norm": 0.04386439174413681, + "elapsed": 645.6040184497833 + }, + { + "step": 2000, + "loss": 0.6160917282104492, + "error": 0.35546875, + "gradient_norm": 0.06268990784883499, + "elapsed": 650.7723731994629 + }, + { + "step": 2016, + "loss": 0.6343611478805542, + "error": 0.388671875, + "gradient_norm": 0.04243326932191849, + "elapsed": 655.972663640976 + }, + { + "step": 2032, + "loss": 0.062292590737342834, + "error": 0.021484375, + "gradient_norm": 0.016680095344781876, + "elapsed": 660.8079733848572 + }, + { + "step": 2048, + "loss": 0.5316072702407837, + "error": 0.26953125, + "gradient_norm": 0.057860780507326126, + "elapsed": 665.5760209560394 + }, + { + "step": 2064, + "loss": 0.605312705039978, + "error": 0.3623046875, + "gradient_norm": 0.04028146713972092, + "elapsed": 682.7294294834137 + }, + { + "step": 2080, + "loss": 0.56633460521698, + "error": 0.3330078125, + "gradient_norm": 0.09528280049562454, + "elapsed": 687.4644649028778 + }, + { + "step": 2096, + "loss": 0.3905397057533264, + "error": 0.1943359375, + "gradient_norm": 0.049456462264060974, + "elapsed": 692.1492264270782 + }, + { + "step": 2112, + "loss": 0.28124868869781494, + "error": 0.1259765625, + "gradient_norm": 0.059239838272333145, + "elapsed": 696.8701393604279 + }, + { + "step": 2128, + "loss": 0.6364338994026184, + "error": 0.392578125, + "gradient_norm": 0.08667811006307602, + "elapsed": 701.683988571167 + }, + { + "step": 2144, + "loss": 0.20683243870735168, + "error": 0.07421875, + "gradient_norm": 0.1100710779428482, + "elapsed": 706.4000360965729 + }, + { + "step": 2160, + "loss": 0.5912737250328064, + "error": 0.341796875, + "gradient_norm": 0.05641854554414749, + "elapsed": 711.2359964847565 + }, + { + "step": 2176, + "loss": 0.27793264389038086, + "error": 0.12109375, + "gradient_norm": 0.0893034040927887, + "elapsed": 715.9508004188538 + }, + { + "step": 2192, + "loss": 0.6474133133888245, + "error": 0.4072265625, + "gradient_norm": 0.06980258971452713, + "elapsed": 720.651974439621 + }, + { + "step": 2208, + "loss": 0.5961858630180359, + "error": 0.35546875, + "gradient_norm": 0.06530112773180008, + "elapsed": 725.496098279953 + }, + { + "step": 2224, + "loss": 0.47581571340560913, + "error": 0.263671875, + "gradient_norm": 0.04470043256878853, + "elapsed": 730.2880010604858 + }, + { + "step": 2240, + "loss": 0.577988862991333, + "error": 0.318359375, + "gradient_norm": 0.07201159745454788, + "elapsed": 735.006133556366 + }, + { + "step": 2256, + "loss": 0.28444671630859375, + "error": 0.1181640625, + "gradient_norm": 0.048656050115823746, + "elapsed": 739.6868116855621 + }, + { + "step": 2272, + "loss": 0.2776409089565277, + "error": 0.1201171875, + "gradient_norm": 0.05783981829881668, + "elapsed": 744.3517308235168 + }, + { + "step": 2288, + "loss": 0.621599555015564, + "error": 0.37109375, + "gradient_norm": 0.09731200337409973, + "elapsed": 749.0351710319519 + }, + { + "step": 2304, + "loss": 0.3333754539489746, + "error": 0.1513671875, + "gradient_norm": 0.07069239765405655, + "elapsed": 753.7588081359863 + }, + { + "step": 2320, + "loss": 0.4687051773071289, + "error": 0.2490234375, + "gradient_norm": 0.044891707599163055, + "elapsed": 758.4588432312012 + }, + { + "step": 2336, + "loss": 0.19801637530326843, + "error": 0.078125, + "gradient_norm": 0.10036595165729523, + "elapsed": 763.256409406662 + }, + { + "step": 2352, + "loss": 0.6186277866363525, + "error": 0.388671875, + "gradient_norm": 0.09069584310054779, + "elapsed": 767.9986386299133 + }, + { + "step": 2368, + "loss": 0.6177258491516113, + "error": 0.373046875, + "gradient_norm": 0.049019571393728256, + "elapsed": 772.730831861496 + }, + { + "step": 2384, + "loss": 0.17707547545433044, + "error": 0.0673828125, + "gradient_norm": 0.045190781354904175, + "elapsed": 777.4072704315186 + }, + { + "step": 2400, + "loss": 0.20144733786582947, + "error": 0.08203125, + "gradient_norm": 0.04537162929773331, + "elapsed": 782.0841658115387 + }, + { + "step": 2416, + "loss": 0.6151775121688843, + "error": 0.365234375, + "gradient_norm": 0.050534047186374664, + "elapsed": 786.762966632843 + }, + { + "step": 2432, + "loss": 0.5533859133720398, + "error": 0.314453125, + "gradient_norm": 0.06006559729576111, + "elapsed": 791.4656012058258 + }, + { + "step": 2448, + "loss": 0.5329082012176514, + "error": 0.2880859375, + "gradient_norm": 0.04018115997314453, + "elapsed": 796.1704161167145 + }, + { + "step": 2464, + "loss": 0.6338047981262207, + "error": 0.4140625, + "gradient_norm": 0.06069163978099823, + "elapsed": 800.9180119037628 + }, + { + "step": 2480, + "loss": 0.1603008508682251, + "error": 0.0673828125, + "gradient_norm": 0.040350593626499176, + "elapsed": 805.6127603054047 + }, + { + "step": 2496, + "loss": 0.505940318107605, + "error": 0.2568359375, + "gradient_norm": 0.05209952965378761, + "elapsed": 810.3740313053131 + }, + { + "step": 2512, + "loss": 0.5528728365898132, + "error": 0.298828125, + "gradient_norm": 0.11757992953062057, + "elapsed": 815.1708807945251 + }, + { + "step": 2528, + "loss": 0.5028313994407654, + "error": 0.2666015625, + "gradient_norm": 0.08823780715465546, + "elapsed": 819.8585045337677 + }, + { + "step": 2544, + "loss": 0.5002262592315674, + "error": 0.2783203125, + "gradient_norm": 0.04888603836297989, + "elapsed": 824.5714073181152 + }, + { + "step": 2560, + "loss": 0.6007894277572632, + "error": 0.328125, + "gradient_norm": 0.05186954140663147, + "elapsed": 829.3080432415009 + }, + { + "step": 2576, + "loss": 0.18641480803489685, + "error": 0.076171875, + "gradient_norm": 0.03799928352236748, + "elapsed": 834.044020652771 + }, + { + "step": 2592, + "loss": 0.3050769865512848, + "error": 0.1396484375, + "gradient_norm": 0.10119257122278214, + "elapsed": 838.8401296138763 + }, + { + "step": 2608, + "loss": 0.6063439846038818, + "error": 0.361328125, + "gradient_norm": 0.04979367554187775, + "elapsed": 844.3572654724121 + }, + { + "step": 2624, + "loss": 0.5751967430114746, + "error": 0.3369140625, + "gradient_norm": 0.04269539937376976, + "elapsed": 849.0660374164581 + }, + { + "step": 2640, + "loss": 0.3902108669281006, + "error": 0.193359375, + "gradient_norm": 0.10029696673154831, + "elapsed": 853.8638062477112 + }, + { + "step": 2656, + "loss": 0.15081660449504852, + "error": 0.0625, + "gradient_norm": 0.0303852129727602, + "elapsed": 858.9793758392334 + }, + { + "step": 2672, + "loss": 0.6503090858459473, + "error": 0.400390625, + "gradient_norm": 0.12611964344978333, + "elapsed": 863.9151141643524 + }, + { + "step": 2688, + "loss": 0.5587317943572998, + "error": 0.31640625, + "gradient_norm": 0.10028114914894104, + "elapsed": 868.7600305080414 + }, + { + "step": 2704, + "loss": 0.4399867355823517, + "error": 0.21484375, + "gradient_norm": 0.06889455020427704, + "elapsed": 873.4544236660004 + }, + { + "step": 2720, + "loss": 0.5865127444267273, + "error": 0.337890625, + "gradient_norm": 0.03671631962060928, + "elapsed": 878.0982644557953 + }, + { + "step": 2736, + "loss": 0.6078637838363647, + "error": 0.3701171875, + "gradient_norm": 0.04679318517446518, + "elapsed": 883.0424642562866 + }, + { + "step": 2752, + "loss": 0.5825340151786804, + "error": 0.337890625, + "gradient_norm": 0.05619681254029274, + "elapsed": 887.908124923706 + }, + { + "step": 2768, + "loss": 0.5970422029495239, + "error": 0.3369140625, + "gradient_norm": 0.041302867233753204, + "elapsed": 892.6760206222534 + }, + { + "step": 2784, + "loss": 0.3870226740837097, + "error": 0.1826171875, + "gradient_norm": 0.05731065198779106, + "elapsed": 897.6246056556702 + }, + { + "step": 2800, + "loss": 0.38130277395248413, + "error": 0.1943359375, + "gradient_norm": 0.059244755655527115, + "elapsed": 902.3360238075256 + }, + { + "step": 2816, + "loss": 0.2617901563644409, + "error": 0.1064453125, + "gradient_norm": 0.041736964136362076, + "elapsed": 907.1600468158722 + }, + { + "step": 2832, + "loss": 0.5819337368011475, + "error": 0.314453125, + "gradient_norm": 0.04097156226634979, + "elapsed": 912.0244295597076 + }, + { + "step": 2848, + "loss": 0.41393283009529114, + "error": 0.2001953125, + "gradient_norm": 0.10456771403551102, + "elapsed": 916.8225846290588 + }, + { + "step": 2864, + "loss": 0.5019145011901855, + "error": 0.2548828125, + "gradient_norm": 0.04843736067414284, + "elapsed": 921.538754940033 + }, + { + "step": 2880, + "loss": 0.04561338573694229, + "error": 0.0146484375, + "gradient_norm": 0.025407327339053154, + "elapsed": 926.2588667869568 + }, + { + "step": 2896, + "loss": 0.4338858723640442, + "error": 0.205078125, + "gradient_norm": 0.09900517761707306, + "elapsed": 930.9781975746155 + }, + { + "step": 2912, + "loss": 0.33922863006591797, + "error": 0.162109375, + "gradient_norm": 0.10189604014158249, + "elapsed": 935.6816267967224 + }, + { + "step": 2928, + "loss": 0.5294322967529297, + "error": 0.2822265625, + "gradient_norm": 0.09060791879892349, + "elapsed": 940.4373068809509 + }, + { + "step": 2944, + "loss": 0.037007369101047516, + "error": 0.01171875, + "gradient_norm": 0.05506489425897598, + "elapsed": 945.1270468235016 + }, + { + "step": 2960, + "loss": 0.6096771359443665, + "error": 0.349609375, + "gradient_norm": 0.04987221211194992, + "elapsed": 949.8300130367279 + }, + { + "step": 2976, + "loss": 0.6157823801040649, + "error": 0.373046875, + "gradient_norm": 0.03614233434200287, + "elapsed": 954.5701997280121 + }, + { + "step": 2992, + "loss": 0.1978239268064499, + "error": 0.080078125, + "gradient_norm": 0.05847112461924553, + "elapsed": 959.2756471633911 + }, + { + "step": 3008, + "loss": 0.5237340927124023, + "error": 0.2841796875, + "gradient_norm": 0.06993591040372849, + "elapsed": 963.9875864982605 + }, + { + "step": 3024, + "loss": 0.4559935927391052, + "error": 0.2373046875, + "gradient_norm": 0.05698448419570923, + "elapsed": 968.7997305393219 + }, + { + "step": 3040, + "loss": 0.5025208592414856, + "error": 0.259765625, + "gradient_norm": 0.14909739792346954, + "elapsed": 973.6042547225952 + }, + { + "step": 3056, + "loss": 0.3223109245300293, + "error": 0.1416015625, + "gradient_norm": 0.032974764704704285, + "elapsed": 978.4760546684265 + }, + { + "step": 3072, + "loss": 0.06682582199573517, + "error": 0.021484375, + "gradient_norm": 0.04433188587427139, + "elapsed": 983.2894048690796 + }, + { + "step": 3088, + "loss": 0.5919550061225891, + "error": 0.34765625, + "gradient_norm": 0.06721373647451401, + "elapsed": 1000.9520287513733 + }, + { + "step": 3104, + "loss": 0.5988063812255859, + "error": 0.3642578125, + "gradient_norm": 0.05654948577284813, + "elapsed": 1005.7442932128906 + }, + { + "step": 3120, + "loss": 0.4922299385070801, + "error": 0.2470703125, + "gradient_norm": 0.07545466721057892, + "elapsed": 1010.4616096019745 + }, + { + "step": 3136, + "loss": 0.4533671736717224, + "error": 0.236328125, + "gradient_norm": 0.06288722902536392, + "elapsed": 1015.3559956550598 + }, + { + "step": 3152, + "loss": 0.5070517063140869, + "error": 0.2666015625, + "gradient_norm": 0.07274917513132095, + "elapsed": 1020.0764343738556 + }, + { + "step": 3168, + "loss": 0.5999464988708496, + "error": 0.3408203125, + "gradient_norm": 0.05777016654610634, + "elapsed": 1024.9410600662231 + }, + { + "step": 3184, + "loss": 0.5758363008499146, + "error": 0.3427734375, + "gradient_norm": 0.051027461886405945, + "elapsed": 1029.7082171440125 + }, + { + "step": 3200, + "loss": 0.05016190931200981, + "error": 0.017578125, + "gradient_norm": 0.009175656363368034, + "elapsed": 1034.3982915878296 + }, + { + "step": 3216, + "loss": 0.5471057295799255, + "error": 0.318359375, + "gradient_norm": 0.07572721689939499, + "elapsed": 1039.117841243744 + }, + { + "step": 3232, + "loss": 0.4141446352005005, + "error": 0.193359375, + "gradient_norm": 0.10056859254837036, + "elapsed": 1043.880026102066 + }, + { + "step": 3248, + "loss": 0.5812438726425171, + "error": 0.3212890625, + "gradient_norm": 0.05781616270542145, + "elapsed": 1048.6406455039978 + }, + { + "step": 3264, + "loss": 0.19184701144695282, + "error": 0.078125, + "gradient_norm": 0.05367236211895943, + "elapsed": 1053.5672237873077 + }, + { + "step": 3280, + "loss": 0.5420833826065063, + "error": 0.28515625, + "gradient_norm": 0.052405405789613724, + "elapsed": 1058.3841104507446 + }, + { + "step": 3296, + "loss": 0.4419598877429962, + "error": 0.2177734375, + "gradient_norm": 0.05814693495631218, + "elapsed": 1063.1880333423615 + }, + { + "step": 3312, + "loss": 0.4525642991065979, + "error": 0.208984375, + "gradient_norm": 0.1061021164059639, + "elapsed": 1068.1370933055878 + }, + { + "step": 3328, + "loss": 0.32664671540260315, + "error": 0.154296875, + "gradient_norm": 0.05649850144982338, + "elapsed": 1073.1963467597961 + }, + { + "step": 3344, + "loss": 0.2655770182609558, + "error": 0.1220703125, + "gradient_norm": 0.04070372134447098, + "elapsed": 1078.2698318958282 + }, + { + "step": 3360, + "loss": 0.5894330739974976, + "error": 0.3544921875, + "gradient_norm": 0.0643400028347969, + "elapsed": 1083.0184152126312 + }, + { + "step": 3376, + "loss": 0.6118791103363037, + "error": 0.361328125, + "gradient_norm": 0.08537904173135757, + "elapsed": 1087.834038734436 + }, + { + "step": 3392, + "loss": 0.40694907307624817, + "error": 0.19921875, + "gradient_norm": 0.11411692947149277, + "elapsed": 1092.8119947910309 + }, + { + "step": 3408, + "loss": 0.04629015550017357, + "error": 0.0146484375, + "gradient_norm": 0.017204072326421738, + "elapsed": 1097.5751783847809 + }, + { + "step": 3424, + "loss": 0.20639702677726746, + "error": 0.0849609375, + "gradient_norm": 0.04801144450902939, + "elapsed": 1102.2970931529999 + }, + { + "step": 3440, + "loss": 0.6051071286201477, + "error": 0.33984375, + "gradient_norm": 0.045392412692308426, + "elapsed": 1107.1080610752106 + }, + { + "step": 3456, + "loss": 0.6553700566291809, + "error": 0.40625, + "gradient_norm": 0.05593863129615784, + "elapsed": 1111.8409752845764 + }, + { + "step": 3472, + "loss": 0.591402530670166, + "error": 0.3515625, + "gradient_norm": 0.051181379705667496, + "elapsed": 1116.5800333023071 + }, + { + "step": 3488, + "loss": 0.30494624376296997, + "error": 0.12109375, + "gradient_norm": 0.05175542086362839, + "elapsed": 1121.276373386383 + }, + { + "step": 3504, + "loss": 0.5065370798110962, + "error": 0.279296875, + "gradient_norm": 0.10419930517673492, + "elapsed": 1125.9883344173431 + }, + { + "step": 3520, + "loss": 0.3915700614452362, + "error": 0.1953125, + "gradient_norm": 0.060416825115680695, + "elapsed": 1130.7958455085754 + }, + { + "step": 3536, + "loss": 0.624374270439148, + "error": 0.3759765625, + "gradient_norm": 0.06069556251168251, + "elapsed": 1135.5360939502716 + }, + { + "step": 3552, + "loss": 0.5830206274986267, + "error": 0.3359375, + "gradient_norm": 0.046013280749320984, + "elapsed": 1140.312029838562 + }, + { + "step": 3568, + "loss": 0.4201379716396332, + "error": 0.2119140625, + "gradient_norm": 0.06909621506929398, + "elapsed": 1145.0904593467712 + }, + { + "step": 3584, + "loss": 0.28215405344963074, + "error": 0.1181640625, + "gradient_norm": 0.07625982910394669, + "elapsed": 1149.8156151771545 + }, + { + "step": 3600, + "loss": 0.5229164361953735, + "error": 0.275390625, + "gradient_norm": 0.055048178881406784, + "elapsed": 1154.5280592441559 + }, + { + "step": 3616, + "loss": 0.47238075733184814, + "error": 0.2314453125, + "gradient_norm": 0.06473162025213242, + "elapsed": 1159.2720873355865 + }, + { + "step": 3632, + "loss": 0.46245503425598145, + "error": 0.228515625, + "gradient_norm": 0.07382887601852417, + "elapsed": 1164.0119998455048 + }, + { + "step": 3648, + "loss": 0.37509745359420776, + "error": 0.171875, + "gradient_norm": 0.051260266453027725, + "elapsed": 1168.7440350055695 + }, + { + "step": 3664, + "loss": 0.1948484629392624, + "error": 0.080078125, + "gradient_norm": 0.059623416513204575, + "elapsed": 1173.3906588554382 + }, + { + "step": 3680, + "loss": 0.5552756786346436, + "error": 0.3115234375, + "gradient_norm": 0.08073585480451584, + "elapsed": 1178.0645008087158 + }, + { + "step": 3696, + "loss": 0.6405904293060303, + "error": 0.39453125, + "gradient_norm": 0.05899551138281822, + "elapsed": 1182.730489730835 + }, + { + "step": 3712, + "loss": 0.2767012119293213, + "error": 0.119140625, + "gradient_norm": 0.06593579798936844, + "elapsed": 1187.377315044403 + }, + { + "step": 3728, + "loss": 0.315812885761261, + "error": 0.134765625, + "gradient_norm": 0.035905495285987854, + "elapsed": 1192.0582301616669 + }, + { + "step": 3744, + "loss": 0.6033951640129089, + "error": 0.3544921875, + "gradient_norm": 0.05226197466254234, + "elapsed": 1196.7101175785065 + }, + { + "step": 3760, + "loss": 0.5202592611312866, + "error": 0.275390625, + "gradient_norm": 0.06367512047290802, + "elapsed": 1201.3543090820312 + }, + { + "step": 3776, + "loss": 0.24639368057250977, + "error": 0.1083984375, + "gradient_norm": 0.09370873868465424, + "elapsed": 1206.0717165470123 + }, + { + "step": 3792, + "loss": 0.6175658702850342, + "error": 0.375, + "gradient_norm": 0.06221585348248482, + "elapsed": 1210.754029750824 + }, + { + "step": 3808, + "loss": 0.41153696179389954, + "error": 0.2119140625, + "gradient_norm": 0.05355365574359894, + "elapsed": 1215.4374370574951 + }, + { + "step": 3824, + "loss": 0.28002214431762695, + "error": 0.1123046875, + "gradient_norm": 0.03846330568194389, + "elapsed": 1220.1207013130188 + }, + { + "step": 3840, + "loss": 0.0484195351600647, + "error": 0.013671875, + "gradient_norm": 0.03470242768526077, + "elapsed": 1224.8153104782104 + }, + { + "step": 3856, + "loss": 0.1407160609960556, + "error": 0.0458984375, + "gradient_norm": 0.04061700031161308, + "elapsed": 1229.5512235164642 + }, + { + "step": 3872, + "loss": 0.5881794691085815, + "error": 0.3427734375, + "gradient_norm": 0.062013477087020874, + "elapsed": 1234.3750183582306 + }, + { + "step": 3888, + "loss": 0.17833612859249115, + "error": 0.06640625, + "gradient_norm": 0.038856204599142075, + "elapsed": 1239.110375881195 + }, + { + "step": 3904, + "loss": 0.06211477518081665, + "error": 0.0224609375, + "gradient_norm": 0.02150108851492405, + "elapsed": 1243.800644159317 + }, + { + "step": 3920, + "loss": 0.06039723381400108, + "error": 0.01953125, + "gradient_norm": 0.019367367029190063, + "elapsed": 1248.4831748008728 + }, + { + "step": 3936, + "loss": 0.6010214686393738, + "error": 0.3525390625, + "gradient_norm": 0.051659151911735535, + "elapsed": 1253.1423478126526 + }, + { + "step": 3952, + "loss": 0.5867137312889099, + "error": 0.3388671875, + "gradient_norm": 0.058528851717710495, + "elapsed": 1257.9799931049347 + }, + { + "step": 3968, + "loss": 0.5231834650039673, + "error": 0.2578125, + "gradient_norm": 0.10128334909677505, + "elapsed": 1262.6990082263947 + }, + { + "step": 3984, + "loss": 0.6251651644706726, + "error": 0.353515625, + "gradient_norm": 0.06211795285344124, + "elapsed": 1267.4289934635162 + }, + { + "step": 4000, + "loss": 0.06667037308216095, + "error": 0.01953125, + "gradient_norm": 0.048018258064985275, + "elapsed": 1272.132089138031 + }, + { + "step": 4016, + "loss": 0.5286938548088074, + "error": 0.2744140625, + "gradient_norm": 0.05509360507130623, + "elapsed": 1276.8878977298737 + }, + { + "step": 4032, + "loss": 0.34016552567481995, + "error": 0.1591796875, + "gradient_norm": 0.07597329467535019, + "elapsed": 1281.7364926338196 + }, + { + "step": 4048, + "loss": 0.17750494182109833, + "error": 0.078125, + "gradient_norm": 0.06314503401517868, + "elapsed": 1286.5033600330353 + }, + { + "step": 4064, + "loss": 0.5882893800735474, + "error": 0.34375, + "gradient_norm": 0.10986580699682236, + "elapsed": 1291.1944887638092 + }, + { + "step": 4080, + "loss": 0.4923543930053711, + "error": 0.2568359375, + "gradient_norm": 0.050325747579336166, + "elapsed": 1295.9372322559357 + }, + { + "step": 4096, + "loss": 0.44146978855133057, + "error": 0.2236328125, + "gradient_norm": 0.06535191088914871, + "elapsed": 1300.641023159027 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 1024, + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "1024": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 804757, + "weights": "weights-1024.npz", + "weights_sha256": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "validation": "validation-1024.json", + "complete": true + }, + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "ff4595e8f3eb7cfaa8da5a58a31e106d9684c7b8437f330573a1291f19f5777a", + "complete": true + } + }, + "selection": "Predefined last-three and all-four noninitial temporal2 checkpoint means; every validation condition evaluated before group selection", + "test_data_used": false, + "derivation_source_sha256": "b68813c7dab697a554185020c430ef05f1c35bedcda5b85b7d165af75461e914" + }, + "training_source_snapshot": "training_sources/temporal2_swa", + "selected_checkpoint_steps": [ + "mean3" + ], + "checkpoint_records": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.2445763221153846, + "mean3": 0.24451622596153846, + "mean4": 0.24484675480769236, + "blend-mean3": 0.24570312499999997, + "blend-mean4": 0.24591346153846153 + }, + "selected": "mean3" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2528545673076923, + "mean3": 0.25321514423076924, + "mean4": 0.2538611778846154, + "blend-mean3": 0.25310997596153845, + "blend-mean4": 0.2530498798076923 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23366887019230773, + "mean3": 0.23392427884615385, + "mean4": 0.234375, + "blend-mean3": 0.2338792067307692, + "blend-mean4": 0.23404447115384613 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23886718750000002, + "mean3": 0.23937800480769234, + "mean4": 0.2393780048076923, + "blend-mean3": 0.23942307692307693, + "blend-mean4": 0.2392578125 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24463641826923077, + "mean3": 0.24471153846153845, + "mean4": 0.24505709134615386, + "blend-mean3": 0.24580829326923076, + "blend-mean4": 0.2457782451923077 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23652343749999996, + "mean3": 0.2379957932692308, + "mean4": 0.23756009615384613, + "blend-mean3": 0.23751502403846153, + "blend-mean4": 0.23737980769230768 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.23562199519230764, + "mean3": 0.23643329326923077, + "mean4": 0.2361177884615384, + "blend-mean3": 0.23662860576923078, + "blend-mean4": 0.23634314903846157 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.2329627403846154, + "mean3": 0.2335186298076923, + "mean4": 0.23344350961538457, + "blend-mean3": 0.23333834134615383, + "blend-mean4": 0.2334134615384615 + }, + "selected": "incumbent" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2325420673076923 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "condition_same1", + "training_run": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_accumulate_train.py": "9f672468a8b72966b3aa04fd22e5d40b47b0768f1c802c267a1da08244c4323b", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 803777, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 11639, + "surface_code_bX_d3_r03_center_3_5": 10232, + "surface_code_bX_d3_r05_center_3_5": 9180, + "surface_code_bX_d3_r07_center_3_5": 10239, + "surface_code_bX_d3_r09_center_3_5": 6051, + "surface_code_bX_d3_r11_center_3_5": 8012, + "surface_code_bX_d3_r13_center_3_5": 6713, + "surface_code_bX_d3_r15_center_3_5": 6022, + "surface_code_bX_d3_r17_center_3_5": 7425, + "surface_code_bX_d3_r19_center_3_5": 8635, + "surface_code_bX_d3_r21_center_3_5": 10217, + "surface_code_bX_d3_r23_center_3_5": 6026, + "surface_code_bX_d3_r25_center_3_5": 4490, + "surface_code_bX_d3_r01_center_5_3": 7371, + "surface_code_bX_d3_r03_center_5_3": 5992, + "surface_code_bX_d3_r05_center_5_3": 6712, + "surface_code_bX_d3_r07_center_5_3": 6716, + "surface_code_bX_d3_r09_center_5_3": 7941, + "surface_code_bX_d3_r11_center_5_3": 6001, + "surface_code_bX_d3_r13_center_5_3": 8037, + "surface_code_bX_d3_r15_center_5_3": 8542, + "surface_code_bX_d3_r17_center_5_3": 10153, + "surface_code_bX_d3_r19_center_5_3": 10675, + "surface_code_bX_d3_r21_center_5_3": 7993, + "surface_code_bX_d3_r23_center_5_3": 6652, + "surface_code_bX_d3_r25_center_5_3": 8608, + "surface_code_bX_d3_r01_center_5_7": 8590, + "surface_code_bX_d3_r03_center_5_7": 11633, + "surface_code_bX_d3_r05_center_5_7": 8588, + "surface_code_bX_d3_r07_center_5_7": 10695, + "surface_code_bX_d3_r09_center_5_7": 7964, + "surface_code_bX_d3_r11_center_5_7": 11658, + "surface_code_bX_d3_r13_center_5_7": 6021, + "surface_code_bX_d3_r15_center_5_7": 9727, + "surface_code_bX_d3_r17_center_5_7": 4526, + "surface_code_bX_d3_r19_center_5_7": 9642, + "surface_code_bX_d3_r21_center_5_7": 3708, + "surface_code_bX_d3_r23_center_5_7": 6687, + "surface_code_bX_d3_r25_center_5_7": 7972, + "surface_code_bX_d3_r01_center_7_5": 6757, + "surface_code_bX_d3_r03_center_7_5": 6726, + "surface_code_bX_d3_r05_center_7_5": 4504, + "surface_code_bX_d3_r07_center_7_5": 8034, + "surface_code_bX_d3_r09_center_7_5": 8633, + "surface_code_bX_d3_r11_center_7_5": 11109, + "surface_code_bX_d3_r13_center_7_5": 9695, + "surface_code_bX_d3_r15_center_7_5": 7370, + "surface_code_bX_d3_r17_center_7_5": 7323, + "surface_code_bX_d3_r19_center_7_5": 10247, + "surface_code_bX_d3_r21_center_7_5": 6718, + "surface_code_bX_d3_r23_center_7_5": 8064, + "surface_code_bX_d3_r25_center_7_5": 8018, + "surface_code_bZ_d3_r01_center_3_5": 2856, + "surface_code_bZ_d3_r03_center_3_5": 6780, + "surface_code_bZ_d3_r05_center_3_5": 8610, + "surface_code_bZ_d3_r07_center_3_5": 9152, + "surface_code_bZ_d3_r09_center_3_5": 4522, + "surface_code_bZ_d3_r11_center_3_5": 3703, + "surface_code_bZ_d3_r13_center_3_5": 6001, + "surface_code_bZ_d3_r15_center_3_5": 7377, + "surface_code_bZ_d3_r17_center_3_5": 4517, + "surface_code_bZ_d3_r19_center_3_5": 10242, + "surface_code_bZ_d3_r21_center_3_5": 6747, + "surface_code_bZ_d3_r23_center_3_5": 7422, + "surface_code_bZ_d3_r25_center_3_5": 10606, + "surface_code_bZ_d3_r01_center_5_3": 5272, + "surface_code_bZ_d3_r03_center_5_3": 11200, + "surface_code_bZ_d3_r05_center_5_3": 4514, + "surface_code_bZ_d3_r07_center_5_3": 8002, + "surface_code_bZ_d3_r09_center_5_3": 8008, + "surface_code_bZ_d3_r11_center_5_3": 8689, + "surface_code_bZ_d3_r13_center_5_3": 8604, + "surface_code_bZ_d3_r15_center_5_3": 5981, + "surface_code_bZ_d3_r17_center_5_3": 5307, + "surface_code_bZ_d3_r19_center_5_3": 6713, + "surface_code_bZ_d3_r21_center_5_3": 8570, + "surface_code_bZ_d3_r23_center_5_3": 6700, + "surface_code_bZ_d3_r25_center_5_3": 10199, + "surface_code_bZ_d3_r01_center_5_7": 6730, + "surface_code_bZ_d3_r03_center_5_7": 7959, + "surface_code_bZ_d3_r05_center_5_7": 9741, + "surface_code_bZ_d3_r07_center_5_7": 10727, + "surface_code_bZ_d3_r09_center_5_7": 11979, + "surface_code_bZ_d3_r11_center_5_7": 3694, + "surface_code_bZ_d3_r13_center_5_7": 6746, + "surface_code_bZ_d3_r15_center_5_7": 6686, + "surface_code_bZ_d3_r17_center_5_7": 10647, + "surface_code_bZ_d3_r19_center_5_7": 8011, + "surface_code_bZ_d3_r21_center_5_7": 6000, + "surface_code_bZ_d3_r23_center_5_7": 9176, + "surface_code_bZ_d3_r25_center_5_7": 6009, + "surface_code_bZ_d3_r01_center_7_5": 9076, + "surface_code_bZ_d3_r03_center_7_5": 9182, + "surface_code_bZ_d3_r05_center_7_5": 6769, + "surface_code_bZ_d3_r07_center_7_5": 11140, + "surface_code_bZ_d3_r09_center_7_5": 7359, + "surface_code_bZ_d3_r11_center_7_5": 8582, + "surface_code_bZ_d3_r13_center_7_5": 5284, + "surface_code_bZ_d3_r15_center_7_5": 6694, + "surface_code_bZ_d3_r17_center_7_5": 5965, + "surface_code_bZ_d3_r19_center_7_5": 6016, + "surface_code_bZ_d3_r21_center_7_5": 9225, + "surface_code_bZ_d3_r23_center_7_5": 4509, + "surface_code_bZ_d3_r25_center_7_5": 6694 + }, + "steps": 1024, + "batch_size": 256, + "accumulate_conditions": 4, + "effective_batch_size": 1024, + "condition_policy": "same", + "training_draws": 1048576, + "condition_sampling": "Draw one condition index per microbatch in both arms; same-condition control reuses the first index while mixed arm uses all indices. Both arms consume identical RNG draws with equal-sized condition pools.", + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.00025, + "sampling_seed": 20261190, + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": true, + "explicit_rng_reset": true, + "sampling_state_source": "Fresh NumPy default_rng seed 20261190", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal2_swa/weights-mean3.npz", + "starting_checkpoint_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "starting_training_provenance": { + "initialization": "Uniform averages of the same session-trained temporal trajectory; no external weights", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from this session's trained checkpoint", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "training_source_sha256": { + "learned_exact__temporal_train.py": "7d48d2fc7f62d0bec3023b3df1c2ac28537d0417966131ae3a156697a34cda5f", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "eligible_training_shots": 2067520, + "unique_training_rows_seen_in_this_phase": 1778773, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 18357, + "surface_code_bX_d3_r03_center_3_5": 16816, + "surface_code_bX_d3_r05_center_3_5": 17999, + "surface_code_bX_d3_r07_center_3_5": 15225, + "surface_code_bX_d3_r09_center_3_5": 16132, + "surface_code_bX_d3_r11_center_3_5": 17041, + "surface_code_bX_d3_r13_center_3_5": 18477, + "surface_code_bX_d3_r15_center_3_5": 18214, + "surface_code_bX_d3_r17_center_3_5": 16505, + "surface_code_bX_d3_r19_center_3_5": 17120, + "surface_code_bX_d3_r21_center_3_5": 17563, + "surface_code_bX_d3_r23_center_3_5": 16681, + "surface_code_bX_d3_r25_center_3_5": 18379, + "surface_code_bX_d3_r01_center_5_3": 17450, + "surface_code_bX_d3_r03_center_5_3": 17161, + "surface_code_bX_d3_r05_center_5_3": 15797, + "surface_code_bX_d3_r07_center_5_3": 17800, + "surface_code_bX_d3_r09_center_5_3": 17190, + "surface_code_bX_d3_r11_center_5_3": 15840, + "surface_code_bX_d3_r13_center_5_3": 15178, + "surface_code_bX_d3_r15_center_5_3": 14897, + "surface_code_bX_d3_r17_center_5_3": 18252, + "surface_code_bX_d3_r19_center_5_3": 17083, + "surface_code_bX_d3_r21_center_5_3": 17229, + "surface_code_bX_d3_r23_center_5_3": 14735, + "surface_code_bX_d3_r25_center_5_3": 17949, + "surface_code_bX_d3_r01_center_5_7": 17431, + "surface_code_bX_d3_r03_center_5_7": 16583, + "surface_code_bX_d3_r05_center_5_7": 16891, + "surface_code_bX_d3_r07_center_5_7": 17969, + "surface_code_bX_d3_r09_center_5_7": 17966, + "surface_code_bX_d3_r11_center_5_7": 14424, + "surface_code_bX_d3_r13_center_5_7": 16930, + "surface_code_bX_d3_r15_center_5_7": 15205, + "surface_code_bX_d3_r17_center_5_7": 18252, + "surface_code_bX_d3_r19_center_5_7": 17077, + "surface_code_bX_d3_r21_center_5_7": 16770, + "surface_code_bX_d3_r23_center_5_7": 17308, + "surface_code_bX_d3_r25_center_5_7": 17481, + "surface_code_bX_d3_r01_center_7_5": 16630, + "surface_code_bX_d3_r03_center_7_5": 17439, + "surface_code_bX_d3_r05_center_7_5": 15811, + "surface_code_bX_d3_r07_center_7_5": 16637, + "surface_code_bX_d3_r09_center_7_5": 18306, + "surface_code_bX_d3_r11_center_7_5": 18327, + "surface_code_bX_d3_r13_center_7_5": 17974, + "surface_code_bX_d3_r15_center_7_5": 16106, + "surface_code_bX_d3_r17_center_7_5": 15834, + "surface_code_bX_d3_r19_center_7_5": 17242, + "surface_code_bX_d3_r21_center_7_5": 17889, + "surface_code_bX_d3_r23_center_7_5": 17440, + "surface_code_bX_d3_r25_center_7_5": 17087, + "surface_code_bZ_d3_r01_center_3_5": 16236, + "surface_code_bZ_d3_r03_center_3_5": 17278, + "surface_code_bZ_d3_r05_center_3_5": 16577, + "surface_code_bZ_d3_r07_center_3_5": 17376, + "surface_code_bZ_d3_r09_center_3_5": 16000, + "surface_code_bZ_d3_r11_center_3_5": 15634, + "surface_code_bZ_d3_r13_center_3_5": 14950, + "surface_code_bZ_d3_r15_center_3_5": 16600, + "surface_code_bZ_d3_r17_center_3_5": 15381, + "surface_code_bZ_d3_r19_center_3_5": 16823, + "surface_code_bZ_d3_r21_center_3_5": 18789, + "surface_code_bZ_d3_r23_center_3_5": 15616, + "surface_code_bZ_d3_r25_center_3_5": 17088, + "surface_code_bZ_d3_r01_center_5_3": 17935, + "surface_code_bZ_d3_r03_center_5_3": 16256, + "surface_code_bZ_d3_r05_center_5_3": 17959, + "surface_code_bZ_d3_r07_center_5_3": 18401, + "surface_code_bZ_d3_r09_center_5_3": 16405, + "surface_code_bZ_d3_r11_center_5_3": 17274, + "surface_code_bZ_d3_r13_center_5_3": 18172, + "surface_code_bZ_d3_r15_center_5_3": 17525, + "surface_code_bZ_d3_r17_center_5_3": 18643, + "surface_code_bZ_d3_r19_center_5_3": 17816, + "surface_code_bZ_d3_r21_center_5_3": 17404, + "surface_code_bZ_d3_r23_center_5_3": 17253, + "surface_code_bZ_d3_r25_center_5_3": 17667, + "surface_code_bZ_d3_r01_center_5_7": 16203, + "surface_code_bZ_d3_r03_center_5_7": 17214, + "surface_code_bZ_d3_r05_center_5_7": 16799, + "surface_code_bZ_d3_r07_center_5_7": 17896, + "surface_code_bZ_d3_r09_center_5_7": 16411, + "surface_code_bZ_d3_r11_center_5_7": 17726, + "surface_code_bZ_d3_r13_center_5_7": 16313, + "surface_code_bZ_d3_r15_center_5_7": 17824, + "surface_code_bZ_d3_r17_center_5_7": 15656, + "surface_code_bZ_d3_r19_center_5_7": 17169, + "surface_code_bZ_d3_r21_center_5_7": 17194, + "surface_code_bZ_d3_r23_center_5_7": 16779, + "surface_code_bZ_d3_r25_center_5_7": 16970, + "surface_code_bZ_d3_r01_center_7_5": 16762, + "surface_code_bZ_d3_r03_center_7_5": 17320, + "surface_code_bZ_d3_r05_center_7_5": 17522, + "surface_code_bZ_d3_r07_center_7_5": 17914, + "surface_code_bZ_d3_r09_center_7_5": 18439, + "surface_code_bZ_d3_r11_center_7_5": 18218, + "surface_code_bZ_d3_r13_center_7_5": 17907, + "surface_code_bZ_d3_r15_center_7_5": 17597, + "surface_code_bZ_d3_r17_center_7_5": 18252, + "surface_code_bZ_d3_r19_center_7_5": 18379, + "surface_code_bZ_d3_r21_center_7_5": 16818, + "surface_code_bZ_d3_r23_center_7_5": 18430, + "surface_code_bZ_d3_r25_center_7_5": 17924 + }, + "steps": 4096, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.0005, + "sampling_seed": 20261121, + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_exact/temporal1/rng-2048.json", + "session_trained_starting_checkpoint": "/run-state/workspace/research/learned_exact/temporal1/weights-2048.npz", + "starting_checkpoint_sha256": "26be9e0259b69a5870bf73e80a5a29fcf3519a3ff63e1d219c57a2113d9d34be", + "starting_training_provenance": { + "initialization": "Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now", + "original_initialization": "Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)", + "rich_starting_checkpoint": "/run-state/workspace/research/learned_exact/rich1/weights-1024.npz", + "rich_checkpoint_sha256": "04fea2cf8c598cd5587d450b50cdce58aee9a8c770a2c2da57d7a48e3bf3e2a6", + "architecture": "Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.", + "training": "Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only", + "steps": 2048, + "batch_size": 1024, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "learning_rate": 0.001, + "sampling_seed": 20261111, + "optimizer_restored": false, + "rng_restored": false, + "session_trained_starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.6317505836486816, + "error": 0.3681640625, + "gradient_norm": 0.04013459011912346, + "elapsed": 30.971998691558838 + }, + { + "step": 16, + "loss": 0.5091081857681274, + "error": 0.291015625, + "gradient_norm": 0.042228709906339645, + "elapsed": 35.17463397979736 + }, + { + "step": 32, + "loss": 0.626472532749176, + "error": 0.3642578125, + "gradient_norm": 0.05872415751218796, + "elapsed": 39.678136110305786 + }, + { + "step": 48, + "loss": 0.6005369424819946, + "error": 0.3515625, + "gradient_norm": 0.03848014399409294, + "elapsed": 44.16946887969971 + }, + { + "step": 64, + "loss": 0.5523768663406372, + "error": 0.302734375, + "gradient_norm": 0.06031862646341324, + "elapsed": 48.65217089653015 + }, + { + "step": 80, + "loss": 0.3981674611568451, + "error": 0.19921875, + "gradient_norm": 0.0542079322040081, + "elapsed": 53.21601867675781 + }, + { + "step": 96, + "loss": 0.5601426362991333, + "error": 0.2978515625, + "gradient_norm": 0.04770371690392494, + "elapsed": 57.81089663505554 + }, + { + "step": 112, + "loss": 0.5878150463104248, + "error": 0.34765625, + "gradient_norm": 0.10699950158596039, + "elapsed": 62.42190766334534 + }, + { + "step": 128, + "loss": 0.5232458114624023, + "error": 0.2861328125, + "gradient_norm": 0.0911584198474884, + "elapsed": 67.00223755836487 + }, + { + "step": 144, + "loss": 0.6119767427444458, + "error": 0.3623046875, + "gradient_norm": 0.062474437057971954, + "elapsed": 71.54070782661438 + }, + { + "step": 160, + "loss": 0.3037984371185303, + "error": 0.1474609375, + "gradient_norm": 0.05718141421675682, + "elapsed": 76.08167362213135 + }, + { + "step": 176, + "loss": 0.6038273572921753, + "error": 0.3662109375, + "gradient_norm": 0.0437164381146431, + "elapsed": 80.71864247322083 + }, + { + "step": 192, + "loss": 0.3304370641708374, + "error": 0.1572265625, + "gradient_norm": 0.05684761330485344, + "elapsed": 85.54437017440796 + }, + { + "step": 208, + "loss": 0.5785484313964844, + "error": 0.3251953125, + "gradient_norm": 0.09597272425889969, + "elapsed": 91.51522874832153 + }, + { + "step": 224, + "loss": 0.3110499978065491, + "error": 0.13671875, + "gradient_norm": 0.04815748706459999, + "elapsed": 97.1228940486908 + }, + { + "step": 240, + "loss": 0.6213864684104919, + "error": 0.3623046875, + "gradient_norm": 0.0540502592921257, + "elapsed": 102.90286135673523 + }, + { + "step": 256, + "loss": 0.2535272240638733, + "error": 0.1064453125, + "gradient_norm": 0.029962118715047836, + "elapsed": 108.39288640022278 + }, + { + "step": 272, + "loss": 0.6126939058303833, + "error": 0.3671875, + "gradient_norm": 0.06887879222631454, + "elapsed": 113.83897161483765 + }, + { + "step": 288, + "loss": 0.4556676149368286, + "error": 0.2236328125, + "gradient_norm": 0.16127081215381622, + "elapsed": 119.93085813522339 + }, + { + "step": 304, + "loss": 0.4973585605621338, + "error": 0.255859375, + "gradient_norm": 0.08082302659749985, + "elapsed": 125.90891909599304 + }, + { + "step": 320, + "loss": 0.6455868482589722, + "error": 0.419921875, + "gradient_norm": 0.04339660331606865, + "elapsed": 131.20537638664246 + }, + { + "step": 336, + "loss": 0.5343132615089417, + "error": 0.2880859375, + "gradient_norm": 0.07518009096384048, + "elapsed": 136.59086871147156 + }, + { + "step": 352, + "loss": 0.6505346894264221, + "error": 0.4033203125, + "gradient_norm": 0.03800992667675018, + "elapsed": 142.21085906028748 + }, + { + "step": 368, + "loss": 0.4882712960243225, + "error": 0.251953125, + "gradient_norm": 0.08170920610427856, + "elapsed": 146.95903658866882 + }, + { + "step": 384, + "loss": 0.5292021036148071, + "error": 0.296875, + "gradient_norm": 0.08454013615846634, + "elapsed": 151.6385259628296 + }, + { + "step": 400, + "loss": 0.6272899508476257, + "error": 0.3837890625, + "gradient_norm": 0.051436979323625565, + "elapsed": 156.3343904018402 + }, + { + "step": 416, + "loss": 0.052130259573459625, + "error": 0.0166015625, + "gradient_norm": 0.02377190627157688, + "elapsed": 160.92345547676086 + }, + { + "step": 432, + "loss": 0.5256737470626831, + "error": 0.3046875, + "gradient_norm": 0.07986386120319366, + "elapsed": 165.52879118919373 + }, + { + "step": 448, + "loss": 0.15193665027618408, + "error": 0.0576171875, + "gradient_norm": 0.06491660326719284, + "elapsed": 170.14827823638916 + }, + { + "step": 464, + "loss": 0.6418055295944214, + "error": 0.40625, + "gradient_norm": 0.07290885597467422, + "elapsed": 174.64974284172058 + }, + { + "step": 480, + "loss": 0.6055159568786621, + "error": 0.357421875, + "gradient_norm": 0.0795595794916153, + "elapsed": 179.17218685150146 + }, + { + "step": 496, + "loss": 0.6372283697128296, + "error": 0.3916015625, + "gradient_norm": 0.04387903958559036, + "elapsed": 183.77568197250366 + }, + { + "step": 512, + "loss": 0.637977123260498, + "error": 0.408203125, + "gradient_norm": 0.060665905475616455, + "elapsed": 188.31205368041992 + }, + { + "step": 528, + "loss": 0.4668862223625183, + "error": 0.2451171875, + "gradient_norm": 0.08566711097955704, + "elapsed": 206.40719985961914 + }, + { + "step": 544, + "loss": 0.4584413170814514, + "error": 0.244140625, + "gradient_norm": 0.08538200706243515, + "elapsed": 211.02819895744324 + }, + { + "step": 560, + "loss": 0.5615692138671875, + "error": 0.3291015625, + "gradient_norm": 0.043748609721660614, + "elapsed": 215.66470766067505 + }, + { + "step": 576, + "loss": 0.5151895880699158, + "error": 0.2880859375, + "gradient_norm": 0.05164863541722298, + "elapsed": 220.18949556350708 + }, + { + "step": 592, + "loss": 0.5618112087249756, + "error": 0.3291015625, + "gradient_norm": 0.05998719856142998, + "elapsed": 224.7216100692749 + }, + { + "step": 608, + "loss": 0.659294843673706, + "error": 0.431640625, + "gradient_norm": 0.09910348802804947, + "elapsed": 229.26827573776245 + }, + { + "step": 624, + "loss": 0.5895233154296875, + "error": 0.3447265625, + "gradient_norm": 0.045334093272686005, + "elapsed": 233.83731055259705 + }, + { + "step": 640, + "loss": 0.6081801056861877, + "error": 0.3388671875, + "gradient_norm": 0.06578423827886581, + "elapsed": 238.36345624923706 + }, + { + "step": 656, + "loss": 0.5349816083908081, + "error": 0.2939453125, + "gradient_norm": 0.09989562630653381, + "elapsed": 242.95086026191711 + }, + { + "step": 672, + "loss": 0.5871994495391846, + "error": 0.328125, + "gradient_norm": 0.08132346719503403, + "elapsed": 247.67088556289673 + }, + { + "step": 688, + "loss": 0.06012660637497902, + "error": 0.0146484375, + "gradient_norm": 0.012170507572591305, + "elapsed": 252.3202247619629 + }, + { + "step": 704, + "loss": 0.42179757356643677, + "error": 0.21484375, + "gradient_norm": 0.08384513854980469, + "elapsed": 256.91991782188416 + }, + { + "step": 720, + "loss": 0.6111758947372437, + "error": 0.3720703125, + "gradient_norm": 0.06689880788326263, + "elapsed": 261.56407928466797 + }, + { + "step": 736, + "loss": 0.29969727993011475, + "error": 0.1318359375, + "gradient_norm": 0.0743367150425911, + "elapsed": 266.22199630737305 + }, + { + "step": 752, + "loss": 0.051849883049726486, + "error": 0.0166015625, + "gradient_norm": 0.017005126923322678, + "elapsed": 270.8602342605591 + }, + { + "step": 768, + "loss": 0.6178420186042786, + "error": 0.3759765625, + "gradient_norm": 0.027732960879802704, + "elapsed": 275.47888374328613 + }, + { + "step": 784, + "loss": 0.45798996090888977, + "error": 0.228515625, + "gradient_norm": 0.0630083829164505, + "elapsed": 280.1709156036377 + }, + { + "step": 800, + "loss": 0.5104988813400269, + "error": 0.2724609375, + "gradient_norm": 0.041733670979738235, + "elapsed": 286.17937707901 + }, + { + "step": 816, + "loss": 0.6336112022399902, + "error": 0.3837890625, + "gradient_norm": 0.0755191296339035, + "elapsed": 291.7506103515625 + }, + { + "step": 832, + "loss": 0.6260952353477478, + "error": 0.3603515625, + "gradient_norm": 0.0318005345761776, + "elapsed": 297.31094622612 + }, + { + "step": 848, + "loss": 0.5870074033737183, + "error": 0.3525390625, + "gradient_norm": 0.12073405832052231, + "elapsed": 303.11089158058167 + }, + { + "step": 864, + "loss": 0.5125640034675598, + "error": 0.26953125, + "gradient_norm": 0.038650237023830414, + "elapsed": 308.7288725376129 + }, + { + "step": 880, + "loss": 0.19194915890693665, + "error": 0.0703125, + "gradient_norm": 0.061878547072410583, + "elapsed": 314.37042355537415 + }, + { + "step": 896, + "loss": 0.5409250259399414, + "error": 0.2919921875, + "gradient_norm": 0.06288820505142212, + "elapsed": 319.9398190975189 + }, + { + "step": 912, + "loss": 0.6164936423301697, + "error": 0.3701171875, + "gradient_norm": 0.043224163353443146, + "elapsed": 325.361323595047 + }, + { + "step": 928, + "loss": 0.16032151877880096, + "error": 0.0625, + "gradient_norm": 0.030957572162151337, + "elapsed": 331.21752285957336 + }, + { + "step": 944, + "loss": 0.646601676940918, + "error": 0.3818359375, + "gradient_norm": 0.05670839175581932, + "elapsed": 336.7825517654419 + }, + { + "step": 960, + "loss": 0.402952641248703, + "error": 0.1865234375, + "gradient_norm": 0.07500886172056198, + "elapsed": 342.6888346672058 + }, + { + "step": 976, + "loss": 0.5537433624267578, + "error": 0.2939453125, + "gradient_norm": 0.04955969750881195, + "elapsed": 348.5554690361023 + }, + { + "step": 992, + "loss": 0.559626579284668, + "error": 0.294921875, + "gradient_norm": 0.048295993357896805, + "elapsed": 354.3531894683838 + }, + { + "step": 1008, + "loss": 0.5034694671630859, + "error": 0.2705078125, + "gradient_norm": 0.05729879066348076, + "elapsed": 360.0949149131775 + }, + { + "step": 1024, + "loss": 0.3119734525680542, + "error": 0.1259765625, + "gradient_norm": 0.052326612174510956, + "elapsed": 365.7881224155426 + }, + { + "step": 1040, + "loss": 0.35799849033355713, + "error": 0.173828125, + "gradient_norm": 0.03801804035902023, + "elapsed": 386.5749418735504 + }, + { + "step": 1056, + "loss": 0.6178948879241943, + "error": 0.3515625, + "gradient_norm": 0.03620661422610283, + "elapsed": 391.48247838020325 + }, + { + "step": 1072, + "loss": 0.49231401085853577, + "error": 0.24609375, + "gradient_norm": 0.04391559213399887, + "elapsed": 396.08718824386597 + }, + { + "step": 1088, + "loss": 0.4119300842285156, + "error": 0.2001953125, + "gradient_norm": 0.1104700043797493, + "elapsed": 400.5326828956604 + }, + { + "step": 1104, + "loss": 0.4926626682281494, + "error": 0.265625, + "gradient_norm": 0.04246886447072029, + "elapsed": 404.95741271972656 + }, + { + "step": 1120, + "loss": 0.5027930736541748, + "error": 0.2607421875, + "gradient_norm": 0.0547240674495697, + "elapsed": 409.40319633483887 + }, + { + "step": 1136, + "loss": 0.5948058366775513, + "error": 0.3544921875, + "gradient_norm": 0.06810063123703003, + "elapsed": 413.8514006137848 + }, + { + "step": 1152, + "loss": 0.26567256450653076, + "error": 0.125, + "gradient_norm": 0.06689104437828064, + "elapsed": 418.29868721961975 + }, + { + "step": 1168, + "loss": 0.2866836190223694, + "error": 0.1240234375, + "gradient_norm": 0.029536213725805283, + "elapsed": 422.75131845474243 + }, + { + "step": 1184, + "loss": 0.6342021822929382, + "error": 0.4091796875, + "gradient_norm": 0.0704190731048584, + "elapsed": 427.1991722583771 + }, + { + "step": 1200, + "loss": 0.41626787185668945, + "error": 0.212890625, + "gradient_norm": 0.04480795934796333, + "elapsed": 431.6600706577301 + }, + { + "step": 1216, + "loss": 0.28460952639579773, + "error": 0.1337890625, + "gradient_norm": 0.03666983172297478, + "elapsed": 436.14414525032043 + }, + { + "step": 1232, + "loss": 0.044482216238975525, + "error": 0.0146484375, + "gradient_norm": 0.04537617415189743, + "elapsed": 440.6220428943634 + }, + { + "step": 1248, + "loss": 0.42564862966537476, + "error": 0.2119140625, + "gradient_norm": 0.03382417559623718, + "elapsed": 445.06736421585083 + }, + { + "step": 1264, + "loss": 0.27150213718414307, + "error": 0.123046875, + "gradient_norm": 0.033046118915081024, + "elapsed": 449.544029712677 + }, + { + "step": 1280, + "loss": 0.4927375912666321, + "error": 0.255859375, + "gradient_norm": 0.06812550127506256, + "elapsed": 454.07198667526245 + }, + { + "step": 1296, + "loss": 0.5541940927505493, + "error": 0.28125, + "gradient_norm": 0.1435294896364212, + "elapsed": 458.6031415462494 + }, + { + "step": 1312, + "loss": 0.5575842261314392, + "error": 0.2958984375, + "gradient_norm": 0.03811952844262123, + "elapsed": 463.1806228160858 + }, + { + "step": 1328, + "loss": 0.3479428291320801, + "error": 0.1591796875, + "gradient_norm": 0.0709012895822525, + "elapsed": 467.84689688682556 + }, + { + "step": 1344, + "loss": 0.1685580611228943, + "error": 0.0693359375, + "gradient_norm": 0.05423415079712868, + "elapsed": 472.6908576488495 + }, + { + "step": 1360, + "loss": 0.18506410717964172, + "error": 0.0771484375, + "gradient_norm": 0.03418596833944321, + "elapsed": 477.4269769191742 + }, + { + "step": 1376, + "loss": 0.5654555559158325, + "error": 0.3173828125, + "gradient_norm": 0.0685155838727951, + "elapsed": 482.08285188674927 + }, + { + "step": 1392, + "loss": 0.6116407513618469, + "error": 0.3603515625, + "gradient_norm": 0.05198948457837105, + "elapsed": 486.7167499065399 + }, + { + "step": 1408, + "loss": 0.4014682471752167, + "error": 0.19140625, + "gradient_norm": 0.1024075523018837, + "elapsed": 491.4308760166168 + }, + { + "step": 1424, + "loss": 0.051035866141319275, + "error": 0.0166015625, + "gradient_norm": 0.010207361541688442, + "elapsed": 496.1818380355835 + }, + { + "step": 1440, + "loss": 0.4725648760795593, + "error": 0.2412109375, + "gradient_norm": 0.03977378085255623, + "elapsed": 500.8668632507324 + }, + { + "step": 1456, + "loss": 0.5407818555831909, + "error": 0.2939453125, + "gradient_norm": 0.088577501475811, + "elapsed": 505.49274134635925 + }, + { + "step": 1472, + "loss": 0.5655064582824707, + "error": 0.3076171875, + "gradient_norm": 0.04452778398990631, + "elapsed": 510.2188584804535 + }, + { + "step": 1488, + "loss": 0.5799556374549866, + "error": 0.30859375, + "gradient_norm": 0.03976206108927727, + "elapsed": 514.9319434165955 + }, + { + "step": 1504, + "loss": 0.4660354256629944, + "error": 0.25390625, + "gradient_norm": 0.04365506023168564, + "elapsed": 519.5848798751831 + }, + { + "step": 1520, + "loss": 0.5505894422531128, + "error": 0.30859375, + "gradient_norm": 0.057772211730480194, + "elapsed": 524.3388590812683 + }, + { + "step": 1536, + "loss": 0.6251416206359863, + "error": 0.400390625, + "gradient_norm": 0.09649194777011871, + "elapsed": 529.483047246933 + }, + { + "step": 1552, + "loss": 0.05424533039331436, + "error": 0.0185546875, + "gradient_norm": 0.011683990247547626, + "elapsed": 548.1828610897064 + }, + { + "step": 1568, + "loss": 0.33612310886383057, + "error": 0.1611328125, + "gradient_norm": 0.051817383617162704, + "elapsed": 553.4256420135498 + }, + { + "step": 1584, + "loss": 0.045015305280685425, + "error": 0.0166015625, + "gradient_norm": 0.022604886442422867, + "elapsed": 558.6308543682098 + }, + { + "step": 1600, + "loss": 0.2701840102672577, + "error": 0.119140625, + "gradient_norm": 0.02910422720015049, + "elapsed": 563.8571691513062 + }, + { + "step": 1616, + "loss": 0.18982334434986115, + "error": 0.0849609375, + "gradient_norm": 0.025524422526359558, + "elapsed": 568.8628678321838 + }, + { + "step": 1632, + "loss": 0.3950161337852478, + "error": 0.185546875, + "gradient_norm": 0.08419577777385712, + "elapsed": 574.0815451145172 + }, + { + "step": 1648, + "loss": 0.49384528398513794, + "error": 0.255859375, + "gradient_norm": 0.08879344165325165, + "elapsed": 579.1229114532471 + }, + { + "step": 1664, + "loss": 0.5671384930610657, + "error": 0.3115234375, + "gradient_norm": 0.05374513566493988, + "elapsed": 584.114851474762 + }, + { + "step": 1680, + "loss": 0.6192574501037598, + "error": 0.37890625, + "gradient_norm": 0.043836336582899094, + "elapsed": 589.0708522796631 + }, + { + "step": 1696, + "loss": 0.2619469463825226, + "error": 0.1171875, + "gradient_norm": 0.040093280375003815, + "elapsed": 594.2814819812775 + }, + { + "step": 1712, + "loss": 0.33178141713142395, + "error": 0.162109375, + "gradient_norm": 0.04902712255716324, + "elapsed": 599.3068840503693 + }, + { + "step": 1728, + "loss": 0.385281503200531, + "error": 0.171875, + "gradient_norm": 0.03541380167007446, + "elapsed": 604.5308682918549 + }, + { + "step": 1744, + "loss": 0.1628715693950653, + "error": 0.0693359375, + "gradient_norm": 0.06111741065979004, + "elapsed": 609.309522151947 + }, + { + "step": 1760, + "loss": 0.5239119529724121, + "error": 0.2861328125, + "gradient_norm": 0.08513613045215607, + "elapsed": 614.0396001338959 + }, + { + "step": 1776, + "loss": 0.35721707344055176, + "error": 0.150390625, + "gradient_norm": 0.06337940692901611, + "elapsed": 618.6857132911682 + }, + { + "step": 1792, + "loss": 0.5985626578330994, + "error": 0.33203125, + "gradient_norm": 0.035725343972444534, + "elapsed": 623.3352344036102 + }, + { + "step": 1808, + "loss": 0.34676820039749146, + "error": 0.15234375, + "gradient_norm": 0.08163885772228241, + "elapsed": 627.9495220184326 + }, + { + "step": 1824, + "loss": 0.5633711814880371, + "error": 0.3037109375, + "gradient_norm": 0.05938677117228508, + "elapsed": 632.5820379257202 + }, + { + "step": 1840, + "loss": 0.6256523132324219, + "error": 0.384765625, + "gradient_norm": 0.04545137286186218, + "elapsed": 637.205274105072 + }, + { + "step": 1856, + "loss": 0.28091639280319214, + "error": 0.1298828125, + "gradient_norm": 0.04705077037215233, + "elapsed": 641.883561372757 + }, + { + "step": 1872, + "loss": 0.516182541847229, + "error": 0.263671875, + "gradient_norm": 0.08828777819871902, + "elapsed": 646.5188939571381 + }, + { + "step": 1888, + "loss": 0.48386621475219727, + "error": 0.25390625, + "gradient_norm": 0.05322824418544769, + "elapsed": 651.148512840271 + }, + { + "step": 1904, + "loss": 0.6141921281814575, + "error": 0.388671875, + "gradient_norm": 0.050139278173446655, + "elapsed": 655.7796437740326 + }, + { + "step": 1920, + "loss": 0.18002840876579285, + "error": 0.0712890625, + "gradient_norm": 0.04201133921742439, + "elapsed": 660.4064948558807 + }, + { + "step": 1936, + "loss": 0.17531852424144745, + "error": 0.0732421875, + "gradient_norm": 0.024726318195462227, + "elapsed": 664.9991583824158 + }, + { + "step": 1952, + "loss": 0.5088322758674622, + "error": 0.2744140625, + "gradient_norm": 0.04693225398659706, + "elapsed": 669.5544555187225 + }, + { + "step": 1968, + "loss": 0.5684165358543396, + "error": 0.3310546875, + "gradient_norm": 0.031029095873236656, + "elapsed": 674.2354445457458 + }, + { + "step": 1984, + "loss": 0.06459524482488632, + "error": 0.017578125, + "gradient_norm": 0.03600892797112465, + "elapsed": 678.7982559204102 + }, + { + "step": 2000, + "loss": 0.3614455461502075, + "error": 0.1748046875, + "gradient_norm": 0.07060294598340988, + "elapsed": 683.2650325298309 + }, + { + "step": 2016, + "loss": 0.35535523295402527, + "error": 0.166015625, + "gradient_norm": 0.05873403698205948, + "elapsed": 687.7125518321991 + }, + { + "step": 2032, + "loss": 0.5638720989227295, + "error": 0.3232421875, + "gradient_norm": 0.07380504906177521, + "elapsed": 692.1461188793182 + }, + { + "step": 2048, + "loss": 0.5301838517189026, + "error": 0.2919921875, + "gradient_norm": 0.05435395985841751, + "elapsed": 696.6235508918762 + } + ] + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.250907301902771, + "error": 0.1083984375, + "gradient_norm": 0.07171476632356644, + "elapsed": 44.811134576797485 + }, + { + "step": 16, + "loss": 0.5958679914474487, + "error": 0.3662109375, + "gradient_norm": 0.07673005014657974, + "elapsed": 49.90856671333313 + }, + { + "step": 32, + "loss": 0.47648972272872925, + "error": 0.2421875, + "gradient_norm": 0.08561501652002335, + "elapsed": 55.179388761520386 + }, + { + "step": 48, + "loss": 0.06145006790757179, + "error": 0.0234375, + "gradient_norm": 0.01556467730551958, + "elapsed": 61.0339195728302 + }, + { + "step": 64, + "loss": 0.3687053918838501, + "error": 0.1884765625, + "gradient_norm": 0.08752371370792389, + "elapsed": 65.95811891555786 + }, + { + "step": 80, + "loss": 0.6481984853744507, + "error": 0.4140625, + "gradient_norm": 0.05311283841729164, + "elapsed": 70.56021332740784 + }, + { + "step": 96, + "loss": 0.42319929599761963, + "error": 0.2138671875, + "gradient_norm": 0.05047478526830673, + "elapsed": 75.11613631248474 + }, + { + "step": 112, + "loss": 0.47527259588241577, + "error": 0.24609375, + "gradient_norm": 0.038366906344890594, + "elapsed": 79.53446984291077 + }, + { + "step": 128, + "loss": 0.5996723175048828, + "error": 0.3369140625, + "gradient_norm": 0.1213272362947464, + "elapsed": 83.97515749931335 + }, + { + "step": 144, + "loss": 0.04971993714570999, + "error": 0.0146484375, + "gradient_norm": 0.008080735802650452, + "elapsed": 88.44039463996887 + }, + { + "step": 160, + "loss": 0.35900360345840454, + "error": 0.162109375, + "gradient_norm": 0.03359593451023102, + "elapsed": 92.89548206329346 + }, + { + "step": 176, + "loss": 0.5342063903808594, + "error": 0.2978515625, + "gradient_norm": 0.04794691130518913, + "elapsed": 97.35658049583435 + }, + { + "step": 192, + "loss": 0.6300076246261597, + "error": 0.369140625, + "gradient_norm": 0.081769198179245, + "elapsed": 101.81493759155273 + }, + { + "step": 208, + "loss": 0.6191903948783875, + "error": 0.3828125, + "gradient_norm": 0.07145775109529495, + "elapsed": 106.2480263710022 + }, + { + "step": 224, + "loss": 0.5155678391456604, + "error": 0.28515625, + "gradient_norm": 0.06772179156541824, + "elapsed": 110.71284222602844 + }, + { + "step": 240, + "loss": 0.634708046913147, + "error": 0.3857421875, + "gradient_norm": 0.09493093192577362, + "elapsed": 115.14978742599487 + }, + { + "step": 256, + "loss": 0.1840895414352417, + "error": 0.0751953125, + "gradient_norm": 0.025586696341633797, + "elapsed": 119.61202120780945 + }, + { + "step": 272, + "loss": 0.2775103449821472, + "error": 0.12890625, + "gradient_norm": 0.06913147866725922, + "elapsed": 124.02584528923035 + }, + { + "step": 288, + "loss": 0.6163080334663391, + "error": 0.3642578125, + "gradient_norm": 0.05895426496863365, + "elapsed": 128.46512532234192 + }, + { + "step": 304, + "loss": 0.5276986360549927, + "error": 0.287109375, + "gradient_norm": 0.06955187022686005, + "elapsed": 132.89240765571594 + }, + { + "step": 320, + "loss": 0.44859516620635986, + "error": 0.22265625, + "gradient_norm": 0.07272452116012573, + "elapsed": 137.32864713668823 + }, + { + "step": 336, + "loss": 0.48315611481666565, + "error": 0.2626953125, + "gradient_norm": 0.03321139141917229, + "elapsed": 141.80009770393372 + }, + { + "step": 352, + "loss": 0.6107717752456665, + "error": 0.3544921875, + "gradient_norm": 0.05243214592337608, + "elapsed": 146.36439752578735 + }, + { + "step": 368, + "loss": 0.6215153932571411, + "error": 0.357421875, + "gradient_norm": 0.04383325204253197, + "elapsed": 150.99996852874756 + }, + { + "step": 384, + "loss": 0.6130329966545105, + "error": 0.35546875, + "gradient_norm": 0.04113119840621948, + "elapsed": 155.62374639511108 + }, + { + "step": 400, + "loss": 0.30471885204315186, + "error": 0.142578125, + "gradient_norm": 0.04447556659579277, + "elapsed": 160.17594957351685 + }, + { + "step": 416, + "loss": 0.6154489517211914, + "error": 0.37109375, + "gradient_norm": 0.04456057772040367, + "elapsed": 164.7639675140381 + }, + { + "step": 432, + "loss": 0.6134694218635559, + "error": 0.337890625, + "gradient_norm": 0.04219559207558632, + "elapsed": 169.32792139053345 + }, + { + "step": 448, + "loss": 0.5463185906410217, + "error": 0.2939453125, + "gradient_norm": 0.07746092975139618, + "elapsed": 173.88445162773132 + }, + { + "step": 464, + "loss": 0.06016772612929344, + "error": 0.01953125, + "gradient_norm": 0.01364185381680727, + "elapsed": 178.42725706100464 + }, + { + "step": 480, + "loss": 0.388141393661499, + "error": 0.18359375, + "gradient_norm": 0.04870256036520004, + "elapsed": 182.99062085151672 + }, + { + "step": 496, + "loss": 0.44524821639060974, + "error": 0.2216796875, + "gradient_norm": 0.03453445807099342, + "elapsed": 187.56396961212158 + }, + { + "step": 512, + "loss": 0.34312355518341064, + "error": 0.154296875, + "gradient_norm": 0.06794509291648865, + "elapsed": 192.27511191368103 + }, + { + "step": 528, + "loss": 0.19467462599277496, + "error": 0.0771484375, + "gradient_norm": 0.042381469160318375, + "elapsed": 197.7108268737793 + }, + { + "step": 544, + "loss": 0.46226584911346436, + "error": 0.2421875, + "gradient_norm": 0.06073570251464844, + "elapsed": 202.97405791282654 + }, + { + "step": 560, + "loss": 0.525318443775177, + "error": 0.2822265625, + "gradient_norm": 0.06954885274171829, + "elapsed": 208.69676971435547 + }, + { + "step": 576, + "loss": 0.6158387064933777, + "error": 0.349609375, + "gradient_norm": 0.07587578892707825, + "elapsed": 214.80397653579712 + }, + { + "step": 592, + "loss": 0.5515886545181274, + "error": 0.298828125, + "gradient_norm": 0.04969338700175285, + "elapsed": 220.27399611473083 + }, + { + "step": 608, + "loss": 0.18365338444709778, + "error": 0.0654296875, + "gradient_norm": 0.08657706528902054, + "elapsed": 224.81246256828308 + }, + { + "step": 624, + "loss": 0.4578855633735657, + "error": 0.2421875, + "gradient_norm": 0.04942100867629051, + "elapsed": 229.45902252197266 + }, + { + "step": 640, + "loss": 0.37826013565063477, + "error": 0.1865234375, + "gradient_norm": 0.047499872744083405, + "elapsed": 233.9695644378662 + }, + { + "step": 656, + "loss": 0.40863412618637085, + "error": 0.2001953125, + "gradient_norm": 0.07845330238342285, + "elapsed": 238.584894657135 + }, + { + "step": 672, + "loss": 0.5640332698822021, + "error": 0.2880859375, + "gradient_norm": 0.057469289749860764, + "elapsed": 243.0929844379425 + }, + { + "step": 688, + "loss": 0.030216243118047714, + "error": 0.0078125, + "gradient_norm": 0.04682641476392746, + "elapsed": 247.581125497818 + }, + { + "step": 704, + "loss": 0.375002384185791, + "error": 0.1826171875, + "gradient_norm": 0.04864194989204407, + "elapsed": 252.1564691066742 + }, + { + "step": 720, + "loss": 0.5145515203475952, + "error": 0.2744140625, + "gradient_norm": 0.052671682089567184, + "elapsed": 256.6466488838196 + }, + { + "step": 736, + "loss": 0.067174531519413, + "error": 0.0224609375, + "gradient_norm": 0.019299577921628952, + "elapsed": 261.1185076236725 + }, + { + "step": 752, + "loss": 0.24909992516040802, + "error": 0.111328125, + "gradient_norm": 0.06907463818788528, + "elapsed": 265.61960339546204 + }, + { + "step": 768, + "loss": 0.5088074207305908, + "error": 0.2744140625, + "gradient_norm": 0.06963017582893372, + "elapsed": 270.07474064826965 + }, + { + "step": 784, + "loss": 0.3783387839794159, + "error": 0.1826171875, + "gradient_norm": 0.05537794530391693, + "elapsed": 274.52722239494324 + }, + { + "step": 800, + "loss": 0.6107200980186462, + "error": 0.3623046875, + "gradient_norm": 0.0470259003341198, + "elapsed": 279.0401859283447 + }, + { + "step": 816, + "loss": 0.5778236389160156, + "error": 0.3212890625, + "gradient_norm": 0.10146680474281311, + "elapsed": 283.5114622116089 + }, + { + "step": 832, + "loss": 0.576002299785614, + "error": 0.3076171875, + "gradient_norm": 0.07760787010192871, + "elapsed": 288.04797434806824 + }, + { + "step": 848, + "loss": 0.6179666519165039, + "error": 0.3740234375, + "gradient_norm": 0.07383852452039719, + "elapsed": 292.60600209236145 + }, + { + "step": 864, + "loss": 0.3105512857437134, + "error": 0.1455078125, + "gradient_norm": 0.052953749895095825, + "elapsed": 297.12180352211 + }, + { + "step": 880, + "loss": 0.4802623987197876, + "error": 0.2548828125, + "gradient_norm": 0.07736275345087051, + "elapsed": 301.6091134548187 + }, + { + "step": 896, + "loss": 0.5572722554206848, + "error": 0.318359375, + "gradient_norm": 0.053303152322769165, + "elapsed": 306.1978073120117 + }, + { + "step": 912, + "loss": 0.34814420342445374, + "error": 0.1669921875, + "gradient_norm": 0.037726350128650665, + "elapsed": 310.78571581840515 + }, + { + "step": 928, + "loss": 0.41743016242980957, + "error": 0.21875, + "gradient_norm": 0.05238872766494751, + "elapsed": 315.24156188964844 + }, + { + "step": 944, + "loss": 0.5757850408554077, + "error": 0.3173828125, + "gradient_norm": 0.05837905779480934, + "elapsed": 319.78475165367126 + }, + { + "step": 960, + "loss": 0.40727972984313965, + "error": 0.197265625, + "gradient_norm": 0.059294261038303375, + "elapsed": 324.2090265750885 + }, + { + "step": 976, + "loss": 0.32715001702308655, + "error": 0.1533203125, + "gradient_norm": 0.11543179303407669, + "elapsed": 328.6462152004242 + }, + { + "step": 992, + "loss": 0.5578742623329163, + "error": 0.314453125, + "gradient_norm": 0.06282714009284973, + "elapsed": 333.0712504386902 + }, + { + "step": 1008, + "loss": 0.5052692294120789, + "error": 0.265625, + "gradient_norm": 0.04039420187473297, + "elapsed": 337.5182821750641 + }, + { + "step": 1024, + "loss": 0.18790806829929352, + "error": 0.08203125, + "gradient_norm": 0.028905188664793968, + "elapsed": 342.08340406417847 + }, + { + "step": 1040, + "loss": 0.6317684650421143, + "error": 0.3681640625, + "gradient_norm": 0.03441835194826126, + "elapsed": 358.8279616832733 + }, + { + "step": 1056, + "loss": 0.40474164485931396, + "error": 0.2021484375, + "gradient_norm": 0.036449309438467026, + "elapsed": 363.30218267440796 + }, + { + "step": 1072, + "loss": 0.518299400806427, + "error": 0.2666015625, + "gradient_norm": 0.0886964276432991, + "elapsed": 367.87997555732727 + }, + { + "step": 1088, + "loss": 0.2522922158241272, + "error": 0.099609375, + "gradient_norm": 0.07553310692310333, + "elapsed": 372.4414882659912 + }, + { + "step": 1104, + "loss": 0.6214810609817505, + "error": 0.3701171875, + "gradient_norm": 0.10188957303762436, + "elapsed": 376.9120502471924 + }, + { + "step": 1120, + "loss": 0.6307054162025452, + "error": 0.3720703125, + "gradient_norm": 0.07353860139846802, + "elapsed": 381.3824534416199 + }, + { + "step": 1136, + "loss": 0.5259381532669067, + "error": 0.2763671875, + "gradient_norm": 0.05779678374528885, + "elapsed": 385.8413143157959 + }, + { + "step": 1152, + "loss": 0.4995541572570801, + "error": 0.259765625, + "gradient_norm": 0.046648140996694565, + "elapsed": 390.28326058387756 + }, + { + "step": 1168, + "loss": 0.6075694561004639, + "error": 0.3701171875, + "gradient_norm": 0.10612073540687561, + "elapsed": 394.8162364959717 + }, + { + "step": 1184, + "loss": 0.2105136513710022, + "error": 0.080078125, + "gradient_norm": 0.0716402605175972, + "elapsed": 399.2960283756256 + }, + { + "step": 1200, + "loss": 0.6371631026268005, + "error": 0.3857421875, + "gradient_norm": 0.0549108125269413, + "elapsed": 403.7899103164673 + }, + { + "step": 1216, + "loss": 0.5450670719146729, + "error": 0.2939453125, + "gradient_norm": 0.11688558012247086, + "elapsed": 408.34677600860596 + }, + { + "step": 1232, + "loss": 0.035783201456069946, + "error": 0.01171875, + "gradient_norm": 0.02951689623296261, + "elapsed": 412.8558337688446 + }, + { + "step": 1248, + "loss": 0.5582903623580933, + "error": 0.3046875, + "gradient_norm": 0.055107031017541885, + "elapsed": 417.29854226112366 + }, + { + "step": 1264, + "loss": 0.5154441595077515, + "error": 0.27734375, + "gradient_norm": 0.04474929720163345, + "elapsed": 421.7792055606842 + }, + { + "step": 1280, + "loss": 0.35227546095848083, + "error": 0.16015625, + "gradient_norm": 0.05024837702512741, + "elapsed": 426.54427456855774 + }, + { + "step": 1296, + "loss": 0.19417589902877808, + "error": 0.0830078125, + "gradient_norm": 0.026926057413220406, + "elapsed": 431.320588350296 + }, + { + "step": 1312, + "loss": 0.4768218398094177, + "error": 0.248046875, + "gradient_norm": 0.15099607408046722, + "elapsed": 435.96817326545715 + }, + { + "step": 1328, + "loss": 0.48580923676490784, + "error": 0.2509765625, + "gradient_norm": 0.08925126492977142, + "elapsed": 440.64917039871216 + }, + { + "step": 1344, + "loss": 0.42041274905204773, + "error": 0.1982421875, + "gradient_norm": 0.08321093022823334, + "elapsed": 445.34370946884155 + }, + { + "step": 1360, + "loss": 0.06403929740190506, + "error": 0.0185546875, + "gradient_norm": 0.03817005455493927, + "elapsed": 449.98669385910034 + }, + { + "step": 1376, + "loss": 0.463126003742218, + "error": 0.2275390625, + "gradient_norm": 0.08894515782594681, + "elapsed": 454.6478977203369 + }, + { + "step": 1392, + "loss": 0.5995306968688965, + "error": 0.373046875, + "gradient_norm": 0.06733685731887817, + "elapsed": 459.35924530029297 + }, + { + "step": 1408, + "loss": 0.49053263664245605, + "error": 0.25, + "gradient_norm": 0.10475508868694305, + "elapsed": 464.100093126297 + }, + { + "step": 1424, + "loss": 0.6220744848251343, + "error": 0.3818359375, + "gradient_norm": 0.03653963655233383, + "elapsed": 468.89601135253906 + }, + { + "step": 1440, + "loss": 0.39706122875213623, + "error": 0.2021484375, + "gradient_norm": 0.04344598576426506, + "elapsed": 474.03999519348145 + }, + { + "step": 1456, + "loss": 0.5386708974838257, + "error": 0.3095703125, + "gradient_norm": 0.12589037418365479, + "elapsed": 478.8600504398346 + }, + { + "step": 1472, + "loss": 0.49776726961135864, + "error": 0.271484375, + "gradient_norm": 0.058137863874435425, + "elapsed": 483.5920066833496 + }, + { + "step": 1488, + "loss": 0.4757428765296936, + "error": 0.2412109375, + "gradient_norm": 0.050453316420316696, + "elapsed": 488.4611999988556 + }, + { + "step": 1504, + "loss": 0.5694847702980042, + "error": 0.337890625, + "gradient_norm": 0.052419569343328476, + "elapsed": 493.26151037216187 + }, + { + "step": 1520, + "loss": 0.5997745990753174, + "error": 0.3603515625, + "gradient_norm": 0.04338108375668526, + "elapsed": 498.0421245098114 + }, + { + "step": 1536, + "loss": 0.6195274591445923, + "error": 0.3876953125, + "gradient_norm": 0.04848463833332062, + "elapsed": 502.8808298110962 + }, + { + "step": 1552, + "loss": 0.46315908432006836, + "error": 0.2353515625, + "gradient_norm": 0.06380566209554672, + "elapsed": 507.5519721508026 + }, + { + "step": 1568, + "loss": 0.605262041091919, + "error": 0.36328125, + "gradient_norm": 0.05077619478106499, + "elapsed": 512.457685470581 + }, + { + "step": 1584, + "loss": 0.48782041668891907, + "error": 0.232421875, + "gradient_norm": 0.09017211943864822, + "elapsed": 517.2960062026978 + }, + { + "step": 1600, + "loss": 0.3881351947784424, + "error": 0.1875, + "gradient_norm": 0.07205695658922195, + "elapsed": 522.0911631584167 + }, + { + "step": 1616, + "loss": 0.4966873526573181, + "error": 0.24609375, + "gradient_norm": 0.0582038015127182, + "elapsed": 526.8861901760101 + }, + { + "step": 1632, + "loss": 0.5844199657440186, + "error": 0.33203125, + "gradient_norm": 0.05101500824093819, + "elapsed": 531.6640138626099 + }, + { + "step": 1648, + "loss": 0.31010180711746216, + "error": 0.1318359375, + "gradient_norm": 0.053135693073272705, + "elapsed": 536.4960391521454 + }, + { + "step": 1664, + "loss": 0.6174807548522949, + "error": 0.3779296875, + "gradient_norm": 0.04161194711923599, + "elapsed": 541.2560484409332 + }, + { + "step": 1680, + "loss": 0.18213607370853424, + "error": 0.0751953125, + "gradient_norm": 0.07171957194805145, + "elapsed": 546.0000085830688 + }, + { + "step": 1696, + "loss": 0.5445692539215088, + "error": 0.2998046875, + "gradient_norm": 0.054499462246894836, + "elapsed": 551.1221191883087 + }, + { + "step": 1712, + "loss": 0.05744167044758797, + "error": 0.017578125, + "gradient_norm": 0.013108699582517147, + "elapsed": 556.5286149978638 + }, + { + "step": 1728, + "loss": 0.6381571292877197, + "error": 0.3896484375, + "gradient_norm": 0.05157556012272835, + "elapsed": 561.8000066280365 + }, + { + "step": 1744, + "loss": 0.5301004648208618, + "error": 0.28125, + "gradient_norm": 0.04218568280339241, + "elapsed": 567.2760035991669 + }, + { + "step": 1760, + "loss": 0.5275102257728577, + "error": 0.26953125, + "gradient_norm": 0.06798839569091797, + "elapsed": 572.5601994991302 + }, + { + "step": 1776, + "loss": 0.6443773508071899, + "error": 0.4091796875, + "gradient_norm": 0.07035460323095322, + "elapsed": 577.9789206981659 + }, + { + "step": 1792, + "loss": 0.6012362241744995, + "error": 0.337890625, + "gradient_norm": 0.05189951881766319, + "elapsed": 583.028017282486 + }, + { + "step": 1808, + "loss": 0.2939091920852661, + "error": 0.12109375, + "gradient_norm": 0.05555355176329613, + "elapsed": 588.0501506328583 + }, + { + "step": 1824, + "loss": 0.2059091478586197, + "error": 0.08984375, + "gradient_norm": 0.045679714530706406, + "elapsed": 593.2120039463043 + }, + { + "step": 1840, + "loss": 0.6289581060409546, + "error": 0.349609375, + "gradient_norm": 0.04742642492055893, + "elapsed": 598.7767763137817 + }, + { + "step": 1856, + "loss": 0.5532636642456055, + "error": 0.294921875, + "gradient_norm": 0.05997413396835327, + "elapsed": 604.0475382804871 + }, + { + "step": 1872, + "loss": 0.45995670557022095, + "error": 0.228515625, + "gradient_norm": 0.05674462765455246, + "elapsed": 609.292379617691 + }, + { + "step": 1888, + "loss": 0.6178656816482544, + "error": 0.359375, + "gradient_norm": 0.08857566863298416, + "elapsed": 614.5639882087708 + }, + { + "step": 1904, + "loss": 0.5531284213066101, + "error": 0.287109375, + "gradient_norm": 0.10257937759160995, + "elapsed": 619.5600035190582 + }, + { + "step": 1920, + "loss": 0.04184349626302719, + "error": 0.013671875, + "gradient_norm": 0.04087059944868088, + "elapsed": 624.6679775714874 + }, + { + "step": 1936, + "loss": 0.5924860239028931, + "error": 0.3505859375, + "gradient_norm": 0.036822713911533356, + "elapsed": 629.936680316925 + }, + { + "step": 1952, + "loss": 0.46996980905532837, + "error": 0.2421875, + "gradient_norm": 0.034442272037267685, + "elapsed": 635.1109762191772 + }, + { + "step": 1968, + "loss": 0.17859068512916565, + "error": 0.0712890625, + "gradient_norm": 0.03440066799521446, + "elapsed": 640.32000207901 + }, + { + "step": 1984, + "loss": 0.6192275285720825, + "error": 0.3701171875, + "gradient_norm": 0.04386439174413681, + "elapsed": 645.6040184497833 + }, + { + "step": 2000, + "loss": 0.6160917282104492, + "error": 0.35546875, + "gradient_norm": 0.06268990784883499, + "elapsed": 650.7723731994629 + }, + { + "step": 2016, + "loss": 0.6343611478805542, + "error": 0.388671875, + "gradient_norm": 0.04243326932191849, + "elapsed": 655.972663640976 + }, + { + "step": 2032, + "loss": 0.062292590737342834, + "error": 0.021484375, + "gradient_norm": 0.016680095344781876, + "elapsed": 660.8079733848572 + }, + { + "step": 2048, + "loss": 0.5316072702407837, + "error": 0.26953125, + "gradient_norm": 0.057860780507326126, + "elapsed": 665.5760209560394 + }, + { + "step": 2064, + "loss": 0.605312705039978, + "error": 0.3623046875, + "gradient_norm": 0.04028146713972092, + "elapsed": 682.7294294834137 + }, + { + "step": 2080, + "loss": 0.56633460521698, + "error": 0.3330078125, + "gradient_norm": 0.09528280049562454, + "elapsed": 687.4644649028778 + }, + { + "step": 2096, + "loss": 0.3905397057533264, + "error": 0.1943359375, + "gradient_norm": 0.049456462264060974, + "elapsed": 692.1492264270782 + }, + { + "step": 2112, + "loss": 0.28124868869781494, + "error": 0.1259765625, + "gradient_norm": 0.059239838272333145, + "elapsed": 696.8701393604279 + }, + { + "step": 2128, + "loss": 0.6364338994026184, + "error": 0.392578125, + "gradient_norm": 0.08667811006307602, + "elapsed": 701.683988571167 + }, + { + "step": 2144, + "loss": 0.20683243870735168, + "error": 0.07421875, + "gradient_norm": 0.1100710779428482, + "elapsed": 706.4000360965729 + }, + { + "step": 2160, + "loss": 0.5912737250328064, + "error": 0.341796875, + "gradient_norm": 0.05641854554414749, + "elapsed": 711.2359964847565 + }, + { + "step": 2176, + "loss": 0.27793264389038086, + "error": 0.12109375, + "gradient_norm": 0.0893034040927887, + "elapsed": 715.9508004188538 + }, + { + "step": 2192, + "loss": 0.6474133133888245, + "error": 0.4072265625, + "gradient_norm": 0.06980258971452713, + "elapsed": 720.651974439621 + }, + { + "step": 2208, + "loss": 0.5961858630180359, + "error": 0.35546875, + "gradient_norm": 0.06530112773180008, + "elapsed": 725.496098279953 + }, + { + "step": 2224, + "loss": 0.47581571340560913, + "error": 0.263671875, + "gradient_norm": 0.04470043256878853, + "elapsed": 730.2880010604858 + }, + { + "step": 2240, + "loss": 0.577988862991333, + "error": 0.318359375, + "gradient_norm": 0.07201159745454788, + "elapsed": 735.006133556366 + }, + { + "step": 2256, + "loss": 0.28444671630859375, + "error": 0.1181640625, + "gradient_norm": 0.048656050115823746, + "elapsed": 739.6868116855621 + }, + { + "step": 2272, + "loss": 0.2776409089565277, + "error": 0.1201171875, + "gradient_norm": 0.05783981829881668, + "elapsed": 744.3517308235168 + }, + { + "step": 2288, + "loss": 0.621599555015564, + "error": 0.37109375, + "gradient_norm": 0.09731200337409973, + "elapsed": 749.0351710319519 + }, + { + "step": 2304, + "loss": 0.3333754539489746, + "error": 0.1513671875, + "gradient_norm": 0.07069239765405655, + "elapsed": 753.7588081359863 + }, + { + "step": 2320, + "loss": 0.4687051773071289, + "error": 0.2490234375, + "gradient_norm": 0.044891707599163055, + "elapsed": 758.4588432312012 + }, + { + "step": 2336, + "loss": 0.19801637530326843, + "error": 0.078125, + "gradient_norm": 0.10036595165729523, + "elapsed": 763.256409406662 + }, + { + "step": 2352, + "loss": 0.6186277866363525, + "error": 0.388671875, + "gradient_norm": 0.09069584310054779, + "elapsed": 767.9986386299133 + }, + { + "step": 2368, + "loss": 0.6177258491516113, + "error": 0.373046875, + "gradient_norm": 0.049019571393728256, + "elapsed": 772.730831861496 + }, + { + "step": 2384, + "loss": 0.17707547545433044, + "error": 0.0673828125, + "gradient_norm": 0.045190781354904175, + "elapsed": 777.4072704315186 + }, + { + "step": 2400, + "loss": 0.20144733786582947, + "error": 0.08203125, + "gradient_norm": 0.04537162929773331, + "elapsed": 782.0841658115387 + }, + { + "step": 2416, + "loss": 0.6151775121688843, + "error": 0.365234375, + "gradient_norm": 0.050534047186374664, + "elapsed": 786.762966632843 + }, + { + "step": 2432, + "loss": 0.5533859133720398, + "error": 0.314453125, + "gradient_norm": 0.06006559729576111, + "elapsed": 791.4656012058258 + }, + { + "step": 2448, + "loss": 0.5329082012176514, + "error": 0.2880859375, + "gradient_norm": 0.04018115997314453, + "elapsed": 796.1704161167145 + }, + { + "step": 2464, + "loss": 0.6338047981262207, + "error": 0.4140625, + "gradient_norm": 0.06069163978099823, + "elapsed": 800.9180119037628 + }, + { + "step": 2480, + "loss": 0.1603008508682251, + "error": 0.0673828125, + "gradient_norm": 0.040350593626499176, + "elapsed": 805.6127603054047 + }, + { + "step": 2496, + "loss": 0.505940318107605, + "error": 0.2568359375, + "gradient_norm": 0.05209952965378761, + "elapsed": 810.3740313053131 + }, + { + "step": 2512, + "loss": 0.5528728365898132, + "error": 0.298828125, + "gradient_norm": 0.11757992953062057, + "elapsed": 815.1708807945251 + }, + { + "step": 2528, + "loss": 0.5028313994407654, + "error": 0.2666015625, + "gradient_norm": 0.08823780715465546, + "elapsed": 819.8585045337677 + }, + { + "step": 2544, + "loss": 0.5002262592315674, + "error": 0.2783203125, + "gradient_norm": 0.04888603836297989, + "elapsed": 824.5714073181152 + }, + { + "step": 2560, + "loss": 0.6007894277572632, + "error": 0.328125, + "gradient_norm": 0.05186954140663147, + "elapsed": 829.3080432415009 + }, + { + "step": 2576, + "loss": 0.18641480803489685, + "error": 0.076171875, + "gradient_norm": 0.03799928352236748, + "elapsed": 834.044020652771 + }, + { + "step": 2592, + "loss": 0.3050769865512848, + "error": 0.1396484375, + "gradient_norm": 0.10119257122278214, + "elapsed": 838.8401296138763 + }, + { + "step": 2608, + "loss": 0.6063439846038818, + "error": 0.361328125, + "gradient_norm": 0.04979367554187775, + "elapsed": 844.3572654724121 + }, + { + "step": 2624, + "loss": 0.5751967430114746, + "error": 0.3369140625, + "gradient_norm": 0.04269539937376976, + "elapsed": 849.0660374164581 + }, + { + "step": 2640, + "loss": 0.3902108669281006, + "error": 0.193359375, + "gradient_norm": 0.10029696673154831, + "elapsed": 853.8638062477112 + }, + { + "step": 2656, + "loss": 0.15081660449504852, + "error": 0.0625, + "gradient_norm": 0.0303852129727602, + "elapsed": 858.9793758392334 + }, + { + "step": 2672, + "loss": 0.6503090858459473, + "error": 0.400390625, + "gradient_norm": 0.12611964344978333, + "elapsed": 863.9151141643524 + }, + { + "step": 2688, + "loss": 0.5587317943572998, + "error": 0.31640625, + "gradient_norm": 0.10028114914894104, + "elapsed": 868.7600305080414 + }, + { + "step": 2704, + "loss": 0.4399867355823517, + "error": 0.21484375, + "gradient_norm": 0.06889455020427704, + "elapsed": 873.4544236660004 + }, + { + "step": 2720, + "loss": 0.5865127444267273, + "error": 0.337890625, + "gradient_norm": 0.03671631962060928, + "elapsed": 878.0982644557953 + }, + { + "step": 2736, + "loss": 0.6078637838363647, + "error": 0.3701171875, + "gradient_norm": 0.04679318517446518, + "elapsed": 883.0424642562866 + }, + { + "step": 2752, + "loss": 0.5825340151786804, + "error": 0.337890625, + "gradient_norm": 0.05619681254029274, + "elapsed": 887.908124923706 + }, + { + "step": 2768, + "loss": 0.5970422029495239, + "error": 0.3369140625, + "gradient_norm": 0.041302867233753204, + "elapsed": 892.6760206222534 + }, + { + "step": 2784, + "loss": 0.3870226740837097, + "error": 0.1826171875, + "gradient_norm": 0.05731065198779106, + "elapsed": 897.6246056556702 + }, + { + "step": 2800, + "loss": 0.38130277395248413, + "error": 0.1943359375, + "gradient_norm": 0.059244755655527115, + "elapsed": 902.3360238075256 + }, + { + "step": 2816, + "loss": 0.2617901563644409, + "error": 0.1064453125, + "gradient_norm": 0.041736964136362076, + "elapsed": 907.1600468158722 + }, + { + "step": 2832, + "loss": 0.5819337368011475, + "error": 0.314453125, + "gradient_norm": 0.04097156226634979, + "elapsed": 912.0244295597076 + }, + { + "step": 2848, + "loss": 0.41393283009529114, + "error": 0.2001953125, + "gradient_norm": 0.10456771403551102, + "elapsed": 916.8225846290588 + }, + { + "step": 2864, + "loss": 0.5019145011901855, + "error": 0.2548828125, + "gradient_norm": 0.04843736067414284, + "elapsed": 921.538754940033 + }, + { + "step": 2880, + "loss": 0.04561338573694229, + "error": 0.0146484375, + "gradient_norm": 0.025407327339053154, + "elapsed": 926.2588667869568 + }, + { + "step": 2896, + "loss": 0.4338858723640442, + "error": 0.205078125, + "gradient_norm": 0.09900517761707306, + "elapsed": 930.9781975746155 + }, + { + "step": 2912, + "loss": 0.33922863006591797, + "error": 0.162109375, + "gradient_norm": 0.10189604014158249, + "elapsed": 935.6816267967224 + }, + { + "step": 2928, + "loss": 0.5294322967529297, + "error": 0.2822265625, + "gradient_norm": 0.09060791879892349, + "elapsed": 940.4373068809509 + }, + { + "step": 2944, + "loss": 0.037007369101047516, + "error": 0.01171875, + "gradient_norm": 0.05506489425897598, + "elapsed": 945.1270468235016 + }, + { + "step": 2960, + "loss": 0.6096771359443665, + "error": 0.349609375, + "gradient_norm": 0.04987221211194992, + "elapsed": 949.8300130367279 + }, + { + "step": 2976, + "loss": 0.6157823801040649, + "error": 0.373046875, + "gradient_norm": 0.03614233434200287, + "elapsed": 954.5701997280121 + }, + { + "step": 2992, + "loss": 0.1978239268064499, + "error": 0.080078125, + "gradient_norm": 0.05847112461924553, + "elapsed": 959.2756471633911 + }, + { + "step": 3008, + "loss": 0.5237340927124023, + "error": 0.2841796875, + "gradient_norm": 0.06993591040372849, + "elapsed": 963.9875864982605 + }, + { + "step": 3024, + "loss": 0.4559935927391052, + "error": 0.2373046875, + "gradient_norm": 0.05698448419570923, + "elapsed": 968.7997305393219 + }, + { + "step": 3040, + "loss": 0.5025208592414856, + "error": 0.259765625, + "gradient_norm": 0.14909739792346954, + "elapsed": 973.6042547225952 + }, + { + "step": 3056, + "loss": 0.3223109245300293, + "error": 0.1416015625, + "gradient_norm": 0.032974764704704285, + "elapsed": 978.4760546684265 + }, + { + "step": 3072, + "loss": 0.06682582199573517, + "error": 0.021484375, + "gradient_norm": 0.04433188587427139, + "elapsed": 983.2894048690796 + }, + { + "step": 3088, + "loss": 0.5919550061225891, + "error": 0.34765625, + "gradient_norm": 0.06721373647451401, + "elapsed": 1000.9520287513733 + }, + { + "step": 3104, + "loss": 0.5988063812255859, + "error": 0.3642578125, + "gradient_norm": 0.05654948577284813, + "elapsed": 1005.7442932128906 + }, + { + "step": 3120, + "loss": 0.4922299385070801, + "error": 0.2470703125, + "gradient_norm": 0.07545466721057892, + "elapsed": 1010.4616096019745 + }, + { + "step": 3136, + "loss": 0.4533671736717224, + "error": 0.236328125, + "gradient_norm": 0.06288722902536392, + "elapsed": 1015.3559956550598 + }, + { + "step": 3152, + "loss": 0.5070517063140869, + "error": 0.2666015625, + "gradient_norm": 0.07274917513132095, + "elapsed": 1020.0764343738556 + }, + { + "step": 3168, + "loss": 0.5999464988708496, + "error": 0.3408203125, + "gradient_norm": 0.05777016654610634, + "elapsed": 1024.9410600662231 + }, + { + "step": 3184, + "loss": 0.5758363008499146, + "error": 0.3427734375, + "gradient_norm": 0.051027461886405945, + "elapsed": 1029.7082171440125 + }, + { + "step": 3200, + "loss": 0.05016190931200981, + "error": 0.017578125, + "gradient_norm": 0.009175656363368034, + "elapsed": 1034.3982915878296 + }, + { + "step": 3216, + "loss": 0.5471057295799255, + "error": 0.318359375, + "gradient_norm": 0.07572721689939499, + "elapsed": 1039.117841243744 + }, + { + "step": 3232, + "loss": 0.4141446352005005, + "error": 0.193359375, + "gradient_norm": 0.10056859254837036, + "elapsed": 1043.880026102066 + }, + { + "step": 3248, + "loss": 0.5812438726425171, + "error": 0.3212890625, + "gradient_norm": 0.05781616270542145, + "elapsed": 1048.6406455039978 + }, + { + "step": 3264, + "loss": 0.19184701144695282, + "error": 0.078125, + "gradient_norm": 0.05367236211895943, + "elapsed": 1053.5672237873077 + }, + { + "step": 3280, + "loss": 0.5420833826065063, + "error": 0.28515625, + "gradient_norm": 0.052405405789613724, + "elapsed": 1058.3841104507446 + }, + { + "step": 3296, + "loss": 0.4419598877429962, + "error": 0.2177734375, + "gradient_norm": 0.05814693495631218, + "elapsed": 1063.1880333423615 + }, + { + "step": 3312, + "loss": 0.4525642991065979, + "error": 0.208984375, + "gradient_norm": 0.1061021164059639, + "elapsed": 1068.1370933055878 + }, + { + "step": 3328, + "loss": 0.32664671540260315, + "error": 0.154296875, + "gradient_norm": 0.05649850144982338, + "elapsed": 1073.1963467597961 + }, + { + "step": 3344, + "loss": 0.2655770182609558, + "error": 0.1220703125, + "gradient_norm": 0.04070372134447098, + "elapsed": 1078.2698318958282 + }, + { + "step": 3360, + "loss": 0.5894330739974976, + "error": 0.3544921875, + "gradient_norm": 0.0643400028347969, + "elapsed": 1083.0184152126312 + }, + { + "step": 3376, + "loss": 0.6118791103363037, + "error": 0.361328125, + "gradient_norm": 0.08537904173135757, + "elapsed": 1087.834038734436 + }, + { + "step": 3392, + "loss": 0.40694907307624817, + "error": 0.19921875, + "gradient_norm": 0.11411692947149277, + "elapsed": 1092.8119947910309 + }, + { + "step": 3408, + "loss": 0.04629015550017357, + "error": 0.0146484375, + "gradient_norm": 0.017204072326421738, + "elapsed": 1097.5751783847809 + }, + { + "step": 3424, + "loss": 0.20639702677726746, + "error": 0.0849609375, + "gradient_norm": 0.04801144450902939, + "elapsed": 1102.2970931529999 + }, + { + "step": 3440, + "loss": 0.6051071286201477, + "error": 0.33984375, + "gradient_norm": 0.045392412692308426, + "elapsed": 1107.1080610752106 + }, + { + "step": 3456, + "loss": 0.6553700566291809, + "error": 0.40625, + "gradient_norm": 0.05593863129615784, + "elapsed": 1111.8409752845764 + }, + { + "step": 3472, + "loss": 0.591402530670166, + "error": 0.3515625, + "gradient_norm": 0.051181379705667496, + "elapsed": 1116.5800333023071 + }, + { + "step": 3488, + "loss": 0.30494624376296997, + "error": 0.12109375, + "gradient_norm": 0.05175542086362839, + "elapsed": 1121.276373386383 + }, + { + "step": 3504, + "loss": 0.5065370798110962, + "error": 0.279296875, + "gradient_norm": 0.10419930517673492, + "elapsed": 1125.9883344173431 + }, + { + "step": 3520, + "loss": 0.3915700614452362, + "error": 0.1953125, + "gradient_norm": 0.060416825115680695, + "elapsed": 1130.7958455085754 + }, + { + "step": 3536, + "loss": 0.624374270439148, + "error": 0.3759765625, + "gradient_norm": 0.06069556251168251, + "elapsed": 1135.5360939502716 + }, + { + "step": 3552, + "loss": 0.5830206274986267, + "error": 0.3359375, + "gradient_norm": 0.046013280749320984, + "elapsed": 1140.312029838562 + }, + { + "step": 3568, + "loss": 0.4201379716396332, + "error": 0.2119140625, + "gradient_norm": 0.06909621506929398, + "elapsed": 1145.0904593467712 + }, + { + "step": 3584, + "loss": 0.28215405344963074, + "error": 0.1181640625, + "gradient_norm": 0.07625982910394669, + "elapsed": 1149.8156151771545 + }, + { + "step": 3600, + "loss": 0.5229164361953735, + "error": 0.275390625, + "gradient_norm": 0.055048178881406784, + "elapsed": 1154.5280592441559 + }, + { + "step": 3616, + "loss": 0.47238075733184814, + "error": 0.2314453125, + "gradient_norm": 0.06473162025213242, + "elapsed": 1159.2720873355865 + }, + { + "step": 3632, + "loss": 0.46245503425598145, + "error": 0.228515625, + "gradient_norm": 0.07382887601852417, + "elapsed": 1164.0119998455048 + }, + { + "step": 3648, + "loss": 0.37509745359420776, + "error": 0.171875, + "gradient_norm": 0.051260266453027725, + "elapsed": 1168.7440350055695 + }, + { + "step": 3664, + "loss": 0.1948484629392624, + "error": 0.080078125, + "gradient_norm": 0.059623416513204575, + "elapsed": 1173.3906588554382 + }, + { + "step": 3680, + "loss": 0.5552756786346436, + "error": 0.3115234375, + "gradient_norm": 0.08073585480451584, + "elapsed": 1178.0645008087158 + }, + { + "step": 3696, + "loss": 0.6405904293060303, + "error": 0.39453125, + "gradient_norm": 0.05899551138281822, + "elapsed": 1182.730489730835 + }, + { + "step": 3712, + "loss": 0.2767012119293213, + "error": 0.119140625, + "gradient_norm": 0.06593579798936844, + "elapsed": 1187.377315044403 + }, + { + "step": 3728, + "loss": 0.315812885761261, + "error": 0.134765625, + "gradient_norm": 0.035905495285987854, + "elapsed": 1192.0582301616669 + }, + { + "step": 3744, + "loss": 0.6033951640129089, + "error": 0.3544921875, + "gradient_norm": 0.05226197466254234, + "elapsed": 1196.7101175785065 + }, + { + "step": 3760, + "loss": 0.5202592611312866, + "error": 0.275390625, + "gradient_norm": 0.06367512047290802, + "elapsed": 1201.3543090820312 + }, + { + "step": 3776, + "loss": 0.24639368057250977, + "error": 0.1083984375, + "gradient_norm": 0.09370873868465424, + "elapsed": 1206.0717165470123 + }, + { + "step": 3792, + "loss": 0.6175658702850342, + "error": 0.375, + "gradient_norm": 0.06221585348248482, + "elapsed": 1210.754029750824 + }, + { + "step": 3808, + "loss": 0.41153696179389954, + "error": 0.2119140625, + "gradient_norm": 0.05355365574359894, + "elapsed": 1215.4374370574951 + }, + { + "step": 3824, + "loss": 0.28002214431762695, + "error": 0.1123046875, + "gradient_norm": 0.03846330568194389, + "elapsed": 1220.1207013130188 + }, + { + "step": 3840, + "loss": 0.0484195351600647, + "error": 0.013671875, + "gradient_norm": 0.03470242768526077, + "elapsed": 1224.8153104782104 + }, + { + "step": 3856, + "loss": 0.1407160609960556, + "error": 0.0458984375, + "gradient_norm": 0.04061700031161308, + "elapsed": 1229.5512235164642 + }, + { + "step": 3872, + "loss": 0.5881794691085815, + "error": 0.3427734375, + "gradient_norm": 0.062013477087020874, + "elapsed": 1234.3750183582306 + }, + { + "step": 3888, + "loss": 0.17833612859249115, + "error": 0.06640625, + "gradient_norm": 0.038856204599142075, + "elapsed": 1239.110375881195 + }, + { + "step": 3904, + "loss": 0.06211477518081665, + "error": 0.0224609375, + "gradient_norm": 0.02150108851492405, + "elapsed": 1243.800644159317 + }, + { + "step": 3920, + "loss": 0.06039723381400108, + "error": 0.01953125, + "gradient_norm": 0.019367367029190063, + "elapsed": 1248.4831748008728 + }, + { + "step": 3936, + "loss": 0.6010214686393738, + "error": 0.3525390625, + "gradient_norm": 0.051659151911735535, + "elapsed": 1253.1423478126526 + }, + { + "step": 3952, + "loss": 0.5867137312889099, + "error": 0.3388671875, + "gradient_norm": 0.058528851717710495, + "elapsed": 1257.9799931049347 + }, + { + "step": 3968, + "loss": 0.5231834650039673, + "error": 0.2578125, + "gradient_norm": 0.10128334909677505, + "elapsed": 1262.6990082263947 + }, + { + "step": 3984, + "loss": 0.6251651644706726, + "error": 0.353515625, + "gradient_norm": 0.06211795285344124, + "elapsed": 1267.4289934635162 + }, + { + "step": 4000, + "loss": 0.06667037308216095, + "error": 0.01953125, + "gradient_norm": 0.048018258064985275, + "elapsed": 1272.132089138031 + }, + { + "step": 4016, + "loss": 0.5286938548088074, + "error": 0.2744140625, + "gradient_norm": 0.05509360507130623, + "elapsed": 1276.8878977298737 + }, + { + "step": 4032, + "loss": 0.34016552567481995, + "error": 0.1591796875, + "gradient_norm": 0.07597329467535019, + "elapsed": 1281.7364926338196 + }, + { + "step": 4048, + "loss": 0.17750494182109833, + "error": 0.078125, + "gradient_norm": 0.06314503401517868, + "elapsed": 1286.5033600330353 + }, + { + "step": 4064, + "loss": 0.5882893800735474, + "error": 0.34375, + "gradient_norm": 0.10986580699682236, + "elapsed": 1291.1944887638092 + }, + { + "step": 4080, + "loss": 0.4923543930053711, + "error": 0.2568359375, + "gradient_norm": 0.050325747579336166, + "elapsed": 1295.9372322559357 + }, + { + "step": 4096, + "loss": 0.44146978855133057, + "error": 0.2236328125, + "gradient_norm": 0.06535191088914871, + "elapsed": 1300.641023159027 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_optimizer_steps": [ + 1024, + 2048, + 3072, + 4096 + ], + "source_training_run": "temporal2", + "source_weights_sha256": { + "1024": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "2048": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "3072": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "4096": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 804757, + "weights": "weights-1024.npz", + "weights_sha256": "0d809362d5afe1dc781f716e3aee1a9bc5a8f75fed6cc0ff6339b9abcf600ada", + "validation": "validation-1024.json", + "complete": true + }, + "2048": { + "step": 2048, + "new_training_shots": 2097152, + "unique_training_rows_seen_in_this_phase": 1293629, + "weights": "weights-2048.npz", + "weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "validation": "validation-2048.json", + "complete": true + }, + "3072": { + "step": 3072, + "new_training_shots": 3145728, + "unique_training_rows_seen_in_this_phase": 1594502, + "weights": "weights-3072.npz", + "weights_sha256": "fabbb42432fb0975023f0a367a366b8db591c6866719b4c7efb85cfe91934c65", + "validation": "validation-3072.json", + "complete": true + }, + "4096": { + "step": 4096, + "new_training_shots": 4194304, + "unique_training_rows_seen_in_this_phase": 1778773, + "weights": "weights-4096.npz", + "weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "validation": "validation-4096.json", + "complete": true + } + }, + "weights_sha256": "ff4595e8f3eb7cfaa8da5a58a31e106d9684c7b8437f330573a1291f19f5777a", + "complete": true + } + }, + "selection": "Predefined last-three and all-four noninitial temporal2 checkpoint means; every validation condition evaluated before group selection", + "test_data_used": false, + "derivation_source_sha256": "b68813c7dab697a554185020c430ef05f1c35bedcda5b85b7d165af75461e914" + }, + "loss": "Binary conditional logical likelihood computed by exact frontier elimination", + "validation_shots_per_condition": 1024, + "uniform_validation": true, + "uniform_validation_seed": 20261028, + "test_data_used": false, + "log": [ + { + "step": 1, + "loss": 0.5063965320587158, + "error": 0.263671875, + "gradient_norm": 0.05583755671977997, + "elapsed": 33.61826181411743 + }, + { + "step": 16, + "loss": 0.5231766700744629, + "error": 0.2822265625, + "gradient_norm": 0.05158894136548042, + "elapsed": 48.65802335739136 + }, + { + "step": 32, + "loss": 0.2955678701400757, + "error": 0.1376953125, + "gradient_norm": 0.0717208981513977, + "elapsed": 64.75103712081909 + }, + { + "step": 48, + "loss": 0.5808531045913696, + "error": 0.337890625, + "gradient_norm": 0.0497879758477211, + "elapsed": 81.12590050697327 + }, + { + "step": 64, + "loss": 0.6466071605682373, + "error": 0.3955078125, + "gradient_norm": 0.05340445786714554, + "elapsed": 97.40131282806396 + }, + { + "step": 80, + "loss": 0.43967077136039734, + "error": 0.2197265625, + "gradient_norm": 0.05488451197743416, + "elapsed": 113.68819904327393 + }, + { + "step": 96, + "loss": 0.3481931686401367, + "error": 0.166015625, + "gradient_norm": 0.08198399841785431, + "elapsed": 129.79422783851624 + }, + { + "step": 112, + "loss": 0.37728914618492126, + "error": 0.177734375, + "gradient_norm": 0.04957005754113197, + "elapsed": 146.01310849189758 + }, + { + "step": 128, + "loss": 0.19336706399917603, + "error": 0.07421875, + "gradient_norm": 0.03228567913174629, + "elapsed": 162.3233504295349 + }, + { + "step": 144, + "loss": 0.05673666670918465, + "error": 0.013671875, + "gradient_norm": 0.010086167603731155, + "elapsed": 178.27910375595093 + }, + { + "step": 160, + "loss": 0.05576886981725693, + "error": 0.0185546875, + "gradient_norm": 0.015833213925361633, + "elapsed": 194.4404194355011 + }, + { + "step": 176, + "loss": 0.6271512508392334, + "error": 0.39453125, + "gradient_norm": 0.0890795886516571, + "elapsed": 210.55058026313782 + }, + { + "step": 192, + "loss": 0.5520341992378235, + "error": 0.2998046875, + "gradient_norm": 0.12568876147270203, + "elapsed": 226.60093927383423 + }, + { + "step": 208, + "loss": 0.5262938737869263, + "error": 0.2822265625, + "gradient_norm": 0.055265434086322784, + "elapsed": 244.85273218154907 + }, + { + "step": 224, + "loss": 0.5956001281738281, + "error": 0.3369140625, + "gradient_norm": 0.06895016878843307, + "elapsed": 264.53393387794495 + }, + { + "step": 240, + "loss": 0.25704875588417053, + "error": 0.1259765625, + "gradient_norm": 0.11300098150968552, + "elapsed": 283.89024353027344 + }, + { + "step": 256, + "loss": 0.6143664121627808, + "error": 0.369140625, + "gradient_norm": 0.05419369786977768, + "elapsed": 300.05279064178467 + }, + { + "step": 272, + "loss": 0.5590812563896179, + "error": 0.294921875, + "gradient_norm": 0.06284675002098083, + "elapsed": 315.92391777038574 + }, + { + "step": 288, + "loss": 0.6163386106491089, + "error": 0.353515625, + "gradient_norm": 0.06826888024806976, + "elapsed": 331.96330738067627 + }, + { + "step": 304, + "loss": 0.6250298619270325, + "error": 0.37890625, + "gradient_norm": 0.0710018053650856, + "elapsed": 348.11866188049316 + }, + { + "step": 320, + "loss": 0.3802686631679535, + "error": 0.1796875, + "gradient_norm": 0.05896822363138199, + "elapsed": 364.3013961315155 + }, + { + "step": 336, + "loss": 0.2594846487045288, + "error": 0.1123046875, + "gradient_norm": 0.0468285046517849, + "elapsed": 380.80411195755005 + }, + { + "step": 352, + "loss": 0.19520026445388794, + "error": 0.076171875, + "gradient_norm": 0.032125141471624374, + "elapsed": 396.8971872329712 + }, + { + "step": 368, + "loss": 0.621718168258667, + "error": 0.37890625, + "gradient_norm": 0.0545712448656559, + "elapsed": 412.920996427536 + }, + { + "step": 384, + "loss": 0.6092393398284912, + "error": 0.349609375, + "gradient_norm": 0.04697328060865402, + "elapsed": 428.92249155044556 + }, + { + "step": 400, + "loss": 0.33656495809555054, + "error": 0.171875, + "gradient_norm": 0.04851065203547478, + "elapsed": 444.8614237308502 + }, + { + "step": 416, + "loss": 0.563441812992096, + "error": 0.302734375, + "gradient_norm": 0.06761237233877182, + "elapsed": 460.89916157722473 + }, + { + "step": 432, + "loss": 0.41032207012176514, + "error": 0.205078125, + "gradient_norm": 0.07552587240934372, + "elapsed": 476.91754388809204 + }, + { + "step": 448, + "loss": 0.6176105737686157, + "error": 0.3583984375, + "gradient_norm": 0.03991354629397392, + "elapsed": 492.909494638443 + }, + { + "step": 464, + "loss": 0.47970300912857056, + "error": 0.26171875, + "gradient_norm": 0.08514834195375443, + "elapsed": 508.9842050075531 + }, + { + "step": 480, + "loss": 0.6145294904708862, + "error": 0.3779296875, + "gradient_norm": 0.04053078964352608, + "elapsed": 525.0681574344635 + }, + { + "step": 496, + "loss": 0.5232605934143066, + "error": 0.28125, + "gradient_norm": 0.07535209506750107, + "elapsed": 541.048586845398 + }, + { + "step": 512, + "loss": 0.06574343144893646, + "error": 0.01953125, + "gradient_norm": 0.038100212812423706, + "elapsed": 557.0923149585724 + }, + { + "step": 528, + "loss": 0.052529145032167435, + "error": 0.021484375, + "gradient_norm": 0.017167840152978897, + "elapsed": 588.7646441459656 + }, + { + "step": 544, + "loss": 0.5886420011520386, + "error": 0.3447265625, + "gradient_norm": 0.04695608466863632, + "elapsed": 607.2257866859436 + }, + { + "step": 560, + "loss": 0.6055985689163208, + "error": 0.3466796875, + "gradient_norm": 0.032950498163700104, + "elapsed": 625.9134004116058 + }, + { + "step": 576, + "loss": 0.4632350206375122, + "error": 0.2431640625, + "gradient_norm": 0.07214360684156418, + "elapsed": 642.5683023929596 + }, + { + "step": 592, + "loss": 0.5995157361030579, + "error": 0.33984375, + "gradient_norm": 0.05927892401814461, + "elapsed": 659.0285487174988 + }, + { + "step": 608, + "loss": 0.2751845121383667, + "error": 0.1171875, + "gradient_norm": 0.06076137721538544, + "elapsed": 675.2659955024719 + }, + { + "step": 624, + "loss": 0.0518009215593338, + "error": 0.0205078125, + "gradient_norm": 0.017002176493406296, + "elapsed": 691.3256914615631 + }, + { + "step": 640, + "loss": 0.6293823719024658, + "error": 0.4013671875, + "gradient_norm": 0.07381543517112732, + "elapsed": 707.3796145915985 + }, + { + "step": 656, + "loss": 0.2956032454967499, + "error": 0.126953125, + "gradient_norm": 0.06658996641635895, + "elapsed": 723.4796185493469 + }, + { + "step": 672, + "loss": 0.5275129079818726, + "error": 0.28125, + "gradient_norm": 0.0742238238453865, + "elapsed": 739.52592253685 + }, + { + "step": 688, + "loss": 0.48426946997642517, + "error": 0.251953125, + "gradient_norm": 0.08587855845689774, + "elapsed": 755.599978685379 + }, + { + "step": 704, + "loss": 0.5284034013748169, + "error": 0.298828125, + "gradient_norm": 0.07507473230361938, + "elapsed": 771.6798233985901 + }, + { + "step": 720, + "loss": 0.45124661922454834, + "error": 0.2333984375, + "gradient_norm": 0.040898919105529785, + "elapsed": 787.8532867431641 + }, + { + "step": 736, + "loss": 0.04965062811970711, + "error": 0.0146484375, + "gradient_norm": 0.013609266839921474, + "elapsed": 804.1182470321655 + }, + { + "step": 752, + "loss": 0.04790960252285004, + "error": 0.01171875, + "gradient_norm": 0.01157061941921711, + "elapsed": 820.3099284172058 + }, + { + "step": 768, + "loss": 0.046329010277986526, + "error": 0.0146484375, + "gradient_norm": 0.013687756843864918, + "elapsed": 836.2443821430206 + }, + { + "step": 784, + "loss": 0.20798391103744507, + "error": 0.0830078125, + "gradient_norm": 0.10879658162593842, + "elapsed": 853.994068145752 + }, + { + "step": 800, + "loss": 0.3236527144908905, + "error": 0.1494140625, + "gradient_norm": 0.04277466610074043, + "elapsed": 872.6724886894226 + }, + { + "step": 816, + "loss": 0.5978351831436157, + "error": 0.3310546875, + "gradient_norm": 0.09687308222055435, + "elapsed": 890.0722959041595 + }, + { + "step": 832, + "loss": 0.5914890766143799, + "error": 0.3515625, + "gradient_norm": 0.05389918386936188, + "elapsed": 907.574702501297 + }, + { + "step": 848, + "loss": 0.3500230312347412, + "error": 0.154296875, + "gradient_norm": 0.05182121321558952, + "elapsed": 925.516667842865 + }, + { + "step": 864, + "loss": 0.3173527717590332, + "error": 0.126953125, + "gradient_norm": 0.10333289951086044, + "elapsed": 943.2102818489075 + }, + { + "step": 880, + "loss": 0.6407152414321899, + "error": 0.41015625, + "gradient_norm": 0.03933756425976753, + "elapsed": 960.0137810707092 + }, + { + "step": 896, + "loss": 0.3448338210582733, + "error": 0.1591796875, + "gradient_norm": 0.048397257924079895, + "elapsed": 976.2672023773193 + }, + { + "step": 912, + "loss": 0.2199687361717224, + "error": 0.0830078125, + "gradient_norm": 0.11513829976320267, + "elapsed": 992.4728758335114 + }, + { + "step": 928, + "loss": 0.16880497336387634, + "error": 0.072265625, + "gradient_norm": 0.031767718493938446, + "elapsed": 1008.5988037586212 + }, + { + "step": 944, + "loss": 0.053500816226005554, + "error": 0.017578125, + "gradient_norm": 0.014627245254814625, + "elapsed": 1024.7008044719696 + }, + { + "step": 960, + "loss": 0.5974152684211731, + "error": 0.341796875, + "gradient_norm": 0.09594274312257767, + "elapsed": 1040.908540725708 + }, + { + "step": 976, + "loss": 0.34772756695747375, + "error": 0.1572265625, + "gradient_norm": 0.04134370759129524, + "elapsed": 1056.9926254749298 + }, + { + "step": 992, + "loss": 0.4953954815864563, + "error": 0.2744140625, + "gradient_norm": 0.09671331197023392, + "elapsed": 1073.0582761764526 + }, + { + "step": 1008, + "loss": 0.6424463987350464, + "error": 0.4013671875, + "gradient_norm": 0.13621115684509277, + "elapsed": 1089.2002465724945 + }, + { + "step": 1024, + "loss": 0.1914748251438141, + "error": 0.0771484375, + "gradient_norm": 0.05097605288028717, + "elapsed": 1105.341599225998 + } + ], + "condition_mixing_plan": { + "hypothesis": "Mixing uniformly sampled geometry/basis/duration conditions in each gradient update reduces condition-gradient fluctuations", + "parent": "temporal2_swa/weights-mean3.npz", + "new_random_parameter_initializations": 0, + "sampling_seed": 20261190, + "arms": [ + "same", + "mixed" + ], + "microbatches_per_update": 4, + "microbatch_size": 256, + "effective_batch_size": 1024, + "optimizer_updates": 1024, + "learning_rate": 0.00025, + "optimizer": "Fresh AdamW state, weight decay1e-4, global gradient norm clip1 after averaging gradients", + "sampling_control": "Both arms draw four condition indices then four256-row batches per update. Same arm reuses the first condition index; mixed uses all four. Equal-sized condition pools make RNG states identical.", + "training": "All104 d3 conditions and all supplied training rows eligible;1,048,576 training draws in each arm", + "selection": "Full validation checkpoints512/1024, per-group mean across all13 durations; raw or equal blend with recorded small contextual reference; incumbent retained on ties", + "test_data_used": false + }, + "accumulation_numerical_control": { + "status": "passed", + "device": "cpu", + "condition": "surface_code_bZ_d3_r13_center_5_7", + "parent_checkpoint_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "trainer_source_sha256": "9f672468a8b72966b3aa04fd22e5d40b47b0768f1c802c267a1da08244c4323b", + "gradient_relative_l2_difference": 1.0312139158546257e-06, + "maximum_gradient_difference": 4.023313522338867e-07, + "mean_loss_difference": 0.0, + "maximum_optimizer_update_difference": 1.0697840480133891e-06, + "matched_rng_state_after_1024_updates": true, + "precision_audit": { + "float64_full_vs_accumulated_gradient_relative_l2": 2.4022986924332267e-15, + "float64_full_vs_accumulated_update_maximum_difference": 1.6631390275384517e-15, + "float32_full_gradient_relative_l2_vs_float64": 1.1454018534911662e-06, + "float32_accumulated_gradient_relative_l2_vs_float64": 9.16593382832008e-07, + "float32_full_update_maximum_difference_vs_float64": 6.5271394129382524e-06, + "float32_accumulated_update_maximum_difference_vs_float64": 7.5969234609516415e-06, + "initial_failed_check": { + "maximum_float32_update_difference": 1.0697840480133891e-06, + "original_tolerance": 1e-06 + }, + "interpretation": "Float64 audit checks accumulation algebra independently of float32 reduction rounding and first-Adam-step sensitivity near zero gradients. Original failure is retained; production model/gradient precision and optimizer are unchanged." + }, + "training_draws_each_arm": 1048576, + "draws_by_condition": { + "same": [ + 17408, + 14336, + 12288, + 14336, + 7168, + 10240, + 8192, + 7168, + 9216, + 11264, + 14336, + 7168, + 5120, + 9216, + 7168, + 8192, + 8192, + 10240, + 7168, + 10240, + 11264, + 14336, + 15360, + 10240, + 8192, + 11264, + 11264, + 17408, + 11264, + 15360, + 10240, + 17408, + 7168, + 13312, + 5120, + 13312, + 4096, + 8192, + 10240, + 8192, + 8192, + 5120, + 10240, + 11264, + 16384, + 13312, + 9216, + 9216, + 14336, + 8192, + 10240, + 10240, + 3072, + 8192, + 11264, + 12288, + 5120, + 4096, + 7168, + 9216, + 5120, + 14336, + 8192, + 9216, + 15360, + 6144, + 16384, + 5120, + 10240, + 10240, + 11264, + 11264, + 7168, + 6144, + 8192, + 11264, + 8192, + 14336, + 8192, + 10240, + 13312, + 15360, + 18432, + 4096, + 8192, + 8192, + 15360, + 10240, + 7168, + 12288, + 7168, + 12288, + 12288, + 8192, + 16384, + 9216, + 11264, + 6144, + 8192, + 7168, + 7168, + 12288, + 5120, + 8192 + ], + "mixed": [ + 14336, + 9472, + 8448, + 12032, + 8960, + 11776, + 9984, + 8448, + 9216, + 11264, + 12288, + 11008, + 7936, + 11008, + 9984, + 8448, + 11776, + 9984, + 9984, + 10752, + 8448, + 9984, + 9728, + 10240, + 8704, + 8448, + 8192, + 10496, + 8704, + 11008, + 9984, + 13824, + 8960, + 11264, + 9984, + 11008, + 13824, + 11264, + 9984, + 9216, + 9472, + 11008, + 9472, + 11776, + 12800, + 10240, + 8192, + 8192, + 9728, + 11008, + 8960, + 11264, + 8704, + 10496, + 10240, + 11776, + 7936, + 9216, + 9472, + 10752, + 8448, + 12288, + 9216, + 9728, + 11008, + 9472, + 11008, + 10240, + 8704, + 8448, + 9216, + 9728, + 9728, + 8960, + 10496, + 11520, + 9216, + 8704, + 6400, + 12032, + 11008, + 12288, + 12288, + 7936, + 10752, + 7936, + 12032, + 9216, + 8448, + 9472, + 9472, + 10752, + 10752, + 10752, + 12800, + 10496, + 10496, + 12032, + 8448, + 8960, + 7680, + 9472, + 11008, + 8448 + ] + }, + "scope": "Numerical and sampling controls only. All gradient/update probes are discarded; no trained candidate checkpoint or validation score is produced.", + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/condition_same1", + "selected_checkpoint_steps": [ + "1024", + "512" + ], + "checkpoint_records": { + "512": { + "step": 512, + "new_training_shots": 524288, + "unique_training_rows_seen_in_this_phase": 451734, + "weights": "weights-512.npz", + "weights_sha256": "4cf3ebae65f19ed882d90aac2157db4127d715f9c688c987280c9aac28efad84", + "validation": "validation-512.json", + "complete": true + }, + "1024": { + "step": 1024, + "new_training_shots": 1048576, + "unique_training_rows_seen_in_this_phase": 803777, + "weights": "weights-1024.npz", + "weights_sha256": "c515815d285cc2eafe52d8ced2df1c754ac578ba54786b98770e15238dc4eaad", + "validation": "validation-1024.json", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure per group among incumbent and listed session-trained checkpoints; when listed, blend candidates average the recorded small-contextual reference and new probabilities equally", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24451622596153846, + "512": 0.24528245192307693, + "1024": 0.24529747596153847, + "blend-512": 0.24562800480769229, + "blend-1024": 0.24574819711538462 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2527794471153846, + "512": 0.25326021634615387, + "1024": 0.252734375, + "blend-512": 0.2533954326923077, + "blend-1024": 0.25307992788461536 + }, + "selected": "1024" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.23366887019230773, + "512": 0.23359375, + "1024": 0.2334435096153846, + "blend-512": 0.23426983173076926, + "blend-1024": 0.23384915865384612 + }, + "selected": "1024" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23889723557692305, + "512": 0.23933293269230774, + "1024": 0.23951322115384613, + "blend-512": 0.23915264423076918, + "blend-1024": 0.239453125 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.2446213942307692, + "512": 0.2444561298076923, + "1024": 0.24489182692307693, + "blend-512": 0.24508713942307692, + "blend-1024": 0.24568810096153845 + }, + "selected": "512" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23652343749999996, + "512": 0.23765024038461538, + "1024": 0.2379206730769231, + "blend-512": 0.23787560096153845, + "blend-1024": 0.23759014423076924 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.2356670673076923, + "512": 0.23619290865384618, + "1024": 0.23629807692307692, + "blend-512": 0.23610276442307693, + "blend-1024": 0.23593750000000002 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23294771634615385, + "512": 0.23398437499999997, + "1024": 0.23342848557692308, + "blend-512": 0.2337590144230769, + "blend-1024": 0.2334435096153846 + }, + "selected": "incumbent" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23228665865384618 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998 + }, + "selected": "incumbent" + } + ] + }, + { + "name": "group_specialize1", + "training_run": { + "experiment": "group-specific d3 continuation", + "groups": { + "d3_bX_center_3_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_3_5", + "parent_model": { + "weights": "weights/contextual-temporal2_swa-mean3.npz", + "training_checkpoint": "temporal2_swa/mean3" + }, + "parent_weights_sha256": "a61fb22f803b795c2a39b6c19dc3a368d536cb21419ba773778601b28e4403fe", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162496, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 11586, + "surface_code_bX_d3_r03_center_3_5": 13164, + "surface_code_bX_d3_r05_center_3_5": 14692, + "surface_code_bX_d3_r07_center_3_5": 12423, + "surface_code_bX_d3_r09_center_3_5": 13507, + "surface_code_bX_d3_r11_center_3_5": 9165, + "surface_code_bX_d3_r13_center_3_5": 14569, + "surface_code_bX_d3_r15_center_3_5": 11563, + "surface_code_bX_d3_r17_center_3_5": 14132, + "surface_code_bX_d3_r19_center_3_5": 9704, + "surface_code_bX_d3_r21_center_3_5": 12014, + "surface_code_bX_d3_r23_center_3_5": 13117, + "surface_code_bX_d3_r25_center_3_5": 12860 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261200, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_3_5", + "step": 1, + "loss": 0.5817165970802307, + "error": 0.3388671875, + "gradient_norm": 0.07810031622648239, + "elapsed": 23.888731479644775 + }, + { + "group": "d3_bX_center_3_5", + "step": 16, + "loss": 0.43716299533843994, + "error": 0.2177734375, + "gradient_norm": 0.05689458176493645, + "elapsed": 28.204753398895264 + }, + { + "group": "d3_bX_center_3_5", + "step": 32, + "loss": 0.44627559185028076, + "error": 0.208984375, + "gradient_norm": 0.056756604462862015, + "elapsed": 32.84233617782593 + }, + { + "group": "d3_bX_center_3_5", + "step": 48, + "loss": 0.4319554567337036, + "error": 0.234375, + "gradient_norm": 0.05750993266701698, + "elapsed": 37.434494495391846 + }, + { + "group": "d3_bX_center_3_5", + "step": 64, + "loss": 0.2955609858036041, + "error": 0.1279296875, + "gradient_norm": 0.07982950657606125, + "elapsed": 42.03733849525452 + }, + { + "group": "d3_bX_center_3_5", + "step": 80, + "loss": 0.051099054515361786, + "error": 0.01953125, + "gradient_norm": 0.01472504436969757, + "elapsed": 46.64323449134827 + }, + { + "group": "d3_bX_center_3_5", + "step": 96, + "loss": 0.3553770184516907, + "error": 0.1767578125, + "gradient_norm": 0.04556305333971977, + "elapsed": 51.289584159851074 + }, + { + "group": "d3_bX_center_3_5", + "step": 112, + "loss": 0.49853652715682983, + "error": 0.255859375, + "gradient_norm": 0.05837372690439224, + "elapsed": 55.921807527542114 + }, + { + "group": "d3_bX_center_3_5", + "step": 128, + "loss": 0.6128357648849487, + "error": 0.3759765625, + "gradient_norm": 0.04268687590956688, + "elapsed": 60.54293370246887 + }, + { + "group": "d3_bX_center_3_5", + "step": 144, + "loss": 0.40158310532569885, + "error": 0.2109375, + "gradient_norm": 0.06899380683898926, + "elapsed": 66.70903372764587 + }, + { + "group": "d3_bX_center_3_5", + "step": 160, + "loss": 0.6189148426055908, + "error": 0.369140625, + "gradient_norm": 0.049649614840745926, + "elapsed": 71.31301522254944 + }, + { + "group": "d3_bX_center_3_5", + "step": 176, + "loss": 0.5736979246139526, + "error": 0.3271484375, + "gradient_norm": 0.06365907937288284, + "elapsed": 75.90330648422241 + }, + { + "group": "d3_bX_center_3_5", + "step": 192, + "loss": 0.5324695706367493, + "error": 0.294921875, + "gradient_norm": 0.05174271762371063, + "elapsed": 80.51115894317627 + }, + { + "group": "d3_bX_center_3_5", + "step": 208, + "loss": 0.6137855052947998, + "error": 0.3623046875, + "gradient_norm": 0.04891493543982506, + "elapsed": 85.1122133731842 + }, + { + "group": "d3_bX_center_3_5", + "step": 224, + "loss": 0.6262054443359375, + "error": 0.400390625, + "gradient_norm": 0.0478600338101387, + "elapsed": 89.77170705795288 + }, + { + "group": "d3_bX_center_3_5", + "step": 240, + "loss": 0.5114355087280273, + "error": 0.2802734375, + "gradient_norm": 0.06124471500515938, + "elapsed": 94.34836196899414 + }, + { + "group": "d3_bX_center_3_5", + "step": 256, + "loss": 0.3812999129295349, + "error": 0.181640625, + "gradient_norm": 0.050427597016096115, + "elapsed": 98.88006901741028 + } + ] + }, + "d3_bX_center_5_3": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_5_3", + "parent_model": { + "weights": "weights/contextual-condition_same1-1024.npz", + "training_checkpoint": "condition_same1/1024" + }, + "parent_weights_sha256": "c515815d285cc2eafe52d8ced2df1c754ac578ba54786b98770e15238dc4eaad", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 161233, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_3": 11129, + "surface_code_bX_d3_r03_center_5_3": 15369, + "surface_code_bX_d3_r05_center_5_3": 14677, + "surface_code_bX_d3_r07_center_5_3": 9707, + "surface_code_bX_d3_r09_center_5_3": 11152, + "surface_code_bX_d3_r11_center_5_3": 12800, + "surface_code_bX_d3_r13_center_5_3": 13443, + "surface_code_bX_d3_r15_center_5_3": 12388, + "surface_code_bX_d3_r17_center_5_3": 15158, + "surface_code_bX_d3_r19_center_5_3": 10218, + "surface_code_bX_d3_r21_center_5_3": 10711, + "surface_code_bX_d3_r23_center_5_3": 13773, + "surface_code_bX_d3_r25_center_5_3": 10708 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261201, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_5_3", + "step": 1, + "loss": 0.4805193245410919, + "error": 0.2578125, + "gradient_norm": 0.05444623902440071, + "elapsed": 102.3664813041687 + }, + { + "group": "d3_bX_center_5_3", + "step": 16, + "loss": 0.2784017324447632, + "error": 0.11328125, + "gradient_norm": 0.08824625611305237, + "elapsed": 106.75308656692505 + }, + { + "group": "d3_bX_center_5_3", + "step": 32, + "loss": 0.6410393118858337, + "error": 0.412109375, + "gradient_norm": 0.03859763592481613, + "elapsed": 111.4091112613678 + }, + { + "group": "d3_bX_center_5_3", + "step": 48, + "loss": 0.42605704069137573, + "error": 0.2099609375, + "gradient_norm": 0.050592850893735886, + "elapsed": 116.04315447807312 + }, + { + "group": "d3_bX_center_5_3", + "step": 64, + "loss": 0.5663277506828308, + "error": 0.298828125, + "gradient_norm": 0.055698245763778687, + "elapsed": 120.68257761001587 + }, + { + "group": "d3_bX_center_5_3", + "step": 80, + "loss": 0.6572779417037964, + "error": 0.4267578125, + "gradient_norm": 0.07223570346832275, + "elapsed": 125.41016721725464 + }, + { + "group": "d3_bX_center_5_3", + "step": 96, + "loss": 0.5440086126327515, + "error": 0.2998046875, + "gradient_norm": 0.08954599499702454, + "elapsed": 130.22392392158508 + }, + { + "group": "d3_bX_center_5_3", + "step": 112, + "loss": 0.5094837546348572, + "error": 0.2548828125, + "gradient_norm": 0.06551362574100494, + "elapsed": 134.7945008277893 + }, + { + "group": "d3_bX_center_5_3", + "step": 128, + "loss": 0.5803394317626953, + "error": 0.3193359375, + "gradient_norm": 0.06082230061292648, + "elapsed": 139.35728001594543 + }, + { + "group": "d3_bX_center_5_3", + "step": 144, + "loss": 0.616602897644043, + "error": 0.375, + "gradient_norm": 0.050001099705696106, + "elapsed": 145.55171418190002 + }, + { + "group": "d3_bX_center_5_3", + "step": 160, + "loss": 0.5520708560943604, + "error": 0.2880859375, + "gradient_norm": 0.06085196137428284, + "elapsed": 150.15428566932678 + }, + { + "group": "d3_bX_center_5_3", + "step": 176, + "loss": 0.6117234230041504, + "error": 0.3740234375, + "gradient_norm": 0.0825766772031784, + "elapsed": 154.74532389640808 + }, + { + "group": "d3_bX_center_5_3", + "step": 192, + "loss": 0.5692043304443359, + "error": 0.3203125, + "gradient_norm": 0.07800327241420746, + "elapsed": 159.3635880947113 + }, + { + "group": "d3_bX_center_5_3", + "step": 208, + "loss": 0.30638742446899414, + "error": 0.130859375, + "gradient_norm": 0.049805574119091034, + "elapsed": 163.99608540534973 + }, + { + "group": "d3_bX_center_5_3", + "step": 224, + "loss": 0.5141903758049011, + "error": 0.28515625, + "gradient_norm": 0.06405262649059296, + "elapsed": 168.6415627002716 + }, + { + "group": "d3_bX_center_5_3", + "step": 240, + "loss": 0.5797978639602661, + "error": 0.34765625, + "gradient_norm": 0.10031016170978546, + "elapsed": 173.26013374328613 + }, + { + "group": "d3_bX_center_5_3", + "step": 256, + "loss": 0.2809719741344452, + "error": 0.12890625, + "gradient_norm": 0.04573458060622215, + "elapsed": 177.8879518508911 + } + ] + }, + "d3_bX_center_5_7": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_5_7", + "parent_model": { + "weights": "weights/contextual-condition_same1-1024.npz", + "training_checkpoint": "condition_same1/1024" + }, + "parent_weights_sha256": "c515815d285cc2eafe52d8ced2df1c754ac578ba54786b98770e15238dc4eaad", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162612, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_7": 13532, + "surface_code_bX_d3_r03_center_5_7": 12060, + "surface_code_bX_d3_r05_center_5_7": 14744, + "surface_code_bX_d3_r07_center_5_7": 11642, + "surface_code_bX_d3_r09_center_5_7": 13167, + "surface_code_bX_d3_r11_center_5_7": 8639, + "surface_code_bX_d3_r13_center_5_7": 14627, + "surface_code_bX_d3_r15_center_5_7": 11178, + "surface_code_bX_d3_r17_center_5_7": 10160, + "surface_code_bX_d3_r19_center_5_7": 13125, + "surface_code_bX_d3_r21_center_5_7": 13464, + "surface_code_bX_d3_r23_center_5_7": 13143, + "surface_code_bX_d3_r25_center_5_7": 13131 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261202, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_5_7", + "step": 1, + "loss": 0.18060244619846344, + "error": 0.0712890625, + "gradient_norm": 0.035179879516363144, + "elapsed": 181.32161450386047 + }, + { + "group": "d3_bX_center_5_7", + "step": 16, + "loss": 0.5082811117172241, + "error": 0.2705078125, + "gradient_norm": 0.07098715752363205, + "elapsed": 185.63990426063538 + }, + { + "group": "d3_bX_center_5_7", + "step": 32, + "loss": 0.5253040790557861, + "error": 0.2880859375, + "gradient_norm": 0.16328570246696472, + "elapsed": 190.24219703674316 + }, + { + "group": "d3_bX_center_5_7", + "step": 48, + "loss": 0.631301760673523, + "error": 0.3994140625, + "gradient_norm": 0.057355962693691254, + "elapsed": 194.84725713729858 + }, + { + "group": "d3_bX_center_5_7", + "step": 64, + "loss": 0.27920418977737427, + "error": 0.1240234375, + "gradient_norm": 0.06183589994907379, + "elapsed": 199.47137212753296 + }, + { + "group": "d3_bX_center_5_7", + "step": 80, + "loss": 0.611309289932251, + "error": 0.3544921875, + "gradient_norm": 0.07737621665000916, + "elapsed": 204.0849051475525 + }, + { + "group": "d3_bX_center_5_7", + "step": 96, + "loss": 0.2803115248680115, + "error": 0.1279296875, + "gradient_norm": 0.05086443945765495, + "elapsed": 208.7057957649231 + }, + { + "group": "d3_bX_center_5_7", + "step": 112, + "loss": 0.5856442451477051, + "error": 0.330078125, + "gradient_norm": 0.09568645805120468, + "elapsed": 213.3731656074524 + }, + { + "group": "d3_bX_center_5_7", + "step": 128, + "loss": 0.6120781898498535, + "error": 0.3486328125, + "gradient_norm": 0.07464266568422318, + "elapsed": 218.0141613483429 + }, + { + "group": "d3_bX_center_5_7", + "step": 144, + "loss": 0.4921022355556488, + "error": 0.24609375, + "gradient_norm": 0.04171774536371231, + "elapsed": 224.291086435318 + }, + { + "group": "d3_bX_center_5_7", + "step": 160, + "loss": 0.6169480085372925, + "error": 0.375, + "gradient_norm": 0.06097063049674034, + "elapsed": 229.43670320510864 + }, + { + "group": "d3_bX_center_5_7", + "step": 176, + "loss": 0.6014459729194641, + "error": 0.3720703125, + "gradient_norm": 0.049403320997953415, + "elapsed": 235.6041157245636 + }, + { + "group": "d3_bX_center_5_7", + "step": 192, + "loss": 0.5643549561500549, + "error": 0.3076171875, + "gradient_norm": 0.034399617463350296, + "elapsed": 242.02996158599854 + }, + { + "group": "d3_bX_center_5_7", + "step": 208, + "loss": 0.04667453467845917, + "error": 0.0146484375, + "gradient_norm": 0.021298106759786606, + "elapsed": 247.37174129486084 + }, + { + "group": "d3_bX_center_5_7", + "step": 224, + "loss": 0.5067787170410156, + "error": 0.2607421875, + "gradient_norm": 0.056687332689762115, + "elapsed": 251.9976110458374 + }, + { + "group": "d3_bX_center_5_7", + "step": 240, + "loss": 0.42991048097610474, + "error": 0.2255859375, + "gradient_norm": 0.061536215245723724, + "elapsed": 256.75613379478455 + }, + { + "group": "d3_bX_center_5_7", + "step": 256, + "loss": 0.47317343950271606, + "error": 0.2529296875, + "gradient_norm": 0.060076676309108734, + "elapsed": 261.4124813079834 + } + ] + }, + "d3_bX_center_7_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bX_center_7_5", + "parent_model": { + "weights": "weights/contextual-temporal2-2048.npz", + "training_checkpoint": "temporal2/2048", + "blend_contextual": true + }, + "parent_weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162880, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_7_5": 13450, + "surface_code_bX_d3_r03_center_7_5": 11109, + "surface_code_bX_d3_r05_center_7_5": 14012, + "surface_code_bX_d3_r07_center_7_5": 13898, + "surface_code_bX_d3_r09_center_7_5": 12398, + "surface_code_bX_d3_r11_center_7_5": 9664, + "surface_code_bX_d3_r13_center_7_5": 11550, + "surface_code_bX_d3_r15_center_7_5": 12809, + "surface_code_bX_d3_r17_center_7_5": 10673, + "surface_code_bX_d3_r19_center_7_5": 13751, + "surface_code_bX_d3_r21_center_7_5": 13442, + "surface_code_bX_d3_r23_center_7_5": 13774, + "surface_code_bX_d3_r25_center_7_5": 12350 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261203, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bX_center_7_5", + "step": 1, + "loss": 0.6286593675613403, + "error": 0.3916015625, + "gradient_norm": 0.048550695180892944, + "elapsed": 264.77757954597473 + }, + { + "group": "d3_bX_center_7_5", + "step": 16, + "loss": 0.5998052954673767, + "error": 0.3564453125, + "gradient_norm": 0.04667327180504799, + "elapsed": 269.1457931995392 + }, + { + "group": "d3_bX_center_7_5", + "step": 32, + "loss": 0.6372991800308228, + "error": 0.3984375, + "gradient_norm": 0.03931272402405739, + "elapsed": 273.81044721603394 + }, + { + "group": "d3_bX_center_7_5", + "step": 48, + "loss": 0.32325083017349243, + "error": 0.1455078125, + "gradient_norm": 0.053585249930620193, + "elapsed": 278.48719453811646 + }, + { + "group": "d3_bX_center_7_5", + "step": 64, + "loss": 0.6184052228927612, + "error": 0.3974609375, + "gradient_norm": 0.04405878111720085, + "elapsed": 283.16093349456787 + }, + { + "group": "d3_bX_center_7_5", + "step": 80, + "loss": 0.30300217866897583, + "error": 0.1318359375, + "gradient_norm": 0.03475452959537506, + "elapsed": 287.8628993034363 + }, + { + "group": "d3_bX_center_7_5", + "step": 96, + "loss": 0.4532725214958191, + "error": 0.23828125, + "gradient_norm": 0.053579334169626236, + "elapsed": 292.54087567329407 + }, + { + "group": "d3_bX_center_7_5", + "step": 112, + "loss": 0.5722991824150085, + "error": 0.333984375, + "gradient_norm": 0.05200285091996193, + "elapsed": 297.2698106765747 + }, + { + "group": "d3_bX_center_7_5", + "step": 128, + "loss": 0.47720301151275635, + "error": 0.248046875, + "gradient_norm": 0.08435481041669846, + "elapsed": 301.9647386074066 + }, + { + "group": "d3_bX_center_7_5", + "step": 144, + "loss": 0.49832063913345337, + "error": 0.2666015625, + "gradient_norm": 0.06509781628847122, + "elapsed": 308.208101272583 + }, + { + "group": "d3_bX_center_7_5", + "step": 160, + "loss": 0.05153600126504898, + "error": 0.015625, + "gradient_norm": 0.018944455310702324, + "elapsed": 312.88946986198425 + }, + { + "group": "d3_bX_center_7_5", + "step": 176, + "loss": 0.3049379885196686, + "error": 0.1376953125, + "gradient_norm": 0.03572608530521393, + "elapsed": 317.5962097644806 + }, + { + "group": "d3_bX_center_7_5", + "step": 192, + "loss": 0.4833422899246216, + "error": 0.2275390625, + "gradient_norm": 0.11588290333747864, + "elapsed": 322.2771329879761 + }, + { + "group": "d3_bX_center_7_5", + "step": 208, + "loss": 0.5812653303146362, + "error": 0.34765625, + "gradient_norm": 0.04924288019537926, + "elapsed": 326.9544439315796 + }, + { + "group": "d3_bX_center_7_5", + "step": 224, + "loss": 0.5518968105316162, + "error": 0.2919921875, + "gradient_norm": 0.049676258116960526, + "elapsed": 331.7683095932007 + }, + { + "group": "d3_bX_center_7_5", + "step": 240, + "loss": 0.599678099155426, + "error": 0.353515625, + "gradient_norm": 0.09019427001476288, + "elapsed": 337.0053963661194 + }, + { + "group": "d3_bX_center_7_5", + "step": 256, + "loss": 0.6168051362037659, + "error": 0.373046875, + "gradient_norm": 0.045873139053583145, + "elapsed": 342.27088832855225 + } + ] + }, + "d3_bZ_center_3_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_3_5", + "parent_model": { + "weights": "weights/contextual-condition_same1-512.npz", + "training_checkpoint": "condition_same1/512" + }, + "parent_weights_sha256": "4cf3ebae65f19ed882d90aac2157db4127d715f9c688c987280c9aac28efad84", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162257, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_3_5": 13149, + "surface_code_bZ_d3_r03_center_3_5": 12112, + "surface_code_bZ_d3_r05_center_3_5": 12434, + "surface_code_bZ_d3_r07_center_3_5": 13778, + "surface_code_bZ_d3_r09_center_3_5": 12830, + "surface_code_bZ_d3_r11_center_3_5": 6034, + "surface_code_bZ_d3_r13_center_3_5": 13524, + "surface_code_bZ_d3_r15_center_3_5": 13160, + "surface_code_bZ_d3_r17_center_3_5": 12823, + "surface_code_bZ_d3_r19_center_3_5": 11129, + "surface_code_bZ_d3_r21_center_3_5": 13793, + "surface_code_bZ_d3_r23_center_3_5": 14080, + "surface_code_bZ_d3_r25_center_3_5": 13411 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261204, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_3_5", + "step": 1, + "loss": 0.36515435576438904, + "error": 0.17578125, + "gradient_norm": 0.068653903901577, + "elapsed": 346.68829584121704 + }, + { + "group": "d3_bZ_center_3_5", + "step": 16, + "loss": 0.2806941568851471, + "error": 0.1318359375, + "gradient_norm": 0.06498919427394867, + "elapsed": 352.6486053466797 + }, + { + "group": "d3_bZ_center_3_5", + "step": 32, + "loss": 0.5172728300094604, + "error": 0.2578125, + "gradient_norm": 0.06919123977422714, + "elapsed": 358.0916488170624 + }, + { + "group": "d3_bZ_center_3_5", + "step": 48, + "loss": 0.5654157400131226, + "error": 0.3134765625, + "gradient_norm": 0.062110695987939835, + "elapsed": 364.1197271347046 + }, + { + "group": "d3_bZ_center_3_5", + "step": 64, + "loss": 0.5950935482978821, + "error": 0.349609375, + "gradient_norm": 0.06901932507753372, + "elapsed": 370.44589829444885 + }, + { + "group": "d3_bZ_center_3_5", + "step": 80, + "loss": 0.3655591607093811, + "error": 0.1865234375, + "gradient_norm": 0.06035780534148216, + "elapsed": 376.3442976474762 + }, + { + "group": "d3_bZ_center_3_5", + "step": 96, + "loss": 0.5849340558052063, + "error": 0.345703125, + "gradient_norm": 0.0669141560792923, + "elapsed": 381.8527054786682 + }, + { + "group": "d3_bZ_center_3_5", + "step": 112, + "loss": 0.04215944558382034, + "error": 0.013671875, + "gradient_norm": 0.029389331117272377, + "elapsed": 386.54820346832275 + }, + { + "group": "d3_bZ_center_3_5", + "step": 128, + "loss": 0.619553804397583, + "error": 0.3876953125, + "gradient_norm": 0.053926873952150345, + "elapsed": 391.31534695625305 + }, + { + "group": "d3_bZ_center_3_5", + "step": 144, + "loss": 0.3793254494667053, + "error": 0.1923828125, + "gradient_norm": 0.07844529300928116, + "elapsed": 397.51641821861267 + }, + { + "group": "d3_bZ_center_3_5", + "step": 160, + "loss": 0.3429756164550781, + "error": 0.1572265625, + "gradient_norm": 0.06213530898094177, + "elapsed": 402.1174716949463 + }, + { + "group": "d3_bZ_center_3_5", + "step": 176, + "loss": 0.2883482277393341, + "error": 0.1416015625, + "gradient_norm": 0.07786665111780167, + "elapsed": 406.72908902168274 + }, + { + "group": "d3_bZ_center_3_5", + "step": 192, + "loss": 0.03280383348464966, + "error": 0.0087890625, + "gradient_norm": 0.035463444888591766, + "elapsed": 411.33272552490234 + }, + { + "group": "d3_bZ_center_3_5", + "step": 208, + "loss": 0.6251656413078308, + "error": 0.38671875, + "gradient_norm": 0.08498021215200424, + "elapsed": 415.93534207344055 + }, + { + "group": "d3_bZ_center_3_5", + "step": 224, + "loss": 0.43049943447113037, + "error": 0.232421875, + "gradient_norm": 0.08405832201242447, + "elapsed": 420.54495644569397 + }, + { + "group": "d3_bZ_center_3_5", + "step": 240, + "loss": 0.5978946089744568, + "error": 0.3349609375, + "gradient_norm": 0.06633604317903519, + "elapsed": 425.1712546348572 + }, + { + "group": "d3_bZ_center_3_5", + "step": 256, + "loss": 0.5690029859542847, + "error": 0.341796875, + "gradient_norm": 0.06171220913529396, + "elapsed": 430.0519812107086 + } + ] + }, + "d3_bZ_center_5_3": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_5_3", + "parent_model": { + "weights": "weights/contextual-temporal2-2048.npz", + "training_checkpoint": "temporal2/2048" + }, + "parent_weights_sha256": "ab1175f9ef7ed52106ce1127b7da91bfc3d91782c0a2fec2f8189f661e3679db", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162569, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_5_3": 11619, + "surface_code_bZ_d3_r03_center_5_3": 13126, + "surface_code_bZ_d3_r05_center_5_3": 12742, + "surface_code_bZ_d3_r07_center_5_3": 9136, + "surface_code_bZ_d3_r09_center_5_3": 15337, + "surface_code_bZ_d3_r11_center_5_3": 11996, + "surface_code_bZ_d3_r13_center_5_3": 12732, + "surface_code_bZ_d3_r15_center_5_3": 13128, + "surface_code_bZ_d3_r17_center_5_3": 14689, + "surface_code_bZ_d3_r19_center_5_3": 11983, + "surface_code_bZ_d3_r21_center_5_3": 11992, + "surface_code_bZ_d3_r23_center_5_3": 11625, + "surface_code_bZ_d3_r25_center_5_3": 12464 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261205, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_5_3", + "step": 1, + "loss": 0.6346971988677979, + "error": 0.3818359375, + "gradient_norm": 0.046160198748111725, + "elapsed": 433.7457048892975 + }, + { + "group": "d3_bZ_center_5_3", + "step": 16, + "loss": 0.46678581833839417, + "error": 0.23828125, + "gradient_norm": 0.04110230877995491, + "elapsed": 438.16989040374756 + }, + { + "group": "d3_bZ_center_5_3", + "step": 32, + "loss": 0.17910712957382202, + "error": 0.064453125, + "gradient_norm": 0.030056120827794075, + "elapsed": 442.8582558631897 + }, + { + "group": "d3_bZ_center_5_3", + "step": 48, + "loss": 0.5041052103042603, + "error": 0.27734375, + "gradient_norm": 0.045486729592084885, + "elapsed": 447.66860795021057 + }, + { + "group": "d3_bZ_center_5_3", + "step": 64, + "loss": 0.5663014054298401, + "error": 0.310546875, + "gradient_norm": 0.04649529233574867, + "elapsed": 452.51550030708313 + }, + { + "group": "d3_bZ_center_5_3", + "step": 80, + "loss": 0.5388609766960144, + "error": 0.2841796875, + "gradient_norm": 0.05346957594156265, + "elapsed": 457.18010997772217 + }, + { + "group": "d3_bZ_center_5_3", + "step": 96, + "loss": 0.6176578998565674, + "error": 0.375, + "gradient_norm": 0.08028864115476608, + "elapsed": 461.89074301719666 + }, + { + "group": "d3_bZ_center_5_3", + "step": 112, + "loss": 0.6225342750549316, + "error": 0.36328125, + "gradient_norm": 0.030471889302134514, + "elapsed": 466.5776717662811 + }, + { + "group": "d3_bZ_center_5_3", + "step": 128, + "loss": 0.2725566625595093, + "error": 0.111328125, + "gradient_norm": 0.05236189067363739, + "elapsed": 471.32313442230225 + }, + { + "group": "d3_bZ_center_5_3", + "step": 144, + "loss": 0.6361372470855713, + "error": 0.3984375, + "gradient_norm": 0.07191100716590881, + "elapsed": 478.3580629825592 + }, + { + "group": "d3_bZ_center_5_3", + "step": 160, + "loss": 0.2549514174461365, + "error": 0.1025390625, + "gradient_norm": 0.0485384576022625, + "elapsed": 484.5399954319 + }, + { + "group": "d3_bZ_center_5_3", + "step": 176, + "loss": 0.06202135607600212, + "error": 0.0205078125, + "gradient_norm": 0.01821581833064556, + "elapsed": 490.2966978549957 + }, + { + "group": "d3_bZ_center_5_3", + "step": 192, + "loss": 0.5546645522117615, + "error": 0.296875, + "gradient_norm": 0.07931670546531677, + "elapsed": 496.1227023601532 + }, + { + "group": "d3_bZ_center_5_3", + "step": 208, + "loss": 0.2724062502384186, + "error": 0.1220703125, + "gradient_norm": 0.0482773631811142, + "elapsed": 501.8398952484131 + }, + { + "group": "d3_bZ_center_5_3", + "step": 224, + "loss": 0.6230898499488831, + "error": 0.3671875, + "gradient_norm": 0.05214303359389305, + "elapsed": 508.2803044319153 + }, + { + "group": "d3_bZ_center_5_3", + "step": 240, + "loss": 0.4187527894973755, + "error": 0.2080078125, + "gradient_norm": 0.046042900532484055, + "elapsed": 513.7485942840576 + }, + { + "group": "d3_bZ_center_5_3", + "step": 256, + "loss": 0.5760256052017212, + "error": 0.3271484375, + "gradient_norm": 0.03505929186940193, + "elapsed": 519.0282807350159 + } + ] + }, + "d3_bZ_center_5_7": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_5_7", + "parent_model": { + "weights": "weights/contextual-temporal2-4096.npz", + "training_checkpoint": "temporal2/4096" + }, + "parent_weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 163281, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_5_7": 11175, + "surface_code_bZ_d3_r03_center_5_7": 13171, + "surface_code_bZ_d3_r05_center_5_7": 12697, + "surface_code_bZ_d3_r07_center_5_7": 11648, + "surface_code_bZ_d3_r09_center_5_7": 14077, + "surface_code_bZ_d3_r11_center_5_7": 13454, + "surface_code_bZ_d3_r13_center_5_7": 11564, + "surface_code_bZ_d3_r15_center_5_7": 12728, + "surface_code_bZ_d3_r17_center_5_7": 12048, + "surface_code_bZ_d3_r19_center_5_7": 14459, + "surface_code_bZ_d3_r21_center_5_7": 14010, + "surface_code_bZ_d3_r23_center_5_7": 10239, + "surface_code_bZ_d3_r25_center_5_7": 12011 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261206, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_5_7", + "step": 1, + "loss": 0.5979939103126526, + "error": 0.357421875, + "gradient_norm": 0.0660991370677948, + "elapsed": 523.6322765350342 + }, + { + "group": "d3_bZ_center_5_7", + "step": 16, + "loss": 0.6150602102279663, + "error": 0.3701171875, + "gradient_norm": 0.04266919568181038, + "elapsed": 528.4157238006592 + }, + { + "group": "d3_bZ_center_5_7", + "step": 32, + "loss": 0.44577696919441223, + "error": 0.2099609375, + "gradient_norm": 0.06689892709255219, + "elapsed": 533.0822012424469 + }, + { + "group": "d3_bZ_center_5_7", + "step": 48, + "loss": 0.4075019657611847, + "error": 0.1884765625, + "gradient_norm": 0.05801992863416672, + "elapsed": 537.763840675354 + }, + { + "group": "d3_bZ_center_5_7", + "step": 64, + "loss": 0.5356203317642212, + "error": 0.2939453125, + "gradient_norm": 0.0543823316693306, + "elapsed": 542.4880893230438 + }, + { + "group": "d3_bZ_center_5_7", + "step": 80, + "loss": 0.45208629965782166, + "error": 0.2275390625, + "gradient_norm": 0.05819695070385933, + "elapsed": 547.1561362743378 + }, + { + "group": "d3_bZ_center_5_7", + "step": 96, + "loss": 0.4151451587677002, + "error": 0.2119140625, + "gradient_norm": 0.07201892882585526, + "elapsed": 551.8683395385742 + }, + { + "group": "d3_bZ_center_5_7", + "step": 112, + "loss": 0.5576318502426147, + "error": 0.31640625, + "gradient_norm": 0.04457806423306465, + "elapsed": 556.642165184021 + }, + { + "group": "d3_bZ_center_5_7", + "step": 128, + "loss": 0.20078304409980774, + "error": 0.08984375, + "gradient_norm": 0.040219370275735855, + "elapsed": 561.4243121147156 + }, + { + "group": "d3_bZ_center_5_7", + "step": 144, + "loss": 0.45917582511901855, + "error": 0.2236328125, + "gradient_norm": 0.0707971602678299, + "elapsed": 567.7284438610077 + }, + { + "group": "d3_bZ_center_5_7", + "step": 160, + "loss": 0.5936293601989746, + "error": 0.345703125, + "gradient_norm": 0.12180078029632568, + "elapsed": 572.3563349246979 + }, + { + "group": "d3_bZ_center_5_7", + "step": 176, + "loss": 0.24654456973075867, + "error": 0.1044921875, + "gradient_norm": 0.04859209433197975, + "elapsed": 577.008533000946 + }, + { + "group": "d3_bZ_center_5_7", + "step": 192, + "loss": 0.4809238612651825, + "error": 0.2509765625, + "gradient_norm": 0.09741280972957611, + "elapsed": 581.7403192520142 + }, + { + "group": "d3_bZ_center_5_7", + "step": 208, + "loss": 0.36378931999206543, + "error": 0.166015625, + "gradient_norm": 0.04881134256720543, + "elapsed": 586.367921590805 + }, + { + "group": "d3_bZ_center_5_7", + "step": 224, + "loss": 0.5131937265396118, + "error": 0.279296875, + "gradient_norm": 0.08562120050191879, + "elapsed": 591.1944098472595 + }, + { + "group": "d3_bZ_center_5_7", + "step": 240, + "loss": 0.4193183183670044, + "error": 0.2099609375, + "gradient_norm": 0.0680096298456192, + "elapsed": 595.8478200435638 + }, + { + "group": "d3_bZ_center_5_7", + "step": 256, + "loss": 0.467867910861969, + "error": 0.24609375, + "gradient_norm": 0.07342159003019333, + "elapsed": 600.4172458648682 + } + ] + }, + "d3_bZ_center_7_5": { + "initialization": "Continue the temporal component of the selected session-trained group decoder; no new random parameters", + "original_initialization": "Base rich network seed20261030 and temporal encoder seed20261104; all fitting occurred in this session", + "group": "d3_bZ_center_7_5", + "parent_model": { + "weights": "weights/contextual-temporal2-4096.npz", + "training_checkpoint": "temporal2/4096" + }, + "parent_weights_sha256": "5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "training": "Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only", + "eligible_training_shots": 258440, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 159856, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_7_5": 10637, + "surface_code_bZ_d3_r03_center_7_5": 13460, + "surface_code_bZ_d3_r05_center_7_5": 12002, + "surface_code_bZ_d3_r07_center_7_5": 8000, + "surface_code_bZ_d3_r09_center_7_5": 10743, + "surface_code_bZ_d3_r11_center_7_5": 16789, + "surface_code_bZ_d3_r13_center_7_5": 12364, + "surface_code_bZ_d3_r15_center_7_5": 15213, + "surface_code_bZ_d3_r17_center_7_5": 14167, + "surface_code_bZ_d3_r19_center_7_5": 11099, + "surface_code_bZ_d3_r21_center_7_5": 13178, + "surface_code_bZ_d3_r23_center_7_5": 12014, + "surface_code_bZ_d3_r25_center_7_5": 10190 + }, + "steps": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global norm clip1", + "optimizer_restored": false, + "rng_restored": false, + "sampling_seed": 20261207, + "validation": "Fixed random screen per condition using seed20261028; full validation is used by the separate selector", + "validation_shots_requested_per_condition": 1024, + "loss": "Uniform binary conditional logical likelihood through exact frontier contraction", + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "test_data_used": false, + "log": [ + { + "group": "d3_bZ_center_7_5", + "step": 1, + "loss": 0.4038092792034149, + "error": 0.197265625, + "gradient_norm": 0.05896063148975372, + "elapsed": 603.840416431427 + }, + { + "group": "d3_bZ_center_7_5", + "step": 16, + "loss": 0.6033527851104736, + "error": 0.3515625, + "gradient_norm": 0.05784430727362633, + "elapsed": 608.1250426769257 + }, + { + "group": "d3_bZ_center_7_5", + "step": 32, + "loss": 0.5283372402191162, + "error": 0.283203125, + "gradient_norm": 0.050800539553165436, + "elapsed": 612.7134759426117 + }, + { + "group": "d3_bZ_center_7_5", + "step": 48, + "loss": 0.5995811820030212, + "error": 0.3291015625, + "gradient_norm": 0.05547967553138733, + "elapsed": 617.2784404754639 + }, + { + "group": "d3_bZ_center_7_5", + "step": 64, + "loss": 0.40154707431793213, + "error": 0.205078125, + "gradient_norm": 0.06852669268846512, + "elapsed": 621.8420352935791 + }, + { + "group": "d3_bZ_center_7_5", + "step": 80, + "loss": 0.4995174705982208, + "error": 0.2763671875, + "gradient_norm": 0.061341386288404465, + "elapsed": 626.40260887146 + }, + { + "group": "d3_bZ_center_7_5", + "step": 96, + "loss": 0.5751184225082397, + "error": 0.3251953125, + "gradient_norm": 0.07929262518882751, + "elapsed": 630.9725329875946 + }, + { + "group": "d3_bZ_center_7_5", + "step": 112, + "loss": 0.624832808971405, + "error": 0.369140625, + "gradient_norm": 0.045014865696430206, + "elapsed": 635.5494453907013 + }, + { + "group": "d3_bZ_center_7_5", + "step": 128, + "loss": 0.4616764783859253, + "error": 0.224609375, + "gradient_norm": 0.0743650421500206, + "elapsed": 640.093489408493 + }, + { + "group": "d3_bZ_center_7_5", + "step": 144, + "loss": 0.5214440822601318, + "error": 0.2724609375, + "gradient_norm": 0.05418862774968147, + "elapsed": 646.2130215167999 + }, + { + "group": "d3_bZ_center_7_5", + "step": 160, + "loss": 0.27278852462768555, + "error": 0.12109375, + "gradient_norm": 0.059856753796339035, + "elapsed": 650.7696936130524 + }, + { + "group": "d3_bZ_center_7_5", + "step": 176, + "loss": 0.5251824259757996, + "error": 0.2734375, + "gradient_norm": 0.0982872024178505, + "elapsed": 655.3179745674133 + }, + { + "group": "d3_bZ_center_7_5", + "step": 192, + "loss": 0.510776937007904, + "error": 0.2744140625, + "gradient_norm": 0.0638406053185463, + "elapsed": 659.8532302379608 + }, + { + "group": "d3_bZ_center_7_5", + "step": 208, + "loss": 0.4173796772956848, + "error": 0.20703125, + "gradient_norm": 0.0652337446808815, + "elapsed": 664.3970146179199 + }, + { + "group": "d3_bZ_center_7_5", + "step": 224, + "loss": 0.42136240005493164, + "error": 0.203125, + "gradient_norm": 0.04171523451805115, + "elapsed": 668.9384174346924 + }, + { + "group": "d3_bZ_center_7_5", + "step": 240, + "loss": 0.2494639754295349, + "error": 0.1201171875, + "gradient_norm": 0.06969694793224335, + "elapsed": 673.4954979419708 + }, + { + "group": "d3_bZ_center_7_5", + "step": 256, + "loss": 0.26821407675743103, + "error": 0.1181640625, + "gradient_norm": 0.04254033416509628, + "elapsed": 678.0544662475586 + } + ] + } + }, + "initialization": "Continue session-trained selected temporal components; no new random parameters", + "training": "Each group samples uniformly over its own13 durations; supplied training labels only", + "eligible_training_shots": 2067520, + "steps": 2048, + "steps_per_group": 256, + "batch_size": 1024, + "learning_rate": 0.0001, + "optimizer_restored": false, + "rng_restored": false, + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "run_config": { + "package": "/run-state/workspace/research/context_upgrades/short_categorical3/package", + "output": "/run-state/workspace/research/learned_exact/group_specialize1", + "steps": 256, + "eval_every": 128, + "batch": 1024, + "validation_shots": 1024, + "validation_batch": 1024, + "learning_rate": 0.0001, + "seed": 20261200, + "groups": [ + "d3_bX_center_3_5", + "d3_bX_center_5_3", + "d3_bX_center_5_7", + "d3_bX_center_7_5", + "d3_bZ_center_3_5", + "d3_bZ_center_5_3", + "d3_bZ_center_5_7", + "d3_bZ_center_7_5" + ], + "training_source_sha256": { + "learned_exact__specialize_train.py": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "parent_config_sha256": "50123b5d6a4515814bb74a93963e83d17c2d3eb47af4d12b7757f523ac7c2f6a", + "parent_provenance_sha256": "7c76c4ba7b6bb90ddb1ac3fa9cd5d27788fdad2bf6bc6f95e8187824c971bdfb", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1" + }, + "parent_record": "training_sources/group_specialize1/parent_training_provenance.json", + "new_random_parameters": 0, + "training_draws": 2097152, + "test_data_used": false, + "declared_plan": { + "hypothesis": "Group-specific fine-tuning may reduce conflicting updates across d3 geometries and bases", + "parents": "The temporal component selected for each of the8 groups in CURRENT after fresh2_continuation_finished.json", + "new_random_parameters": 0, + "sampling_seeds": "20261200 plus lexicographic group rank0..7", + "training": "256 updates per group,B1024,LR.0001; uniform sampling of all13 durations and all258440 training rows per group", + "optimizer": "Fresh AdamW moments for every group, weight decay1e-4, global gradient norm clip1", + "total_optimizer_updates": 2048, + "total_training_draws": 2097152, + "validation": "Screen at0/128/256. Full validation at0/128/256; step0 is a diagnostic, excluded from new checkpoint selection", + "selection": "Per-group mean failure over all13 durations: incumbent, raw128/256, or equal small-contextual blend128/256; retain incumbent on ties", + "short_model_followup": "Recheck the previously training-fitted categorical1 heads after group replacement", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "selection_eligible": false, + "submission_eligible": false, + "trainer_sha256": "5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95", + "run": "/run-state/workspace/research/learned_exact/specialize_smoke2", + "checks": [ + { + "group": "d3_bX_center_3_5", + "parent_exact": true, + "fresh_zero_optimizer": true, + "one_update_changes_parameters": true, + "sampling_replay_exact": true, + "all13_durations_evaluated": true + }, + { + "group": "d3_bZ_center_7_5", + "parent_exact": true, + "fresh_zero_optimizer": true, + "one_update_changes_parameters": true, + "sampling_replay_exact": true, + "all13_durations_evaluated": true + } + ], + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/group_specialize1", + "selected_checkpoints": { + "d3_bX_center_3_5": 128, + "d3_bX_center_5_7": 256, + "d3_bX_center_7_5": 128, + "d3_bZ_center_7_5": 128 + }, + "checkpoint_records": { + "d3_bX_center_3_5": { + "group": "d3_bX_center_3_5", + "step": 128, + "training_draws": 131072, + "unique_training_rows_seen_in_this_phase": 101608, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_3_5": 7393, + "surface_code_bX_d3_r03_center_3_5": 9191, + "surface_code_bX_d3_r05_center_3_5": 9634, + "surface_code_bX_d3_r07_center_3_5": 9218, + "surface_code_bX_d3_r09_center_3_5": 6691, + "surface_code_bX_d3_r11_center_3_5": 6028, + "surface_code_bX_d3_r13_center_3_5": 9122, + "surface_code_bX_d3_r15_center_3_5": 5301, + "surface_code_bX_d3_r17_center_3_5": 8630, + "surface_code_bX_d3_r19_center_3_5": 5276, + "surface_code_bX_d3_r21_center_3_5": 8553, + "surface_code_bX_d3_r23_center_3_5": 7977, + "surface_code_bX_d3_r25_center_3_5": 8594 + }, + "weights": "weights-128.npz", + "weights_sha256": "90c6cb7fd3be8d363318f45257de6670ba19d9336d096dc3efb309bac88b2bf9", + "complete": true + }, + "d3_bX_center_5_7": { + "group": "d3_bX_center_5_7", + "step": 256, + "training_draws": 262144, + "unique_training_rows_seen_in_this_phase": 162612, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_5_7": 13532, + "surface_code_bX_d3_r03_center_5_7": 12060, + "surface_code_bX_d3_r05_center_5_7": 14744, + "surface_code_bX_d3_r07_center_5_7": 11642, + "surface_code_bX_d3_r09_center_5_7": 13167, + "surface_code_bX_d3_r11_center_5_7": 8639, + "surface_code_bX_d3_r13_center_5_7": 14627, + "surface_code_bX_d3_r15_center_5_7": 11178, + "surface_code_bX_d3_r17_center_5_7": 10160, + "surface_code_bX_d3_r19_center_5_7": 13125, + "surface_code_bX_d3_r21_center_5_7": 13464, + "surface_code_bX_d3_r23_center_5_7": 13143, + "surface_code_bX_d3_r25_center_5_7": 13131 + }, + "weights": "weights-256.npz", + "weights_sha256": "7dc5b5ed51423bae023bb2c15de420850fef4fedb82760a7bcd993393301e038", + "complete": true + }, + "d3_bX_center_7_5": { + "group": "d3_bX_center_7_5", + "step": 128, + "training_draws": 131072, + "unique_training_rows_seen_in_this_phase": 101875, + "unique_rows_by_condition": { + "surface_code_bX_d3_r01_center_7_5": 7327, + "surface_code_bX_d3_r03_center_7_5": 6711, + "surface_code_bX_d3_r05_center_7_5": 9068, + "surface_code_bX_d3_r07_center_7_5": 9212, + "surface_code_bX_d3_r09_center_7_5": 6001, + "surface_code_bX_d3_r11_center_7_5": 7353, + "surface_code_bX_d3_r13_center_7_5": 7373, + "surface_code_bX_d3_r15_center_7_5": 8580, + "surface_code_bX_d3_r17_center_7_5": 6713, + "surface_code_bX_d3_r19_center_7_5": 9686, + "surface_code_bX_d3_r21_center_7_5": 8553, + "surface_code_bX_d3_r23_center_7_5": 7325, + "surface_code_bX_d3_r25_center_7_5": 7973 + }, + "weights": "weights-128.npz", + "weights_sha256": "1dc16b14813ebfd874acf9c907870144bc6ac98c8de8b4e8c47e41cdcfb3f1c3", + "complete": true + }, + "d3_bZ_center_7_5": { + "group": "d3_bZ_center_7_5", + "step": 128, + "training_draws": 131072, + "unique_training_rows_seen_in_this_phase": 101460, + "unique_rows_by_condition": { + "surface_code_bZ_d3_r01_center_7_5": 7386, + "surface_code_bZ_d3_r03_center_7_5": 7382, + "surface_code_bZ_d3_r05_center_7_5": 7375, + "surface_code_bZ_d3_r07_center_7_5": 4523, + "surface_code_bZ_d3_r09_center_7_5": 6016, + "surface_code_bZ_d3_r11_center_7_5": 10680, + "surface_code_bZ_d3_r13_center_7_5": 9644, + "surface_code_bZ_d3_r15_center_7_5": 7341, + "surface_code_bZ_d3_r17_center_7_5": 9210, + "surface_code_bZ_d3_r19_center_7_5": 8536, + "surface_code_bZ_d3_r21_center_7_5": 7410, + "surface_code_bZ_d3_r23_center_7_5": 8625, + "surface_code_bZ_d3_r25_center_7_5": 7332 + }, + "weights": "weights-128.npz", + "weights_sha256": "8f78092b6539927132aebd28deb0e0d1b72f43596b79e074e3206f4a784dd000", + "complete": true + } + }, + "selection": "Minimum full-validation mean failure across all13 durations per group among incumbent, specialized128/256 and equal small-contextual blends; retain incumbent on ties", + "blend_reference": "/run-state/workspace/research/context_upgrades/continuation2/predictions", + "history": [ + { + "group": "d3_bX_center_3_5", + "candidates": { + "incumbent": 0.24451622596153846, + "128": 0.2444110576923077, + "blend-128": 0.24523737980769234, + "256": 0.24468149038461534, + "blend-256": 0.24532752403846156 + }, + "selected": "128" + }, + { + "group": "d3_bX_center_5_3", + "candidates": { + "incumbent": 0.2526592548076923, + "128": 0.2528094951923077, + "blend-128": 0.25312499999999993, + "256": 0.2532001201923077, + "blend-256": 0.25318509615384616 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_7", + "candidates": { + "incumbent": 0.2333984375, + "128": 0.23329326923076926, + "blend-128": 0.23414963942307693, + "256": 0.233203125, + "blend-256": 0.2338641826923077 + }, + "selected": "256" + }, + { + "group": "d3_bX_center_7_5", + "candidates": { + "incumbent": 0.23889723557692305, + "128": 0.23933293269230768, + "blend-128": 0.23880709134615385, + "256": 0.23907752403846153, + "blend-256": 0.23888221153846154 + }, + "selected": "blend-128" + }, + { + "group": "d3_bZ_center_3_5", + "candidates": { + "incumbent": 0.24447115384615387, + "128": 0.24456129807692306, + "blend-128": 0.24534254807692307, + "256": 0.24462139423076923, + "blend-256": 0.24505709134615386 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_3", + "candidates": { + "incumbent": 0.23652343749999996, + "128": 0.2371394230769231, + "blend-128": 0.23753004807692307, + "256": 0.2373347355769231, + "blend-256": 0.23728966346153849 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "candidates": { + "incumbent": 0.2356670673076923, + "128": 0.23635817307692306, + "blend-128": 0.23662860576923073, + "256": 0.23571213942307687, + "blend-256": 0.23638822115384614 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_7_5", + "candidates": { + "incumbent": 0.23294771634615385, + "128": 0.23282752403846158, + "blend-128": 0.2331280048076923, + "256": 0.23348858173076922, + "blend-256": 0.23336838942307692 + }, + "selected": "128" + }, + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23228665865384618 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998 + }, + "selected": "incumbent" + } + ] + } + ], + "turbo_d5_experiment": { + "method": "Three passes of extrinsic log-odds feedback between complementary exact CSS syndrome-likelihood contractions, damping 1, messages clipped to [-8,8]. Induced dependencies are approximated.", + "initialization": "Logistic coefficients randomly initialized Normal(0,.01), seed 20261103; all underlying states built in this session from permitted even-fitted DEMs.", + "training": "4096 uniformly sampled training rows per all 26 d5 conditions (sample seed 20261023); BCE plus 1e-5 L2, L-BFGS-B up to 300 iterations.", + "screen": { + "scope": "Diagnostic screen only: both d5 bases, rounds 5/13/25, 1024 uniform validation samples per condition", + "sample_seed": 20261031, + "results": [ + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "rounds": 5, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 5.466358661651611, + "elapsed": 7.00129771232605, + "first_pass_max_delta": 8.940696716308594e-07, + "failure": [ + 0.1025390625, + 0.1044921875, + 0.1025390625 + ], + "peak_gpu_bytes": 4742925056 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "rounds": 5, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 1.1764235496520996, + "elapsed": 8.178237438201904, + "first_pass_max_delta": 8.940696716308594e-07, + "failure": [ + 0.1025390625, + 0.0966796875, + 0.1005859375 + ], + "peak_gpu_bytes": 4742925056 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "rounds": 13, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 7.137438058853149, + "elapsed": 16.021901607513428, + "first_pass_max_delta": 1.1324882507324219e-06, + "failure": [ + 0.2548828125, + 0.2490234375, + 0.25 + ], + "peak_gpu_bytes": 11611887104 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "rounds": 13, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 3.088695526123047, + "elapsed": 19.11112403869629, + "first_pass_max_delta": 1.1324882507324219e-06, + "failure": [ + 0.2548828125, + 0.2490234375, + 0.2412109375 + ], + "peak_gpu_bytes": 11611887104 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "rounds": 25, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 10.504217624664307, + "elapsed": 30.677946090698242, + "first_pass_max_delta": 1.5497207641601562e-06, + "failure": [ + 0.3916015625, + 0.38671875, + 0.3896484375 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "rounds": 25, + "basis": "X", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 5.937381267547607, + "elapsed": 36.615668296813965, + "first_pass_max_delta": 1.5497207641601562e-06, + "failure": [ + 0.3916015625, + 0.3857421875, + 0.3896484375 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "rounds": 5, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 4.611798286437988, + "elapsed": 41.71111083030701, + "first_pass_max_delta": 2.0265579223632812e-06, + "failure": [ + 0.1005859375, + 0.1015625, + 0.09765625 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "rounds": 5, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 1.1570250988006592, + "elapsed": 42.86858010292053, + "first_pass_max_delta": 2.0265579223632812e-06, + "failure": [ + 0.1005859375, + 0.0986328125, + 0.095703125 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "rounds": 13, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 6.715797185897827, + "elapsed": 50.234126567840576, + "first_pass_max_delta": 1.0132789611816406e-06, + "failure": [ + 0.236328125, + 0.234375, + 0.2314453125 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "rounds": 13, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 3.08017635345459, + "elapsed": 53.31461310386658, + "first_pass_max_delta": 1.0132789611816406e-06, + "failure": [ + 0.236328125, + 0.23828125, + 0.234375 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "rounds": 25, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 0.5, + "seconds": 9.802945375442505, + "elapsed": 64.01536726951599, + "first_pass_max_delta": 1.4901161193847656e-06, + "failure": [ + 0.384765625, + 0.3857421875, + 0.38671875 + ], + "peak_gpu_bytes": 21913887488 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "rounds": 25, + "basis": "Z", + "shots": 1024, + "batch": 192, + "damping": 1.0, + "seconds": 5.927323341369629, + "elapsed": 69.9429976940155, + "first_pass_max_delta": 1.4901161193847656e-06, + "failure": [ + 0.384765625, + 0.3701171875, + 0.361328125 + ], + "peak_gpu_bytes": 21913887488 + } + ] + }, + "cache": { + "method": "Three extrinsic-message passes between exact CSS likelihoods, damping 1, extrinsic clipping [-8,8]", + "scope": "All 26 d5 conditions. Full validation and 4096 training shots per condition.", + "training_selection": "Same uniformly sampled training indices as d5_cache, seed 20261023; labels are only used downstream in ensemble fitting.", + "model_selection": "Damping 1 and three passes chosen from a six-condition, 1024-validation-shot diagnostic screen of .5/1 damping and 1/2/3 passes.", + "batch": 384, + "test_data_used": false, + "resume_note": "Initial dynamic allocator failed at X/r21 after saving X/r1 through r19. Those complete records are retained; remaining conditions resumed with a 90 percent preallocated pool.", + "records": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "batch": 384, + "validation": { + "seconds": 0.0023708343505859375, + "shots": 5120, + "first_pass_max_delta": 0.0, + "failure": [ + 0.0080078125, + 0.0080078125, + 0.0080078125 + ] + }, + "train": { + "seconds": 0.00203704833984375, + "shots": 4096, + "first_pass_max_delta": 0.0, + "failure": [ + 0.00830078125, + 0.00830078125, + 0.00830078125 + ] + }, + "elapsed": 0.031897783279418945, + "peak_gpu_bytes": 0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "batch": 384, + "validation": { + "seconds": 6.5025129318237305, + "shots": 5120, + "first_pass_max_delta": 1.1622905731201172e-06, + "failure": [ + 0.05390625, + 0.05234375, + 0.0515625 + ] + }, + "train": { + "seconds": 1.8498849868774414, + "shots": 4096, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.056640625, + 0.056884765625, + 0.057373046875 + ] + }, + "elapsed": 9.963430881500244, + "peak_gpu_bytes": 6053389568 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "batch": 384, + "validation": { + "seconds": 7.887800455093384, + "shots": 5120, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.1111328125, + 0.1078125, + 0.1078125 + ] + }, + "train": { + "seconds": 3.1277287006378174, + "shots": 4096, + "first_pass_max_delta": 1.5497207641601562e-06, + "failure": [ + 0.110595703125, + 0.1044921875, + 0.106689453125 + ] + }, + "elapsed": 21.591607809066772, + "peak_gpu_bytes": 9485051136 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "batch": 384, + "validation": { + "seconds": 9.284316062927246, + "shots": 5120, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.1638671875, + 0.16328125, + 0.16328125 + ] + }, + "train": { + "seconds": 4.408588647842407, + "shots": 4096, + "first_pass_max_delta": 3.2186508178710938e-06, + "failure": [ + 0.165771484375, + 0.15966796875, + 0.160888671875 + ] + }, + "elapsed": 35.83207678794861, + "peak_gpu_bytes": 12921052416 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "batch": 384, + "validation": { + "seconds": 10.81107211112976, + "shots": 5120, + "first_pass_max_delta": 4.172325134277344e-06, + "failure": [ + 0.1994140625, + 0.1947265625, + 0.192578125 + ] + }, + "train": { + "seconds": 5.6971564292907715, + "shots": 4096, + "first_pass_max_delta": 1.9073486328125e-06, + "failure": [ + 0.193603515625, + 0.190185546875, + 0.1865234375 + ] + }, + "elapsed": 52.94058084487915, + "peak_gpu_bytes": 16355555584 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "batch": 384, + "validation": { + "seconds": 13.042934894561768, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.2330078125, + 0.229296875, + 0.2283203125 + ] + }, + "train": { + "seconds": 6.935072898864746, + "shots": 4096, + "first_pass_max_delta": 1.043081283569336e-06, + "failure": [ + 0.237060546875, + 0.2373046875, + 0.23388671875 + ] + }, + "elapsed": 73.53631615638733, + "peak_gpu_bytes": 19787549696 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "batch": 384, + "validation": { + "seconds": 14.011132955551147, + "shots": 5120, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.251953125, + 0.243359375, + 0.2427734375 + ] + }, + "train": { + "seconds": 8.214681386947632, + "shots": 4096, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.261962890625, + 0.257080078125, + 0.254150390625 + ] + }, + "elapsed": 96.39840364456177, + "peak_gpu_bytes": 23221127680 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "batch": 384, + "validation": { + "seconds": 15.821684837341309, + "shots": 5120, + "first_pass_max_delta": 2.3245811462402344e-06, + "failure": [ + 0.2822265625, + 0.286328125, + 0.2798828125 + ] + }, + "train": { + "seconds": 9.5097815990448, + "shots": 4096, + "first_pass_max_delta": 1.8477439880371094e-06, + "failure": [ + 0.294677734375, + 0.28515625, + 0.2861328125 + ] + }, + "elapsed": 122.39457035064697, + "peak_gpu_bytes": 26659319552 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "batch": 384, + "validation": { + "seconds": 18.90661311149597, + "shots": 5120, + "first_pass_max_delta": 2.3245811462402344e-06, + "failure": [ + 0.329296875, + 0.323828125, + 0.3169921875 + ] + }, + "train": { + "seconds": 11.201237440109253, + "shots": 4096, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.3046875, + 0.304931640625, + 0.302978515625 + ] + }, + "elapsed": 153.40053129196167, + "peak_gpu_bytes": 30096252672 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "batch": 384, + "validation": { + "seconds": 22.513427734375, + "shots": 5120, + "first_pass_max_delta": 1.4007091522216797e-06, + "failure": [ + 0.3560546875, + 0.3458984375, + 0.3455078125 + ] + }, + "train": { + "seconds": 16.373472213745117, + "shots": 4096, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.350341796875, + 0.3447265625, + 0.339111328125 + ] + }, + "elapsed": 193.22454714775085, + "peak_gpu_bytes": 33531435520 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 20.595962524414062, + "shots": 5120, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.3640625, + 0.3626953125, + 0.3607421875 + ] + }, + "train": { + "seconds": 13.13056755065918, + "shots": 4096, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.366455078125, + 0.364013671875, + 0.3603515625 + ] + }, + "elapsed": 36.23082995414734, + "peak_gpu_bytes": 36971696384 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 21.875932693481445, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.3857421875, + 0.3837890625, + 0.3794921875 + ] + }, + "train": { + "seconds": 14.333576440811157, + "shots": 4096, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.37841796875, + 0.380859375, + 0.378173828125 + ] + }, + "elapsed": 73.29396986961365, + "peak_gpu_bytes": 40408369664 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 23.68450117111206, + "shots": 5120, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.38828125, + 0.39140625, + 0.390234375 + ] + }, + "train": { + "seconds": 15.625046253204346, + "shots": 4096, + "first_pass_max_delta": 2.3543834686279297e-06, + "failure": [ + 0.401611328125, + 0.3984375, + 0.3896484375 + ] + }, + "elapsed": 113.62051224708557, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 0.0020935535430908203, + "shots": 5120, + "first_pass_max_delta": 0.0, + "failure": [ + 0.0078125, + 0.0078125, + 0.0078125 + ] + }, + "train": { + "seconds": 0.0018491744995117188, + "shots": 4096, + "first_pass_max_delta": 0.0, + "failure": [ + 0.006103515625, + 0.006103515625, + 0.006103515625 + ] + }, + "elapsed": 113.74299573898315, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 6.421818256378174, + "shots": 5120, + "first_pass_max_delta": 9.5367431640625e-07, + "failure": [ + 0.0474609375, + 0.0466796875, + 0.04609375 + ] + }, + "train": { + "seconds": 2.009964942932129, + "shots": 4096, + "first_pass_max_delta": 1.6093254089355469e-06, + "failure": [ + 0.05224609375, + 0.050537109375, + 0.050537109375 + ] + }, + "elapsed": 122.82617926597595, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 8.133492231369019, + "shots": 5120, + "first_pass_max_delta": 2.115964889526367e-06, + "failure": [ + 0.1037109375, + 0.1029296875, + 0.102734375 + ] + }, + "train": { + "seconds": 3.179387331008911, + "shots": 4096, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.108642578125, + 0.1044921875, + 0.10595703125 + ] + }, + "elapsed": 134.6406970024109, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 13.694931983947754, + "shots": 5120, + "first_pass_max_delta": 2.3245811462402344e-06, + "failure": [ + 0.1484375, + 0.14765625, + 0.1494140625 + ] + }, + "train": { + "seconds": 6.147953748703003, + "shots": 4096, + "first_pass_max_delta": 2.0563602447509766e-06, + "failure": [ + 0.147705078125, + 0.144775390625, + 0.143310546875 + ] + }, + "elapsed": 155.0307319164276, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 14.462661504745483, + "shots": 5120, + "first_pass_max_delta": 1.4901161193847656e-06, + "failure": [ + 0.181640625, + 0.1765625, + 0.1734375 + ] + }, + "train": { + "seconds": 6.59630274772644, + "shots": 4096, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.181640625, + 0.173583984375, + 0.17431640625 + ] + }, + "elapsed": 176.9893820285797, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 15.458272933959961, + "shots": 5120, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.2208984375, + 0.2169921875, + 0.2189453125 + ] + }, + "train": { + "seconds": 8.347567081451416, + "shots": 4096, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.2216796875, + 0.214111328125, + 0.209716796875 + ] + }, + "elapsed": 201.48220419883728, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 16.03638219833374, + "shots": 5120, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.2439453125, + 0.2349609375, + 0.2333984375 + ] + }, + "train": { + "seconds": 8.29888391494751, + "shots": 4096, + "first_pass_max_delta": 8.344650268554688e-07, + "failure": [ + 0.24365234375, + 0.248046875, + 0.2451171875 + ] + }, + "elapsed": 226.75215530395508, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 16.009416103363037, + "shots": 5120, + "first_pass_max_delta": 1.341104507446289e-06, + "failure": [ + 0.271875, + 0.264453125, + 0.2638671875 + ] + }, + "train": { + "seconds": 9.500921726226807, + "shots": 4096, + "first_pass_max_delta": 1.0728836059570312e-06, + "failure": [ + 0.28076171875, + 0.267333984375, + 0.267333984375 + ] + }, + "elapsed": 252.95993447303772, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 17.426681518554688, + "shots": 5120, + "first_pass_max_delta": 1.6242265701293945e-06, + "failure": [ + 0.31484375, + 0.3056640625, + 0.3087890625 + ] + }, + "train": { + "seconds": 10.742947816848755, + "shots": 4096, + "first_pass_max_delta": 1.430511474609375e-06, + "failure": [ + 0.310791015625, + 0.309814453125, + 0.31103515625 + ] + }, + "elapsed": 281.84620356559753, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 18.49993872642517, + "shots": 5120, + "first_pass_max_delta": 1.9073486328125e-06, + "failure": [ + 0.334375, + 0.334765625, + 0.33515625 + ] + }, + "train": { + "seconds": 11.90273404121399, + "shots": 4096, + "first_pass_max_delta": 1.3113021850585938e-06, + "failure": [ + 0.327880859375, + 0.315673828125, + 0.310546875 + ] + }, + "elapsed": 313.02247071266174, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 20.121089458465576, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.34609375, + 0.342578125, + 0.344140625 + ] + }, + "train": { + "seconds": 13.077136278152466, + "shots": 4096, + "first_pass_max_delta": 1.6391277313232422e-06, + "failure": [ + 0.349853515625, + 0.34765625, + 0.352294921875 + ] + }, + "elapsed": 347.0259063243866, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 22.116555213928223, + "shots": 5120, + "first_pass_max_delta": 1.6689300537109375e-06, + "failure": [ + 0.3625, + 0.3625, + 0.3564453125 + ] + }, + "train": { + "seconds": 14.53529953956604, + "shots": 4096, + "first_pass_max_delta": 1.7285346984863281e-06, + "failure": [ + 0.361572265625, + 0.36083984375, + 0.35205078125 + ] + }, + "elapsed": 384.53587651252747, + "peak_gpu_bytes": 43842280448 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "batch": 384, + "gpu_allocation": "90 percent preallocated contiguous pool", + "validation": { + "seconds": 24.039794921875, + "shots": 5120, + "first_pass_max_delta": 1.2516975402832031e-06, + "failure": [ + 0.397265625, + 0.3810546875, + 0.3755859375 + ] + }, + "train": { + "seconds": 15.72797179222107, + "shots": 4096, + "first_pass_max_delta": 1.1920928955078125e-06, + "failure": [ + 0.378662109375, + 0.370849609375, + 0.369384765625 + ] + }, + "elapsed": 425.2448420524597, + "peak_gpu_bytes": 43842280448 + } + ] + }, + "selection": "Full-validation mean failure per basis group, comparing incumbent, raw pass3, calibrated pass3, confidence ensemble, and confidence+matching ensemble.", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": { + "failure": 0.24024939903846157 + }, + "turbo_raw": { + "failure": 0.2359375 + }, + "turbo_calibrated": { + "failure": 0.23592247596153845, + "train_loss": 0.4342440304618462, + "iterations": 8, + "optimizer_success": true + }, + "turbo_confidence": { + "failure": 0.23646334134615385, + "train_loss": 0.4325824823965761, + "iterations": 31, + "optimizer_success": true + }, + "turbo_ensemble": { + "failure": 0.23825120192307692, + "train_loss": 0.43104343457008354, + "iterations": 128, + "optimizer_success": true + } + }, + "selected": "turbo_calibrated" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": { + "failure": 0.22627704326923076 + }, + "turbo_raw": { + "failure": 0.2242938701923077 + }, + "turbo_calibrated": { + "failure": 0.22444411057692307, + "train_loss": 0.41862854651685183, + "iterations": 8, + "optimizer_success": true + }, + "turbo_confidence": { + "failure": 0.22463942307692308, + "train_loss": 0.4165407454935999, + "iterations": 28, + "optimizer_success": true + }, + "turbo_ensemble": { + "failure": 0.22291165865384616, + "train_loss": 0.4143765903988058, + "iterations": 153, + "optimizer_success": true + } + }, + "selected": "turbo_ensemble" + } + ], + "test_data_used": false, + "memory_optimization": { + "method": "Logical parity retained in forward state, marginalized out of stored histories and backward syndrome-likelihood messages; half the on-partition history size.", + "equivalence_checks": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 3.2687214002180554e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 3.698800981055683e-07 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 4.061699030444288e-07 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "log_likelihood_max_delta": 0.0, + "logical_max_delta": 0.0, + "edge_posterior_max_delta": 4.5500107148654934e-07 + } + ], + "runtime_batch": 512, + "gpu_pool": "90 percent preallocated before JAX backend initialization" + } + }, + "neural_d5_history": [ + { + "training": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261101", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to exact complementary-CSS-conditioned relevant-edge logits; exact width-14 contraction predicts logical probability", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; complementary conditioning held fixed", + "steps": 512, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261101, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 512, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.12617039680480957, + "error": 0.0390625, + "gradient_norm": 0.04250018671154976, + "elapsed": 18.675416231155396 + }, + { + "step": 16, + "loss": 0.6377020478248596, + "error": 0.4140625, + "gradient_norm": 0.09590183943510056, + "elapsed": 23.17981266975403 + }, + { + "step": 32, + "loss": 0.29977816343307495, + "error": 0.12109375, + "gradient_norm": 0.07157808542251587, + "elapsed": 28.000701189041138 + }, + { + "step": 48, + "loss": 0.34505343437194824, + "error": 0.1484375, + "gradient_norm": 0.07669594883918762, + "elapsed": 32.97374606132507 + }, + { + "step": 64, + "loss": 0.5405071973800659, + "error": 0.29296875, + "gradient_norm": 0.08529861271381378, + "elapsed": 37.794785499572754 + }, + { + "step": 80, + "loss": 0.5131822228431702, + "error": 0.28515625, + "gradient_norm": 0.12556222081184387, + "elapsed": 42.73275876045227 + }, + { + "step": 96, + "loss": 0.6790875196456909, + "error": 0.421875, + "gradient_norm": 0.19858981668949127, + "elapsed": 47.55139684677124 + }, + { + "step": 112, + "loss": 0.4744196832180023, + "error": 0.2421875, + "gradient_norm": 0.14321450889110565, + "elapsed": 52.42716360092163 + }, + { + "step": 128, + "loss": 0.01264211069792509, + "error": 0.00390625, + "gradient_norm": 0.007236324716359377, + "elapsed": 57.2592077255249 + }, + { + "step": 144, + "loss": 0.35788118839263916, + "error": 0.15234375, + "gradient_norm": 0.07203944772481918, + "elapsed": 64.91656231880188 + }, + { + "step": 160, + "loss": 0.6330419778823853, + "error": 0.3671875, + "gradient_norm": 0.08350329101085663, + "elapsed": 69.75011849403381 + }, + { + "step": 176, + "loss": 0.6195905208587646, + "error": 0.4140625, + "gradient_norm": 0.11415330320596695, + "elapsed": 74.56864047050476 + }, + { + "step": 192, + "loss": 0.5832147598266602, + "error": 0.37109375, + "gradient_norm": 0.3569585978984833, + "elapsed": 79.38981986045837 + }, + { + "step": 208, + "loss": 0.6469261646270752, + "error": 0.4296875, + "gradient_norm": 0.18999285995960236, + "elapsed": 84.23919153213501 + }, + { + "step": 224, + "loss": 0.5015400648117065, + "error": 0.26171875, + "gradient_norm": 0.14661277830600739, + "elapsed": 89.08856391906738 + }, + { + "step": 240, + "loss": 0.5771075487136841, + "error": 0.30859375, + "gradient_norm": 0.16081298887729645, + "elapsed": 94.75072908401489 + }, + { + "step": 256, + "loss": 0.4888438582420349, + "error": 0.265625, + "gradient_norm": 0.0695391371846199, + "elapsed": 101.01203680038452 + }, + { + "step": 272, + "loss": 0.4024130702018738, + "error": 0.171875, + "gradient_norm": 0.12405848503112793, + "elapsed": 110.68109226226807 + }, + { + "step": 288, + "loss": 0.5895810723304749, + "error": 0.34375, + "gradient_norm": 0.11818791180849075, + "elapsed": 117.13554787635803 + }, + { + "step": 304, + "loss": 0.4740591049194336, + "error": 0.23828125, + "gradient_norm": 0.12323135882616043, + "elapsed": 123.14409065246582 + }, + { + "step": 320, + "loss": 0.007106379605829716, + "error": 0.0, + "gradient_norm": 0.011303205043077469, + "elapsed": 129.3651967048645 + }, + { + "step": 336, + "loss": 0.11020991206169128, + "error": 0.046875, + "gradient_norm": 0.09031850099563599, + "elapsed": 135.01193165779114 + }, + { + "step": 352, + "loss": 0.47800248861312866, + "error": 0.23046875, + "gradient_norm": 0.09636854380369186, + "elapsed": 141.10205006599426 + }, + { + "step": 368, + "loss": 0.4062168598175049, + "error": 0.203125, + "gradient_norm": 0.17921771109104156, + "elapsed": 146.6507167816162 + }, + { + "step": 384, + "loss": 0.24366013705730438, + "error": 0.12109375, + "gradient_norm": 0.11793741583824158, + "elapsed": 152.7517864704132 + }, + { + "step": 400, + "loss": 0.4949762225151062, + "error": 0.28515625, + "gradient_norm": 0.09550267457962036, + "elapsed": 160.96661829948425 + }, + { + "step": 416, + "loss": 0.21066513657569885, + "error": 0.08984375, + "gradient_norm": 0.07445460557937622, + "elapsed": 165.83068180084229 + }, + { + "step": 432, + "loss": 0.4017776548862457, + "error": 0.18359375, + "gradient_norm": 0.1278357356786728, + "elapsed": 170.6406123638153 + }, + { + "step": 448, + "loss": 0.11823543906211853, + "error": 0.04296875, + "gradient_norm": 0.09968453645706177, + "elapsed": 175.4701704978943 + }, + { + "step": 464, + "loss": 0.47654634714126587, + "error": 0.2265625, + "gradient_norm": 0.18101797997951508, + "elapsed": 180.26738119125366 + }, + { + "step": 480, + "loss": 0.4916652739048004, + "error": 0.24609375, + "gradient_norm": 0.08958703279495239, + "elapsed": 185.08883357048035 + }, + { + "step": 496, + "loss": 0.5418418645858765, + "error": 0.3515625, + "gradient_norm": 0.08218713104724884, + "elapsed": 189.9677882194519 + }, + { + "step": 512, + "loss": 0.5470219850540161, + "error": 0.359375, + "gradient_norm": 0.07939601689577103, + "elapsed": 194.77887177467346 + } + ] + }, + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with incumbent.", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23592247596153845, + "128": 0.23888221153846154, + "blend-128": 0.23536658653846151, + "256": 0.23865685096153846, + "blend-256": 0.23538161057692308, + "384": 0.23852163461538461, + "blend-384": 0.23487079326923077, + "512": 0.23870192307692306, + "blend-512": 0.23482572115384615 + }, + "selected": "blend-512" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22291165865384616, + "128": 0.2279897836538462, + "blend-128": 0.22366286057692308, + "256": 0.2274188701923077, + "blend-256": 0.22304687500000003, + "384": 0.22729867788461536, + "blend-384": 0.22337740384615384, + "512": 0.22662259615384617, + "blend-512": 0.22355769230769235 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "512": { + "step": 512, + "training_samples": 131072, + "weights_sha256": "86aa65455686eb06a430030bd4b8242ac78521dccf4e9b07f1e93b2aa2ec40af", + "complete": true + } + }, + "runtime": "Shared initial complementary-CSS priors between neural and physical branches in blended groups. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + { + "training": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23482572115384615, + "256": 0.2346754807692308, + "blend-256": 0.23484074519230771, + "512": 0.23569711538461538, + "blend-512": 0.2338341346153846, + "768": 0.23470552884615387, + "blend-768": 0.23464543269230764, + "1024": 0.23653846153846153, + "blend-1024": 0.23445012019230768 + }, + "selected": "blend-512" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22291165865384616, + "256": 0.2231520432692308, + "blend-256": 0.2219951923076923, + "512": 0.22303185096153846, + "blend-512": 0.22211538461538463, + "768": 0.22279146634615382, + "blend-768": 0.2219501201923077, + "1024": 0.22291165865384616, + "blend-1024": 0.22182992788461542 + }, + "selected": "blend-1024" + } + ], + "checkpoints": { + "512": { + "step": 512, + "training_samples": 131072, + "weights_sha256": "6109f95c51d7b8803085c84b6bb34e3f199cc349bd846d6007c8f9a4f2a0c4fe", + "complete": true + }, + "1024": { + "step": 1024, + "training_samples": 262144, + "weights_sha256": "46aa01e703f38fa153206c54ff0ce7083d839de7aeb51bf14c8e732d52d5bd2d", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "training_source_sha256": { + "learned_d5__train.py": "b73af9da21332dee9a43f653b514695b020fbc3516604b2e721d8cf0ea876d53", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "5e9420df1f6dd56518925e910096fb9bc93bd796a5933b13bf894a1a96256cdf", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 507282, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 19592, + "surface_code_bX_d5_r03_center_5_5": 19646, + "surface_code_bX_d5_r05_center_5_5": 19513, + "surface_code_bX_d5_r07_center_5_5": 19341, + "surface_code_bX_d5_r09_center_5_5": 19211, + "surface_code_bX_d5_r11_center_5_5": 19239, + "surface_code_bX_d5_r13_center_5_5": 19679, + "surface_code_bX_d5_r15_center_5_5": 19455, + "surface_code_bX_d5_r17_center_5_5": 19479, + "surface_code_bX_d5_r19_center_5_5": 19479, + "surface_code_bX_d5_r21_center_5_5": 19551, + "surface_code_bX_d5_r23_center_5_5": 19586, + "surface_code_bX_d5_r25_center_5_5": 19526, + "surface_code_bZ_d5_r01_center_5_5": 19652, + "surface_code_bZ_d5_r03_center_5_5": 19732, + "surface_code_bZ_d5_r05_center_5_5": 19754, + "surface_code_bZ_d5_r07_center_5_5": 19194, + "surface_code_bZ_d5_r09_center_5_5": 19641, + "surface_code_bZ_d5_r11_center_5_5": 19611, + "surface_code_bZ_d5_r13_center_5_5": 19424, + "surface_code_bZ_d5_r15_center_5_5": 19380, + "surface_code_bZ_d5_r17_center_5_5": 19384, + "surface_code_bZ_d5_r19_center_5_5": 19684, + "surface_code_bZ_d5_r21_center_5_5": 19559, + "surface_code_bZ_d5_r23_center_5_5": 19524, + "surface_code_bZ_d5_r25_center_5_5": 19446 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 2048, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261113, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_d5/feedback3_pilot/rng-768.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/feedback3_pilot/weights-768.npz", + "starting_checkpoint_sha256": "bc2ba1c529317ce1b5b661efae4707eca49c6995d6f22b04193fe7642662fed8", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4341062307357788, + "objective": 0.4341062307357788, + "error": 0.208984375, + "gradient_norm": 0.07617632299661636, + "elapsed": 31.45817995071411 + }, + { + "step": 16, + "loss": 0.5996706485748291, + "objective": 0.5996706485748291, + "error": 0.359375, + "gradient_norm": 0.05249844491481781, + "elapsed": 56.34200572967529 + }, + { + "step": 32, + "loss": 0.4388691186904907, + "objective": 0.4388691186904907, + "error": 0.2041015625, + "gradient_norm": 0.0376109778881073, + "elapsed": 67.83739852905273 + }, + { + "step": 48, + "loss": 0.5373439788818359, + "objective": 0.5373439788818359, + "error": 0.2919921875, + "gradient_norm": 0.06261218339204788, + "elapsed": 76.69065475463867 + }, + { + "step": 64, + "loss": 0.24871854484081268, + "objective": 0.24871854484081268, + "error": 0.1162109375, + "gradient_norm": 0.05284671485424042, + "elapsed": 86.3852767944336 + }, + { + "step": 80, + "loss": 0.26628297567367554, + "objective": 0.26628297567367554, + "error": 0.123046875, + "gradient_norm": 0.04054367542266846, + "elapsed": 95.77356100082397 + }, + { + "step": 96, + "loss": 0.48436349630355835, + "objective": 0.48436349630355835, + "error": 0.259765625, + "gradient_norm": 0.05399860441684723, + "elapsed": 107.06293416023254 + }, + { + "step": 112, + "loss": 0.41063767671585083, + "objective": 0.41063767671585083, + "error": 0.1943359375, + "gradient_norm": 0.043602071702480316, + "elapsed": 116.78119611740112 + }, + { + "step": 128, + "loss": 0.3990316390991211, + "objective": 0.3990316390991211, + "error": 0.1865234375, + "gradient_norm": 0.0424419641494751, + "elapsed": 125.6915397644043 + }, + { + "step": 144, + "loss": 0.5119550228118896, + "objective": 0.5119550228118896, + "error": 0.2646484375, + "gradient_norm": 0.07688591629266739, + "elapsed": 136.20711088180542 + }, + { + "step": 160, + "loss": 0.3388235569000244, + "objective": 0.3388235569000244, + "error": 0.1630859375, + "gradient_norm": 0.07015731930732727, + "elapsed": 145.3505516052246 + }, + { + "step": 176, + "loss": 0.5952156186103821, + "objective": 0.5952156186103821, + "error": 0.3369140625, + "gradient_norm": 0.039373140782117844, + "elapsed": 154.77994871139526 + }, + { + "step": 192, + "loss": 0.15157413482666016, + "objective": 0.15157413482666016, + "error": 0.0634765625, + "gradient_norm": 0.029710670933127403, + "elapsed": 164.46801733970642 + }, + { + "step": 208, + "loss": 0.3120684027671814, + "objective": 0.3120684027671814, + "error": 0.1474609375, + "gradient_norm": 0.035548821091651917, + "elapsed": 173.24825358390808 + }, + { + "step": 224, + "loss": 0.5486405491828918, + "objective": 0.5486405491828918, + "error": 0.2900390625, + "gradient_norm": 0.0503678023815155, + "elapsed": 185.29849314689636 + }, + { + "step": 240, + "loss": 0.6046283841133118, + "objective": 0.6046283841133118, + "error": 0.3349609375, + "gradient_norm": 0.05043461173772812, + "elapsed": 197.54880928993225 + }, + { + "step": 256, + "loss": 0.5926339626312256, + "objective": 0.5926339626312256, + "error": 0.3359375, + "gradient_norm": 0.051241543143987656, + "elapsed": 211.79861068725586 + }, + { + "step": 272, + "loss": 0.4018518924713135, + "objective": 0.4018518924713135, + "error": 0.1943359375, + "gradient_norm": 0.0772147998213768, + "elapsed": 222.41974115371704 + }, + { + "step": 288, + "loss": 0.13863243162631989, + "objective": 0.13863243162631989, + "error": 0.0556640625, + "gradient_norm": 0.03334609419107437, + "elapsed": 234.04247426986694 + }, + { + "step": 304, + "loss": 0.562490701675415, + "objective": 0.562490701675415, + "error": 0.337890625, + "gradient_norm": 0.04585934057831764, + "elapsed": 242.65421533584595 + }, + { + "step": 320, + "loss": 0.5352796316146851, + "objective": 0.5352796316146851, + "error": 0.294921875, + "gradient_norm": 0.0837635025382042, + "elapsed": 252.10656356811523 + }, + { + "step": 336, + "loss": 0.26082637906074524, + "objective": 0.26082637906074524, + "error": 0.1220703125, + "gradient_norm": 0.048336997628211975, + "elapsed": 262.33449625968933 + }, + { + "step": 352, + "loss": 0.5959363579750061, + "objective": 0.5959363579750061, + "error": 0.3388671875, + "gradient_norm": 0.06797357648611069, + "elapsed": 271.9942307472229 + }, + { + "step": 368, + "loss": 0.48994284868240356, + "objective": 0.48994284868240356, + "error": 0.2587890625, + "gradient_norm": 0.06296153366565704, + "elapsed": 283.0493588447571 + }, + { + "step": 384, + "loss": 0.5710494518280029, + "objective": 0.5710494518280029, + "error": 0.3134765625, + "gradient_norm": 0.045333269983530045, + "elapsed": 294.64637446403503 + }, + { + "step": 400, + "loss": 0.5957783460617065, + "objective": 0.5957783460617065, + "error": 0.349609375, + "gradient_norm": 0.03918786719441414, + "elapsed": 307.6200888156891 + }, + { + "step": 416, + "loss": 0.27521568536758423, + "objective": 0.27521568536758423, + "error": 0.1220703125, + "gradient_norm": 0.038001637905836105, + "elapsed": 317.01610231399536 + }, + { + "step": 432, + "loss": 0.02379823848605156, + "objective": 0.02379823848605156, + "error": 0.0078125, + "gradient_norm": 0.007661945186555386, + "elapsed": 326.9360330104828 + }, + { + "step": 448, + "loss": 0.56734299659729, + "objective": 0.56734299659729, + "error": 0.3271484375, + "gradient_norm": 0.057416290044784546, + "elapsed": 339.6289041042328 + }, + { + "step": 464, + "loss": 0.10715995728969574, + "objective": 0.10715995728969574, + "error": 0.0380859375, + "gradient_norm": 0.02532491274178028, + "elapsed": 349.8584108352661 + }, + { + "step": 480, + "loss": 0.6143364310264587, + "objective": 0.6143364310264587, + "error": 0.36328125, + "gradient_norm": 0.08023032546043396, + "elapsed": 360.36362075805664 + }, + { + "step": 496, + "loss": 0.44069671630859375, + "objective": 0.44069671630859375, + "error": 0.2197265625, + "gradient_norm": 0.048025116324424744, + "elapsed": 369.48225808143616 + }, + { + "step": 512, + "loss": 0.019900165498256683, + "objective": 0.019900165498256683, + "error": 0.0107421875, + "gradient_norm": 0.0038635791279375553, + "elapsed": 378.59970593452454 + }, + { + "step": 528, + "loss": 0.033316534012556076, + "objective": 0.033316534012556076, + "error": 0.009765625, + "gradient_norm": 0.009174940176308155, + "elapsed": 393.4021761417389 + }, + { + "step": 544, + "loss": 0.41130945086479187, + "objective": 0.41130945086479187, + "error": 0.20703125, + "gradient_norm": 0.04695262759923935, + "elapsed": 402.8586280345917 + }, + { + "step": 560, + "loss": 0.5885373950004578, + "objective": 0.5885373950004578, + "error": 0.3544921875, + "gradient_norm": 0.08534500002861023, + "elapsed": 416.98661041259766 + }, + { + "step": 576, + "loss": 0.3804720640182495, + "objective": 0.3804720640182495, + "error": 0.19140625, + "gradient_norm": 0.05163278803229332, + "elapsed": 427.7550480365753 + }, + { + "step": 592, + "loss": 0.6101120710372925, + "objective": 0.6101120710372925, + "error": 0.3525390625, + "gradient_norm": 0.05593184754252434, + "elapsed": 441.05026268959045 + }, + { + "step": 608, + "loss": 0.5586092472076416, + "objective": 0.5586092472076416, + "error": 0.302734375, + "gradient_norm": 0.07458740472793579, + "elapsed": 452.95383286476135 + }, + { + "step": 624, + "loss": 0.5992780923843384, + "objective": 0.5992780923843384, + "error": 0.357421875, + "gradient_norm": 0.03618372976779938, + "elapsed": 466.1582691669464 + }, + { + "step": 640, + "loss": 0.3536975383758545, + "objective": 0.3536975383758545, + "error": 0.1650390625, + "gradient_norm": 0.05353165790438652, + "elapsed": 477.166255235672 + }, + { + "step": 656, + "loss": 0.4926893711090088, + "objective": 0.4926893711090088, + "error": 0.2626953125, + "gradient_norm": 0.05201377719640732, + "elapsed": 491.1417751312256 + }, + { + "step": 672, + "loss": 0.5754991173744202, + "objective": 0.5754991173744202, + "error": 0.3271484375, + "gradient_norm": 0.08167096972465515, + "elapsed": 501.630366563797 + }, + { + "step": 688, + "loss": 0.5685014724731445, + "objective": 0.5685014724731445, + "error": 0.333984375, + "gradient_norm": 0.043775107711553574, + "elapsed": 514.2880456447601 + }, + { + "step": 704, + "loss": 0.022465089336037636, + "objective": 0.022465089336037636, + "error": 0.0068359375, + "gradient_norm": 0.010172540321946144, + "elapsed": 522.9173214435577 + }, + { + "step": 720, + "loss": 0.035460107028484344, + "objective": 0.035460107028484344, + "error": 0.0107421875, + "gradient_norm": 0.010515578091144562, + "elapsed": 532.8470129966736 + }, + { + "step": 736, + "loss": 0.44765588641166687, + "objective": 0.44765588641166687, + "error": 0.2138671875, + "gradient_norm": 0.09050357341766357, + "elapsed": 541.9488840103149 + }, + { + "step": 752, + "loss": 0.5933939218521118, + "objective": 0.5933939218521118, + "error": 0.3359375, + "gradient_norm": 0.0665116235613823, + "elapsed": 552.9967355728149 + }, + { + "step": 768, + "loss": 0.6100764870643616, + "objective": 0.6100764870643616, + "error": 0.3515625, + "gradient_norm": 0.0821211114525795, + "elapsed": 563.7709202766418 + }, + { + "step": 784, + "loss": 0.02964692935347557, + "objective": 0.02964692935347557, + "error": 0.009765625, + "gradient_norm": 0.012663272209465504, + "elapsed": 573.1517221927643 + }, + { + "step": 800, + "loss": 0.38091832399368286, + "objective": 0.38091832399368286, + "error": 0.1904296875, + "gradient_norm": 0.060622021555900574, + "elapsed": 582.5687477588654 + }, + { + "step": 816, + "loss": 0.552335262298584, + "objective": 0.552335262298584, + "error": 0.3076171875, + "gradient_norm": 0.14419035613536835, + "elapsed": 594.4292685985565 + }, + { + "step": 832, + "loss": 0.5943340063095093, + "objective": 0.5943340063095093, + "error": 0.34375, + "gradient_norm": 0.0633513554930687, + "elapsed": 605.2052299976349 + }, + { + "step": 848, + "loss": 0.6074100732803345, + "objective": 0.6074100732803345, + "error": 0.3486328125, + "gradient_norm": 0.04225531220436096, + "elapsed": 614.8996202945709 + }, + { + "step": 864, + "loss": 0.6198879480361938, + "objective": 0.6198879480361938, + "error": 0.361328125, + "gradient_norm": 0.04208856821060181, + "elapsed": 625.4266908168793 + }, + { + "step": 880, + "loss": 0.6151762008666992, + "objective": 0.6151762008666992, + "error": 0.369140625, + "gradient_norm": 0.06261089444160461, + "elapsed": 636.0696911811829 + }, + { + "step": 896, + "loss": 0.49680083990097046, + "objective": 0.49680083990097046, + "error": 0.25390625, + "gradient_norm": 0.0827067643404007, + "elapsed": 644.6893246173859 + }, + { + "step": 912, + "loss": 0.4610927402973175, + "objective": 0.4610927402973175, + "error": 0.23828125, + "gradient_norm": 0.06652095168828964, + "elapsed": 655.969132900238 + }, + { + "step": 928, + "loss": 0.5218505859375, + "objective": 0.5218505859375, + "error": 0.2685546875, + "gradient_norm": 0.07188194245100021, + "elapsed": 667.5352523326874 + }, + { + "step": 944, + "loss": 0.33009427785873413, + "objective": 0.33009427785873413, + "error": 0.1533203125, + "gradient_norm": 0.05718810483813286, + "elapsed": 677.8397319316864 + }, + { + "step": 960, + "loss": 0.5703234672546387, + "objective": 0.5703234672546387, + "error": 0.3193359375, + "gradient_norm": 0.11168288439512253, + "elapsed": 687.8742904663086 + }, + { + "step": 976, + "loss": 0.025548014789819717, + "objective": 0.025548014789819717, + "error": 0.0107421875, + "gradient_norm": 0.009453393518924713, + "elapsed": 698.294285774231 + }, + { + "step": 992, + "loss": 0.45398157835006714, + "objective": 0.45398157835006714, + "error": 0.2412109375, + "gradient_norm": 0.04607952758669853, + "elapsed": 707.903199672699 + }, + { + "step": 1008, + "loss": 0.3412189781665802, + "objective": 0.3412189781665802, + "error": 0.1513671875, + "gradient_norm": 0.0432075597345829, + "elapsed": 718.5662748813629 + }, + { + "step": 1024, + "loss": 0.4376429319381714, + "objective": 0.4376429319381714, + "error": 0.2275390625, + "gradient_norm": 0.07974351197481155, + "elapsed": 728.8954858779907 + }, + { + "step": 1040, + "loss": 0.33512815833091736, + "objective": 0.33512815833091736, + "error": 0.150390625, + "gradient_norm": 0.04476875811815262, + "elapsed": 744.0822694301605 + }, + { + "step": 1056, + "loss": 0.5214208364486694, + "objective": 0.5214208364486694, + "error": 0.283203125, + "gradient_norm": 0.08898192644119263, + "elapsed": 755.1484262943268 + }, + { + "step": 1072, + "loss": 0.13849599659442902, + "objective": 0.13849599659442902, + "error": 0.052734375, + "gradient_norm": 0.028359953314065933, + "elapsed": 764.3303108215332 + }, + { + "step": 1088, + "loss": 0.323838472366333, + "objective": 0.323838472366333, + "error": 0.1435546875, + "gradient_norm": 0.04081716760993004, + "elapsed": 773.2739362716675 + }, + { + "step": 1104, + "loss": 0.5627881288528442, + "objective": 0.5627881288528442, + "error": 0.3125, + "gradient_norm": 0.08322097361087799, + "elapsed": 784.7223973274231 + }, + { + "step": 1120, + "loss": 0.44111010432243347, + "objective": 0.44111010432243347, + "error": 0.2216796875, + "gradient_norm": 0.05700977146625519, + "elapsed": 795.085648059845 + }, + { + "step": 1136, + "loss": 0.6395992040634155, + "objective": 0.6395992040634155, + "error": 0.39453125, + "gradient_norm": 0.0744553729891777, + "elapsed": 805.7942585945129 + }, + { + "step": 1152, + "loss": 0.5433304309844971, + "objective": 0.5433304309844971, + "error": 0.287109375, + "gradient_norm": 0.04814797267317772, + "elapsed": 817.3382890224457 + }, + { + "step": 1168, + "loss": 0.5708576440811157, + "objective": 0.5708576440811157, + "error": 0.3203125, + "gradient_norm": 0.051331400871276855, + "elapsed": 829.288791179657 + }, + { + "step": 1184, + "loss": 0.5447035431861877, + "objective": 0.5447035431861877, + "error": 0.2939453125, + "gradient_norm": 0.10116687417030334, + "elapsed": 839.6822843551636 + }, + { + "step": 1200, + "loss": 0.6125671863555908, + "objective": 0.6125671863555908, + "error": 0.3642578125, + "gradient_norm": 0.04368080571293831, + "elapsed": 850.2262740135193 + }, + { + "step": 1216, + "loss": 0.5002380609512329, + "objective": 0.5002380609512329, + "error": 0.259765625, + "gradient_norm": 0.04939017817378044, + "elapsed": 862.3783452510834 + }, + { + "step": 1232, + "loss": 0.5698772668838501, + "objective": 0.5698772668838501, + "error": 0.3173828125, + "gradient_norm": 0.04916854575276375, + "elapsed": 871.4622664451599 + }, + { + "step": 1248, + "loss": 0.6046518683433533, + "objective": 0.6046518683433533, + "error": 0.341796875, + "gradient_norm": 0.04919794574379921, + "elapsed": 883.3905737400055 + }, + { + "step": 1264, + "loss": 0.5913128852844238, + "objective": 0.5913128852844238, + "error": 0.357421875, + "gradient_norm": 0.046917904168367386, + "elapsed": 892.4264807701111 + }, + { + "step": 1280, + "loss": 0.5027461051940918, + "objective": 0.5027461051940918, + "error": 0.2626953125, + "gradient_norm": 0.04705750197172165, + "elapsed": 902.5875842571259 + }, + { + "step": 1296, + "loss": 0.13519814610481262, + "objective": 0.13519814610481262, + "error": 0.052734375, + "gradient_norm": 0.02625490538775921, + "elapsed": 912.4087471961975 + }, + { + "step": 1312, + "loss": 0.5862359404563904, + "objective": 0.5862359404563904, + "error": 0.3271484375, + "gradient_norm": 0.05441493168473244, + "elapsed": 923.992555141449 + }, + { + "step": 1328, + "loss": 0.6031408309936523, + "objective": 0.6031408309936523, + "error": 0.3505859375, + "gradient_norm": 0.05901554971933365, + "elapsed": 933.3936491012573 + }, + { + "step": 1344, + "loss": 0.5823733806610107, + "objective": 0.5823733806610107, + "error": 0.3310546875, + "gradient_norm": 0.0842989832162857, + "elapsed": 941.979998588562 + }, + { + "step": 1360, + "loss": 0.6241492033004761, + "objective": 0.6241492033004761, + "error": 0.3720703125, + "gradient_norm": 0.04446673393249512, + "elapsed": 954.969649553299 + }, + { + "step": 1376, + "loss": 0.5829156637191772, + "objective": 0.5829156637191772, + "error": 0.361328125, + "gradient_norm": 0.06615480780601501, + "elapsed": 966.0245676040649 + }, + { + "step": 1392, + "loss": 0.5968320369720459, + "objective": 0.5968320369720459, + "error": 0.34765625, + "gradient_norm": 0.05093541368842125, + "elapsed": 975.1022663116455 + }, + { + "step": 1408, + "loss": 0.045559000223875046, + "objective": 0.045559000223875046, + "error": 0.01171875, + "gradient_norm": 0.02514980360865593, + "elapsed": 987.2391452789307 + }, + { + "step": 1424, + "loss": 0.22601813077926636, + "objective": 0.22601813077926636, + "error": 0.09765625, + "gradient_norm": 0.04834206402301788, + "elapsed": 996.4583384990692 + }, + { + "step": 1440, + "loss": 0.23011144995689392, + "objective": 0.23011144995689392, + "error": 0.111328125, + "gradient_norm": 0.050687842071056366, + "elapsed": 1007.1440904140472 + }, + { + "step": 1456, + "loss": 0.018240466713905334, + "objective": 0.018240466713905334, + "error": 0.0078125, + "gradient_norm": 0.005604141391813755, + "elapsed": 1016.4502851963043 + }, + { + "step": 1472, + "loss": 0.4498720169067383, + "objective": 0.4498720169067383, + "error": 0.232421875, + "gradient_norm": 0.08179625123739243, + "elapsed": 1028.8303294181824 + }, + { + "step": 1488, + "loss": 0.24151627719402313, + "objective": 0.24151627719402313, + "error": 0.107421875, + "gradient_norm": 0.03838668763637543, + "elapsed": 1037.8867321014404 + }, + { + "step": 1504, + "loss": 0.46122002601623535, + "objective": 0.46122002601623535, + "error": 0.232421875, + "gradient_norm": 0.0726623386144638, + "elapsed": 1047.7258644104004 + }, + { + "step": 1520, + "loss": 0.5085602402687073, + "objective": 0.5085602402687073, + "error": 0.2705078125, + "gradient_norm": 0.06673175096511841, + "elapsed": 1059.352120399475 + }, + { + "step": 1536, + "loss": 0.6105246543884277, + "objective": 0.6105246543884277, + "error": 0.3818359375, + "gradient_norm": 0.04271261766552925, + "elapsed": 1070.1413230895996 + }, + { + "step": 1552, + "loss": 0.4792126417160034, + "objective": 0.4792126417160034, + "error": 0.2578125, + "gradient_norm": 0.05200039595365524, + "elapsed": 1086.444006204605 + }, + { + "step": 1568, + "loss": 0.5814266204833984, + "objective": 0.5814266204833984, + "error": 0.330078125, + "gradient_norm": 0.05867309868335724, + "elapsed": 1097.2902619838715 + }, + { + "step": 1584, + "loss": 0.6321226358413696, + "objective": 0.6321226358413696, + "error": 0.3798828125, + "gradient_norm": 0.05418067052960396, + "elapsed": 1107.9767682552338 + }, + { + "step": 1600, + "loss": 0.5931253433227539, + "objective": 0.5931253433227539, + "error": 0.3603515625, + "gradient_norm": 0.06396215409040451, + "elapsed": 1121.782609462738 + }, + { + "step": 1616, + "loss": 0.6411516666412354, + "objective": 0.6411516666412354, + "error": 0.38671875, + "gradient_norm": 0.05035768821835518, + "elapsed": 1132.7197887897491 + }, + { + "step": 1632, + "loss": 0.4267754852771759, + "objective": 0.4267754852771759, + "error": 0.2080078125, + "gradient_norm": 0.09109894186258316, + "elapsed": 1139.1667578220367 + }, + { + "step": 1648, + "loss": 0.21246182918548584, + "objective": 0.21246182918548584, + "error": 0.095703125, + "gradient_norm": 0.04478950425982475, + "elapsed": 1149.1183021068573 + }, + { + "step": 1664, + "loss": 0.46360665559768677, + "objective": 0.46360665559768677, + "error": 0.251953125, + "gradient_norm": 0.07668188214302063, + "elapsed": 1161.1197745800018 + }, + { + "step": 1680, + "loss": 0.46281397342681885, + "objective": 0.46281397342681885, + "error": 0.236328125, + "gradient_norm": 0.07954126596450806, + "elapsed": 1171.8474535942078 + }, + { + "step": 1696, + "loss": 0.2484058141708374, + "objective": 0.2484058141708374, + "error": 0.12109375, + "gradient_norm": 0.047261305153369904, + "elapsed": 1185.6542596817017 + }, + { + "step": 1712, + "loss": 0.24310235679149628, + "objective": 0.24310235679149628, + "error": 0.1064453125, + "gradient_norm": 0.07262872904539108, + "elapsed": 1197.8986082077026 + }, + { + "step": 1728, + "loss": 0.009729458019137383, + "objective": 0.009729458019137383, + "error": 0.001953125, + "gradient_norm": 0.01146845705807209, + "elapsed": 1208.495581150055 + }, + { + "step": 1744, + "loss": 0.24568752944469452, + "objective": 0.24568752944469452, + "error": 0.10546875, + "gradient_norm": 0.05830742046236992, + "elapsed": 1219.9394850730896 + }, + { + "step": 1760, + "loss": 0.022546378895640373, + "objective": 0.022546378895640373, + "error": 0.0068359375, + "gradient_norm": 0.007667526602745056, + "elapsed": 1229.5703229904175 + }, + { + "step": 1776, + "loss": 0.5848401784896851, + "objective": 0.5848401784896851, + "error": 0.3271484375, + "gradient_norm": 0.061901818960905075, + "elapsed": 1238.750280380249 + }, + { + "step": 1792, + "loss": 0.6031335592269897, + "objective": 0.6031335592269897, + "error": 0.3671875, + "gradient_norm": 0.0676632970571518, + "elapsed": 1247.7468683719635 + }, + { + "step": 1808, + "loss": 0.6210961937904358, + "objective": 0.6210961937904358, + "error": 0.3603515625, + "gradient_norm": 0.0718468651175499, + "elapsed": 1256.1821897029877 + }, + { + "step": 1824, + "loss": 0.570877730846405, + "objective": 0.570877730846405, + "error": 0.3212890625, + "gradient_norm": 0.05575930327177048, + "elapsed": 1266.4091975688934 + }, + { + "step": 1840, + "loss": 0.5711429119110107, + "objective": 0.5711429119110107, + "error": 0.31640625, + "gradient_norm": 0.0691002607345581, + "elapsed": 1277.4722146987915 + }, + { + "step": 1856, + "loss": 0.36046335101127625, + "objective": 0.36046335101127625, + "error": 0.16796875, + "gradient_norm": 0.04694395884871483, + "elapsed": 1287.1420249938965 + }, + { + "step": 1872, + "loss": 0.4688999652862549, + "objective": 0.4688999652862549, + "error": 0.2216796875, + "gradient_norm": 0.07401346415281296, + "elapsed": 1297.3945078849792 + }, + { + "step": 1888, + "loss": 0.46385282278060913, + "objective": 0.46385282278060913, + "error": 0.2373046875, + "gradient_norm": 0.05608939751982689, + "elapsed": 1305.9779334068298 + }, + { + "step": 1904, + "loss": 0.60875403881073, + "objective": 0.60875403881073, + "error": 0.365234375, + "gradient_norm": 0.05085878074169159, + "elapsed": 1317.3097081184387 + }, + { + "step": 1920, + "loss": 0.12223530560731888, + "objective": 0.12223530560731888, + "error": 0.0458984375, + "gradient_norm": 0.024870412424206734, + "elapsed": 1328.6486887931824 + }, + { + "step": 1936, + "loss": 0.3486189544200897, + "objective": 0.3486189544200897, + "error": 0.16796875, + "gradient_norm": 0.04780663549900055, + "elapsed": 1336.6701011657715 + }, + { + "step": 1952, + "loss": 0.5777363777160645, + "objective": 0.5777363777160645, + "error": 0.3427734375, + "gradient_norm": 0.0571451336145401, + "elapsed": 1346.9158833026886 + }, + { + "step": 1968, + "loss": 0.39320266246795654, + "objective": 0.39320266246795654, + "error": 0.1884765625, + "gradient_norm": 0.05673858895897865, + "elapsed": 1354.9182631969452 + }, + { + "step": 1984, + "loss": 0.5900611281394958, + "objective": 0.5900611281394958, + "error": 0.3349609375, + "gradient_norm": 0.06593932211399078, + "elapsed": 1364.2754452228546 + }, + { + "step": 2000, + "loss": 0.6212430000305176, + "objective": 0.6212430000305176, + "error": 0.3857421875, + "gradient_norm": 0.040818918496370316, + "elapsed": 1374.7192046642303 + }, + { + "step": 2016, + "loss": 0.15605247020721436, + "objective": 0.15605247020721436, + "error": 0.0556640625, + "gradient_norm": 0.03108786791563034, + "elapsed": 1386.2740807533264 + }, + { + "step": 2032, + "loss": 0.22049596905708313, + "objective": 0.22049596905708313, + "error": 0.1015625, + "gradient_norm": 0.042733557522296906, + "elapsed": 1396.6422457695007 + }, + { + "step": 2048, + "loss": 0.5642613172531128, + "objective": 0.5642613172531128, + "error": 0.306640625, + "gradient_norm": 0.07527482509613037, + "elapsed": 1407.6688070297241 + } + ] + }, + "training_source_snapshot": "training_sources/full3_1", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2338341346153846, + "512": 0.2336688701923077, + "blend-512": 0.23399939903846154, + "1024": 0.23329326923076923, + "blend-1024": 0.23342848557692306, + "1536": 0.2330679086538462, + "blend-1536": 0.23291766826923077, + "2048": 0.2335186298076923, + "blend-2048": 0.23290264423076928 + }, + "selected": "blend-2048" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22182992788461542, + "512": 0.22143930288461539, + "blend-512": 0.22125901442307694, + "1024": 0.22104867788461538, + "blend-1024": 0.22079326923076922, + "1536": 0.22017728365384615, + "blend-1536": 0.22095853365384618, + "2048": 0.22076322115384617, + "blend-2048": 0.22025240384615385 + }, + "selected": "1536" + } + ], + "checkpoints": { + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "gpu_gradient_control.json": { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "data": "First1024 rows of the authorized4096 training sample; no validation labels", + "weights": "Random scratch parameters, seed20261112; gradients only, no parameter update", + "block_size": 32, + "records": [ + { + "batch": 256, + "seconds_per_gradient": 0.38611968358357746, + "shots_per_second": 663.0068625977924, + "memory_stats": { + "num_allocs": 694, + "bytes_in_use": 306432, + "peak_bytes_in_use": 3054084608, + "largest_alloc_size": 3047267584, + "bytes_limit": 76526240993, + "bytes_reserved": 0, + "peak_bytes_reserved": 0, + "largest_free_block_bytes": 0, + "pool_bytes": 76526240768, + "peak_pool_bytes": 76526240768 + } + }, + { + "batch": 512, + "seconds_per_gradient": 0.6622018814086914, + "shots_per_second": 773.178111350017, + "memory_stats": { + "num_allocs": 1332, + "bytes_in_use": 308480, + "peak_bytes_in_use": 6079704832, + "largest_alloc_size": 6069432576, + "bytes_limit": 76526240993, + "bytes_reserved": 0, + "peak_bytes_reserved": 0, + "largest_free_block_bytes": 0, + "pool_bytes": 76526240768, + "peak_pool_bytes": 76526240768 + } + }, + { + "batch": 1024, + "seconds_per_gradient": 1.117707888285319, + "shots_per_second": 916.1606630252231, + "memory_stats": { + "num_allocs": 1970, + "bytes_in_use": 312576, + "peak_bytes_in_use": 12138994176, + "largest_alloc_size": 12122019840, + "bytes_limit": 76526240993, + "bytes_reserved": 0, + "peak_bytes_reserved": 0, + "largest_free_block_bytes": 0, + "pool_bytes": 76526240768, + "peak_pool_bytes": 76526240768 + } + } + ], + "original_gradient_gpu_control": { + "loss_max_difference": 1.6689300537109375e-06, + "prediction_max_difference": 1.0132789611816406e-06, + "neural_gradient_relative_difference": 5.505155786522664e-05, + "float64_precision_audit": "/run-state/workspace/research/learned_d5/full3_1/gpu_gradient_precision.json", + "tolerance_rationale": "Original3e-5 GPU gradient threshold failed at5.51e-5. Independent float64 audits of both float32 algorithms across six X/Z durations found comparable relative rounding errors up to5.72e-5, with probability errors below6.2e-7. Use1e-4 relative for this accumulated derivative." + } + }, + "gpu_gradient_precision.json": { + "data": "First16 supplied training rows per listed condition; no parameter updates", + "weights": "full3_1/weights-1536.npz", + "reference": "Original unblocked algorithm in float64, fixed float32 neural edge probabilities", + "source_sha256": { + "gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8" + }, + "initial_gpu_control_failure": { + "relative_neural_gradient_difference": 5.505155786522664e-05, + "original_tolerance": 3e-05, + "maximum_loss_difference": 1.6689300537109375e-06, + "maximum_prediction_difference": 1.0132789611816406e-06 + }, + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.30205945019442737, + "unblocked_float32": { + "maximum_loss_error": 2.966804864001915e-07, + "maximum_probability_error": 9.592670685565352e-08, + "neural_gradient_maximum_absolute_error": 1.6391277313232422e-07, + "neural_gradient_relative_error": 3.6604459916077934e-06, + "neural_gradient_cosine": 0.9999999999933656 + }, + "blocked_float32": { + "maximum_loss_error": 1.7747119684941026e-07, + "maximum_probability_error": 8.879568846875685e-08, + "neural_gradient_maximum_absolute_error": 1.7881393432617188e-07, + "neural_gradient_relative_error": 4.366049097416422e-06, + "neural_gradient_cosine": 0.9999999999904692 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.22069588396473294, + "unblocked_float32": { + "maximum_loss_error": 5.498523059088711e-07, + "maximum_probability_error": 9.703680636796719e-08, + "neural_gradient_maximum_absolute_error": 6.686605047434568e-08, + "neural_gradient_relative_error": 2.392500410145668e-06, + "neural_gradient_cosine": 0.999999999997144 + }, + "blocked_float32": { + "maximum_loss_error": 8.745212829311194e-08, + "maximum_probability_error": 6.418482079162402e-08, + "neural_gradient_maximum_absolute_error": 6.705522537231445e-08, + "neural_gradient_relative_error": 1.7739189351699108e-06, + "neural_gradient_cosine": 0.9999999999984265 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.4664494516878606, + "unblocked_float32": { + "maximum_loss_error": 3.922858555771569e-07, + "maximum_probability_error": 2.581999101192167e-07, + "neural_gradient_maximum_absolute_error": 1.7015263438224792e-06, + "neural_gradient_relative_error": 2.234804892316077e-05, + "neural_gradient_cosine": 0.9999999997509151 + }, + "blocked_float32": { + "maximum_loss_error": 3.3479861938356947e-07, + "maximum_probability_error": 1.4954284288659636e-07, + "neural_gradient_maximum_absolute_error": 1.6633421182632446e-06, + "neural_gradient_relative_error": 2.4167285966292737e-05, + "neural_gradient_cosine": 0.9999999997089409 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.438354906018253, + "unblocked_float32": { + "maximum_loss_error": 6.361644384611509e-07, + "maximum_probability_error": 3.6173952677742705e-07, + "neural_gradient_maximum_absolute_error": 1.9436702132225037e-06, + "neural_gradient_relative_error": 5.252014500992631e-05, + "neural_gradient_cosine": 0.9999999986254251 + }, + "blocked_float32": { + "maximum_loss_error": 5.060161181180689e-07, + "maximum_probability_error": 2.589724067414423e-07, + "neural_gradient_maximum_absolute_error": 1.946929842233658e-06, + "neural_gradient_relative_error": 5.71756656511251e-05, + "neural_gradient_cosine": 0.999999998372327 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.3057787329709659, + "unblocked_float32": { + "maximum_loss_error": 6.74491174690317e-07, + "maximum_probability_error": 4.3885854938974234e-07, + "neural_gradient_maximum_absolute_error": 8.174683898687363e-07, + "neural_gradient_relative_error": 4.090547224844183e-05, + "neural_gradient_cosine": 0.9999999991633716 + }, + "blocked_float32": { + "maximum_loss_error": 6.643292806973733e-07, + "maximum_probability_error": 4.835620329712853e-07, + "neural_gradient_maximum_absolute_error": 1.1210795491933823e-06, + "neural_gradient_relative_error": 5.584921905818847e-05, + "neural_gradient_cosine": 0.9999999984491473 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "training_rows": 16, + "reference_neural_gradient_norm": 0.2501411033127809, + "unblocked_float32": { + "maximum_loss_error": 1.167099820564843e-06, + "maximum_probability_error": 4.921027032533942e-07, + "neural_gradient_maximum_absolute_error": 7.14324414730072e-07, + "neural_gradient_relative_error": 4.528117886548381e-05, + "neural_gradient_cosine": 0.9999999989770499 + }, + "blocked_float32": { + "maximum_loss_error": 1.4055183996664056e-06, + "maximum_probability_error": 6.113119928041755e-07, + "neural_gradient_maximum_absolute_error": 7.075723260641098e-07, + "neural_gradient_relative_error": 5.112087336342683e-05, + "neural_gradient_cosine": 0.9999999986947755 + } + } + ], + "status": "passed" + } + } + }, + { + "training": { + "initialization": "Uniform parameter averages of checkpoints from the same session-initialized training trajectory; no external weights", + "prior_pass": 3, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "hidden_width": 64, + "training": "No new optimizer updates; all learning comes from the recorded source trajectory and its session-trained parent", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "training_source_sha256": { + "learned_d5__train.py": "b73af9da21332dee9a43f653b514695b020fbc3516604b2e721d8cf0ea876d53", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "5e9420df1f6dd56518925e910096fb9bc93bd796a5933b13bf894a1a96256cdf", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 507282, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 19592, + "surface_code_bX_d5_r03_center_5_5": 19646, + "surface_code_bX_d5_r05_center_5_5": 19513, + "surface_code_bX_d5_r07_center_5_5": 19341, + "surface_code_bX_d5_r09_center_5_5": 19211, + "surface_code_bX_d5_r11_center_5_5": 19239, + "surface_code_bX_d5_r13_center_5_5": 19679, + "surface_code_bX_d5_r15_center_5_5": 19455, + "surface_code_bX_d5_r17_center_5_5": 19479, + "surface_code_bX_d5_r19_center_5_5": 19479, + "surface_code_bX_d5_r21_center_5_5": 19551, + "surface_code_bX_d5_r23_center_5_5": 19586, + "surface_code_bX_d5_r25_center_5_5": 19526, + "surface_code_bZ_d5_r01_center_5_5": 19652, + "surface_code_bZ_d5_r03_center_5_5": 19732, + "surface_code_bZ_d5_r05_center_5_5": 19754, + "surface_code_bZ_d5_r07_center_5_5": 19194, + "surface_code_bZ_d5_r09_center_5_5": 19641, + "surface_code_bZ_d5_r11_center_5_5": 19611, + "surface_code_bZ_d5_r13_center_5_5": 19424, + "surface_code_bZ_d5_r15_center_5_5": 19380, + "surface_code_bZ_d5_r17_center_5_5": 19384, + "surface_code_bZ_d5_r19_center_5_5": 19684, + "surface_code_bZ_d5_r21_center_5_5": 19559, + "surface_code_bZ_d5_r23_center_5_5": 19524, + "surface_code_bZ_d5_r25_center_5_5": 19446 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 2048, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261113, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_d5/feedback3_pilot/rng-768.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/feedback3_pilot/weights-768.npz", + "starting_checkpoint_sha256": "bc2ba1c529317ce1b5b661efae4707eca49c6995d6f22b04193fe7642662fed8", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4341062307357788, + "objective": 0.4341062307357788, + "error": 0.208984375, + "gradient_norm": 0.07617632299661636, + "elapsed": 31.45817995071411 + }, + { + "step": 16, + "loss": 0.5996706485748291, + "objective": 0.5996706485748291, + "error": 0.359375, + "gradient_norm": 0.05249844491481781, + "elapsed": 56.34200572967529 + }, + { + "step": 32, + "loss": 0.4388691186904907, + "objective": 0.4388691186904907, + "error": 0.2041015625, + "gradient_norm": 0.0376109778881073, + "elapsed": 67.83739852905273 + }, + { + "step": 48, + "loss": 0.5373439788818359, + "objective": 0.5373439788818359, + "error": 0.2919921875, + "gradient_norm": 0.06261218339204788, + "elapsed": 76.69065475463867 + }, + { + "step": 64, + "loss": 0.24871854484081268, + "objective": 0.24871854484081268, + "error": 0.1162109375, + "gradient_norm": 0.05284671485424042, + "elapsed": 86.3852767944336 + }, + { + "step": 80, + "loss": 0.26628297567367554, + "objective": 0.26628297567367554, + "error": 0.123046875, + "gradient_norm": 0.04054367542266846, + "elapsed": 95.77356100082397 + }, + { + "step": 96, + "loss": 0.48436349630355835, + "objective": 0.48436349630355835, + "error": 0.259765625, + "gradient_norm": 0.05399860441684723, + "elapsed": 107.06293416023254 + }, + { + "step": 112, + "loss": 0.41063767671585083, + "objective": 0.41063767671585083, + "error": 0.1943359375, + "gradient_norm": 0.043602071702480316, + "elapsed": 116.78119611740112 + }, + { + "step": 128, + "loss": 0.3990316390991211, + "objective": 0.3990316390991211, + "error": 0.1865234375, + "gradient_norm": 0.0424419641494751, + "elapsed": 125.6915397644043 + }, + { + "step": 144, + "loss": 0.5119550228118896, + "objective": 0.5119550228118896, + "error": 0.2646484375, + "gradient_norm": 0.07688591629266739, + "elapsed": 136.20711088180542 + }, + { + "step": 160, + "loss": 0.3388235569000244, + "objective": 0.3388235569000244, + "error": 0.1630859375, + "gradient_norm": 0.07015731930732727, + "elapsed": 145.3505516052246 + }, + { + "step": 176, + "loss": 0.5952156186103821, + "objective": 0.5952156186103821, + "error": 0.3369140625, + "gradient_norm": 0.039373140782117844, + "elapsed": 154.77994871139526 + }, + { + "step": 192, + "loss": 0.15157413482666016, + "objective": 0.15157413482666016, + "error": 0.0634765625, + "gradient_norm": 0.029710670933127403, + "elapsed": 164.46801733970642 + }, + { + "step": 208, + "loss": 0.3120684027671814, + "objective": 0.3120684027671814, + "error": 0.1474609375, + "gradient_norm": 0.035548821091651917, + "elapsed": 173.24825358390808 + }, + { + "step": 224, + "loss": 0.5486405491828918, + "objective": 0.5486405491828918, + "error": 0.2900390625, + "gradient_norm": 0.0503678023815155, + "elapsed": 185.29849314689636 + }, + { + "step": 240, + "loss": 0.6046283841133118, + "objective": 0.6046283841133118, + "error": 0.3349609375, + "gradient_norm": 0.05043461173772812, + "elapsed": 197.54880928993225 + }, + { + "step": 256, + "loss": 0.5926339626312256, + "objective": 0.5926339626312256, + "error": 0.3359375, + "gradient_norm": 0.051241543143987656, + "elapsed": 211.79861068725586 + }, + { + "step": 272, + "loss": 0.4018518924713135, + "objective": 0.4018518924713135, + "error": 0.1943359375, + "gradient_norm": 0.0772147998213768, + "elapsed": 222.41974115371704 + }, + { + "step": 288, + "loss": 0.13863243162631989, + "objective": 0.13863243162631989, + "error": 0.0556640625, + "gradient_norm": 0.03334609419107437, + "elapsed": 234.04247426986694 + }, + { + "step": 304, + "loss": 0.562490701675415, + "objective": 0.562490701675415, + "error": 0.337890625, + "gradient_norm": 0.04585934057831764, + "elapsed": 242.65421533584595 + }, + { + "step": 320, + "loss": 0.5352796316146851, + "objective": 0.5352796316146851, + "error": 0.294921875, + "gradient_norm": 0.0837635025382042, + "elapsed": 252.10656356811523 + }, + { + "step": 336, + "loss": 0.26082637906074524, + "objective": 0.26082637906074524, + "error": 0.1220703125, + "gradient_norm": 0.048336997628211975, + "elapsed": 262.33449625968933 + }, + { + "step": 352, + "loss": 0.5959363579750061, + "objective": 0.5959363579750061, + "error": 0.3388671875, + "gradient_norm": 0.06797357648611069, + "elapsed": 271.9942307472229 + }, + { + "step": 368, + "loss": 0.48994284868240356, + "objective": 0.48994284868240356, + "error": 0.2587890625, + "gradient_norm": 0.06296153366565704, + "elapsed": 283.0493588447571 + }, + { + "step": 384, + "loss": 0.5710494518280029, + "objective": 0.5710494518280029, + "error": 0.3134765625, + "gradient_norm": 0.045333269983530045, + "elapsed": 294.64637446403503 + }, + { + "step": 400, + "loss": 0.5957783460617065, + "objective": 0.5957783460617065, + "error": 0.349609375, + "gradient_norm": 0.03918786719441414, + "elapsed": 307.6200888156891 + }, + { + "step": 416, + "loss": 0.27521568536758423, + "objective": 0.27521568536758423, + "error": 0.1220703125, + "gradient_norm": 0.038001637905836105, + "elapsed": 317.01610231399536 + }, + { + "step": 432, + "loss": 0.02379823848605156, + "objective": 0.02379823848605156, + "error": 0.0078125, + "gradient_norm": 0.007661945186555386, + "elapsed": 326.9360330104828 + }, + { + "step": 448, + "loss": 0.56734299659729, + "objective": 0.56734299659729, + "error": 0.3271484375, + "gradient_norm": 0.057416290044784546, + "elapsed": 339.6289041042328 + }, + { + "step": 464, + "loss": 0.10715995728969574, + "objective": 0.10715995728969574, + "error": 0.0380859375, + "gradient_norm": 0.02532491274178028, + "elapsed": 349.8584108352661 + }, + { + "step": 480, + "loss": 0.6143364310264587, + "objective": 0.6143364310264587, + "error": 0.36328125, + "gradient_norm": 0.08023032546043396, + "elapsed": 360.36362075805664 + }, + { + "step": 496, + "loss": 0.44069671630859375, + "objective": 0.44069671630859375, + "error": 0.2197265625, + "gradient_norm": 0.048025116324424744, + "elapsed": 369.48225808143616 + }, + { + "step": 512, + "loss": 0.019900165498256683, + "objective": 0.019900165498256683, + "error": 0.0107421875, + "gradient_norm": 0.0038635791279375553, + "elapsed": 378.59970593452454 + }, + { + "step": 528, + "loss": 0.033316534012556076, + "objective": 0.033316534012556076, + "error": 0.009765625, + "gradient_norm": 0.009174940176308155, + "elapsed": 393.4021761417389 + }, + { + "step": 544, + "loss": 0.41130945086479187, + "objective": 0.41130945086479187, + "error": 0.20703125, + "gradient_norm": 0.04695262759923935, + "elapsed": 402.8586280345917 + }, + { + "step": 560, + "loss": 0.5885373950004578, + "objective": 0.5885373950004578, + "error": 0.3544921875, + "gradient_norm": 0.08534500002861023, + "elapsed": 416.98661041259766 + }, + { + "step": 576, + "loss": 0.3804720640182495, + "objective": 0.3804720640182495, + "error": 0.19140625, + "gradient_norm": 0.05163278803229332, + "elapsed": 427.7550480365753 + }, + { + "step": 592, + "loss": 0.6101120710372925, + "objective": 0.6101120710372925, + "error": 0.3525390625, + "gradient_norm": 0.05593184754252434, + "elapsed": 441.05026268959045 + }, + { + "step": 608, + "loss": 0.5586092472076416, + "objective": 0.5586092472076416, + "error": 0.302734375, + "gradient_norm": 0.07458740472793579, + "elapsed": 452.95383286476135 + }, + { + "step": 624, + "loss": 0.5992780923843384, + "objective": 0.5992780923843384, + "error": 0.357421875, + "gradient_norm": 0.03618372976779938, + "elapsed": 466.1582691669464 + }, + { + "step": 640, + "loss": 0.3536975383758545, + "objective": 0.3536975383758545, + "error": 0.1650390625, + "gradient_norm": 0.05353165790438652, + "elapsed": 477.166255235672 + }, + { + "step": 656, + "loss": 0.4926893711090088, + "objective": 0.4926893711090088, + "error": 0.2626953125, + "gradient_norm": 0.05201377719640732, + "elapsed": 491.1417751312256 + }, + { + "step": 672, + "loss": 0.5754991173744202, + "objective": 0.5754991173744202, + "error": 0.3271484375, + "gradient_norm": 0.08167096972465515, + "elapsed": 501.630366563797 + }, + { + "step": 688, + "loss": 0.5685014724731445, + "objective": 0.5685014724731445, + "error": 0.333984375, + "gradient_norm": 0.043775107711553574, + "elapsed": 514.2880456447601 + }, + { + "step": 704, + "loss": 0.022465089336037636, + "objective": 0.022465089336037636, + "error": 0.0068359375, + "gradient_norm": 0.010172540321946144, + "elapsed": 522.9173214435577 + }, + { + "step": 720, + "loss": 0.035460107028484344, + "objective": 0.035460107028484344, + "error": 0.0107421875, + "gradient_norm": 0.010515578091144562, + "elapsed": 532.8470129966736 + }, + { + "step": 736, + "loss": 0.44765588641166687, + "objective": 0.44765588641166687, + "error": 0.2138671875, + "gradient_norm": 0.09050357341766357, + "elapsed": 541.9488840103149 + }, + { + "step": 752, + "loss": 0.5933939218521118, + "objective": 0.5933939218521118, + "error": 0.3359375, + "gradient_norm": 0.0665116235613823, + "elapsed": 552.9967355728149 + }, + { + "step": 768, + "loss": 0.6100764870643616, + "objective": 0.6100764870643616, + "error": 0.3515625, + "gradient_norm": 0.0821211114525795, + "elapsed": 563.7709202766418 + }, + { + "step": 784, + "loss": 0.02964692935347557, + "objective": 0.02964692935347557, + "error": 0.009765625, + "gradient_norm": 0.012663272209465504, + "elapsed": 573.1517221927643 + }, + { + "step": 800, + "loss": 0.38091832399368286, + "objective": 0.38091832399368286, + "error": 0.1904296875, + "gradient_norm": 0.060622021555900574, + "elapsed": 582.5687477588654 + }, + { + "step": 816, + "loss": 0.552335262298584, + "objective": 0.552335262298584, + "error": 0.3076171875, + "gradient_norm": 0.14419035613536835, + "elapsed": 594.4292685985565 + }, + { + "step": 832, + "loss": 0.5943340063095093, + "objective": 0.5943340063095093, + "error": 0.34375, + "gradient_norm": 0.0633513554930687, + "elapsed": 605.2052299976349 + }, + { + "step": 848, + "loss": 0.6074100732803345, + "objective": 0.6074100732803345, + "error": 0.3486328125, + "gradient_norm": 0.04225531220436096, + "elapsed": 614.8996202945709 + }, + { + "step": 864, + "loss": 0.6198879480361938, + "objective": 0.6198879480361938, + "error": 0.361328125, + "gradient_norm": 0.04208856821060181, + "elapsed": 625.4266908168793 + }, + { + "step": 880, + "loss": 0.6151762008666992, + "objective": 0.6151762008666992, + "error": 0.369140625, + "gradient_norm": 0.06261089444160461, + "elapsed": 636.0696911811829 + }, + { + "step": 896, + "loss": 0.49680083990097046, + "objective": 0.49680083990097046, + "error": 0.25390625, + "gradient_norm": 0.0827067643404007, + "elapsed": 644.6893246173859 + }, + { + "step": 912, + "loss": 0.4610927402973175, + "objective": 0.4610927402973175, + "error": 0.23828125, + "gradient_norm": 0.06652095168828964, + "elapsed": 655.969132900238 + }, + { + "step": 928, + "loss": 0.5218505859375, + "objective": 0.5218505859375, + "error": 0.2685546875, + "gradient_norm": 0.07188194245100021, + "elapsed": 667.5352523326874 + }, + { + "step": 944, + "loss": 0.33009427785873413, + "objective": 0.33009427785873413, + "error": 0.1533203125, + "gradient_norm": 0.05718810483813286, + "elapsed": 677.8397319316864 + }, + { + "step": 960, + "loss": 0.5703234672546387, + "objective": 0.5703234672546387, + "error": 0.3193359375, + "gradient_norm": 0.11168288439512253, + "elapsed": 687.8742904663086 + }, + { + "step": 976, + "loss": 0.025548014789819717, + "objective": 0.025548014789819717, + "error": 0.0107421875, + "gradient_norm": 0.009453393518924713, + "elapsed": 698.294285774231 + }, + { + "step": 992, + "loss": 0.45398157835006714, + "objective": 0.45398157835006714, + "error": 0.2412109375, + "gradient_norm": 0.04607952758669853, + "elapsed": 707.903199672699 + }, + { + "step": 1008, + "loss": 0.3412189781665802, + "objective": 0.3412189781665802, + "error": 0.1513671875, + "gradient_norm": 0.0432075597345829, + "elapsed": 718.5662748813629 + }, + { + "step": 1024, + "loss": 0.4376429319381714, + "objective": 0.4376429319381714, + "error": 0.2275390625, + "gradient_norm": 0.07974351197481155, + "elapsed": 728.8954858779907 + }, + { + "step": 1040, + "loss": 0.33512815833091736, + "objective": 0.33512815833091736, + "error": 0.150390625, + "gradient_norm": 0.04476875811815262, + "elapsed": 744.0822694301605 + }, + { + "step": 1056, + "loss": 0.5214208364486694, + "objective": 0.5214208364486694, + "error": 0.283203125, + "gradient_norm": 0.08898192644119263, + "elapsed": 755.1484262943268 + }, + { + "step": 1072, + "loss": 0.13849599659442902, + "objective": 0.13849599659442902, + "error": 0.052734375, + "gradient_norm": 0.028359953314065933, + "elapsed": 764.3303108215332 + }, + { + "step": 1088, + "loss": 0.323838472366333, + "objective": 0.323838472366333, + "error": 0.1435546875, + "gradient_norm": 0.04081716760993004, + "elapsed": 773.2739362716675 + }, + { + "step": 1104, + "loss": 0.5627881288528442, + "objective": 0.5627881288528442, + "error": 0.3125, + "gradient_norm": 0.08322097361087799, + "elapsed": 784.7223973274231 + }, + { + "step": 1120, + "loss": 0.44111010432243347, + "objective": 0.44111010432243347, + "error": 0.2216796875, + "gradient_norm": 0.05700977146625519, + "elapsed": 795.085648059845 + }, + { + "step": 1136, + "loss": 0.6395992040634155, + "objective": 0.6395992040634155, + "error": 0.39453125, + "gradient_norm": 0.0744553729891777, + "elapsed": 805.7942585945129 + }, + { + "step": 1152, + "loss": 0.5433304309844971, + "objective": 0.5433304309844971, + "error": 0.287109375, + "gradient_norm": 0.04814797267317772, + "elapsed": 817.3382890224457 + }, + { + "step": 1168, + "loss": 0.5708576440811157, + "objective": 0.5708576440811157, + "error": 0.3203125, + "gradient_norm": 0.051331400871276855, + "elapsed": 829.288791179657 + }, + { + "step": 1184, + "loss": 0.5447035431861877, + "objective": 0.5447035431861877, + "error": 0.2939453125, + "gradient_norm": 0.10116687417030334, + "elapsed": 839.6822843551636 + }, + { + "step": 1200, + "loss": 0.6125671863555908, + "objective": 0.6125671863555908, + "error": 0.3642578125, + "gradient_norm": 0.04368080571293831, + "elapsed": 850.2262740135193 + }, + { + "step": 1216, + "loss": 0.5002380609512329, + "objective": 0.5002380609512329, + "error": 0.259765625, + "gradient_norm": 0.04939017817378044, + "elapsed": 862.3783452510834 + }, + { + "step": 1232, + "loss": 0.5698772668838501, + "objective": 0.5698772668838501, + "error": 0.3173828125, + "gradient_norm": 0.04916854575276375, + "elapsed": 871.4622664451599 + }, + { + "step": 1248, + "loss": 0.6046518683433533, + "objective": 0.6046518683433533, + "error": 0.341796875, + "gradient_norm": 0.04919794574379921, + "elapsed": 883.3905737400055 + }, + { + "step": 1264, + "loss": 0.5913128852844238, + "objective": 0.5913128852844238, + "error": 0.357421875, + "gradient_norm": 0.046917904168367386, + "elapsed": 892.4264807701111 + }, + { + "step": 1280, + "loss": 0.5027461051940918, + "objective": 0.5027461051940918, + "error": 0.2626953125, + "gradient_norm": 0.04705750197172165, + "elapsed": 902.5875842571259 + }, + { + "step": 1296, + "loss": 0.13519814610481262, + "objective": 0.13519814610481262, + "error": 0.052734375, + "gradient_norm": 0.02625490538775921, + "elapsed": 912.4087471961975 + }, + { + "step": 1312, + "loss": 0.5862359404563904, + "objective": 0.5862359404563904, + "error": 0.3271484375, + "gradient_norm": 0.05441493168473244, + "elapsed": 923.992555141449 + }, + { + "step": 1328, + "loss": 0.6031408309936523, + "objective": 0.6031408309936523, + "error": 0.3505859375, + "gradient_norm": 0.05901554971933365, + "elapsed": 933.3936491012573 + }, + { + "step": 1344, + "loss": 0.5823733806610107, + "objective": 0.5823733806610107, + "error": 0.3310546875, + "gradient_norm": 0.0842989832162857, + "elapsed": 941.979998588562 + }, + { + "step": 1360, + "loss": 0.6241492033004761, + "objective": 0.6241492033004761, + "error": 0.3720703125, + "gradient_norm": 0.04446673393249512, + "elapsed": 954.969649553299 + }, + { + "step": 1376, + "loss": 0.5829156637191772, + "objective": 0.5829156637191772, + "error": 0.361328125, + "gradient_norm": 0.06615480780601501, + "elapsed": 966.0245676040649 + }, + { + "step": 1392, + "loss": 0.5968320369720459, + "objective": 0.5968320369720459, + "error": 0.34765625, + "gradient_norm": 0.05093541368842125, + "elapsed": 975.1022663116455 + }, + { + "step": 1408, + "loss": 0.045559000223875046, + "objective": 0.045559000223875046, + "error": 0.01171875, + "gradient_norm": 0.02514980360865593, + "elapsed": 987.2391452789307 + }, + { + "step": 1424, + "loss": 0.22601813077926636, + "objective": 0.22601813077926636, + "error": 0.09765625, + "gradient_norm": 0.04834206402301788, + "elapsed": 996.4583384990692 + }, + { + "step": 1440, + "loss": 0.23011144995689392, + "objective": 0.23011144995689392, + "error": 0.111328125, + "gradient_norm": 0.050687842071056366, + "elapsed": 1007.1440904140472 + }, + { + "step": 1456, + "loss": 0.018240466713905334, + "objective": 0.018240466713905334, + "error": 0.0078125, + "gradient_norm": 0.005604141391813755, + "elapsed": 1016.4502851963043 + }, + { + "step": 1472, + "loss": 0.4498720169067383, + "objective": 0.4498720169067383, + "error": 0.232421875, + "gradient_norm": 0.08179625123739243, + "elapsed": 1028.8303294181824 + }, + { + "step": 1488, + "loss": 0.24151627719402313, + "objective": 0.24151627719402313, + "error": 0.107421875, + "gradient_norm": 0.03838668763637543, + "elapsed": 1037.8867321014404 + }, + { + "step": 1504, + "loss": 0.46122002601623535, + "objective": 0.46122002601623535, + "error": 0.232421875, + "gradient_norm": 0.0726623386144638, + "elapsed": 1047.7258644104004 + }, + { + "step": 1520, + "loss": 0.5085602402687073, + "objective": 0.5085602402687073, + "error": 0.2705078125, + "gradient_norm": 0.06673175096511841, + "elapsed": 1059.352120399475 + }, + { + "step": 1536, + "loss": 0.6105246543884277, + "objective": 0.6105246543884277, + "error": 0.3818359375, + "gradient_norm": 0.04271261766552925, + "elapsed": 1070.1413230895996 + }, + { + "step": 1552, + "loss": 0.4792126417160034, + "objective": 0.4792126417160034, + "error": 0.2578125, + "gradient_norm": 0.05200039595365524, + "elapsed": 1086.444006204605 + }, + { + "step": 1568, + "loss": 0.5814266204833984, + "objective": 0.5814266204833984, + "error": 0.330078125, + "gradient_norm": 0.05867309868335724, + "elapsed": 1097.2902619838715 + }, + { + "step": 1584, + "loss": 0.6321226358413696, + "objective": 0.6321226358413696, + "error": 0.3798828125, + "gradient_norm": 0.05418067052960396, + "elapsed": 1107.9767682552338 + }, + { + "step": 1600, + "loss": 0.5931253433227539, + "objective": 0.5931253433227539, + "error": 0.3603515625, + "gradient_norm": 0.06396215409040451, + "elapsed": 1121.782609462738 + }, + { + "step": 1616, + "loss": 0.6411516666412354, + "objective": 0.6411516666412354, + "error": 0.38671875, + "gradient_norm": 0.05035768821835518, + "elapsed": 1132.7197887897491 + }, + { + "step": 1632, + "loss": 0.4267754852771759, + "objective": 0.4267754852771759, + "error": 0.2080078125, + "gradient_norm": 0.09109894186258316, + "elapsed": 1139.1667578220367 + }, + { + "step": 1648, + "loss": 0.21246182918548584, + "objective": 0.21246182918548584, + "error": 0.095703125, + "gradient_norm": 0.04478950425982475, + "elapsed": 1149.1183021068573 + }, + { + "step": 1664, + "loss": 0.46360665559768677, + "objective": 0.46360665559768677, + "error": 0.251953125, + "gradient_norm": 0.07668188214302063, + "elapsed": 1161.1197745800018 + }, + { + "step": 1680, + "loss": 0.46281397342681885, + "objective": 0.46281397342681885, + "error": 0.236328125, + "gradient_norm": 0.07954126596450806, + "elapsed": 1171.8474535942078 + }, + { + "step": 1696, + "loss": 0.2484058141708374, + "objective": 0.2484058141708374, + "error": 0.12109375, + "gradient_norm": 0.047261305153369904, + "elapsed": 1185.6542596817017 + }, + { + "step": 1712, + "loss": 0.24310235679149628, + "objective": 0.24310235679149628, + "error": 0.1064453125, + "gradient_norm": 0.07262872904539108, + "elapsed": 1197.8986082077026 + }, + { + "step": 1728, + "loss": 0.009729458019137383, + "objective": 0.009729458019137383, + "error": 0.001953125, + "gradient_norm": 0.01146845705807209, + "elapsed": 1208.495581150055 + }, + { + "step": 1744, + "loss": 0.24568752944469452, + "objective": 0.24568752944469452, + "error": 0.10546875, + "gradient_norm": 0.05830742046236992, + "elapsed": 1219.9394850730896 + }, + { + "step": 1760, + "loss": 0.022546378895640373, + "objective": 0.022546378895640373, + "error": 0.0068359375, + "gradient_norm": 0.007667526602745056, + "elapsed": 1229.5703229904175 + }, + { + "step": 1776, + "loss": 0.5848401784896851, + "objective": 0.5848401784896851, + "error": 0.3271484375, + "gradient_norm": 0.061901818960905075, + "elapsed": 1238.750280380249 + }, + { + "step": 1792, + "loss": 0.6031335592269897, + "objective": 0.6031335592269897, + "error": 0.3671875, + "gradient_norm": 0.0676632970571518, + "elapsed": 1247.7468683719635 + }, + { + "step": 1808, + "loss": 0.6210961937904358, + "objective": 0.6210961937904358, + "error": 0.3603515625, + "gradient_norm": 0.0718468651175499, + "elapsed": 1256.1821897029877 + }, + { + "step": 1824, + "loss": 0.570877730846405, + "objective": 0.570877730846405, + "error": 0.3212890625, + "gradient_norm": 0.05575930327177048, + "elapsed": 1266.4091975688934 + }, + { + "step": 1840, + "loss": 0.5711429119110107, + "objective": 0.5711429119110107, + "error": 0.31640625, + "gradient_norm": 0.0691002607345581, + "elapsed": 1277.4722146987915 + }, + { + "step": 1856, + "loss": 0.36046335101127625, + "objective": 0.36046335101127625, + "error": 0.16796875, + "gradient_norm": 0.04694395884871483, + "elapsed": 1287.1420249938965 + }, + { + "step": 1872, + "loss": 0.4688999652862549, + "objective": 0.4688999652862549, + "error": 0.2216796875, + "gradient_norm": 0.07401346415281296, + "elapsed": 1297.3945078849792 + }, + { + "step": 1888, + "loss": 0.46385282278060913, + "objective": 0.46385282278060913, + "error": 0.2373046875, + "gradient_norm": 0.05608939751982689, + "elapsed": 1305.9779334068298 + }, + { + "step": 1904, + "loss": 0.60875403881073, + "objective": 0.60875403881073, + "error": 0.365234375, + "gradient_norm": 0.05085878074169159, + "elapsed": 1317.3097081184387 + }, + { + "step": 1920, + "loss": 0.12223530560731888, + "objective": 0.12223530560731888, + "error": 0.0458984375, + "gradient_norm": 0.024870412424206734, + "elapsed": 1328.6486887931824 + }, + { + "step": 1936, + "loss": 0.3486189544200897, + "objective": 0.3486189544200897, + "error": 0.16796875, + "gradient_norm": 0.04780663549900055, + "elapsed": 1336.6701011657715 + }, + { + "step": 1952, + "loss": 0.5777363777160645, + "objective": 0.5777363777160645, + "error": 0.3427734375, + "gradient_norm": 0.0571451336145401, + "elapsed": 1346.9158833026886 + }, + { + "step": 1968, + "loss": 0.39320266246795654, + "objective": 0.39320266246795654, + "error": 0.1884765625, + "gradient_norm": 0.05673858895897865, + "elapsed": 1354.9182631969452 + }, + { + "step": 1984, + "loss": 0.5900611281394958, + "objective": 0.5900611281394958, + "error": 0.3349609375, + "gradient_norm": 0.06593932211399078, + "elapsed": 1364.2754452228546 + }, + { + "step": 2000, + "loss": 0.6212430000305176, + "objective": 0.6212430000305176, + "error": 0.3857421875, + "gradient_norm": 0.040818918496370316, + "elapsed": 1374.7192046642303 + }, + { + "step": 2016, + "loss": 0.15605247020721436, + "objective": 0.15605247020721436, + "error": 0.0556640625, + "gradient_norm": 0.03108786791563034, + "elapsed": 1386.2740807533264 + }, + { + "step": 2032, + "loss": 0.22049596905708313, + "objective": 0.22049596905708313, + "error": 0.1015625, + "gradient_norm": 0.042733557522296906, + "elapsed": 1396.6422457695007 + }, + { + "step": 2048, + "loss": 0.5642613172531128, + "objective": 0.5642613172531128, + "error": 0.306640625, + "gradient_norm": 0.07527482509613037, + "elapsed": 1407.6688070297241 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 512, + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "512": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "512": { + "step": 512, + "training_samples": 524288, + "unique_training_rows_seen_in_this_phase": 324661, + "weights_sha256": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "complete": true + }, + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ff5a023ce2c18be7c29f810a3788a450e3ad3ad2237d6e9448923aa6a28c5074", + "complete": true + } + }, + "selection": "Predefined averages of the last3 or all4 saved noninitial full3_1 checkpoints; evaluate every validation condition before selecting", + "test_data_used": false, + "derivation_source_sha256": "08c498d6952b0380e001371df9a0461a483631a301f93747b821e529e72b349d" + }, + "training_source_snapshot": "training_sources/full3_swa", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23290264423076928, + "mean3": 0.2335186298076923, + "blend-mean3": 0.2325420673076923, + "mean4": 0.23326322115384618, + "blend-mean4": 0.23300781250000002 + }, + "selected": "blend-mean3" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615, + "mean3": 0.22037259615384613, + "blend-mean3": 0.22091346153846153, + "mean4": 0.2205528846153846, + "blend-mean4": 0.22100360576923078 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 491030, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18670, + "surface_code_bX_d5_r03_center_5_5": 18940, + "surface_code_bX_d5_r05_center_5_5": 19128, + "surface_code_bX_d5_r07_center_5_5": 18988, + "surface_code_bX_d5_r09_center_5_5": 18523, + "surface_code_bX_d5_r11_center_5_5": 19227, + "surface_code_bX_d5_r13_center_5_5": 18816, + "surface_code_bX_d5_r15_center_5_5": 18107, + "surface_code_bX_d5_r17_center_5_5": 18728, + "surface_code_bX_d5_r19_center_5_5": 18983, + "surface_code_bX_d5_r21_center_5_5": 18959, + "surface_code_bX_d5_r23_center_5_5": 19079, + "surface_code_bX_d5_r25_center_5_5": 19193, + "surface_code_bZ_d5_r01_center_5_5": 18828, + "surface_code_bZ_d5_r03_center_5_5": 18896, + "surface_code_bZ_d5_r05_center_5_5": 19011, + "surface_code_bZ_d5_r07_center_5_5": 18806, + "surface_code_bZ_d5_r09_center_5_5": 18268, + "surface_code_bZ_d5_r11_center_5_5": 18927, + "surface_code_bZ_d5_r13_center_5_5": 19399, + "surface_code_bZ_d5_r15_center_5_5": 19358, + "surface_code_bZ_d5_r17_center_5_5": 18634, + "surface_code_bZ_d5_r19_center_5_5": 19126, + "surface_code_bZ_d5_r21_center_5_5": 18603, + "surface_code_bZ_d5_r23_center_5_5": 18626, + "surface_code_bZ_d5_r25_center_5_5": 19207 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/fresh2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_warm/weights-512.npz", + "starting_checkpoint_sha256": "d3e3abba07693bd7fd3d17be2dd981d5b803a496e76ba230ed94afeb51f26f4f", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 325678, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 11962, + "surface_code_bX_d5_r03_center_5_5": 10232, + "surface_code_bX_d5_r05_center_5_5": 14014, + "surface_code_bX_d5_r07_center_5_5": 11594, + "surface_code_bX_d5_r09_center_5_5": 12805, + "surface_code_bX_d5_r11_center_5_5": 11644, + "surface_code_bX_d5_r13_center_5_5": 13845, + "surface_code_bX_d5_r15_center_5_5": 10703, + "surface_code_bX_d5_r17_center_5_5": 15460, + "surface_code_bX_d5_r19_center_5_5": 14156, + "surface_code_bX_d5_r21_center_5_5": 11568, + "surface_code_bX_d5_r23_center_5_5": 14156, + "surface_code_bX_d5_r25_center_5_5": 12021, + "surface_code_bZ_d5_r01_center_5_5": 10601, + "surface_code_bZ_d5_r03_center_5_5": 14135, + "surface_code_bZ_d5_r05_center_5_5": 11975, + "surface_code_bZ_d5_r07_center_5_5": 13841, + "surface_code_bZ_d5_r09_center_5_5": 12024, + "surface_code_bZ_d5_r11_center_5_5": 11151, + "surface_code_bZ_d5_r13_center_5_5": 10640, + "surface_code_bZ_d5_r15_center_5_5": 11089, + "surface_code_bZ_d5_r17_center_5_5": 13788, + "surface_code_bZ_d5_r19_center_5_5": 12350, + "surface_code_bZ_d5_r21_center_5_5": 12797, + "surface_code_bZ_d5_r23_center_5_5": 12809, + "surface_code_bZ_d5_r25_center_5_5": 14318 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261135", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6522030830383301, + "objective": 0.6522030830383301, + "error": 0.375, + "gradient_norm": 0.11649785190820694, + "elapsed": 30.089841604232788 + }, + { + "step": 16, + "loss": 0.5927819609642029, + "objective": 0.5927819609642029, + "error": 0.3466796875, + "gradient_norm": 0.07945127785205841, + "elapsed": 48.85365080833435 + }, + { + "step": 32, + "loss": 0.3115929663181305, + "objective": 0.3115929663181305, + "error": 0.13671875, + "gradient_norm": 0.039320655167102814, + "elapsed": 63.60312819480896 + }, + { + "step": 48, + "loss": 0.2456369698047638, + "objective": 0.2456369698047638, + "error": 0.1015625, + "gradient_norm": 0.029398636892437935, + "elapsed": 73.71074151992798 + }, + { + "step": 64, + "loss": 0.6231744885444641, + "objective": 0.6231744885444641, + "error": 0.3759765625, + "gradient_norm": 0.06867238879203796, + "elapsed": 83.75580954551697 + }, + { + "step": 80, + "loss": 0.3674217164516449, + "objective": 0.3674217164516449, + "error": 0.1572265625, + "gradient_norm": 0.0557992123067379, + "elapsed": 94.6383364200592 + }, + { + "step": 96, + "loss": 0.5152362585067749, + "objective": 0.5152362585067749, + "error": 0.2568359375, + "gradient_norm": 0.08284599334001541, + "elapsed": 106.90000939369202 + }, + { + "step": 112, + "loss": 0.020773420110344887, + "objective": 0.020773420110344887, + "error": 0.0048828125, + "gradient_norm": 0.008813572116196156, + "elapsed": 117.77558088302612 + }, + { + "step": 128, + "loss": 0.02593131735920906, + "objective": 0.02593131735920906, + "error": 0.0087890625, + "gradient_norm": 0.00872033555060625, + "elapsed": 128.93439435958862 + }, + { + "step": 144, + "loss": 0.5852900743484497, + "objective": 0.5852900743484497, + "error": 0.3291015625, + "gradient_norm": 0.04771002382040024, + "elapsed": 139.5588686466217 + }, + { + "step": 160, + "loss": 0.46074625849723816, + "objective": 0.46074625849723816, + "error": 0.232421875, + "gradient_norm": 0.08834747970104218, + "elapsed": 151.5595977306366 + }, + { + "step": 176, + "loss": 0.6310865879058838, + "objective": 0.6310865879058838, + "error": 0.376953125, + "gradient_norm": 0.14084596931934357, + "elapsed": 163.7892107963562 + }, + { + "step": 192, + "loss": 0.246865376830101, + "objective": 0.246865376830101, + "error": 0.1103515625, + "gradient_norm": 0.041402049362659454, + "elapsed": 174.28971648216248 + }, + { + "step": 208, + "loss": 0.3103577196598053, + "objective": 0.3103577196598053, + "error": 0.15625, + "gradient_norm": 0.04525696486234665, + "elapsed": 187.03909611701965 + }, + { + "step": 224, + "loss": 0.4523138999938965, + "objective": 0.4523138999938965, + "error": 0.208984375, + "gradient_norm": 0.09180521965026855, + "elapsed": 199.56195068359375 + }, + { + "step": 240, + "loss": 0.02241751179099083, + "objective": 0.02241751179099083, + "error": 0.009765625, + "gradient_norm": 0.009998111054301262, + "elapsed": 212.35500597953796 + }, + { + "step": 256, + "loss": 0.5487150549888611, + "objective": 0.5487150549888611, + "error": 0.294921875, + "gradient_norm": 0.12748055160045624, + "elapsed": 223.03854608535767 + }, + { + "step": 272, + "loss": 0.023057367652654648, + "objective": 0.023057367652654648, + "error": 0.0078125, + "gradient_norm": 0.006953821517527103, + "elapsed": 244.6508972644806 + }, + { + "step": 288, + "loss": 0.5845386981964111, + "objective": 0.5845386981964111, + "error": 0.330078125, + "gradient_norm": 0.06542652100324631, + "elapsed": 256.78167748451233 + }, + { + "step": 304, + "loss": 0.442532479763031, + "objective": 0.442532479763031, + "error": 0.232421875, + "gradient_norm": 0.10874580591917038, + "elapsed": 269.1364529132843 + }, + { + "step": 320, + "loss": 0.3264174163341522, + "objective": 0.3264174163341522, + "error": 0.15625, + "gradient_norm": 0.06276191771030426, + "elapsed": 282.38969564437866 + }, + { + "step": 336, + "loss": 0.386960506439209, + "objective": 0.386960506439209, + "error": 0.177734375, + "gradient_norm": 0.06561421602964401, + "elapsed": 292.9079031944275 + }, + { + "step": 352, + "loss": 0.23919886350631714, + "objective": 0.23919886350631714, + "error": 0.107421875, + "gradient_norm": 0.02755703590810299, + "elapsed": 304.16068935394287 + }, + { + "step": 368, + "loss": 0.5029175281524658, + "objective": 0.5029175281524658, + "error": 0.259765625, + "gradient_norm": 0.0378776490688324, + "elapsed": 315.11088514328003 + }, + { + "step": 384, + "loss": 0.565666675567627, + "objective": 0.565666675567627, + "error": 0.322265625, + "gradient_norm": 0.11368246376514435, + "elapsed": 324.3651068210602 + }, + { + "step": 400, + "loss": 0.5846428275108337, + "objective": 0.5846428275108337, + "error": 0.3408203125, + "gradient_norm": 0.08116643130779266, + "elapsed": 334.70786476135254 + }, + { + "step": 416, + "loss": 0.025111017748713493, + "objective": 0.025111017748713493, + "error": 0.0078125, + "gradient_norm": 0.008838560432195663, + "elapsed": 345.56963562965393 + }, + { + "step": 432, + "loss": 0.628488302230835, + "objective": 0.628488302230835, + "error": 0.3818359375, + "gradient_norm": 0.04001976177096367, + "elapsed": 355.3310384750366 + }, + { + "step": 448, + "loss": 0.4569575786590576, + "objective": 0.4569575786590576, + "error": 0.2578125, + "gradient_norm": 0.06344135850667953, + "elapsed": 367.05255675315857 + }, + { + "step": 464, + "loss": 0.49193111062049866, + "objective": 0.49193111062049866, + "error": 0.24609375, + "gradient_norm": 0.06022385507822037, + "elapsed": 377.38399291038513 + }, + { + "step": 480, + "loss": 0.5920064449310303, + "objective": 0.5920064449310303, + "error": 0.3466796875, + "gradient_norm": 0.036063045263290405, + "elapsed": 387.7266733646393 + }, + { + "step": 496, + "loss": 0.22157302498817444, + "objective": 0.22157302498817444, + "error": 0.09375, + "gradient_norm": 0.04071022942662239, + "elapsed": 397.78643012046814 + }, + { + "step": 512, + "loss": 0.39216887950897217, + "objective": 0.39216887950897217, + "error": 0.1728515625, + "gradient_norm": 0.09079446643590927, + "elapsed": 407.0137679576874 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6092928647994995, + "objective": 0.6092928647994995, + "error": 0.3583984375, + "gradient_norm": 0.08161187171936035, + "elapsed": 27.421262741088867 + }, + { + "step": 16, + "loss": 0.4709879755973816, + "objective": 0.4709879755973816, + "error": 0.2529296875, + "gradient_norm": 0.0541619211435318, + "elapsed": 48.74575757980347 + }, + { + "step": 32, + "loss": 0.5842419862747192, + "objective": 0.5842419862747192, + "error": 0.34375, + "gradient_norm": 0.09450904279947281, + "elapsed": 60.68022179603577 + }, + { + "step": 48, + "loss": 0.5840846300125122, + "objective": 0.5840846300125122, + "error": 0.32421875, + "gradient_norm": 0.04569687321782112, + "elapsed": 74.63272476196289 + }, + { + "step": 64, + "loss": 0.5139708518981934, + "objective": 0.5139708518981934, + "error": 0.2646484375, + "gradient_norm": 0.16111725568771362, + "elapsed": 91.88426613807678 + }, + { + "step": 80, + "loss": 0.49099838733673096, + "objective": 0.49099838733673096, + "error": 0.251953125, + "gradient_norm": 0.04431874305009842, + "elapsed": 105.08457684516907 + }, + { + "step": 96, + "loss": 0.30287861824035645, + "objective": 0.30287861824035645, + "error": 0.14453125, + "gradient_norm": 0.03792181238532066, + "elapsed": 118.16054177284241 + }, + { + "step": 112, + "loss": 0.6026535630226135, + "objective": 0.6026535630226135, + "error": 0.359375, + "gradient_norm": 0.043088704347610474, + "elapsed": 134.6414511203766 + }, + { + "step": 128, + "loss": 0.5983598828315735, + "objective": 0.5983598828315735, + "error": 0.328125, + "gradient_norm": 0.06492504477500916, + "elapsed": 148.38875198364258 + }, + { + "step": 144, + "loss": 0.616276204586029, + "objective": 0.616276204586029, + "error": 0.3857421875, + "gradient_norm": 0.05420554056763649, + "elapsed": 164.11315298080444 + }, + { + "step": 160, + "loss": 0.017882924526929855, + "objective": 0.017882924526929855, + "error": 0.0048828125, + "gradient_norm": 0.004682278726249933, + "elapsed": 178.31525373458862 + }, + { + "step": 176, + "loss": 0.5279660820960999, + "objective": 0.5279660820960999, + "error": 0.271484375, + "gradient_norm": 0.03895021602511406, + "elapsed": 192.20261907577515 + }, + { + "step": 192, + "loss": 0.5794406533241272, + "objective": 0.5794406533241272, + "error": 0.34375, + "gradient_norm": 0.041880734264850616, + "elapsed": 200.32051873207092 + }, + { + "step": 208, + "loss": 0.3353561758995056, + "objective": 0.3353561758995056, + "error": 0.1513671875, + "gradient_norm": 0.07022152841091156, + "elapsed": 212.5193521976471 + }, + { + "step": 224, + "loss": 0.47239983081817627, + "objective": 0.47239983081817627, + "error": 0.23828125, + "gradient_norm": 0.044771477580070496, + "elapsed": 223.36571788787842 + }, + { + "step": 240, + "loss": 0.6235381364822388, + "objective": 0.6235381364822388, + "error": 0.3779296875, + "gradient_norm": 0.047636937350034714, + "elapsed": 233.90032649040222 + }, + { + "step": 256, + "loss": 0.516319751739502, + "objective": 0.516319751739502, + "error": 0.271484375, + "gradient_norm": 0.087476447224617, + "elapsed": 245.52193427085876 + }, + { + "step": 272, + "loss": 0.23385891318321228, + "objective": 0.23385891318321228, + "error": 0.091796875, + "gradient_norm": 0.05921977758407593, + "elapsed": 254.38622951507568 + }, + { + "step": 288, + "loss": 0.31280556321144104, + "objective": 0.31280556321144104, + "error": 0.1318359375, + "gradient_norm": 0.03548427298665047, + "elapsed": 263.25871300697327 + }, + { + "step": 304, + "loss": 0.6208417415618896, + "objective": 0.6208417415618896, + "error": 0.361328125, + "gradient_norm": 0.10255666077136993, + "elapsed": 273.5115919113159 + }, + { + "step": 320, + "loss": 0.5985375642776489, + "objective": 0.5985375642776489, + "error": 0.3603515625, + "gradient_norm": 0.04024764895439148, + "elapsed": 285.4135670661926 + }, + { + "step": 336, + "loss": 0.028151696547865868, + "objective": 0.028151696547865868, + "error": 0.009765625, + "gradient_norm": 0.008847440592944622, + "elapsed": 295.0800693035126 + }, + { + "step": 352, + "loss": 0.6147637963294983, + "objective": 0.6147637963294983, + "error": 0.3603515625, + "gradient_norm": 0.05709920823574066, + "elapsed": 305.32019686698914 + }, + { + "step": 368, + "loss": 0.5955979824066162, + "objective": 0.5955979824066162, + "error": 0.3486328125, + "gradient_norm": 0.04276399686932564, + "elapsed": 316.3869025707245 + }, + { + "step": 384, + "loss": 0.23504304885864258, + "objective": 0.23504304885864258, + "error": 0.1025390625, + "gradient_norm": 0.03205326199531555, + "elapsed": 325.7849349975586 + }, + { + "step": 400, + "loss": 0.13460804522037506, + "objective": 0.13460804522037506, + "error": 0.0546875, + "gradient_norm": 0.03109711967408657, + "elapsed": 335.72691917419434 + }, + { + "step": 416, + "loss": 0.5798783302307129, + "objective": 0.5798783302307129, + "error": 0.322265625, + "gradient_norm": 0.053542010486125946, + "elapsed": 345.7052640914917 + }, + { + "step": 432, + "loss": 0.3892784118652344, + "objective": 0.3892784118652344, + "error": 0.19140625, + "gradient_norm": 0.052194178104400635, + "elapsed": 357.38475036621094 + }, + { + "step": 448, + "loss": 0.23582103848457336, + "objective": 0.23582103848457336, + "error": 0.1181640625, + "gradient_norm": 0.032037943601608276, + "elapsed": 369.5841510295868 + }, + { + "step": 464, + "loss": 0.5408849716186523, + "objective": 0.5408849716186523, + "error": 0.2900390625, + "gradient_norm": 0.07508285343647003, + "elapsed": 379.84099793434143 + }, + { + "step": 480, + "loss": 0.3894873559474945, + "objective": 0.3894873559474945, + "error": 0.19140625, + "gradient_norm": 0.03977999836206436, + "elapsed": 390.9687530994415 + }, + { + "step": 496, + "loss": 0.6059300899505615, + "objective": 0.6059300899505615, + "error": 0.361328125, + "gradient_norm": 0.06041429564356804, + "elapsed": 403.2380111217499 + }, + { + "step": 512, + "loss": 0.2117740511894226, + "objective": 0.2117740511894226, + "error": 0.0908203125, + "gradient_norm": 0.05693414434790611, + "elapsed": 414.4854781627655 + }, + { + "step": 528, + "loss": 0.4666211009025574, + "objective": 0.4666211009025574, + "error": 0.2470703125, + "gradient_norm": 0.0764947235584259, + "elapsed": 433.42368054389954 + }, + { + "step": 544, + "loss": 0.22636458277702332, + "objective": 0.22636458277702332, + "error": 0.1083984375, + "gradient_norm": 0.03683016076683998, + "elapsed": 442.92575907707214 + }, + { + "step": 560, + "loss": 0.23172692954540253, + "objective": 0.23172692954540253, + "error": 0.1083984375, + "gradient_norm": 0.034071482717990875, + "elapsed": 453.3129711151123 + }, + { + "step": 576, + "loss": 0.4768703579902649, + "objective": 0.4768703579902649, + "error": 0.2529296875, + "gradient_norm": 0.06308378279209137, + "elapsed": 462.4127457141876 + }, + { + "step": 592, + "loss": 0.5165150165557861, + "objective": 0.5165150165557861, + "error": 0.291015625, + "gradient_norm": 0.07674732059240341, + "elapsed": 473.8309862613678 + }, + { + "step": 608, + "loss": 0.5919064283370972, + "objective": 0.5919064283370972, + "error": 0.3359375, + "gradient_norm": 0.06379934400320053, + "elapsed": 484.3733870983124 + }, + { + "step": 624, + "loss": 0.01804366335272789, + "objective": 0.01804366335272789, + "error": 0.0068359375, + "gradient_norm": 0.005318541545420885, + "elapsed": 495.94076347351074 + }, + { + "step": 640, + "loss": 0.41747498512268066, + "objective": 0.41747498512268066, + "error": 0.1962890625, + "gradient_norm": 0.052116431295871735, + "elapsed": 506.73559165000916 + }, + { + "step": 656, + "loss": 0.6140056848526001, + "objective": 0.6140056848526001, + "error": 0.3896484375, + "gradient_norm": 0.05376415699720383, + "elapsed": 517.2397899627686 + }, + { + "step": 672, + "loss": 0.4098930358886719, + "objective": 0.4098930358886719, + "error": 0.197265625, + "gradient_norm": 0.04737741872668266, + "elapsed": 525.7957897186279 + }, + { + "step": 688, + "loss": 0.3499884009361267, + "objective": 0.3499884009361267, + "error": 0.1650390625, + "gradient_norm": 0.0714973583817482, + "elapsed": 534.9302124977112 + }, + { + "step": 704, + "loss": 0.552291989326477, + "objective": 0.552291989326477, + "error": 0.3095703125, + "gradient_norm": 0.10188189148902893, + "elapsed": 545.4470670223236 + }, + { + "step": 720, + "loss": 0.4040689468383789, + "objective": 0.4040689468383789, + "error": 0.1943359375, + "gradient_norm": 0.06630362570285797, + "elapsed": 554.2920794487 + }, + { + "step": 736, + "loss": 0.3191133439540863, + "objective": 0.3191133439540863, + "error": 0.15625, + "gradient_norm": 0.060587506741285324, + "elapsed": 562.335791349411 + }, + { + "step": 752, + "loss": 0.5949387550354004, + "objective": 0.5949387550354004, + "error": 0.330078125, + "gradient_norm": 0.051291145384311676, + "elapsed": 570.9363489151001 + }, + { + "step": 768, + "loss": 0.4783790409564972, + "objective": 0.4783790409564972, + "error": 0.244140625, + "gradient_norm": 0.08808670938014984, + "elapsed": 581.1555306911469 + }, + { + "step": 784, + "loss": 0.4414710998535156, + "objective": 0.4414710998535156, + "error": 0.20703125, + "gradient_norm": 0.06632383912801743, + "elapsed": 590.4109175205231 + }, + { + "step": 800, + "loss": 0.2536136507987976, + "objective": 0.2536136507987976, + "error": 0.1142578125, + "gradient_norm": 0.03191893920302391, + "elapsed": 601.43274974823 + }, + { + "step": 816, + "loss": 0.22448071837425232, + "objective": 0.22448071837425232, + "error": 0.1015625, + "gradient_norm": 0.04966023191809654, + "elapsed": 612.7252013683319 + }, + { + "step": 832, + "loss": 0.5342355966567993, + "objective": 0.5342355966567993, + "error": 0.2783203125, + "gradient_norm": 0.05757307633757591, + "elapsed": 623.6647284030914 + }, + { + "step": 848, + "loss": 0.2506354749202728, + "objective": 0.2506354749202728, + "error": 0.109375, + "gradient_norm": 0.03991081938147545, + "elapsed": 635.1636409759521 + }, + { + "step": 864, + "loss": 0.40698009729385376, + "objective": 0.40698009729385376, + "error": 0.1953125, + "gradient_norm": 0.09155476838350296, + "elapsed": 645.2128469944 + }, + { + "step": 880, + "loss": 0.563283383846283, + "objective": 0.563283383846283, + "error": 0.3134765625, + "gradient_norm": 0.11409252882003784, + "elapsed": 659.2946681976318 + }, + { + "step": 896, + "loss": 0.13591040670871735, + "objective": 0.13591040670871735, + "error": 0.064453125, + "gradient_norm": 0.02692740224301815, + "elapsed": 668.6167254447937 + }, + { + "step": 912, + "loss": 0.5798318982124329, + "objective": 0.5798318982124329, + "error": 0.3310546875, + "gradient_norm": 0.06674209237098694, + "elapsed": 680.6492185592651 + }, + { + "step": 928, + "loss": 0.6140691041946411, + "objective": 0.6140691041946411, + "error": 0.3857421875, + "gradient_norm": 0.06117575615644455, + "elapsed": 693.1704411506653 + }, + { + "step": 944, + "loss": 0.3964633643627167, + "objective": 0.3964633643627167, + "error": 0.1865234375, + "gradient_norm": 0.08617512136697769, + "elapsed": 708.2128443717957 + }, + { + "step": 960, + "loss": 0.5512299537658691, + "objective": 0.5512299537658691, + "error": 0.2861328125, + "gradient_norm": 0.05705108866095543, + "elapsed": 720.2417063713074 + }, + { + "step": 976, + "loss": 0.454137921333313, + "objective": 0.454137921333313, + "error": 0.216796875, + "gradient_norm": 0.07962293922901154, + "elapsed": 730.2567391395569 + }, + { + "step": 992, + "loss": 0.5681213140487671, + "objective": 0.5681213140487671, + "error": 0.3017578125, + "gradient_norm": 0.09802286326885223, + "elapsed": 742.7380962371826 + }, + { + "step": 1008, + "loss": 0.13060352206230164, + "objective": 0.13060352206230164, + "error": 0.0537109375, + "gradient_norm": 0.04271279275417328, + "elapsed": 750.8077793121338 + }, + { + "step": 1024, + "loss": 0.6129879355430603, + "objective": 0.6129879355430603, + "error": 0.3603515625, + "gradient_norm": 0.04127912223339081, + "elapsed": 761.0585849285126 + }, + { + "step": 1040, + "loss": 0.31361687183380127, + "objective": 0.31361687183380127, + "error": 0.1455078125, + "gradient_norm": 0.04341907799243927, + "elapsed": 776.3491418361664 + }, + { + "step": 1056, + "loss": 0.6326502561569214, + "objective": 0.6326502561569214, + "error": 0.365234375, + "gradient_norm": 0.07518075406551361, + "elapsed": 786.0424168109894 + }, + { + "step": 1072, + "loss": 0.537599503993988, + "objective": 0.537599503993988, + "error": 0.2958984375, + "gradient_norm": 0.08455493301153183, + "elapsed": 795.1607735157013 + }, + { + "step": 1088, + "loss": 0.5953108072280884, + "objective": 0.5953108072280884, + "error": 0.337890625, + "gradient_norm": 0.06973882764577866, + "elapsed": 804.0053510665894 + }, + { + "step": 1104, + "loss": 0.36860400438308716, + "objective": 0.36860400438308716, + "error": 0.1923828125, + "gradient_norm": 0.04828036576509476, + "elapsed": 813.4029138088226 + }, + { + "step": 1120, + "loss": 0.5423247218132019, + "objective": 0.5423247218132019, + "error": 0.28125, + "gradient_norm": 0.04841453209519386, + "elapsed": 823.626978635788 + }, + { + "step": 1136, + "loss": 0.4766136407852173, + "objective": 0.4766136407852173, + "error": 0.236328125, + "gradient_norm": 0.07564551383256912, + "elapsed": 832.4641265869141 + }, + { + "step": 1152, + "loss": 0.5473434925079346, + "objective": 0.5473434925079346, + "error": 0.2958984375, + "gradient_norm": 0.13677075505256653, + "elapsed": 844.9307618141174 + }, + { + "step": 1168, + "loss": 0.3040686249732971, + "objective": 0.3040686249732971, + "error": 0.150390625, + "gradient_norm": 0.045926257967948914, + "elapsed": 854.336992263794 + }, + { + "step": 1184, + "loss": 0.6298375129699707, + "objective": 0.6298375129699707, + "error": 0.3798828125, + "gradient_norm": 0.06807851791381836, + "elapsed": 864.5731596946716 + }, + { + "step": 1200, + "loss": 0.6272540092468262, + "objective": 0.6272540092468262, + "error": 0.37890625, + "gradient_norm": 0.139838308095932, + "elapsed": 877.8357374668121 + }, + { + "step": 1216, + "loss": 0.5224937200546265, + "objective": 0.5224937200546265, + "error": 0.287109375, + "gradient_norm": 0.0647057592868805, + "elapsed": 887.8107197284698 + }, + { + "step": 1232, + "loss": 0.02408422902226448, + "objective": 0.02408422902226448, + "error": 0.0107421875, + "gradient_norm": 0.007562167476862669, + "elapsed": 902.201171875 + }, + { + "step": 1248, + "loss": 0.01936865597963333, + "objective": 0.01936865597963333, + "error": 0.0048828125, + "gradient_norm": 0.006423021201044321, + "elapsed": 914.0247437953949 + }, + { + "step": 1264, + "loss": 0.47522181272506714, + "objective": 0.47522181272506714, + "error": 0.2490234375, + "gradient_norm": 0.04962826892733574, + "elapsed": 927.0462884902954 + }, + { + "step": 1280, + "loss": 0.019577551633119583, + "objective": 0.019577551633119583, + "error": 0.0068359375, + "gradient_norm": 0.008308992721140385, + "elapsed": 939.3647270202637 + }, + { + "step": 1296, + "loss": 0.5085430145263672, + "objective": 0.5085430145263672, + "error": 0.2734375, + "gradient_norm": 0.06214233115315437, + "elapsed": 949.4259700775146 + }, + { + "step": 1312, + "loss": 0.23232896625995636, + "objective": 0.23232896625995636, + "error": 0.1015625, + "gradient_norm": 0.05894213914871216, + "elapsed": 961.3636543750763 + }, + { + "step": 1328, + "loss": 0.5330536365509033, + "objective": 0.5330536365509033, + "error": 0.2861328125, + "gradient_norm": 0.11579663306474686, + "elapsed": 972.1607241630554 + }, + { + "step": 1344, + "loss": 0.019525721669197083, + "objective": 0.019525721669197083, + "error": 0.0087890625, + "gradient_norm": 0.008134250529110432, + "elapsed": 983.0828921794891 + }, + { + "step": 1360, + "loss": 0.22790294885635376, + "objective": 0.22790294885635376, + "error": 0.103515625, + "gradient_norm": 0.04187086224555969, + "elapsed": 991.3167304992676 + }, + { + "step": 1376, + "loss": 0.48713046312332153, + "objective": 0.48713046312332153, + "error": 0.2666015625, + "gradient_norm": 0.06267429888248444, + "elapsed": 1003.5033710002899 + }, + { + "step": 1392, + "loss": 0.6043434143066406, + "objective": 0.6043434143066406, + "error": 0.369140625, + "gradient_norm": 0.037880122661590576, + "elapsed": 1017.8567223548889 + }, + { + "step": 1408, + "loss": 0.034499723464250565, + "objective": 0.034499723464250565, + "error": 0.0068359375, + "gradient_norm": 0.013505477458238602, + "elapsed": 1027.3547134399414 + }, + { + "step": 1424, + "loss": 0.5320160388946533, + "objective": 0.5320160388946533, + "error": 0.306640625, + "gradient_norm": 0.07510018348693848, + "elapsed": 1036.9454221725464 + }, + { + "step": 1440, + "loss": 0.3451523780822754, + "objective": 0.3451523780822754, + "error": 0.171875, + "gradient_norm": 0.06453985720872879, + "elapsed": 1046.1805095672607 + }, + { + "step": 1456, + "loss": 0.21541815996170044, + "objective": 0.21541815996170044, + "error": 0.08984375, + "gradient_norm": 0.043503839522600174, + "elapsed": 1055.850379705429 + }, + { + "step": 1472, + "loss": 0.43667086958885193, + "objective": 0.43667086958885193, + "error": 0.22265625, + "gradient_norm": 0.07311506569385529, + "elapsed": 1066.6324400901794 + }, + { + "step": 1488, + "loss": 0.6163139939308167, + "objective": 0.6163139939308167, + "error": 0.3779296875, + "gradient_norm": 0.06406569480895996, + "elapsed": 1075.7883398532867 + }, + { + "step": 1504, + "loss": 0.23901250958442688, + "objective": 0.23901250958442688, + "error": 0.10546875, + "gradient_norm": 0.04792191833257675, + "elapsed": 1085.4756922721863 + }, + { + "step": 1520, + "loss": 0.3817014694213867, + "objective": 0.3817014694213867, + "error": 0.18359375, + "gradient_norm": 0.046061187982559204, + "elapsed": 1095.974383354187 + }, + { + "step": 1536, + "loss": 0.5593156814575195, + "objective": 0.5593156814575195, + "error": 0.3017578125, + "gradient_norm": 0.0735388696193695, + "elapsed": 1105.913155078888 + } + ] + }, + "training_source_snapshot": "training_sources/fresh2_full", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2325420673076923, + "0": 0.23359374999999996, + "blend-0": 0.23372896634615387, + "512": 0.23342848557692306, + "blend-512": 0.23329326923076926, + "1024": 0.23315805288461536, + "blend-1024": 0.23309795673076922, + "1536": 0.2326923076923077, + "blend-1536": 0.23278245192307695 + }, + "selected": "incumbent" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615, + "0": 0.22125901442307688, + "blend-0": 0.22125901442307694, + "512": 0.22080829326923082, + "blend-512": 0.2211838942307692, + "1024": 0.22052283653846153, + "blend-1024": 0.22031249999999997, + "1536": 0.21953124999999998, + "blend-1536": 0.21998197115384616 + }, + "selected": "1536" + } + ], + "checkpoints": { + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 491030, + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit unused intermediate logical tracking; raw neural branches also omit the unused final physical readout.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "packaged_runtime_control_cpu": { + "device": "cpu", + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "same_cpu_old_vs_new_maximum_difference": 0.0, + "old_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "new_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "cpu_vs_reconstructed_old_gpu_runtime_maximum_difference": 4.976987838745117e-05, + "original_gpu_evaluation_vs_reconstructed_gpu_runtime_maximum_difference": 7.748603820800781e-07, + "initial_failed_control": { + "comparison": "CPU runtime against original GPU evaluator", + "observed_maximum_difference": 4.971027374267578e-05, + "original_tolerance": 3e-06 + }, + "sources": { + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b" + }, + "scope": "Same-device compatibility check. Reconstructed GPU runtime removes the recorded equal physical blend; that reconstruction has floating-point rounding uncertainty.", + "status": "passed_same_device_compatibility" + }, + "cpu_probability_precision": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "validation_syndromes": 7, + "logical_labels_used": false, + "parameter_updates": 0, + "reference": "Float64 neural forward and exact contraction from the same stored weights and fixed float32 input logits, on CPU", + "cpu_float32_vs_float64_maximum_difference": 7.624897924163321e-08, + "cpu_float32_edges_float64_contraction_vs_float64_maximum_difference": 4.725248914372315e-08, + "gpu_float32_vs_float64_maximum_difference": 4.964999121059854e-05, + "cpu_vs_gpu_float32_maximum_difference": 4.971027374267578e-05, + "maximum_neural_edge_probability_difference": 2.6330936014895556e-08, + "float32_edge_values_above_one_minus_1e6": 0, + "scope": "Precision diagnostic only; the published model is unchanged. Same-device old/new packaged-code compatibility was independently exact." + }, + "priors_only_control_cpu": { + "status": "passed", + "device": "cpu", + "source_sha256": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 2.7116777896881104, + "priors_only_seconds_warm": 0.13569164276123047 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 3.557781457901001, + "priors_only_seconds_warm": 1.7711329460144043 + } + ], + "scope": "CPU numerical equivalence on supplied training syndromes; timings are not a controlled speed comparison." + } + } + }, + { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 466919, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved1_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved1_warm/weights-512.npz", + "starting_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317613, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261272", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.1412775069475174, + "objective": 0.1412775069475174, + "error": 0.0595703125, + "gradient_norm": 0.030735325068235397, + "elapsed": 28.457472801208496 + }, + { + "step": 16, + "loss": 0.6315727233886719, + "objective": 0.6315727233886719, + "error": 0.384765625, + "gradient_norm": 0.06563512235879898, + "elapsed": 47.886730670928955 + }, + { + "step": 32, + "loss": 0.5130410194396973, + "objective": 0.5130410194396973, + "error": 0.263671875, + "gradient_norm": 0.10626910626888275, + "elapsed": 60.16136598587036 + }, + { + "step": 48, + "loss": 0.6413166522979736, + "objective": 0.6413166522979736, + "error": 0.408203125, + "gradient_norm": 0.03790846839547157, + "elapsed": 70.9611382484436 + }, + { + "step": 64, + "loss": 0.5491592884063721, + "objective": 0.5491592884063721, + "error": 0.2939453125, + "gradient_norm": 0.093081034719944, + "elapsed": 81.46673464775085 + }, + { + "step": 80, + "loss": 0.6315242648124695, + "objective": 0.6315242648124695, + "error": 0.359375, + "gradient_norm": 0.0384257510304451, + "elapsed": 91.71172666549683 + }, + { + "step": 96, + "loss": 0.6311566829681396, + "objective": 0.6311566829681396, + "error": 0.3798828125, + "gradient_norm": 0.03731638938188553, + "elapsed": 100.83252763748169 + }, + { + "step": 112, + "loss": 0.5327925682067871, + "objective": 0.5327925682067871, + "error": 0.29296875, + "gradient_norm": 0.11202990263700485, + "elapsed": 111.35073852539062 + }, + { + "step": 128, + "loss": 0.6284654140472412, + "objective": 0.6284654140472412, + "error": 0.3740234375, + "gradient_norm": 0.03215613588690758, + "elapsed": 121.32994651794434 + }, + { + "step": 144, + "loss": 0.33964547514915466, + "objective": 0.33964547514915466, + "error": 0.1259765625, + "gradient_norm": 0.05133189633488655, + "elapsed": 131.2744882106781 + }, + { + "step": 160, + "loss": 0.14193454384803772, + "objective": 0.14193454384803772, + "error": 0.0478515625, + "gradient_norm": 0.03264402225613594, + "elapsed": 139.58473920822144 + }, + { + "step": 176, + "loss": 0.14203950762748718, + "objective": 0.14203950762748718, + "error": 0.0654296875, + "gradient_norm": 0.022548990324139595, + "elapsed": 148.9861602783203 + }, + { + "step": 192, + "loss": 0.6307225227355957, + "objective": 0.6307225227355957, + "error": 0.3955078125, + "gradient_norm": 0.08607082068920135, + "elapsed": 162.27514505386353 + }, + { + "step": 208, + "loss": 0.16193106770515442, + "objective": 0.16193106770515442, + "error": 0.064453125, + "gradient_norm": 0.023293493315577507, + "elapsed": 173.59824013710022 + }, + { + "step": 224, + "loss": 0.5426318049430847, + "objective": 0.5426318049430847, + "error": 0.3037109375, + "gradient_norm": 0.03944721072912216, + "elapsed": 182.70232272148132 + }, + { + "step": 240, + "loss": 0.6270365715026855, + "objective": 0.6270365715026855, + "error": 0.3896484375, + "gradient_norm": 0.14661568403244019, + "elapsed": 193.759183883667 + }, + { + "step": 256, + "loss": 0.4933152198791504, + "objective": 0.4933152198791504, + "error": 0.2724609375, + "gradient_norm": 0.1065438985824585, + "elapsed": 205.62959718704224 + }, + { + "step": 272, + "loss": 0.3671969473361969, + "objective": 0.3671969473361969, + "error": 0.177734375, + "gradient_norm": 0.05156548321247101, + "elapsed": 222.249596118927 + }, + { + "step": 288, + "loss": 0.5478869676589966, + "objective": 0.5478869676589966, + "error": 0.3203125, + "gradient_norm": 0.08357688039541245, + "elapsed": 232.2198715209961 + }, + { + "step": 304, + "loss": 0.21171918511390686, + "objective": 0.21171918511390686, + "error": 0.0849609375, + "gradient_norm": 0.06231697276234627, + "elapsed": 241.07631373405457 + }, + { + "step": 320, + "loss": 0.5333335995674133, + "objective": 0.5333335995674133, + "error": 0.2861328125, + "gradient_norm": 0.08931853622198105, + "elapsed": 251.28962755203247 + }, + { + "step": 336, + "loss": 0.12485946714878082, + "objective": 0.12485946714878082, + "error": 0.046875, + "gradient_norm": 0.018839582800865173, + "elapsed": 262.3605041503906 + }, + { + "step": 352, + "loss": 0.2334863245487213, + "objective": 0.2334863245487213, + "error": 0.09765625, + "gradient_norm": 0.03669576346874237, + "elapsed": 273.16373229026794 + }, + { + "step": 368, + "loss": 0.5818328857421875, + "objective": 0.5818328857421875, + "error": 0.3232421875, + "gradient_norm": 0.09833699464797974, + "elapsed": 282.8677294254303 + }, + { + "step": 384, + "loss": 0.6228232383728027, + "objective": 0.6228232383728027, + "error": 0.3671875, + "gradient_norm": 0.033418990671634674, + "elapsed": 295.04902839660645 + }, + { + "step": 400, + "loss": 0.5749450922012329, + "objective": 0.5749450922012329, + "error": 0.333984375, + "gradient_norm": 0.04644288495182991, + "elapsed": 306.67032837867737 + }, + { + "step": 416, + "loss": 0.46251457929611206, + "objective": 0.46251457929611206, + "error": 0.2216796875, + "gradient_norm": 0.06633804738521576, + "elapsed": 317.759464263916 + }, + { + "step": 432, + "loss": 0.5577508211135864, + "objective": 0.5577508211135864, + "error": 0.30859375, + "gradient_norm": 0.0970199704170227, + "elapsed": 327.4626543521881 + }, + { + "step": 448, + "loss": 0.11625733226537704, + "objective": 0.11625733226537704, + "error": 0.0419921875, + "gradient_norm": 0.020417485386133194, + "elapsed": 336.3522970676422 + }, + { + "step": 464, + "loss": 0.23657961189746857, + "objective": 0.23657961189746857, + "error": 0.1025390625, + "gradient_norm": 0.03908605873584747, + "elapsed": 344.3832321166992 + }, + { + "step": 480, + "loss": 0.011504358612000942, + "objective": 0.011504358612000942, + "error": 0.00390625, + "gradient_norm": 0.006708688102662563, + "elapsed": 355.18855381011963 + }, + { + "step": 496, + "loss": 0.3410624563694, + "objective": 0.3410624563694, + "error": 0.1533203125, + "gradient_norm": 0.05804387852549553, + "elapsed": 366.2978138923645 + }, + { + "step": 512, + "loss": 0.034005306661129, + "objective": 0.034005306661129, + "error": 0.0107421875, + "gradient_norm": 0.01019973959773779, + "elapsed": 375.73491764068604 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "b31e8f5ee2b5ea1b661e6bf8b5649bec45b7ab5da74fe9de46e4d06846356b87", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317613, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5523660182952881, + "objective": 0.5523660182952881, + "error": 0.30859375, + "gradient_norm": 0.05200070142745972, + "elapsed": 30.08410096168518 + }, + { + "step": 16, + "loss": 0.5380295515060425, + "objective": 0.5380295515060425, + "error": 0.306640625, + "gradient_norm": 0.0804876759648323, + "elapsed": 50.77648210525513 + }, + { + "step": 32, + "loss": 0.6359301805496216, + "objective": 0.6359301805496216, + "error": 0.3837890625, + "gradient_norm": 0.059380218386650085, + "elapsed": 59.453776836395264 + }, + { + "step": 48, + "loss": 0.2540435492992401, + "objective": 0.2540435492992401, + "error": 0.1083984375, + "gradient_norm": 0.04367281496524811, + "elapsed": 67.29314041137695 + }, + { + "step": 64, + "loss": 0.5867692232131958, + "objective": 0.5867692232131958, + "error": 0.3447265625, + "gradient_norm": 0.053885214030742645, + "elapsed": 78.74847197532654 + }, + { + "step": 80, + "loss": 0.6015321016311646, + "objective": 0.6015321016311646, + "error": 0.365234375, + "gradient_norm": 0.04807985574007034, + "elapsed": 90.48145818710327 + }, + { + "step": 96, + "loss": 0.49287766218185425, + "objective": 0.49287766218185425, + "error": 0.271484375, + "gradient_norm": 0.07899080961942673, + "elapsed": 101.65468978881836 + }, + { + "step": 112, + "loss": 0.3271353542804718, + "objective": 0.3271353542804718, + "error": 0.15234375, + "gradient_norm": 0.049542222172021866, + "elapsed": 111.14713263511658 + }, + { + "step": 128, + "loss": 0.50013667345047, + "objective": 0.50013667345047, + "error": 0.271484375, + "gradient_norm": 0.06454745680093765, + "elapsed": 121.21207547187805 + }, + { + "step": 144, + "loss": 0.028576843440532684, + "objective": 0.028576843440532684, + "error": 0.0087890625, + "gradient_norm": 0.010781333781778812, + "elapsed": 130.69302248954773 + }, + { + "step": 160, + "loss": 0.5668779015541077, + "objective": 0.5668779015541077, + "error": 0.330078125, + "gradient_norm": 0.06098390743136406, + "elapsed": 142.14290237426758 + }, + { + "step": 176, + "loss": 0.3986494839191437, + "objective": 0.3986494839191437, + "error": 0.1884765625, + "gradient_norm": 0.042795032262802124, + "elapsed": 152.75753688812256 + }, + { + "step": 192, + "loss": 0.31897079944610596, + "objective": 0.31897079944610596, + "error": 0.142578125, + "gradient_norm": 0.040675707161426544, + "elapsed": 160.04981398582458 + }, + { + "step": 208, + "loss": 0.5092275142669678, + "objective": 0.5092275142669678, + "error": 0.255859375, + "gradient_norm": 0.07929783314466476, + "elapsed": 169.85345673561096 + }, + { + "step": 224, + "loss": 0.35782667994499207, + "objective": 0.35782667994499207, + "error": 0.1748046875, + "gradient_norm": 0.05785144120454788, + "elapsed": 179.90323066711426 + }, + { + "step": 240, + "loss": 0.5660895109176636, + "objective": 0.5660895109176636, + "error": 0.3349609375, + "gradient_norm": 0.10684454441070557, + "elapsed": 191.3668942451477 + }, + { + "step": 256, + "loss": 0.6265910863876343, + "objective": 0.6265910863876343, + "error": 0.3779296875, + "gradient_norm": 0.034383758902549744, + "elapsed": 200.3055775165558 + }, + { + "step": 272, + "loss": 0.6210677623748779, + "objective": 0.6210677623748779, + "error": 0.369140625, + "gradient_norm": 0.04434216767549515, + "elapsed": 210.09376430511475 + }, + { + "step": 288, + "loss": 0.4892377257347107, + "objective": 0.4892377257347107, + "error": 0.2490234375, + "gradient_norm": 0.1040654331445694, + "elapsed": 220.45881819725037 + }, + { + "step": 304, + "loss": 0.6407739520072937, + "objective": 0.6407739520072937, + "error": 0.3916015625, + "gradient_norm": 0.07782924920320511, + "elapsed": 233.3719048500061 + }, + { + "step": 320, + "loss": 0.4752756953239441, + "objective": 0.4752756953239441, + "error": 0.263671875, + "gradient_norm": 0.051829319447278976, + "elapsed": 244.25844407081604 + }, + { + "step": 336, + "loss": 0.6482080221176147, + "objective": 0.6482080221176147, + "error": 0.41015625, + "gradient_norm": 0.04979892820119858, + "elapsed": 253.1897099018097 + }, + { + "step": 352, + "loss": 0.34022292494773865, + "objective": 0.34022292494773865, + "error": 0.1708984375, + "gradient_norm": 0.09951864182949066, + "elapsed": 264.0781395435333 + }, + { + "step": 368, + "loss": 0.3494992256164551, + "objective": 0.3494992256164551, + "error": 0.15625, + "gradient_norm": 0.10392706841230392, + "elapsed": 275.8111581802368 + }, + { + "step": 384, + "loss": 0.47191378474235535, + "objective": 0.47191378474235535, + "error": 0.25, + "gradient_norm": 0.07366786152124405, + "elapsed": 283.9459602832794 + }, + { + "step": 400, + "loss": 0.583655595779419, + "objective": 0.583655595779419, + "error": 0.3623046875, + "gradient_norm": 0.10394527018070221, + "elapsed": 294.3349726200104 + }, + { + "step": 416, + "loss": 0.6212975978851318, + "objective": 0.6212975978851318, + "error": 0.37109375, + "gradient_norm": 0.054796766489744186, + "elapsed": 304.7477548122406 + }, + { + "step": 432, + "loss": 0.4719577431678772, + "objective": 0.4719577431678772, + "error": 0.2431640625, + "gradient_norm": 0.05418012663722038, + "elapsed": 315.91914200782776 + }, + { + "step": 448, + "loss": 0.5696494579315186, + "objective": 0.5696494579315186, + "error": 0.3330078125, + "gradient_norm": 0.047046076506376266, + "elapsed": 324.96326184272766 + }, + { + "step": 464, + "loss": 0.613875687122345, + "objective": 0.613875687122345, + "error": 0.34765625, + "gradient_norm": 0.05237002298235893, + "elapsed": 334.7670781612396 + }, + { + "step": 480, + "loss": 0.28741705417633057, + "objective": 0.28741705417633057, + "error": 0.1240234375, + "gradient_norm": 0.05365394428372383, + "elapsed": 344.03080439567566 + }, + { + "step": 496, + "loss": 0.3729455769062042, + "objective": 0.3729455769062042, + "error": 0.1875, + "gradient_norm": 0.05905403569340706, + "elapsed": 356.01581716537476 + }, + { + "step": 512, + "loss": 0.38685142993927, + "objective": 0.38685142993927, + "error": 0.17578125, + "gradient_norm": 0.048455506563186646, + "elapsed": 367.7296392917633 + }, + { + "step": 528, + "loss": 0.6062720417976379, + "objective": 0.6062720417976379, + "error": 0.369140625, + "gradient_norm": 0.07544548809528351, + "elapsed": 385.4480962753296 + }, + { + "step": 544, + "loss": 0.520085871219635, + "objective": 0.520085871219635, + "error": 0.279296875, + "gradient_norm": 0.08394371718168259, + "elapsed": 397.71993708610535 + }, + { + "step": 560, + "loss": 0.5944540500640869, + "objective": 0.5944540500640869, + "error": 0.3544921875, + "gradient_norm": 0.05468091368675232, + "elapsed": 406.9417428970337 + }, + { + "step": 576, + "loss": 0.34102559089660645, + "objective": 0.34102559089660645, + "error": 0.1611328125, + "gradient_norm": 0.07333917915821075, + "elapsed": 417.0068130493164 + }, + { + "step": 592, + "loss": 0.47373664379119873, + "objective": 0.47373664379119873, + "error": 0.2412109375, + "gradient_norm": 0.05662858858704567, + "elapsed": 425.1176447868347 + }, + { + "step": 608, + "loss": 0.48517894744873047, + "objective": 0.48517894744873047, + "error": 0.25, + "gradient_norm": 0.08127480745315552, + "elapsed": 434.92080903053284 + }, + { + "step": 624, + "loss": 0.39865612983703613, + "objective": 0.39865612983703613, + "error": 0.1904296875, + "gradient_norm": 0.07332058995962143, + "elapsed": 446.6602101325989 + }, + { + "step": 640, + "loss": 0.41867297887802124, + "objective": 0.41867297887802124, + "error": 0.2177734375, + "gradient_norm": 0.07386308163404465, + "elapsed": 457.0243580341339 + }, + { + "step": 656, + "loss": 0.5108687877655029, + "objective": 0.5108687877655029, + "error": 0.2822265625, + "gradient_norm": 0.052080318331718445, + "elapsed": 469.5842761993408 + }, + { + "step": 672, + "loss": 0.5043742656707764, + "objective": 0.5043742656707764, + "error": 0.2734375, + "gradient_norm": 0.047204963862895966, + "elapsed": 479.356397151947 + }, + { + "step": 688, + "loss": 0.5550935864448547, + "objective": 0.5550935864448547, + "error": 0.30078125, + "gradient_norm": 0.04080262407660484, + "elapsed": 489.9912152290344 + }, + { + "step": 704, + "loss": 0.5698974132537842, + "objective": 0.5698974132537842, + "error": 0.322265625, + "gradient_norm": 0.10692963004112244, + "elapsed": 500.3283371925354 + }, + { + "step": 720, + "loss": 0.45870622992515564, + "objective": 0.45870622992515564, + "error": 0.2255859375, + "gradient_norm": 0.06705734878778458, + "elapsed": 509.82279753685 + }, + { + "step": 736, + "loss": 0.555386483669281, + "objective": 0.555386483669281, + "error": 0.31640625, + "gradient_norm": 0.05112688988447189, + "elapsed": 518.507036447525 + }, + { + "step": 752, + "loss": 0.14282986521720886, + "objective": 0.14282986521720886, + "error": 0.056640625, + "gradient_norm": 0.03209136053919792, + "elapsed": 529.1373023986816 + }, + { + "step": 768, + "loss": 0.5362129807472229, + "objective": 0.5362129807472229, + "error": 0.2841796875, + "gradient_norm": 0.049996186047792435, + "elapsed": 538.9186007976532 + }, + { + "step": 784, + "loss": 0.5071826577186584, + "objective": 0.5071826577186584, + "error": 0.2744140625, + "gradient_norm": 0.04826078191399574, + "elapsed": 549.5225830078125 + }, + { + "step": 800, + "loss": 0.24775367975234985, + "objective": 0.24775367975234985, + "error": 0.107421875, + "gradient_norm": 0.06889795511960983, + "elapsed": 560.7170543670654 + }, + { + "step": 816, + "loss": 0.17432856559753418, + "objective": 0.17432856559753418, + "error": 0.06640625, + "gradient_norm": 0.05147368833422661, + "elapsed": 570.7887880802155 + }, + { + "step": 832, + "loss": 0.5410823822021484, + "objective": 0.5410823822021484, + "error": 0.3115234375, + "gradient_norm": 0.11862928420305252, + "elapsed": 581.9721121788025 + }, + { + "step": 848, + "loss": 0.5555508732795715, + "objective": 0.5555508732795715, + "error": 0.296875, + "gradient_norm": 0.060369592159986496, + "elapsed": 592.2823219299316 + }, + { + "step": 864, + "loss": 0.31839215755462646, + "objective": 0.31839215755462646, + "error": 0.1552734375, + "gradient_norm": 0.063877172768116, + "elapsed": 603.1910541057587 + }, + { + "step": 880, + "loss": 0.481766939163208, + "objective": 0.481766939163208, + "error": 0.2470703125, + "gradient_norm": 0.1623816341161728, + "elapsed": 614.4277107715607 + }, + { + "step": 896, + "loss": 0.5780366659164429, + "objective": 0.5780366659164429, + "error": 0.3037109375, + "gradient_norm": 0.06694691628217697, + "elapsed": 623.9365792274475 + }, + { + "step": 912, + "loss": 0.4794909358024597, + "objective": 0.4794909358024597, + "error": 0.2314453125, + "gradient_norm": 0.07813122123479843, + "elapsed": 633.9845306873322 + }, + { + "step": 928, + "loss": 0.6279138922691345, + "objective": 0.6279138922691345, + "error": 0.380859375, + "gradient_norm": 0.047679927200078964, + "elapsed": 643.7766675949097 + }, + { + "step": 944, + "loss": 0.6401606798171997, + "objective": 0.6401606798171997, + "error": 0.3994140625, + "gradient_norm": 0.07329051941633224, + "elapsed": 655.2369928359985 + }, + { + "step": 960, + "loss": 0.4340277910232544, + "objective": 0.4340277910232544, + "error": 0.2158203125, + "gradient_norm": 0.11762503534555435, + "elapsed": 666.9884371757507 + }, + { + "step": 976, + "loss": 0.44496864080429077, + "objective": 0.44496864080429077, + "error": 0.2236328125, + "gradient_norm": 0.05260347202420235, + "elapsed": 677.3464586734772 + }, + { + "step": 992, + "loss": 0.13230293989181519, + "objective": 0.13230293989181519, + "error": 0.05078125, + "gradient_norm": 0.030240925028920174, + "elapsed": 685.7275724411011 + }, + { + "step": 1008, + "loss": 0.2971688508987427, + "objective": 0.2971688508987427, + "error": 0.1171875, + "gradient_norm": 0.05503479763865471, + "elapsed": 694.1270356178284 + }, + { + "step": 1024, + "loss": 0.5688735246658325, + "objective": 0.5688735246658325, + "error": 0.314453125, + "gradient_norm": 0.06526188552379608, + "elapsed": 703.9192817211151 + }, + { + "step": 1040, + "loss": 0.42805811762809753, + "objective": 0.42805811762809753, + "error": 0.2080078125, + "gradient_norm": 0.13000032305717468, + "elapsed": 720.145961523056 + }, + { + "step": 1056, + "loss": 0.5543602705001831, + "objective": 0.5543602705001831, + "error": 0.298828125, + "gradient_norm": 0.15922385454177856, + "elapsed": 733.5112845897675 + }, + { + "step": 1072, + "loss": 0.031130114570260048, + "objective": 0.031130114570260048, + "error": 0.013671875, + "gradient_norm": 0.008926023729145527, + "elapsed": 742.4467866420746 + }, + { + "step": 1088, + "loss": 0.14947748184204102, + "objective": 0.14947748184204102, + "error": 0.056640625, + "gradient_norm": 0.03975249081850052, + "elapsed": 751.8575854301453 + }, + { + "step": 1104, + "loss": 0.6275734901428223, + "objective": 0.6275734901428223, + "error": 0.3671875, + "gradient_norm": 0.08096148073673248, + "elapsed": 761.5625903606415 + }, + { + "step": 1120, + "loss": 0.23923414945602417, + "objective": 0.23923414945602417, + "error": 0.0966796875, + "gradient_norm": 0.03325376287102699, + "elapsed": 773.9633615016937 + }, + { + "step": 1136, + "loss": 0.570243239402771, + "objective": 0.570243239402771, + "error": 0.31640625, + "gradient_norm": 0.07534287869930267, + "elapsed": 783.1533136367798 + }, + { + "step": 1152, + "loss": 0.4264270067214966, + "objective": 0.4264270067214966, + "error": 0.2119140625, + "gradient_norm": 0.08900073170661926, + "elapsed": 792.1710996627808 + }, + { + "step": 1168, + "loss": 0.5958121418952942, + "objective": 0.5958121418952942, + "error": 0.3583984375, + "gradient_norm": 0.08239343762397766, + "elapsed": 803.1175289154053 + }, + { + "step": 1184, + "loss": 0.2909137010574341, + "objective": 0.2909137010574341, + "error": 0.1416015625, + "gradient_norm": 0.05281354859471321, + "elapsed": 812.6055159568787 + }, + { + "step": 1200, + "loss": 0.6119058728218079, + "objective": 0.6119058728218079, + "error": 0.36328125, + "gradient_norm": 0.056254416704177856, + "elapsed": 823.2276427745819 + }, + { + "step": 1216, + "loss": 0.13595536351203918, + "objective": 0.13595536351203918, + "error": 0.0556640625, + "gradient_norm": 0.04057573154568672, + "elapsed": 834.1696293354034 + }, + { + "step": 1232, + "loss": 0.5840731263160706, + "objective": 0.5840731263160706, + "error": 0.328125, + "gradient_norm": 0.054566267877817154, + "elapsed": 845.3501887321472 + }, + { + "step": 1248, + "loss": 0.3053072690963745, + "objective": 0.3053072690963745, + "error": 0.1337890625, + "gradient_norm": 0.04617297649383545, + "elapsed": 854.9564871788025 + }, + { + "step": 1264, + "loss": 0.6288673281669617, + "objective": 0.6288673281669617, + "error": 0.3994140625, + "gradient_norm": 0.08229745179414749, + "elapsed": 864.8914043903351 + }, + { + "step": 1280, + "loss": 0.5586361289024353, + "objective": 0.5586361289024353, + "error": 0.2958984375, + "gradient_norm": 0.05713959410786629, + "elapsed": 877.0349607467651 + }, + { + "step": 1296, + "loss": 0.3648858666419983, + "objective": 0.3648858666419983, + "error": 0.16796875, + "gradient_norm": 0.08502963185310364, + "elapsed": 888.5764675140381 + }, + { + "step": 1312, + "loss": 0.4747084081172943, + "objective": 0.4747084081172943, + "error": 0.244140625, + "gradient_norm": 0.08609883487224579, + "elapsed": 899.7598609924316 + }, + { + "step": 1328, + "loss": 0.15583917498588562, + "objective": 0.15583917498588562, + "error": 0.05859375, + "gradient_norm": 0.027793049812316895, + "elapsed": 909.47514295578 + }, + { + "step": 1344, + "loss": 0.47515708208084106, + "objective": 0.47515708208084106, + "error": 0.263671875, + "gradient_norm": 0.07668807357549667, + "elapsed": 919.7640328407288 + }, + { + "step": 1360, + "loss": 0.5173689126968384, + "objective": 0.5173689126968384, + "error": 0.2744140625, + "gradient_norm": 0.05054212734103203, + "elapsed": 930.6309463977814 + }, + { + "step": 1376, + "loss": 0.46629998087882996, + "objective": 0.46629998087882996, + "error": 0.24609375, + "gradient_norm": 0.051172077655792236, + "elapsed": 939.0202586650848 + }, + { + "step": 1392, + "loss": 0.11312969774007797, + "objective": 0.11312969774007797, + "error": 0.044921875, + "gradient_norm": 0.05863805115222931, + "elapsed": 949.1451416015625 + }, + { + "step": 1408, + "loss": 0.5750841498374939, + "objective": 0.5750841498374939, + "error": 0.322265625, + "gradient_norm": 0.051106806844472885, + "elapsed": 959.94162940979 + }, + { + "step": 1424, + "loss": 0.5937192440032959, + "objective": 0.5937192440032959, + "error": 0.3408203125, + "gradient_norm": 0.05014815554022789, + "elapsed": 969.5868306159973 + }, + { + "step": 1440, + "loss": 0.5292985439300537, + "objective": 0.5292985439300537, + "error": 0.2958984375, + "gradient_norm": 0.057068243622779846, + "elapsed": 982.6692054271698 + }, + { + "step": 1456, + "loss": 0.5959951877593994, + "objective": 0.5959951877593994, + "error": 0.3408203125, + "gradient_norm": 0.0703694075345993, + "elapsed": 995.0066986083984 + }, + { + "step": 1472, + "loss": 0.018453411757946014, + "objective": 0.018453411757946014, + "error": 0.00390625, + "gradient_norm": 0.012016087770462036, + "elapsed": 1004.0057821273804 + }, + { + "step": 1488, + "loss": 0.5711684823036194, + "objective": 0.5711684823036194, + "error": 0.3095703125, + "gradient_norm": 0.07746906578540802, + "elapsed": 1016.1701967716217 + }, + { + "step": 1504, + "loss": 0.3114882707595825, + "objective": 0.3114882707595825, + "error": 0.1455078125, + "gradient_norm": 0.05321609228849411, + "elapsed": 1026.6053586006165 + }, + { + "step": 1520, + "loss": 0.6433392763137817, + "objective": 0.6433392763137817, + "error": 0.4072265625, + "gradient_norm": 0.05683734640479088, + "elapsed": 1036.1535296440125 + }, + { + "step": 1536, + "loss": 0.38409170508384705, + "objective": 0.38409170508384705, + "error": 0.19140625, + "gradient_norm": 0.07577994465827942, + "elapsed": 1046.9508447647095 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "7b45252d6bb77a39c003c8f34f040d0d672e9dd1a1338a14126e1fe07a02c8c9", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 466919, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/reserved1_full", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23228665865384618, + "0": 0.2337439903846154, + "blend-0": 0.23366887019230773, + "512": 0.23284254807692306, + "blend-512": 0.23275240384615387, + "1024": 0.23356370192307693, + "blend-1024": 0.23315805288461536, + "1536": 0.23218149038461539, + "blend-1536": 0.2330378605769231 + }, + "selected": "1536" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "0": 0.2206580528846154, + "blend-0": 0.2208683894230769, + "512": 0.22100360576923078, + "blend-512": 0.2208984375, + "1024": 0.22104867788461538, + "blend-1024": 0.22019230769230771, + "1536": 0.22264122596153849, + "blend-1536": 0.22032752403846154 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 466919, + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit unused intermediate logical tracking; raw neural branches also omit the unused final physical readout.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "packaged_runtime_control_cpu": { + "device": "cpu", + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "same_cpu_old_vs_new_maximum_difference": 0.0, + "old_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "new_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "cpu_vs_reconstructed_old_gpu_runtime_maximum_difference": 4.976987838745117e-05, + "original_gpu_evaluation_vs_reconstructed_gpu_runtime_maximum_difference": 7.748603820800781e-07, + "initial_failed_control": { + "comparison": "CPU runtime against original GPU evaluator", + "observed_maximum_difference": 4.971027374267578e-05, + "original_tolerance": 3e-06 + }, + "sources": { + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee", + "d5_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b" + }, + "scope": "Same-device compatibility check. Reconstructed GPU runtime removes the recorded equal physical blend; that reconstruction has floating-point rounding uncertainty.", + "status": "passed_same_device_compatibility" + }, + "dispatcher_control_cpu": { + "status": "passed", + "device": "cpu", + "sources": { + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee" + }, + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + } + ], + "scope": "Routing and code-copy check against each direct model implementation, using training detector inputs without labels. Tiny trained temporal/history smoke weights test nonzero feature couplings; they are excluded from model selection and submission.", + "test_data_used": false + }, + "cpu_probability_precision": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "validation_syndromes": 7, + "logical_labels_used": false, + "parameter_updates": 0, + "reference": "Float64 neural forward and exact contraction from the same stored weights and fixed float32 input logits, on CPU", + "cpu_float32_vs_float64_maximum_difference": 7.624897924163321e-08, + "cpu_float32_edges_float64_contraction_vs_float64_maximum_difference": 4.725248914372315e-08, + "gpu_float32_vs_float64_maximum_difference": 4.964999121059854e-05, + "cpu_vs_gpu_float32_maximum_difference": 4.971027374267578e-05, + "maximum_neural_edge_probability_difference": 2.6330936014895556e-08, + "float32_edge_values_above_one_minus_1e6": 0, + "scope": "Precision diagnostic only; the published model is unchanged. Same-device old/new packaged-code compatibility was independently exact." + }, + "priors_only_control_cpu": { + "status": "passed", + "device": "cpu", + "source_sha256": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 2.7116777896881104, + "priors_only_seconds_warm": 0.13569164276123047 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 3.557781457901001, + "priors_only_seconds_warm": 1.7711329460144043 + } + ], + "scope": "CPU numerical equivalence on supplied training syndromes; timings are not a controlled speed comparison." + } + } + } + ], + "short_syndrome_updates": [ + { + "training": { + "initialization": "256 residual logits per condition initialized independently Normal(0,.01), seeds20261126 through20261133; optimized in this session", + "architecture": "One categorical residual per possible8-bit detection syndrome, added to an exact physical DEM logit; no sample IDs or row indices are model features", + "loss": "Binomial logical BCE sufficient statistics plus strength times cross entropy to the fixed physical prior; damped Newton optimization from random residual initialization", + "fixed_prior": "Exact full-DEM probabilities for all256 possible input syndromes, computed now from the authorized packaged even-fitted DEM plans; no external trained weights or decoder answers", + "training": "All19880 supplied training labels for each of eight d3 one-round conditions; only aggregate counts by detection syndrome enter fitting", + "data_scope": "This is a finite categorical classifier, indexed by detection events, not a per-shot answer table. Other122 conditions retain the incumbent in any candidate benchmark.", + "selection": "One common strength and optional equal probability blend for all eight geometries/bases, minimizing full validation mean; all other conditions unchanged", + "base_package": { + "package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "predictions": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/predictions", + "score": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/score.json", + "P": 0.7663217397836538 + }, + "test_data_used": false, + "training_records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 149, + "initial_seed": 20261126, + "physical_plan_sha256": "640c371577096ba08c799b70fd16d03a06a37004feaa15c85c4cb6ef87529080", + "training_arrays_sha256": "a7acd6f6e5372873cf2d34946876a791996238efdea39f7fa33f7d2eabc1c10f" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 157, + "initial_seed": 20261127, + "physical_plan_sha256": "4a0f8f630b7f34fba620a4e03bd77e14fb80149e70b7da80b6176dbd24d9ddc8", + "training_arrays_sha256": "0e2267afc5dc4e761d3b9e09288875f2077215fac2f902ce4151699c38c24531" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 152, + "initial_seed": 20261128, + "physical_plan_sha256": "de8914194be7689d70e9424540923197a5c0465fb42ec96556df97b73ba250c1", + "training_arrays_sha256": "0542609248a5d2c8b410666bb901361b60c39cb8b32b3b46fdd24a6c7913db56" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 147, + "initial_seed": 20261129, + "physical_plan_sha256": "bc1a6888cc5a854f0348cab463b8879c2d176d9509176b944b7f4265e0772ab3", + "training_arrays_sha256": "ccd43f09fba55b2138a5401e6f5c89cc7b4c4ec470a07cd037d9f715acaa1188" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 153, + "initial_seed": 20261130, + "physical_plan_sha256": "1931b5b85d0014c2a928a40c3ec502316ff30ea1632a25c5f64e2694f828434b", + "training_arrays_sha256": "aa27eee730c88b2071b5fd97f9d47a0f3ad010e29202415f786babc073d405e4" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 159, + "initial_seed": 20261131, + "physical_plan_sha256": "6d231f857bbe85040c91af1160c2dda16557a67851deaedc8092412f6abeb294", + "training_arrays_sha256": "569131ce49a2c1060ebd472c0290fc0c1de6e522cd7cd7aa92b10e17cdd1783c" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 158, + "initial_seed": 20261132, + "physical_plan_sha256": "ef285cea44ad63e0452596d4be65c8844ea8a7dcc49fb31b6a6241d367ed63eb", + "training_arrays_sha256": "6928ade685b05f76b7a3a9dc6423504d0bdce09742603c24978aa21fcf106f88" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 160, + "initial_seed": 20261133, + "physical_plan_sha256": "82bee01cf3e00079270a27cb79472322867548df5c9dc4db3252e4c6ec89e6a6", + "training_arrays_sha256": "afbc73fc5ca8e3b8e996377ab3df5a5b9397f36362e72c01feea7848ea1995f3" + } + ], + "records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261126, + "iterations": 8, + "failure": 0.0134765625, + "blended_failure": 0.013671875, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04649575086997129, + "weights_sha256": "d985985dedbe644bfae165330f4f46da14d04efbc4cad1af81c5510115380701" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261126, + "iterations": 6, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04591998541695955, + "weights_sha256": "17383d153dd1dfef62b3d4f6c5b7549c3209150faf0714e78fede09b941ecc3a" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.0458401737684183, + "weights_sha256": "f863a64ca698135f6fac6ac184d3c689db684a15d73bf0565418b240d76b5c58" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.045887733186657405, + "weights_sha256": "ded1a941e0dfc58e55ced6523720445fb70032d2d15c9929b0c93544f7c567f8" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261127, + "iterations": 8, + "failure": 0.0177734375, + "blended_failure": 0.0177734375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05532273244895745, + "weights_sha256": "02950043334a38d3e7980cc97685904338553746653bd2d6a4c9be88ae845270" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261127, + "iterations": 6, + "failure": 0.01875, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055166841080990084, + "weights_sha256": "412ee1f453695e4f3534dbe8d7eb1ca565d06fd7c718b52fe9a306b35e845d9d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261127, + "iterations": 5, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055186840974757456, + "weights_sha256": "12d8f72c2ee5cb837145aaf9a1b485d8517e4374721eebcbea9803d3bfdc8fcd" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261127, + "iterations": 4, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05544033886527203, + "weights_sha256": "d1daa90794c1c3c8cd00134d9b22a7173aee4dd9b139b86f6d3f9b8f2131056d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261128, + "iterations": 7, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.049592331750930654, + "weights_sha256": "ad21a8640e2fe7bbd550225e354dedcbad8cb70433b892f45d28fa2346ab88de" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04900882633372332, + "weights_sha256": "4664564f60149b00b1754a3f9e91c8b04b29ef819b231bf17ea7588346433a57" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04861554683295004, + "weights_sha256": "cad51322361a95020501afa64e356f2a49dd02afa0cd91294d4498f7eb0c5a8d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04843255984360956, + "weights_sha256": "5fe850e6313cb9ed6631697684afeeb7b7c5857a5c74fad66189cfcf8a08218b" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261129, + "iterations": 7, + "failure": 0.0158203125, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05156220348280275, + "weights_sha256": "56c2fd4a7c35033084020cd1f5c9dcc2ab1cf2c631d0e88cc87ac4c715c6af17" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05139675960346585, + "weights_sha256": "0bf66368e18c8d1baecaa614d4c0cec16304ac14bcd29d22d1cdb2a0ff6c0173" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05135569004239689, + "weights_sha256": "d9581a6f29f9d3ea54d482c17995a37b55e3b4253d36e1d49cfce95b398eb5c2" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05141882723288258, + "weights_sha256": "2c4e4592067fcbbe69d6ede68c4494209652a2d510e74aa2ea3b4420c3cdd741" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261130, + "iterations": 7, + "failure": 0.0173828125, + "blended_failure": 0.0173828125, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.054216247940585036, + "weights_sha256": "7b12f028f764293a9496d9fd2ddbf92ba9c23653d7889a602a9ec23f8cde3d6b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261130, + "iterations": 6, + "failure": 0.017578125, + "blended_failure": 0.0171875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05364509063427466, + "weights_sha256": "1ad2ffaafa33009129a0953d79fe2d30ad62308eb9dbf8da0b76eca018a5b55a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261130, + "iterations": 5, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05368896256105915, + "weights_sha256": "64619c9b7bd40a14651bcd056d58f5b55e79eb334a4e5105ff12cb7ff6f2400a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261130, + "iterations": 6, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05387292464104988, + "weights_sha256": "b1490702e212d7cdcc936f55186b15411ced3a8928a1a32f2d4ac1212706fabf" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261131, + "iterations": 8, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04709647994869577, + "weights_sha256": "eb56715dfc5e8c6b8866ceeb2636422acad9992dd2c625355dc21b94c25351f0" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261131, + "iterations": 6, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.046679107084477436, + "weights_sha256": "320cd10cc8cd9d13d20d9ce0ea90413ed8343587f0c77abb0e1c8c84503aa2d8" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261131, + "iterations": 5, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04621785858320204, + "weights_sha256": "c7e63309de0668bd4d5c05169ecd6af1879c88be10947d0fdb958ca37068d433" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261131, + "iterations": 4, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04577880173787941, + "weights_sha256": "494824e979e52fbf0302e706ff6786d89ce60b607afd6b376cad9700f328feda" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261132, + "iterations": 7, + "failure": 0.01484375, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.05068038016752655, + "weights_sha256": "0b4c35df1d44c9353a2ea505205f3def95bb28de0c7052ded18cf599bef2709b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049663607204405706, + "weights_sha256": "b18deed32b51a58789873a1b45718f5c40d1d9500b57e113520b700a66902f1a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261132, + "iterations": 5, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.04918133832768282, + "weights_sha256": "12e71625e223602cbc9f7ae150473a1dad2c32f2d9221a4b88ccb93babc2c41d" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049002647954447996, + "weights_sha256": "e909b83698caba60ad01e28027b28005544cd8e795f88574fc6f81bcf56b2add" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261133, + "iterations": 7, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05204562159505248, + "weights_sha256": "b03b071238dda333574a4da2d9b2bb999cf362a83b9194b1c53871e9438f9f45" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05177096705064832, + "weights_sha256": "2a4c8113ee9a1dadcfc0f1b7ff8d164e7c8771d5764b0512ee1a5de2a8aaa395" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.051861030681133645, + "weights_sha256": "f201491af84870ffa8c1b59e16dea1fea910e7fda32f0e3d82863943222b57ee" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261133, + "iterations": 6, + "failure": 0.01640625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05206536190640361, + "weights_sha256": "b7cfd76b6574457626306868e31ab5327a1950cbbca41f6384eb2c4bc759e800" + } + ], + "choices": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "blend-16": 0.015429687499999999, + "64": 0.0155029296875, + "blend-64": 0.015600585937500001, + "256": 0.0155517578125, + "blend-256": 0.015600585937500001, + "1024": 0.0156005859375, + "blend-1024": 0.015600585937500001 + }, + "selected": "16", + "expected_full_P": 0.7663245567908653, + "validation_P_gain": 2.817007211538435e-06, + "source_sha256": "7e75f14190b18b05e9af540a8ef0f75522060e78c30b05475686ea18faf0035f", + "seconds": 3.316046953201294 + }, + "packaging_selection": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "64": 0.0155029296875, + "256": 0.0155517578125, + "1024": 0.0156005859375 + }, + "selected": "16", + "selection_scope": "One common prior strength for all eight short conditions; other122 condition predictions retained", + "runtime_source_sha256": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af" + }, + { + "training": { + "initialization": "256 residual logits per condition initialized independently Normal(0,.01), seeds20261126 through20261133; optimized in this session", + "architecture": "One categorical residual per possible8-bit detection syndrome, added to an exact physical DEM logit; no sample IDs or row indices are model features", + "loss": "Binomial logical BCE sufficient statistics plus strength times cross entropy to the fixed physical prior; damped Newton optimization from random residual initialization", + "fixed_prior": "Exact full-DEM probabilities for all256 possible input syndromes, computed now from the authorized packaged even-fitted DEM plans; no external trained weights or decoder answers", + "training": "All19880 supplied training labels for each of eight d3 one-round conditions; only aggregate counts by detection syndrome enter fitting", + "data_scope": "This is a finite categorical classifier, indexed by detection events, not a per-shot answer table. Other122 conditions retain the incumbent in any candidate benchmark.", + "selection": "One common strength and optional equal probability blend for all eight geometries/bases, minimizing full validation mean; all other conditions unchanged", + "base_package": { + "package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "predictions": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/predictions", + "score": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/score.json", + "P": 0.7663217397836538 + }, + "test_data_used": false, + "training_records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 149, + "initial_seed": 20261126, + "physical_plan_sha256": "640c371577096ba08c799b70fd16d03a06a37004feaa15c85c4cb6ef87529080", + "training_arrays_sha256": "a7acd6f6e5372873cf2d34946876a791996238efdea39f7fa33f7d2eabc1c10f" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 157, + "initial_seed": 20261127, + "physical_plan_sha256": "4a0f8f630b7f34fba620a4e03bd77e14fb80149e70b7da80b6176dbd24d9ddc8", + "training_arrays_sha256": "0e2267afc5dc4e761d3b9e09288875f2077215fac2f902ce4151699c38c24531" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 152, + "initial_seed": 20261128, + "physical_plan_sha256": "de8914194be7689d70e9424540923197a5c0465fb42ec96556df97b73ba250c1", + "training_arrays_sha256": "0542609248a5d2c8b410666bb901361b60c39cb8b32b3b46fdd24a6c7913db56" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 147, + "initial_seed": 20261129, + "physical_plan_sha256": "bc1a6888cc5a854f0348cab463b8879c2d176d9509176b944b7f4265e0772ab3", + "training_arrays_sha256": "ccd43f09fba55b2138a5401e6f5c89cc7b4c4ec470a07cd037d9f715acaa1188" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 153, + "initial_seed": 20261130, + "physical_plan_sha256": "1931b5b85d0014c2a928a40c3ec502316ff30ea1632a25c5f64e2694f828434b", + "training_arrays_sha256": "aa27eee730c88b2071b5fd97f9d47a0f3ad010e29202415f786babc073d405e4" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 159, + "initial_seed": 20261131, + "physical_plan_sha256": "6d231f857bbe85040c91af1160c2dda16557a67851deaedc8092412f6abeb294", + "training_arrays_sha256": "569131ce49a2c1060ebd472c0290fc0c1de6e522cd7cd7aa92b10e17cdd1783c" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 158, + "initial_seed": 20261132, + "physical_plan_sha256": "ef285cea44ad63e0452596d4be65c8844ea8a7dcc49fb31b6a6241d367ed63eb", + "training_arrays_sha256": "6928ade685b05f76b7a3a9dc6423504d0bdce09742603c24978aa21fcf106f88" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 160, + "initial_seed": 20261133, + "physical_plan_sha256": "82bee01cf3e00079270a27cb79472322867548df5c9dc4db3252e4c6ec89e6a6", + "training_arrays_sha256": "afbc73fc5ca8e3b8e996377ab3df5a5b9397f36362e72c01feea7848ea1995f3" + } + ], + "records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261126, + "iterations": 8, + "failure": 0.0134765625, + "blended_failure": 0.013671875, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04649575086997129, + "weights_sha256": "d985985dedbe644bfae165330f4f46da14d04efbc4cad1af81c5510115380701" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261126, + "iterations": 6, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04591998541695955, + "weights_sha256": "17383d153dd1dfef62b3d4f6c5b7549c3209150faf0714e78fede09b941ecc3a" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.0458401737684183, + "weights_sha256": "f863a64ca698135f6fac6ac184d3c689db684a15d73bf0565418b240d76b5c58" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.045887733186657405, + "weights_sha256": "ded1a941e0dfc58e55ced6523720445fb70032d2d15c9929b0c93544f7c567f8" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261127, + "iterations": 8, + "failure": 0.0177734375, + "blended_failure": 0.0177734375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05532273244895745, + "weights_sha256": "02950043334a38d3e7980cc97685904338553746653bd2d6a4c9be88ae845270" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261127, + "iterations": 6, + "failure": 0.01875, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055166841080990084, + "weights_sha256": "412ee1f453695e4f3534dbe8d7eb1ca565d06fd7c718b52fe9a306b35e845d9d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261127, + "iterations": 5, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055186840974757456, + "weights_sha256": "12d8f72c2ee5cb837145aaf9a1b485d8517e4374721eebcbea9803d3bfdc8fcd" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261127, + "iterations": 4, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05544033886527203, + "weights_sha256": "d1daa90794c1c3c8cd00134d9b22a7173aee4dd9b139b86f6d3f9b8f2131056d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261128, + "iterations": 7, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.049592331750930654, + "weights_sha256": "ad21a8640e2fe7bbd550225e354dedcbad8cb70433b892f45d28fa2346ab88de" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04900882633372332, + "weights_sha256": "4664564f60149b00b1754a3f9e91c8b04b29ef819b231bf17ea7588346433a57" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04861554683295004, + "weights_sha256": "cad51322361a95020501afa64e356f2a49dd02afa0cd91294d4498f7eb0c5a8d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04843255984360956, + "weights_sha256": "5fe850e6313cb9ed6631697684afeeb7b7c5857a5c74fad66189cfcf8a08218b" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261129, + "iterations": 7, + "failure": 0.0158203125, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05156220348280275, + "weights_sha256": "56c2fd4a7c35033084020cd1f5c9dcc2ab1cf2c631d0e88cc87ac4c715c6af17" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05139675960346585, + "weights_sha256": "0bf66368e18c8d1baecaa614d4c0cec16304ac14bcd29d22d1cdb2a0ff6c0173" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05135569004239689, + "weights_sha256": "d9581a6f29f9d3ea54d482c17995a37b55e3b4253d36e1d49cfce95b398eb5c2" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05141882723288258, + "weights_sha256": "2c4e4592067fcbbe69d6ede68c4494209652a2d510e74aa2ea3b4420c3cdd741" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261130, + "iterations": 7, + "failure": 0.0173828125, + "blended_failure": 0.0173828125, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.054216247940585036, + "weights_sha256": "7b12f028f764293a9496d9fd2ddbf92ba9c23653d7889a602a9ec23f8cde3d6b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261130, + "iterations": 6, + "failure": 0.017578125, + "blended_failure": 0.0171875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05364509063427466, + "weights_sha256": "1ad2ffaafa33009129a0953d79fe2d30ad62308eb9dbf8da0b76eca018a5b55a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261130, + "iterations": 5, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05368896256105915, + "weights_sha256": "64619c9b7bd40a14651bcd056d58f5b55e79eb334a4e5105ff12cb7ff6f2400a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261130, + "iterations": 6, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05387292464104988, + "weights_sha256": "b1490702e212d7cdcc936f55186b15411ced3a8928a1a32f2d4ac1212706fabf" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261131, + "iterations": 8, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04709647994869577, + "weights_sha256": "eb56715dfc5e8c6b8866ceeb2636422acad9992dd2c625355dc21b94c25351f0" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261131, + "iterations": 6, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.046679107084477436, + "weights_sha256": "320cd10cc8cd9d13d20d9ce0ea90413ed8343587f0c77abb0e1c8c84503aa2d8" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261131, + "iterations": 5, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04621785858320204, + "weights_sha256": "c7e63309de0668bd4d5c05169ecd6af1879c88be10947d0fdb958ca37068d433" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261131, + "iterations": 4, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04577880173787941, + "weights_sha256": "494824e979e52fbf0302e706ff6786d89ce60b607afd6b376cad9700f328feda" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261132, + "iterations": 7, + "failure": 0.01484375, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.05068038016752655, + "weights_sha256": "0b4c35df1d44c9353a2ea505205f3def95bb28de0c7052ded18cf599bef2709b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049663607204405706, + "weights_sha256": "b18deed32b51a58789873a1b45718f5c40d1d9500b57e113520b700a66902f1a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261132, + "iterations": 5, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.04918133832768282, + "weights_sha256": "12e71625e223602cbc9f7ae150473a1dad2c32f2d9221a4b88ccb93babc2c41d" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049002647954447996, + "weights_sha256": "e909b83698caba60ad01e28027b28005544cd8e795f88574fc6f81bcf56b2add" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261133, + "iterations": 7, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05204562159505248, + "weights_sha256": "b03b071238dda333574a4da2d9b2bb999cf362a83b9194b1c53871e9438f9f45" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05177096705064832, + "weights_sha256": "2a4c8113ee9a1dadcfc0f1b7ff8d164e7c8771d5764b0512ee1a5de2a8aaa395" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.051861030681133645, + "weights_sha256": "f201491af84870ffa8c1b59e16dea1fea910e7fda32f0e3d82863943222b57ee" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261133, + "iterations": 6, + "failure": 0.01640625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05206536190640361, + "weights_sha256": "b7cfd76b6574457626306868e31ab5327a1950cbbca41f6384eb2c4bc759e800" + } + ], + "choices": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "blend-16": 0.015429687499999999, + "64": 0.0155029296875, + "blend-64": 0.015600585937500001, + "256": 0.0155517578125, + "blend-256": 0.015600585937500001, + "1024": 0.0156005859375, + "blend-1024": 0.015600585937500001 + }, + "selected": "16", + "expected_full_P": 0.7663245567908653, + "validation_P_gain": 2.817007211538435e-06, + "source_sha256": "7e75f14190b18b05e9af540a8ef0f75522060e78c30b05475686ea18faf0035f", + "seconds": 3.316046953201294 + }, + "packaging_selection": { + "incumbent": 0.0154296875, + "16": 0.015380859375, + "64": 0.0155029296875, + "256": 0.0155517578125, + "1024": 0.0156005859375 + }, + "selected": "16", + "new_optimizer_updates": 0, + "selection_scope": "One common prior strength for all eight short conditions; other122 condition predictions retained", + "runtime_source_sha256": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af" + }, + { + "training": { + "initialization": "256 residual logits per condition initialized independently Normal(0,.01), seeds20261126 through20261133; optimized in this session", + "architecture": "One categorical residual per possible8-bit detection syndrome, added to an exact physical DEM logit; no sample IDs or row indices are model features", + "loss": "Binomial logical BCE sufficient statistics plus strength times cross entropy to the fixed physical prior; damped Newton optimization from random residual initialization", + "fixed_prior": "Exact full-DEM probabilities for all256 possible input syndromes, computed now from the authorized packaged even-fitted DEM plans; no external trained weights or decoder answers", + "training": "All19880 supplied training labels for each of eight d3 one-round conditions; only aggregate counts by detection syndrome enter fitting", + "data_scope": "This is a finite categorical classifier, indexed by detection events, not a per-shot answer table. Other122 conditions retain the incumbent in any candidate benchmark.", + "selection": "One common strength and optional equal probability blend for all eight geometries/bases, minimizing full validation mean; all other conditions unchanged", + "base_package": { + "package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "predictions": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/predictions", + "score": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/score.json", + "P": 0.7663217397836538 + }, + "test_data_used": false, + "training_records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 149, + "initial_seed": 20261126, + "physical_plan_sha256": "640c371577096ba08c799b70fd16d03a06a37004feaa15c85c4cb6ef87529080", + "training_arrays_sha256": "a7acd6f6e5372873cf2d34946876a791996238efdea39f7fa33f7d2eabc1c10f" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 157, + "initial_seed": 20261127, + "physical_plan_sha256": "4a0f8f630b7f34fba620a4e03bd77e14fb80149e70b7da80b6176dbd24d9ddc8", + "training_arrays_sha256": "0e2267afc5dc4e761d3b9e09288875f2077215fac2f902ce4151699c38c24531" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 152, + "initial_seed": 20261128, + "physical_plan_sha256": "de8914194be7689d70e9424540923197a5c0465fb42ec96556df97b73ba250c1", + "training_arrays_sha256": "0542609248a5d2c8b410666bb901361b60c39cb8b32b3b46fdd24a6c7913db56" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 147, + "initial_seed": 20261129, + "physical_plan_sha256": "bc1a6888cc5a854f0348cab463b8879c2d176d9509176b944b7f4265e0772ab3", + "training_arrays_sha256": "ccd43f09fba55b2138a5401e6f5c89cc7b4c4ec470a07cd037d9f715acaa1188" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "training_shots": 19880, + "observed_syndromes": 153, + "initial_seed": 20261130, + "physical_plan_sha256": "1931b5b85d0014c2a928a40c3ec502316ff30ea1632a25c5f64e2694f828434b", + "training_arrays_sha256": "aa27eee730c88b2071b5fd97f9d47a0f3ad010e29202415f786babc073d405e4" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "training_shots": 19880, + "observed_syndromes": 159, + "initial_seed": 20261131, + "physical_plan_sha256": "6d231f857bbe85040c91af1160c2dda16557a67851deaedc8092412f6abeb294", + "training_arrays_sha256": "569131ce49a2c1060ebd472c0290fc0c1de6e522cd7cd7aa92b10e17cdd1783c" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "training_shots": 19880, + "observed_syndromes": 158, + "initial_seed": 20261132, + "physical_plan_sha256": "ef285cea44ad63e0452596d4be65c8844ea8a7dcc49fb31b6a6241d367ed63eb", + "training_arrays_sha256": "6928ade685b05f76b7a3a9dc6423504d0bdce09742603c24978aa21fcf106f88" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "training_shots": 19880, + "observed_syndromes": 160, + "initial_seed": 20261133, + "physical_plan_sha256": "82bee01cf3e00079270a27cb79472322867548df5c9dc4db3252e4c6ec89e6a6", + "training_arrays_sha256": "afbc73fc5ca8e3b8e996377ab3df5a5b9397f36362e72c01feea7848ea1995f3" + } + ], + "records": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261126, + "iterations": 8, + "failure": 0.0134765625, + "blended_failure": 0.013671875, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04649575086997129, + "weights_sha256": "d985985dedbe644bfae165330f4f46da14d04efbc4cad1af81c5510115380701" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261126, + "iterations": 6, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.04591998541695955, + "weights_sha256": "17383d153dd1dfef62b3d4f6c5b7549c3209150faf0714e78fede09b941ecc3a" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.0458401737684183, + "weights_sha256": "f863a64ca698135f6fac6ac184d3c689db684a15d73bf0565418b240d76b5c58" + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261126, + "iterations": 5, + "failure": 0.0140625, + "blended_failure": 0.0140625, + "incumbent_failure": 0.0134765625, + "negative_log_likelihood": 0.045887733186657405, + "weights_sha256": "ded1a941e0dfc58e55ced6523720445fb70032d2d15c9929b0c93544f7c567f8" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261127, + "iterations": 8, + "failure": 0.0177734375, + "blended_failure": 0.0177734375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05532273244895745, + "weights_sha256": "02950043334a38d3e7980cc97685904338553746653bd2d6a4c9be88ae845270" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261127, + "iterations": 6, + "failure": 0.01875, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055166841080990084, + "weights_sha256": "412ee1f453695e4f3534dbe8d7eb1ca565d06fd7c718b52fe9a306b35e845d9d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261127, + "iterations": 5, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.055186840974757456, + "weights_sha256": "12d8f72c2ee5cb837145aaf9a1b485d8517e4374721eebcbea9803d3bfdc8fcd" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261127, + "iterations": 4, + "failure": 0.01953125, + "blended_failure": 0.0193359375, + "incumbent_failure": 0.0193359375, + "negative_log_likelihood": 0.05544033886527203, + "weights_sha256": "d1daa90794c1c3c8cd00134d9b22a7173aee4dd9b139b86f6d3f9b8f2131056d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261128, + "iterations": 7, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.049592331750930654, + "weights_sha256": "ad21a8640e2fe7bbd550225e354dedcbad8cb70433b892f45d28fa2346ab88de" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04900882633372332, + "weights_sha256": "4664564f60149b00b1754a3f9e91c8b04b29ef819b231bf17ea7588346433a57" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04861554683295004, + "weights_sha256": "cad51322361a95020501afa64e356f2a49dd02afa0cd91294d4498f7eb0c5a8d" + }, + { + "condition": "surface_code_bX_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261128, + "iterations": 6, + "failure": 0.015234375, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.0158203125, + "negative_log_likelihood": 0.04843255984360956, + "weights_sha256": "5fe850e6313cb9ed6631697684afeeb7b7c5857a5c74fad66189cfcf8a08218b" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261129, + "iterations": 7, + "failure": 0.0158203125, + "blended_failure": 0.0158203125, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05156220348280275, + "weights_sha256": "56c2fd4a7c35033084020cd1f5c9dcc2ab1cf2c631d0e88cc87ac4c715c6af17" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05139675960346585, + "weights_sha256": "0bf66368e18c8d1baecaa614d4c0cec16304ac14bcd29d22d1cdb2a0ff6c0173" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05135569004239689, + "weights_sha256": "d9581a6f29f9d3ea54d482c17995a37b55e3b4253d36e1d49cfce95b398eb5c2" + }, + { + "condition": "surface_code_bX_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261129, + "iterations": 6, + "failure": 0.0154296875, + "blended_failure": 0.0154296875, + "incumbent_failure": 0.01484375, + "negative_log_likelihood": 0.05141882723288258, + "weights_sha256": "2c4e4592067fcbbe69d6ede68c4494209652a2d510e74aa2ea3b4420c3cdd741" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 16, + "seed": 20261130, + "iterations": 7, + "failure": 0.0173828125, + "blended_failure": 0.0173828125, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.054216247940585036, + "weights_sha256": "7b12f028f764293a9496d9fd2ddbf92ba9c23653d7889a602a9ec23f8cde3d6b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 64, + "seed": 20261130, + "iterations": 6, + "failure": 0.017578125, + "blended_failure": 0.0171875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05364509063427466, + "weights_sha256": "1ad2ffaafa33009129a0953d79fe2d30ad62308eb9dbf8da0b76eca018a5b55a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 256, + "seed": 20261130, + "iterations": 5, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05368896256105915, + "weights_sha256": "64619c9b7bd40a14651bcd056d58f5b55e79eb334a4e5105ff12cb7ff6f2400a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_3_5", + "prior_strength": 1024, + "seed": 20261130, + "iterations": 6, + "failure": 0.0171875, + "blended_failure": 0.016796875, + "incumbent_failure": 0.016796875, + "negative_log_likelihood": 0.05387292464104988, + "weights_sha256": "b1490702e212d7cdcc936f55186b15411ced3a8928a1a32f2d4ac1212706fabf" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 16, + "seed": 20261131, + "iterations": 8, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04709647994869577, + "weights_sha256": "eb56715dfc5e8c6b8866ceeb2636422acad9992dd2c625355dc21b94c25351f0" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 64, + "seed": 20261131, + "iterations": 6, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.046679107084477436, + "weights_sha256": "320cd10cc8cd9d13d20d9ce0ea90413ed8343587f0c77abb0e1c8c84503aa2d8" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 256, + "seed": 20261131, + "iterations": 5, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04621785858320204, + "weights_sha256": "c7e63309de0668bd4d5c05169ecd6af1879c88be10947d0fdb958ca37068d433" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_3", + "prior_strength": 1024, + "seed": 20261131, + "iterations": 4, + "failure": 0.0125, + "blended_failure": 0.0125, + "incumbent_failure": 0.0125, + "negative_log_likelihood": 0.04577880173787941, + "weights_sha256": "494824e979e52fbf0302e706ff6786d89ce60b607afd6b376cad9700f328feda" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 16, + "seed": 20261132, + "iterations": 7, + "failure": 0.01484375, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.05068038016752655, + "weights_sha256": "0b4c35df1d44c9353a2ea505205f3def95bb28de0c7052ded18cf599bef2709b" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 64, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049663607204405706, + "weights_sha256": "b18deed32b51a58789873a1b45718f5c40d1d9500b57e113520b700a66902f1a" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 256, + "seed": 20261132, + "iterations": 5, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.04918133832768282, + "weights_sha256": "12e71625e223602cbc9f7ae150473a1dad2c32f2d9221a4b88ccb93babc2c41d" + }, + { + "condition": "surface_code_bZ_d3_r01_center_5_7", + "prior_strength": 1024, + "seed": 20261132, + "iterations": 6, + "failure": 0.014453125, + "blended_failure": 0.014453125, + "incumbent_failure": 0.014453125, + "negative_log_likelihood": 0.049002647954447996, + "weights_sha256": "e909b83698caba60ad01e28027b28005544cd8e795f88574fc6f81bcf56b2add" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 16, + "seed": 20261133, + "iterations": 7, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05204562159505248, + "weights_sha256": "b03b071238dda333574a4da2d9b2bb999cf362a83b9194b1c53871e9438f9f45" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 64, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.016015625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05177096705064832, + "weights_sha256": "2a4c8113ee9a1dadcfc0f1b7ff8d164e7c8771d5764b0512ee1a5de2a8aaa395" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 256, + "seed": 20261133, + "iterations": 6, + "failure": 0.016015625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.051861030681133645, + "weights_sha256": "f201491af84870ffa8c1b59e16dea1fea910e7fda32f0e3d82863943222b57ee" + }, + { + "condition": "surface_code_bZ_d3_r01_center_7_5", + "prior_strength": 1024, + "seed": 20261133, + "iterations": 6, + "failure": 0.01640625, + "blended_failure": 0.01640625, + "incumbent_failure": 0.01640625, + "negative_log_likelihood": 0.05206536190640361, + "weights_sha256": "b7cfd76b6574457626306868e31ab5327a1950cbbca41f6384eb2c4bc759e800" + } + ], + "choices": { + "incumbent": 0.0154541015625, + "16": 0.015380859375, + "blend-16": 0.015429687499999999, + "64": 0.0155029296875, + "blend-64": 0.015600585937500001, + "256": 0.0155517578125, + "blend-256": 0.015600585937500001, + "1024": 0.0156005859375, + "blend-1024": 0.015600585937500001 + }, + "selected": "16", + "expected_full_P": 0.7663245567908653, + "validation_P_gain": 2.817007211538435e-06, + "source_sha256": "7e75f14190b18b05e9af540a8ef0f75522060e78c30b05475686ea18faf0035f", + "seconds": 3.316046953201294 + }, + "packaging_selection": { + "incumbent": 0.0155517578125, + "16": 0.015380859375, + "64": 0.0155029296875, + "256": 0.0155517578125, + "1024": 0.0156005859375 + }, + "selected": "16", + "new_optimizer_updates": 0, + "selection_scope": "One common prior strength for all eight short conditions; other122 condition predictions retained", + "runtime_source_sha256": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af" + } + ], + "research_selection_history": { + "path": "selection_history.json", + "sha256": "7e50a88191985a29dc7477a3572f42052c417b282c3f40dbab04cf713fed4be3", + "completed_training_runs": 51, + "assembled_candidates": 41 + }, + "runtime_projection": { + "measured_full_validation_seconds_by_distance": { + "d3": 68.0347409248352, + "d5": 342.34057784080505 + }, + "validation_shots_per_condition": 5120, + "benchmark_shots_per_condition": 25000, + "workload_source": "Supplied data/README.md declares 25000 benchmark rows per condition; no benchmark examples accessed", + "linear_scale": 4.8828125, + "projected_total_seconds": 2003.7857361603528, + "limit_seconds": 3600, + "interpretation": "Projection from complete validation replays, scaling startup/compilation overhead as well as shot work. Retained-path timings are inherited; one-round categorical replacements only remove contractions. This is not a timed benchmark-split run." + }, + "neural_probability_ensemble": { + "new_optimizer_updates": 0, + "new_trainable_parameters": 0, + "initialization": "Constituents trained from random initialization in this session; this step only averages their predicted probabilities.", + "new_training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 467790, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved2_warm/weights-512.npz", + "starting_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317635, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261274", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.2600052058696747, + "objective": 0.2600052058696747, + "error": 0.1123046875, + "gradient_norm": 0.06799795478582382, + "elapsed": 27.333195447921753 + }, + { + "step": 16, + "loss": 0.0312246885150671, + "objective": 0.0312246885150671, + "error": 0.01171875, + "gradient_norm": 0.004962741397321224, + "elapsed": 48.383540868759155 + }, + { + "step": 32, + "loss": 0.22698244452476501, + "objective": 0.22698244452476501, + "error": 0.08984375, + "gradient_norm": 0.06353150308132172, + "elapsed": 57.04609966278076 + }, + { + "step": 48, + "loss": 0.5861443281173706, + "objective": 0.5861443281173706, + "error": 0.3486328125, + "gradient_norm": 0.04095375910401344, + "elapsed": 69.08654689788818 + }, + { + "step": 64, + "loss": 0.6103856563568115, + "objective": 0.6103856563568115, + "error": 0.3662109375, + "gradient_norm": 0.04155975207686424, + "elapsed": 81.63970494270325 + }, + { + "step": 80, + "loss": 0.5673234462738037, + "objective": 0.5673234462738037, + "error": 0.3125, + "gradient_norm": 0.1773851364850998, + "elapsed": 92.5357596874237 + }, + { + "step": 96, + "loss": 0.3763846755027771, + "objective": 0.3763846755027771, + "error": 0.1875, + "gradient_norm": 0.0951203852891922, + "elapsed": 103.12279391288757 + }, + { + "step": 112, + "loss": 0.45539408922195435, + "objective": 0.45539408922195435, + "error": 0.22265625, + "gradient_norm": 0.056369006633758545, + "elapsed": 112.61882042884827 + }, + { + "step": 128, + "loss": 0.015473627485334873, + "objective": 0.015473627485334873, + "error": 0.005859375, + "gradient_norm": 0.005696057807654142, + "elapsed": 125.16960310935974 + }, + { + "step": 144, + "loss": 0.03449750319123268, + "objective": 0.03449750319123268, + "error": 0.0107421875, + "gradient_norm": 0.008358650840818882, + "elapsed": 135.8080232143402 + }, + { + "step": 160, + "loss": 0.5731935501098633, + "objective": 0.5731935501098633, + "error": 0.31640625, + "gradient_norm": 0.056162577122449875, + "elapsed": 145.0349259376526 + }, + { + "step": 176, + "loss": 0.5626271963119507, + "objective": 0.5626271963119507, + "error": 0.314453125, + "gradient_norm": 0.048817526549100876, + "elapsed": 154.84093379974365 + }, + { + "step": 192, + "loss": 0.5507581233978271, + "objective": 0.5507581233978271, + "error": 0.3173828125, + "gradient_norm": 0.06503377854824066, + "elapsed": 164.7195086479187 + }, + { + "step": 208, + "loss": 0.5725968480110168, + "objective": 0.5725968480110168, + "error": 0.3251953125, + "gradient_norm": 0.047704510390758514, + "elapsed": 175.38803815841675 + }, + { + "step": 224, + "loss": 0.5249365568161011, + "objective": 0.5249365568161011, + "error": 0.2802734375, + "gradient_norm": 0.10021239519119263, + "elapsed": 187.0162854194641 + }, + { + "step": 240, + "loss": 0.2526492476463318, + "objective": 0.2526492476463318, + "error": 0.1103515625, + "gradient_norm": 0.06751289963722229, + "elapsed": 196.51696944236755 + }, + { + "step": 256, + "loss": 0.5214780569076538, + "objective": 0.5214780569076538, + "error": 0.275390625, + "gradient_norm": 0.14627203345298767, + "elapsed": 208.2405219078064 + }, + { + "step": 272, + "loss": 0.59315025806427, + "objective": 0.59315025806427, + "error": 0.341796875, + "gradient_norm": 0.03693874180316925, + "elapsed": 224.87874341011047 + }, + { + "step": 288, + "loss": 0.37350377440452576, + "objective": 0.37350377440452576, + "error": 0.169921875, + "gradient_norm": 0.05035478249192238, + "elapsed": 235.2427306175232 + }, + { + "step": 304, + "loss": 0.6201726198196411, + "objective": 0.6201726198196411, + "error": 0.3798828125, + "gradient_norm": 0.04230104014277458, + "elapsed": 244.4733214378357 + }, + { + "step": 320, + "loss": 0.5781067609786987, + "objective": 0.5781067609786987, + "error": 0.3291015625, + "gradient_norm": 0.06764703243970871, + "elapsed": 256.96991300582886 + }, + { + "step": 336, + "loss": 0.13824111223220825, + "objective": 0.13824111223220825, + "error": 0.0556640625, + "gradient_norm": 0.02330971322953701, + "elapsed": 268.097412109375 + }, + { + "step": 352, + "loss": 0.6141752004623413, + "objective": 0.6141752004623413, + "error": 0.37890625, + "gradient_norm": 0.08660273998975754, + "elapsed": 282.79302310943604 + }, + { + "step": 368, + "loss": 0.3470626473426819, + "objective": 0.3470626473426819, + "error": 0.1611328125, + "gradient_norm": 0.05711895599961281, + "elapsed": 293.79467129707336 + }, + { + "step": 384, + "loss": 0.6023644208908081, + "objective": 0.6023644208908081, + "error": 0.3466796875, + "gradient_norm": 0.08649417012929916, + "elapsed": 305.9786322116852 + }, + { + "step": 400, + "loss": 0.03022841364145279, + "objective": 0.03022841364145279, + "error": 0.0087890625, + "gradient_norm": 0.009741511195898056, + "elapsed": 315.06104922294617 + }, + { + "step": 416, + "loss": 0.23827238380908966, + "objective": 0.23827238380908966, + "error": 0.1015625, + "gradient_norm": 0.03526044636964798, + "elapsed": 325.6410942077637 + }, + { + "step": 432, + "loss": 0.43375664949417114, + "objective": 0.43375664949417114, + "error": 0.201171875, + "gradient_norm": 0.03940205276012421, + "elapsed": 336.9890570640564 + }, + { + "step": 448, + "loss": 0.5915575623512268, + "objective": 0.5915575623512268, + "error": 0.3359375, + "gradient_norm": 0.04364592209458351, + "elapsed": 346.9254243373871 + }, + { + "step": 464, + "loss": 0.5641118288040161, + "objective": 0.5641118288040161, + "error": 0.3076171875, + "gradient_norm": 0.052896615117788315, + "elapsed": 356.9816539287567 + }, + { + "step": 480, + "loss": 0.5682889223098755, + "objective": 0.5682889223098755, + "error": 0.322265625, + "gradient_norm": 0.07130409777164459, + "elapsed": 369.16103172302246 + }, + { + "step": 496, + "loss": 0.37034764885902405, + "objective": 0.37034764885902405, + "error": 0.181640625, + "gradient_norm": 0.11464523524045944, + "elapsed": 381.041054725647 + }, + { + "step": 512, + "loss": 0.5398496389389038, + "objective": 0.5398496389389038, + "error": 0.3076171875, + "gradient_norm": 0.05673467367887497, + "elapsed": 394.5030150413513 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "db182d721768f832e1c83f6258b31bef0d8bf2ded239a8ab5a45cbb76378fd30", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317635, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.30839407444000244, + "objective": 0.30839407444000244, + "error": 0.130859375, + "gradient_norm": 0.053425733000040054, + "elapsed": 28.537403345108032 + }, + { + "step": 16, + "loss": 0.021987520158290863, + "objective": 0.021987520158290863, + "error": 0.0078125, + "gradient_norm": 0.01397851575165987, + "elapsed": 48.18276286125183 + }, + { + "step": 32, + "loss": 0.5041587352752686, + "objective": 0.5041587352752686, + "error": 0.2724609375, + "gradient_norm": 0.0528741292655468, + "elapsed": 58.27348470687866 + }, + { + "step": 48, + "loss": 0.4326452612876892, + "objective": 0.4326452612876892, + "error": 0.21484375, + "gradient_norm": 0.0559566393494606, + "elapsed": 68.90473222732544 + }, + { + "step": 64, + "loss": 0.4804917275905609, + "objective": 0.4804917275905609, + "error": 0.248046875, + "gradient_norm": 0.0669105276465416, + "elapsed": 77.87249231338501 + }, + { + "step": 80, + "loss": 0.2889654338359833, + "objective": 0.2889654338359833, + "error": 0.1328125, + "gradient_norm": 0.08293467015028, + "elapsed": 86.87973022460938 + }, + { + "step": 96, + "loss": 0.5135385990142822, + "objective": 0.5135385990142822, + "error": 0.271484375, + "gradient_norm": 0.06412295252084732, + "elapsed": 95.98773431777954 + }, + { + "step": 112, + "loss": 0.31248384714126587, + "objective": 0.31248384714126587, + "error": 0.1357421875, + "gradient_norm": 0.03881710395216942, + "elapsed": 106.47444081306458 + }, + { + "step": 128, + "loss": 0.23868557810783386, + "objective": 0.23868557810783386, + "error": 0.091796875, + "gradient_norm": 0.03896595537662506, + "elapsed": 117.72143626213074 + }, + { + "step": 144, + "loss": 0.5315916538238525, + "objective": 0.5315916538238525, + "error": 0.2890625, + "gradient_norm": 0.09184520691633224, + "elapsed": 126.97882843017578 + }, + { + "step": 160, + "loss": 0.604732096195221, + "objective": 0.604732096195221, + "error": 0.3603515625, + "gradient_norm": 0.044600710272789, + "elapsed": 137.403742313385 + }, + { + "step": 176, + "loss": 0.032417282462120056, + "objective": 0.032417282462120056, + "error": 0.0107421875, + "gradient_norm": 0.010968778282403946, + "elapsed": 147.58081603050232 + }, + { + "step": 192, + "loss": 0.24050910770893097, + "objective": 0.24050910770893097, + "error": 0.087890625, + "gradient_norm": 0.052534136921167374, + "elapsed": 156.545964717865 + }, + { + "step": 208, + "loss": 0.3183761537075043, + "objective": 0.3183761537075043, + "error": 0.1435546875, + "gradient_norm": 0.05253623053431511, + "elapsed": 166.62695455551147 + }, + { + "step": 224, + "loss": 0.6407097578048706, + "objective": 0.6407097578048706, + "error": 0.3837890625, + "gradient_norm": 0.08772490173578262, + "elapsed": 174.46970582008362 + }, + { + "step": 240, + "loss": 0.597212553024292, + "objective": 0.597212553024292, + "error": 0.36328125, + "gradient_norm": 0.13039150834083557, + "elapsed": 184.2768793106079 + }, + { + "step": 256, + "loss": 0.3317721486091614, + "objective": 0.3317721486091614, + "error": 0.14453125, + "gradient_norm": 0.03749232366681099, + "elapsed": 194.6345317363739 + }, + { + "step": 272, + "loss": 0.6330116987228394, + "objective": 0.6330116987228394, + "error": 0.3955078125, + "gradient_norm": 0.06468097865581512, + "elapsed": 205.8717017173767 + }, + { + "step": 288, + "loss": 0.3141757845878601, + "objective": 0.3141757845878601, + "error": 0.138671875, + "gradient_norm": 0.046496689319610596, + "elapsed": 215.2117359638214 + }, + { + "step": 304, + "loss": 0.5782994031906128, + "objective": 0.5782994031906128, + "error": 0.345703125, + "gradient_norm": 0.06487675756216049, + "elapsed": 225.47403240203857 + }, + { + "step": 320, + "loss": 0.45729100704193115, + "objective": 0.45729100704193115, + "error": 0.2255859375, + "gradient_norm": 0.04169687256217003, + "elapsed": 233.03686332702637 + }, + { + "step": 336, + "loss": 0.49350813031196594, + "objective": 0.49350813031196594, + "error": 0.24609375, + "gradient_norm": 0.08623651415109634, + "elapsed": 244.53246903419495 + }, + { + "step": 352, + "loss": 0.25660067796707153, + "objective": 0.25660067796707153, + "error": 0.1103515625, + "gradient_norm": 0.03029652312397957, + "elapsed": 254.88137793540955 + }, + { + "step": 368, + "loss": 0.2295728325843811, + "objective": 0.2295728325843811, + "error": 0.0966796875, + "gradient_norm": 0.042884912341833115, + "elapsed": 262.7415475845337 + }, + { + "step": 384, + "loss": 0.6214326620101929, + "objective": 0.6214326620101929, + "error": 0.3759765625, + "gradient_norm": 0.08176509290933609, + "elapsed": 271.72958397865295 + }, + { + "step": 400, + "loss": 0.6463049650192261, + "objective": 0.6463049650192261, + "error": 0.3984375, + "gradient_norm": 0.08226390928030014, + "elapsed": 281.51069259643555 + }, + { + "step": 416, + "loss": 0.024987798184156418, + "objective": 0.024987798184156418, + "error": 0.0078125, + "gradient_norm": 0.0075854891911149025, + "elapsed": 291.0118627548218 + }, + { + "step": 432, + "loss": 0.5520929098129272, + "objective": 0.5520929098129272, + "error": 0.3125, + "gradient_norm": 0.09755270183086395, + "elapsed": 301.23231768608093 + }, + { + "step": 448, + "loss": 0.6077401638031006, + "objective": 0.6077401638031006, + "error": 0.361328125, + "gradient_norm": 0.04908076301217079, + "elapsed": 312.93572759628296 + }, + { + "step": 464, + "loss": 0.016434211283922195, + "objective": 0.016434211283922195, + "error": 0.005859375, + "gradient_norm": 0.007213531993329525, + "elapsed": 323.8330478668213 + }, + { + "step": 480, + "loss": 0.1582300364971161, + "objective": 0.1582300364971161, + "error": 0.064453125, + "gradient_norm": 0.028335656970739365, + "elapsed": 334.6112554073334 + }, + { + "step": 496, + "loss": 0.5916742086410522, + "objective": 0.5916742086410522, + "error": 0.35546875, + "gradient_norm": 0.08213689178228378, + "elapsed": 345.8490369319916 + }, + { + "step": 512, + "loss": 0.11447565257549286, + "objective": 0.11447565257549286, + "error": 0.04296875, + "gradient_norm": 0.028994916006922722, + "elapsed": 358.71793270111084 + }, + { + "step": 528, + "loss": 0.3011414408683777, + "objective": 0.3011414408683777, + "error": 0.1435546875, + "gradient_norm": 0.04305516928434372, + "elapsed": 373.143226146698 + }, + { + "step": 544, + "loss": 0.3099900782108307, + "objective": 0.3099900782108307, + "error": 0.130859375, + "gradient_norm": 0.06152835488319397, + "elapsed": 380.42762184143066 + }, + { + "step": 560, + "loss": 0.42917633056640625, + "objective": 0.42917633056640625, + "error": 0.203125, + "gradient_norm": 0.051812849938869476, + "elapsed": 390.78397703170776 + }, + { + "step": 576, + "loss": 0.4895544648170471, + "objective": 0.4895544648170471, + "error": 0.2451171875, + "gradient_norm": 0.059052009135484695, + "elapsed": 400.29374146461487 + }, + { + "step": 592, + "loss": 0.5950886011123657, + "objective": 0.5950886011123657, + "error": 0.328125, + "gradient_norm": 0.1449151188135147, + "elapsed": 410.06920647621155 + }, + { + "step": 608, + "loss": 0.3282078504562378, + "objective": 0.3282078504562378, + "error": 0.1484375, + "gradient_norm": 0.06495015323162079, + "elapsed": 420.5240683555603 + }, + { + "step": 624, + "loss": 0.6034166812896729, + "objective": 0.6034166812896729, + "error": 0.3388671875, + "gradient_norm": 0.05658626928925514, + "elapsed": 430.7997169494629 + }, + { + "step": 640, + "loss": 0.590431809425354, + "objective": 0.590431809425354, + "error": 0.3447265625, + "gradient_norm": 0.046094730496406555, + "elapsed": 441.8197224140167 + }, + { + "step": 656, + "loss": 0.2260439246892929, + "objective": 0.2260439246892929, + "error": 0.1015625, + "gradient_norm": 0.06323576718568802, + "elapsed": 450.76086831092834 + }, + { + "step": 672, + "loss": 0.26158156991004944, + "objective": 0.26158156991004944, + "error": 0.1162109375, + "gradient_norm": 0.08324819058179855, + "elapsed": 459.1986529827118 + }, + { + "step": 688, + "loss": 0.4871026873588562, + "objective": 0.4871026873588562, + "error": 0.244140625, + "gradient_norm": 0.051720812916755676, + "elapsed": 470.4437210559845 + }, + { + "step": 704, + "loss": 0.5861694812774658, + "objective": 0.5861694812774658, + "error": 0.341796875, + "gradient_norm": 0.05766218528151512, + "elapsed": 483.85575103759766 + }, + { + "step": 720, + "loss": 0.4168863296508789, + "objective": 0.4168863296508789, + "error": 0.21484375, + "gradient_norm": 0.05056491494178772, + "elapsed": 494.63891077041626 + }, + { + "step": 736, + "loss": 0.42054638266563416, + "objective": 0.42054638266563416, + "error": 0.21875, + "gradient_norm": 0.07021808624267578, + "elapsed": 505.4899232387543 + }, + { + "step": 752, + "loss": 0.2022928148508072, + "objective": 0.2022928148508072, + "error": 0.0849609375, + "gradient_norm": 0.0765448734164238, + "elapsed": 516.2925503253937 + }, + { + "step": 768, + "loss": 0.026398655027151108, + "objective": 0.026398655027151108, + "error": 0.0068359375, + "gradient_norm": 0.00973521638661623, + "elapsed": 524.7940125465393 + }, + { + "step": 784, + "loss": 0.5843480825424194, + "objective": 0.5843480825424194, + "error": 0.345703125, + "gradient_norm": 0.04805552959442139, + "elapsed": 535.345025062561 + }, + { + "step": 800, + "loss": 0.3102012872695923, + "objective": 0.3102012872695923, + "error": 0.134765625, + "gradient_norm": 0.09761057049036026, + "elapsed": 544.4683487415314 + }, + { + "step": 816, + "loss": 0.5332639217376709, + "objective": 0.5332639217376709, + "error": 0.30078125, + "gradient_norm": 0.10398133844137192, + "elapsed": 554.8217175006866 + }, + { + "step": 832, + "loss": 0.4870310425758362, + "objective": 0.4870310425758362, + "error": 0.2685546875, + "gradient_norm": 0.05754273384809494, + "elapsed": 564.9130115509033 + }, + { + "step": 848, + "loss": 0.1336989849805832, + "objective": 0.1336989849805832, + "error": 0.0498046875, + "gradient_norm": 0.02862304449081421, + "elapsed": 573.6143791675568 + }, + { + "step": 864, + "loss": 0.5794297456741333, + "objective": 0.5794297456741333, + "error": 0.3427734375, + "gradient_norm": 0.05002075806260109, + "elapsed": 584.2565310001373 + }, + { + "step": 880, + "loss": 0.6150081753730774, + "objective": 0.6150081753730774, + "error": 0.341796875, + "gradient_norm": 0.0605069138109684, + "elapsed": 596.845867395401 + }, + { + "step": 896, + "loss": 0.3804032504558563, + "objective": 0.3804032504558563, + "error": 0.18359375, + "gradient_norm": 0.057405781000852585, + "elapsed": 606.0786938667297 + }, + { + "step": 912, + "loss": 0.5734928846359253, + "objective": 0.5734928846359253, + "error": 0.2958984375, + "gradient_norm": 0.06807747483253479, + "elapsed": 616.9755277633667 + }, + { + "step": 928, + "loss": 0.23615539073944092, + "objective": 0.23615539073944092, + "error": 0.107421875, + "gradient_norm": 0.04033413156867027, + "elapsed": 625.9104406833649 + }, + { + "step": 944, + "loss": 0.5668450593948364, + "objective": 0.5668450593948364, + "error": 0.3134765625, + "gradient_norm": 0.04825817048549652, + "elapsed": 635.4241654872894 + }, + { + "step": 960, + "loss": 0.1369795948266983, + "objective": 0.1369795948266983, + "error": 0.0537109375, + "gradient_norm": 0.029475854709744453, + "elapsed": 646.0763671398163 + }, + { + "step": 976, + "loss": 0.026218727231025696, + "objective": 0.026218727231025696, + "error": 0.009765625, + "gradient_norm": 0.0067830472253263, + "elapsed": 656.7150173187256 + }, + { + "step": 992, + "loss": 0.6016548871994019, + "objective": 0.6016548871994019, + "error": 0.3564453125, + "gradient_norm": 0.04935981705784798, + "elapsed": 668.9989516735077 + }, + { + "step": 1008, + "loss": 0.1370980143547058, + "objective": 0.1370980143547058, + "error": 0.0546875, + "gradient_norm": 0.04418199881911278, + "elapsed": 677.3821382522583 + }, + { + "step": 1024, + "loss": 0.4085504412651062, + "objective": 0.4085504412651062, + "error": 0.19921875, + "gradient_norm": 0.07943295687437057, + "elapsed": 688.8395888805389 + }, + { + "step": 1040, + "loss": 0.34129297733306885, + "objective": 0.34129297733306885, + "error": 0.15625, + "gradient_norm": 0.04551500454545021, + "elapsed": 703.4613966941833 + }, + { + "step": 1056, + "loss": 0.5297085046768188, + "objective": 0.5297085046768188, + "error": 0.2705078125, + "gradient_norm": 0.06177444010972977, + "elapsed": 714.0862259864807 + }, + { + "step": 1072, + "loss": 0.3833361268043518, + "objective": 0.3833361268043518, + "error": 0.185546875, + "gradient_norm": 0.053057629615068436, + "elapsed": 724.1480000019073 + }, + { + "step": 1088, + "loss": 0.6497273445129395, + "objective": 0.6497273445129395, + "error": 0.421875, + "gradient_norm": 0.10790837556123734, + "elapsed": 735.8740057945251 + }, + { + "step": 1104, + "loss": 0.5393906831741333, + "objective": 0.5393906831741333, + "error": 0.2998046875, + "gradient_norm": 0.06015805900096893, + "elapsed": 743.9961709976196 + }, + { + "step": 1120, + "loss": 0.38553956151008606, + "objective": 0.38553956151008606, + "error": 0.1875, + "gradient_norm": 0.05357081815600395, + "elapsed": 753.2208635807037 + }, + { + "step": 1136, + "loss": 0.5478834509849548, + "objective": 0.5478834509849548, + "error": 0.2900390625, + "gradient_norm": 0.05761478468775749, + "elapsed": 761.3359644412994 + }, + { + "step": 1152, + "loss": 0.5732287168502808, + "objective": 0.5732287168502808, + "error": 0.341796875, + "gradient_norm": 0.07881136238574982, + "elapsed": 771.133172750473 + }, + { + "step": 1168, + "loss": 0.5174047946929932, + "objective": 0.5174047946929932, + "error": 0.29296875, + "gradient_norm": 0.07794999331235886, + "elapsed": 783.7084786891937 + }, + { + "step": 1184, + "loss": 0.5022754669189453, + "objective": 0.5022754669189453, + "error": 0.265625, + "gradient_norm": 0.05175226181745529, + "elapsed": 793.499255657196 + }, + { + "step": 1200, + "loss": 0.5698775053024292, + "objective": 0.5698775053024292, + "error": 0.34375, + "gradient_norm": 0.06385946273803711, + "elapsed": 804.970814704895 + }, + { + "step": 1216, + "loss": 0.6203033924102783, + "objective": 0.6203033924102783, + "error": 0.37109375, + "gradient_norm": 0.07393646240234375, + "elapsed": 816.1773698329926 + }, + { + "step": 1232, + "loss": 0.6154648065567017, + "objective": 0.6154648065567017, + "error": 0.3857421875, + "gradient_norm": 0.04278155043721199, + "elapsed": 827.3619928359985 + }, + { + "step": 1248, + "loss": 0.5948328971862793, + "objective": 0.5948328971862793, + "error": 0.3291015625, + "gradient_norm": 0.062024734914302826, + "elapsed": 838.8370804786682 + }, + { + "step": 1264, + "loss": 0.5644958019256592, + "objective": 0.5644958019256592, + "error": 0.3212890625, + "gradient_norm": 0.12030917406082153, + "elapsed": 849.5000331401825 + }, + { + "step": 1280, + "loss": 0.028782427310943604, + "objective": 0.028782427310943604, + "error": 0.0087890625, + "gradient_norm": 0.009096251800656319, + "elapsed": 857.8837285041809 + }, + { + "step": 1296, + "loss": 0.5129679441452026, + "objective": 0.5129679441452026, + "error": 0.2626953125, + "gradient_norm": 0.12833116948604584, + "elapsed": 868.5195860862732 + }, + { + "step": 1312, + "loss": 0.4095553159713745, + "objective": 0.4095553159713745, + "error": 0.193359375, + "gradient_norm": 0.09977155178785324, + "elapsed": 877.4712297916412 + }, + { + "step": 1328, + "loss": 0.2850862741470337, + "objective": 0.2850862741470337, + "error": 0.1240234375, + "gradient_norm": 0.05365074798464775, + "elapsed": 887.5133347511292 + }, + { + "step": 1344, + "loss": 0.41809165477752686, + "objective": 0.41809165477752686, + "error": 0.19140625, + "gradient_norm": 0.10622142255306244, + "elapsed": 895.0828025341034 + }, + { + "step": 1360, + "loss": 0.3627069890499115, + "objective": 0.3627069890499115, + "error": 0.1650390625, + "gradient_norm": 0.049557290971279144, + "elapsed": 906.2595431804657 + }, + { + "step": 1376, + "loss": 0.023341629654169083, + "objective": 0.023341629654169083, + "error": 0.0068359375, + "gradient_norm": 0.008970360271632671, + "elapsed": 916.6110022068024 + }, + { + "step": 1392, + "loss": 0.519214391708374, + "objective": 0.519214391708374, + "error": 0.26953125, + "gradient_norm": 0.052287619560956955, + "elapsed": 926.660523891449 + }, + { + "step": 1408, + "loss": 0.6152850389480591, + "objective": 0.6152850389480591, + "error": 0.3662109375, + "gradient_norm": 0.049617987126111984, + "elapsed": 936.7533056735992 + }, + { + "step": 1424, + "loss": 0.020841240882873535, + "objective": 0.020841240882873535, + "error": 0.0068359375, + "gradient_norm": 0.008459246717393398, + "elapsed": 946.8231542110443 + }, + { + "step": 1440, + "loss": 0.5963407754898071, + "objective": 0.5963407754898071, + "error": 0.3525390625, + "gradient_norm": 0.08714025467634201, + "elapsed": 956.0344398021698 + }, + { + "step": 1456, + "loss": 0.44305220246315, + "objective": 0.44305220246315, + "error": 0.2099609375, + "gradient_norm": 0.061915796250104904, + "elapsed": 967.506050825119 + }, + { + "step": 1472, + "loss": 0.5292993783950806, + "objective": 0.5292993783950806, + "error": 0.2939453125, + "gradient_norm": 0.10089804977178574, + "elapsed": 977.855934381485 + }, + { + "step": 1488, + "loss": 0.6087026596069336, + "objective": 0.6087026596069336, + "error": 0.345703125, + "gradient_norm": 0.05276322737336159, + "elapsed": 986.2705359458923 + }, + { + "step": 1504, + "loss": 0.3670162558555603, + "objective": 0.3670162558555603, + "error": 0.1796875, + "gradient_norm": 0.0575372576713562, + "elapsed": 995.2220902442932 + }, + { + "step": 1520, + "loss": 0.33479321002960205, + "objective": 0.33479321002960205, + "error": 0.1435546875, + "gradient_norm": 0.056317709386348724, + "elapsed": 1005.2168045043945 + }, + { + "step": 1536, + "loss": 0.5869293212890625, + "objective": 0.5869293212890625, + "error": 0.337890625, + "gradient_norm": 0.07419256865978241, + "elapsed": 1016.8691458702087 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "0f5926c94bb1aa83840c6d257757b80c081835affc2cb34bf9246ba18e00266a", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 467790, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "source_reference_package": "/run-state/workspace/research/context_upgrades/neural_d5_full3_swa/package", + "original_training_provenance": { + "training": { + "initialization": "Uniform parameter averages of checkpoints from the same session-initialized training trajectory; no external weights", + "prior_pass": 3, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "hidden_width": 64, + "training": "No new optimizer updates; all learning comes from the recorded source trajectory and its session-trained parent", + "optimizer_updates_in_derived_run": 0, + "source_training_provenance": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "training_source_sha256": { + "learned_d5__train.py": "b73af9da21332dee9a43f653b514695b020fbc3516604b2e721d8cf0ea876d53", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "5e9420df1f6dd56518925e910096fb9bc93bd796a5933b13bf894a1a96256cdf", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 507282, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 19592, + "surface_code_bX_d5_r03_center_5_5": 19646, + "surface_code_bX_d5_r05_center_5_5": 19513, + "surface_code_bX_d5_r07_center_5_5": 19341, + "surface_code_bX_d5_r09_center_5_5": 19211, + "surface_code_bX_d5_r11_center_5_5": 19239, + "surface_code_bX_d5_r13_center_5_5": 19679, + "surface_code_bX_d5_r15_center_5_5": 19455, + "surface_code_bX_d5_r17_center_5_5": 19479, + "surface_code_bX_d5_r19_center_5_5": 19479, + "surface_code_bX_d5_r21_center_5_5": 19551, + "surface_code_bX_d5_r23_center_5_5": 19586, + "surface_code_bX_d5_r25_center_5_5": 19526, + "surface_code_bZ_d5_r01_center_5_5": 19652, + "surface_code_bZ_d5_r03_center_5_5": 19732, + "surface_code_bZ_d5_r05_center_5_5": 19754, + "surface_code_bZ_d5_r07_center_5_5": 19194, + "surface_code_bZ_d5_r09_center_5_5": 19641, + "surface_code_bZ_d5_r11_center_5_5": 19611, + "surface_code_bZ_d5_r13_center_5_5": 19424, + "surface_code_bZ_d5_r15_center_5_5": 19380, + "surface_code_bZ_d5_r17_center_5_5": 19384, + "surface_code_bZ_d5_r19_center_5_5": 19684, + "surface_code_bZ_d5_r21_center_5_5": 19559, + "surface_code_bZ_d5_r23_center_5_5": 19524, + "surface_code_bZ_d5_r25_center_5_5": 19446 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 2048, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261113, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "sampling_state_source": "/run-state/workspace/research/learned_d5/feedback3_pilot/rng-768.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/feedback3_pilot/weights-768.npz", + "starting_checkpoint_sha256": "bc2ba1c529317ce1b5b661efae4707eca49c6995d6f22b04193fe7642662fed8", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261108", + "prior_pass": 3, + "initial_seed": 20261108, + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1024, + "batch": 256, + "learning_rate": 0.001, + "sampling_seed": 20261108, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "starting_checkpoint": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.011146659031510353, + "error": 0.00390625, + "gradient_norm": 0.011240893043577671, + "elapsed": 21.276997089385986 + }, + { + "step": 16, + "loss": 0.645737886428833, + "error": 0.40625, + "gradient_norm": 0.1628236621618271, + "elapsed": 25.872907638549805 + }, + { + "step": 32, + "loss": 0.574029803276062, + "error": 0.35546875, + "gradient_norm": 0.3000081777572632, + "elapsed": 30.761418342590332 + }, + { + "step": 48, + "loss": 0.574467122554779, + "error": 0.296875, + "gradient_norm": 0.24150623381137848, + "elapsed": 35.67650651931763 + }, + { + "step": 64, + "loss": 0.6003620624542236, + "error": 0.35546875, + "gradient_norm": 0.07430054992437363, + "elapsed": 40.60572576522827 + }, + { + "step": 80, + "loss": 0.5429091453552246, + "error": 0.33203125, + "gradient_norm": 0.15341751277446747, + "elapsed": 45.546849727630615 + }, + { + "step": 96, + "loss": 0.368771493434906, + "error": 0.1640625, + "gradient_norm": 0.08923184871673584, + "elapsed": 50.49156332015991 + }, + { + "step": 112, + "loss": 0.516342043876648, + "error": 0.265625, + "gradient_norm": 0.10965219140052795, + "elapsed": 55.45058846473694 + }, + { + "step": 128, + "loss": 0.5925382971763611, + "error": 0.37109375, + "gradient_norm": 0.055406324565410614, + "elapsed": 60.40891766548157 + }, + { + "step": 144, + "loss": 0.19184258580207825, + "error": 0.07421875, + "gradient_norm": 0.07042146474123001, + "elapsed": 65.33323669433594 + }, + { + "step": 160, + "loss": 0.5202382206916809, + "error": 0.25390625, + "gradient_norm": 0.14782382547855377, + "elapsed": 70.26605796813965 + }, + { + "step": 176, + "loss": 0.46083134412765503, + "error": 0.22265625, + "gradient_norm": 0.09074779599905014, + "elapsed": 75.18221640586853 + }, + { + "step": 192, + "loss": 0.3054918646812439, + "error": 0.14453125, + "gradient_norm": 0.0588168129324913, + "elapsed": 80.1186010837555 + }, + { + "step": 208, + "loss": 0.4836011230945587, + "error": 0.27734375, + "gradient_norm": 0.09208947420120239, + "elapsed": 85.05764293670654 + }, + { + "step": 224, + "loss": 0.6640600562095642, + "error": 0.38671875, + "gradient_norm": 0.22026506066322327, + "elapsed": 89.98808217048645 + }, + { + "step": 240, + "loss": 0.02421322464942932, + "error": 0.00390625, + "gradient_norm": 0.008131005801260471, + "elapsed": 94.90194272994995 + }, + { + "step": 256, + "loss": 0.6302106976509094, + "error": 0.4296875, + "gradient_norm": 0.09762304276227951, + "elapsed": 99.82612204551697 + }, + { + "step": 272, + "loss": 0.5092596411705017, + "error": 0.27734375, + "gradient_norm": 0.11407691985368729, + "elapsed": 110.44065999984741 + }, + { + "step": 288, + "loss": 0.452798455953598, + "error": 0.2265625, + "gradient_norm": 0.1105576679110527, + "elapsed": 115.36984539031982 + }, + { + "step": 304, + "loss": 0.3378596305847168, + "error": 0.18359375, + "gradient_norm": 0.0841713547706604, + "elapsed": 120.29337763786316 + }, + { + "step": 320, + "loss": 0.6271854639053345, + "error": 0.38671875, + "gradient_norm": 0.1972702294588089, + "elapsed": 125.2231035232544 + }, + { + "step": 336, + "loss": 0.04562236741185188, + "error": 0.01171875, + "gradient_norm": 0.027922745794057846, + "elapsed": 130.14725255966187 + }, + { + "step": 352, + "loss": 0.5342530608177185, + "error": 0.26953125, + "gradient_norm": 0.09031179547309875, + "elapsed": 135.08111095428467 + }, + { + "step": 368, + "loss": 0.49785488843917847, + "error": 0.2578125, + "gradient_norm": 0.19366280734539032, + "elapsed": 140.00699138641357 + }, + { + "step": 384, + "loss": 0.5673326253890991, + "error": 0.30859375, + "gradient_norm": 0.20644932985305786, + "elapsed": 144.92276740074158 + }, + { + "step": 400, + "loss": 0.5581298470497131, + "error": 0.3203125, + "gradient_norm": 0.17668266594409943, + "elapsed": 149.86573243141174 + }, + { + "step": 416, + "loss": 0.5564071536064148, + "error": 0.30078125, + "gradient_norm": 0.0821610689163208, + "elapsed": 154.7953712940216 + }, + { + "step": 432, + "loss": 0.5540086030960083, + "error": 0.34765625, + "gradient_norm": 0.1438807100057602, + "elapsed": 159.72657418251038 + }, + { + "step": 448, + "loss": 0.540939450263977, + "error": 0.29296875, + "gradient_norm": 0.17986361682415009, + "elapsed": 164.6689453125 + }, + { + "step": 464, + "loss": 0.45807865262031555, + "error": 0.25, + "gradient_norm": 0.14453186094760895, + "elapsed": 169.58739304542542 + }, + { + "step": 480, + "loss": 0.5191650390625, + "error": 0.22265625, + "gradient_norm": 0.07955105602741241, + "elapsed": 174.5444438457489 + }, + { + "step": 496, + "loss": 0.1692925989627838, + "error": 0.0703125, + "gradient_norm": 0.07875128090381622, + "elapsed": 179.48035550117493 + }, + { + "step": 512, + "loss": 0.5580664873123169, + "error": 0.3125, + "gradient_norm": 0.27090802788734436, + "elapsed": 184.42834162712097 + }, + { + "step": 528, + "loss": 0.26402050256729126, + "error": 0.13671875, + "gradient_norm": 0.13135771453380585, + "elapsed": 195.17691040039062 + }, + { + "step": 544, + "loss": 0.4352915287017822, + "error": 0.1953125, + "gradient_norm": 0.15959712862968445, + "elapsed": 200.0421543121338 + }, + { + "step": 560, + "loss": 0.22861814498901367, + "error": 0.1015625, + "gradient_norm": 0.08776932209730148, + "elapsed": 204.95144605636597 + }, + { + "step": 576, + "loss": 0.28309381008148193, + "error": 0.1328125, + "gradient_norm": 0.11050742119550705, + "elapsed": 209.8526291847229 + }, + { + "step": 592, + "loss": 0.6409220695495605, + "error": 0.41015625, + "gradient_norm": 0.19826626777648926, + "elapsed": 214.84447717666626 + }, + { + "step": 608, + "loss": 0.25090643763542175, + "error": 0.109375, + "gradient_norm": 0.05864342302083969, + "elapsed": 219.72637391090393 + }, + { + "step": 624, + "loss": 0.11423969268798828, + "error": 0.05078125, + "gradient_norm": 0.05318564549088478, + "elapsed": 224.6331377029419 + }, + { + "step": 640, + "loss": 0.32663431763648987, + "error": 0.1328125, + "gradient_norm": 0.06877780705690384, + "elapsed": 229.5065622329712 + }, + { + "step": 656, + "loss": 0.24196995794773102, + "error": 0.10546875, + "gradient_norm": 0.07683655619621277, + "elapsed": 234.4042534828186 + }, + { + "step": 672, + "loss": 0.5349344611167908, + "error": 0.296875, + "gradient_norm": 0.15214307606220245, + "elapsed": 239.26656579971313 + }, + { + "step": 688, + "loss": 0.26759713888168335, + "error": 0.1171875, + "gradient_norm": 0.14698348939418793, + "elapsed": 244.21049737930298 + }, + { + "step": 704, + "loss": 0.37338894605636597, + "error": 0.18359375, + "gradient_norm": 0.10210632532835007, + "elapsed": 249.13519072532654 + }, + { + "step": 720, + "loss": 0.36807945370674133, + "error": 0.17578125, + "gradient_norm": 0.09668388962745667, + "elapsed": 254.06281065940857 + }, + { + "step": 736, + "loss": 0.3736685514450073, + "error": 0.15625, + "gradient_norm": 0.10987236350774765, + "elapsed": 259.01695108413696 + }, + { + "step": 752, + "loss": 0.5266942977905273, + "error": 0.29296875, + "gradient_norm": 0.09041415899991989, + "elapsed": 263.9530746936798 + }, + { + "step": 768, + "loss": 0.360038161277771, + "error": 0.1640625, + "gradient_norm": 0.10391079634428024, + "elapsed": 268.9019305706024 + }, + { + "step": 784, + "loss": 0.5700286626815796, + "error": 0.34375, + "gradient_norm": 0.12206032127141953, + "elapsed": 279.4174163341522 + }, + { + "step": 800, + "loss": 0.42533689737319946, + "error": 0.20703125, + "gradient_norm": 0.06605375558137894, + "elapsed": 284.3391351699829 + }, + { + "step": 816, + "loss": 0.12355346977710724, + "error": 0.046875, + "gradient_norm": 0.06571663916110992, + "elapsed": 289.2815272808075 + }, + { + "step": 832, + "loss": 0.6411258578300476, + "error": 0.3984375, + "gradient_norm": 0.160088911652565, + "elapsed": 294.2048614025116 + }, + { + "step": 848, + "loss": 0.5756919980049133, + "error": 0.3515625, + "gradient_norm": 0.0962308868765831, + "elapsed": 299.15635418891907 + }, + { + "step": 864, + "loss": 0.2706402540206909, + "error": 0.1171875, + "gradient_norm": 0.11391306668519974, + "elapsed": 304.09321761131287 + }, + { + "step": 880, + "loss": 0.33621329069137573, + "error": 0.1640625, + "gradient_norm": 0.09049320220947266, + "elapsed": 309.0412187576294 + }, + { + "step": 896, + "loss": 0.44343245029449463, + "error": 0.23828125, + "gradient_norm": 0.12484703958034515, + "elapsed": 313.98498797416687 + }, + { + "step": 912, + "loss": 0.5987736582756042, + "error": 0.359375, + "gradient_norm": 0.07541236281394958, + "elapsed": 318.9334623813629 + }, + { + "step": 928, + "loss": 0.38585522770881653, + "error": 0.1875, + "gradient_norm": 0.09290861338376999, + "elapsed": 323.86884689331055 + }, + { + "step": 944, + "loss": 0.4820440113544464, + "error": 0.234375, + "gradient_norm": 0.22198310494422913, + "elapsed": 328.7963180541992 + }, + { + "step": 960, + "loss": 0.07455944269895554, + "error": 0.015625, + "gradient_norm": 0.055282026529312134, + "elapsed": 333.75238251686096 + }, + { + "step": 976, + "loss": 0.013475366868078709, + "error": 0.0078125, + "gradient_norm": 0.009843004867434502, + "elapsed": 338.6403331756592 + }, + { + "step": 992, + "loss": 0.4429199695587158, + "error": 0.2265625, + "gradient_norm": 0.09489083290100098, + "elapsed": 343.5606532096863 + }, + { + "step": 1008, + "loss": 0.4892328381538391, + "error": 0.234375, + "gradient_norm": 0.1342826634645462, + "elapsed": 348.5243353843689 + }, + { + "step": 1024, + "loss": 0.6096819043159485, + "error": 0.32421875, + "gradient_norm": 0.17938998341560364, + "elapsed": 353.36506962776184 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4341062307357788, + "objective": 0.4341062307357788, + "error": 0.208984375, + "gradient_norm": 0.07617632299661636, + "elapsed": 31.45817995071411 + }, + { + "step": 16, + "loss": 0.5996706485748291, + "objective": 0.5996706485748291, + "error": 0.359375, + "gradient_norm": 0.05249844491481781, + "elapsed": 56.34200572967529 + }, + { + "step": 32, + "loss": 0.4388691186904907, + "objective": 0.4388691186904907, + "error": 0.2041015625, + "gradient_norm": 0.0376109778881073, + "elapsed": 67.83739852905273 + }, + { + "step": 48, + "loss": 0.5373439788818359, + "objective": 0.5373439788818359, + "error": 0.2919921875, + "gradient_norm": 0.06261218339204788, + "elapsed": 76.69065475463867 + }, + { + "step": 64, + "loss": 0.24871854484081268, + "objective": 0.24871854484081268, + "error": 0.1162109375, + "gradient_norm": 0.05284671485424042, + "elapsed": 86.3852767944336 + }, + { + "step": 80, + "loss": 0.26628297567367554, + "objective": 0.26628297567367554, + "error": 0.123046875, + "gradient_norm": 0.04054367542266846, + "elapsed": 95.77356100082397 + }, + { + "step": 96, + "loss": 0.48436349630355835, + "objective": 0.48436349630355835, + "error": 0.259765625, + "gradient_norm": 0.05399860441684723, + "elapsed": 107.06293416023254 + }, + { + "step": 112, + "loss": 0.41063767671585083, + "objective": 0.41063767671585083, + "error": 0.1943359375, + "gradient_norm": 0.043602071702480316, + "elapsed": 116.78119611740112 + }, + { + "step": 128, + "loss": 0.3990316390991211, + "objective": 0.3990316390991211, + "error": 0.1865234375, + "gradient_norm": 0.0424419641494751, + "elapsed": 125.6915397644043 + }, + { + "step": 144, + "loss": 0.5119550228118896, + "objective": 0.5119550228118896, + "error": 0.2646484375, + "gradient_norm": 0.07688591629266739, + "elapsed": 136.20711088180542 + }, + { + "step": 160, + "loss": 0.3388235569000244, + "objective": 0.3388235569000244, + "error": 0.1630859375, + "gradient_norm": 0.07015731930732727, + "elapsed": 145.3505516052246 + }, + { + "step": 176, + "loss": 0.5952156186103821, + "objective": 0.5952156186103821, + "error": 0.3369140625, + "gradient_norm": 0.039373140782117844, + "elapsed": 154.77994871139526 + }, + { + "step": 192, + "loss": 0.15157413482666016, + "objective": 0.15157413482666016, + "error": 0.0634765625, + "gradient_norm": 0.029710670933127403, + "elapsed": 164.46801733970642 + }, + { + "step": 208, + "loss": 0.3120684027671814, + "objective": 0.3120684027671814, + "error": 0.1474609375, + "gradient_norm": 0.035548821091651917, + "elapsed": 173.24825358390808 + }, + { + "step": 224, + "loss": 0.5486405491828918, + "objective": 0.5486405491828918, + "error": 0.2900390625, + "gradient_norm": 0.0503678023815155, + "elapsed": 185.29849314689636 + }, + { + "step": 240, + "loss": 0.6046283841133118, + "objective": 0.6046283841133118, + "error": 0.3349609375, + "gradient_norm": 0.05043461173772812, + "elapsed": 197.54880928993225 + }, + { + "step": 256, + "loss": 0.5926339626312256, + "objective": 0.5926339626312256, + "error": 0.3359375, + "gradient_norm": 0.051241543143987656, + "elapsed": 211.79861068725586 + }, + { + "step": 272, + "loss": 0.4018518924713135, + "objective": 0.4018518924713135, + "error": 0.1943359375, + "gradient_norm": 0.0772147998213768, + "elapsed": 222.41974115371704 + }, + { + "step": 288, + "loss": 0.13863243162631989, + "objective": 0.13863243162631989, + "error": 0.0556640625, + "gradient_norm": 0.03334609419107437, + "elapsed": 234.04247426986694 + }, + { + "step": 304, + "loss": 0.562490701675415, + "objective": 0.562490701675415, + "error": 0.337890625, + "gradient_norm": 0.04585934057831764, + "elapsed": 242.65421533584595 + }, + { + "step": 320, + "loss": 0.5352796316146851, + "objective": 0.5352796316146851, + "error": 0.294921875, + "gradient_norm": 0.0837635025382042, + "elapsed": 252.10656356811523 + }, + { + "step": 336, + "loss": 0.26082637906074524, + "objective": 0.26082637906074524, + "error": 0.1220703125, + "gradient_norm": 0.048336997628211975, + "elapsed": 262.33449625968933 + }, + { + "step": 352, + "loss": 0.5959363579750061, + "objective": 0.5959363579750061, + "error": 0.3388671875, + "gradient_norm": 0.06797357648611069, + "elapsed": 271.9942307472229 + }, + { + "step": 368, + "loss": 0.48994284868240356, + "objective": 0.48994284868240356, + "error": 0.2587890625, + "gradient_norm": 0.06296153366565704, + "elapsed": 283.0493588447571 + }, + { + "step": 384, + "loss": 0.5710494518280029, + "objective": 0.5710494518280029, + "error": 0.3134765625, + "gradient_norm": 0.045333269983530045, + "elapsed": 294.64637446403503 + }, + { + "step": 400, + "loss": 0.5957783460617065, + "objective": 0.5957783460617065, + "error": 0.349609375, + "gradient_norm": 0.03918786719441414, + "elapsed": 307.6200888156891 + }, + { + "step": 416, + "loss": 0.27521568536758423, + "objective": 0.27521568536758423, + "error": 0.1220703125, + "gradient_norm": 0.038001637905836105, + "elapsed": 317.01610231399536 + }, + { + "step": 432, + "loss": 0.02379823848605156, + "objective": 0.02379823848605156, + "error": 0.0078125, + "gradient_norm": 0.007661945186555386, + "elapsed": 326.9360330104828 + }, + { + "step": 448, + "loss": 0.56734299659729, + "objective": 0.56734299659729, + "error": 0.3271484375, + "gradient_norm": 0.057416290044784546, + "elapsed": 339.6289041042328 + }, + { + "step": 464, + "loss": 0.10715995728969574, + "objective": 0.10715995728969574, + "error": 0.0380859375, + "gradient_norm": 0.02532491274178028, + "elapsed": 349.8584108352661 + }, + { + "step": 480, + "loss": 0.6143364310264587, + "objective": 0.6143364310264587, + "error": 0.36328125, + "gradient_norm": 0.08023032546043396, + "elapsed": 360.36362075805664 + }, + { + "step": 496, + "loss": 0.44069671630859375, + "objective": 0.44069671630859375, + "error": 0.2197265625, + "gradient_norm": 0.048025116324424744, + "elapsed": 369.48225808143616 + }, + { + "step": 512, + "loss": 0.019900165498256683, + "objective": 0.019900165498256683, + "error": 0.0107421875, + "gradient_norm": 0.0038635791279375553, + "elapsed": 378.59970593452454 + }, + { + "step": 528, + "loss": 0.033316534012556076, + "objective": 0.033316534012556076, + "error": 0.009765625, + "gradient_norm": 0.009174940176308155, + "elapsed": 393.4021761417389 + }, + { + "step": 544, + "loss": 0.41130945086479187, + "objective": 0.41130945086479187, + "error": 0.20703125, + "gradient_norm": 0.04695262759923935, + "elapsed": 402.8586280345917 + }, + { + "step": 560, + "loss": 0.5885373950004578, + "objective": 0.5885373950004578, + "error": 0.3544921875, + "gradient_norm": 0.08534500002861023, + "elapsed": 416.98661041259766 + }, + { + "step": 576, + "loss": 0.3804720640182495, + "objective": 0.3804720640182495, + "error": 0.19140625, + "gradient_norm": 0.05163278803229332, + "elapsed": 427.7550480365753 + }, + { + "step": 592, + "loss": 0.6101120710372925, + "objective": 0.6101120710372925, + "error": 0.3525390625, + "gradient_norm": 0.05593184754252434, + "elapsed": 441.05026268959045 + }, + { + "step": 608, + "loss": 0.5586092472076416, + "objective": 0.5586092472076416, + "error": 0.302734375, + "gradient_norm": 0.07458740472793579, + "elapsed": 452.95383286476135 + }, + { + "step": 624, + "loss": 0.5992780923843384, + "objective": 0.5992780923843384, + "error": 0.357421875, + "gradient_norm": 0.03618372976779938, + "elapsed": 466.1582691669464 + }, + { + "step": 640, + "loss": 0.3536975383758545, + "objective": 0.3536975383758545, + "error": 0.1650390625, + "gradient_norm": 0.05353165790438652, + "elapsed": 477.166255235672 + }, + { + "step": 656, + "loss": 0.4926893711090088, + "objective": 0.4926893711090088, + "error": 0.2626953125, + "gradient_norm": 0.05201377719640732, + "elapsed": 491.1417751312256 + }, + { + "step": 672, + "loss": 0.5754991173744202, + "objective": 0.5754991173744202, + "error": 0.3271484375, + "gradient_norm": 0.08167096972465515, + "elapsed": 501.630366563797 + }, + { + "step": 688, + "loss": 0.5685014724731445, + "objective": 0.5685014724731445, + "error": 0.333984375, + "gradient_norm": 0.043775107711553574, + "elapsed": 514.2880456447601 + }, + { + "step": 704, + "loss": 0.022465089336037636, + "objective": 0.022465089336037636, + "error": 0.0068359375, + "gradient_norm": 0.010172540321946144, + "elapsed": 522.9173214435577 + }, + { + "step": 720, + "loss": 0.035460107028484344, + "objective": 0.035460107028484344, + "error": 0.0107421875, + "gradient_norm": 0.010515578091144562, + "elapsed": 532.8470129966736 + }, + { + "step": 736, + "loss": 0.44765588641166687, + "objective": 0.44765588641166687, + "error": 0.2138671875, + "gradient_norm": 0.09050357341766357, + "elapsed": 541.9488840103149 + }, + { + "step": 752, + "loss": 0.5933939218521118, + "objective": 0.5933939218521118, + "error": 0.3359375, + "gradient_norm": 0.0665116235613823, + "elapsed": 552.9967355728149 + }, + { + "step": 768, + "loss": 0.6100764870643616, + "objective": 0.6100764870643616, + "error": 0.3515625, + "gradient_norm": 0.0821211114525795, + "elapsed": 563.7709202766418 + }, + { + "step": 784, + "loss": 0.02964692935347557, + "objective": 0.02964692935347557, + "error": 0.009765625, + "gradient_norm": 0.012663272209465504, + "elapsed": 573.1517221927643 + }, + { + "step": 800, + "loss": 0.38091832399368286, + "objective": 0.38091832399368286, + "error": 0.1904296875, + "gradient_norm": 0.060622021555900574, + "elapsed": 582.5687477588654 + }, + { + "step": 816, + "loss": 0.552335262298584, + "objective": 0.552335262298584, + "error": 0.3076171875, + "gradient_norm": 0.14419035613536835, + "elapsed": 594.4292685985565 + }, + { + "step": 832, + "loss": 0.5943340063095093, + "objective": 0.5943340063095093, + "error": 0.34375, + "gradient_norm": 0.0633513554930687, + "elapsed": 605.2052299976349 + }, + { + "step": 848, + "loss": 0.6074100732803345, + "objective": 0.6074100732803345, + "error": 0.3486328125, + "gradient_norm": 0.04225531220436096, + "elapsed": 614.8996202945709 + }, + { + "step": 864, + "loss": 0.6198879480361938, + "objective": 0.6198879480361938, + "error": 0.361328125, + "gradient_norm": 0.04208856821060181, + "elapsed": 625.4266908168793 + }, + { + "step": 880, + "loss": 0.6151762008666992, + "objective": 0.6151762008666992, + "error": 0.369140625, + "gradient_norm": 0.06261089444160461, + "elapsed": 636.0696911811829 + }, + { + "step": 896, + "loss": 0.49680083990097046, + "objective": 0.49680083990097046, + "error": 0.25390625, + "gradient_norm": 0.0827067643404007, + "elapsed": 644.6893246173859 + }, + { + "step": 912, + "loss": 0.4610927402973175, + "objective": 0.4610927402973175, + "error": 0.23828125, + "gradient_norm": 0.06652095168828964, + "elapsed": 655.969132900238 + }, + { + "step": 928, + "loss": 0.5218505859375, + "objective": 0.5218505859375, + "error": 0.2685546875, + "gradient_norm": 0.07188194245100021, + "elapsed": 667.5352523326874 + }, + { + "step": 944, + "loss": 0.33009427785873413, + "objective": 0.33009427785873413, + "error": 0.1533203125, + "gradient_norm": 0.05718810483813286, + "elapsed": 677.8397319316864 + }, + { + "step": 960, + "loss": 0.5703234672546387, + "objective": 0.5703234672546387, + "error": 0.3193359375, + "gradient_norm": 0.11168288439512253, + "elapsed": 687.8742904663086 + }, + { + "step": 976, + "loss": 0.025548014789819717, + "objective": 0.025548014789819717, + "error": 0.0107421875, + "gradient_norm": 0.009453393518924713, + "elapsed": 698.294285774231 + }, + { + "step": 992, + "loss": 0.45398157835006714, + "objective": 0.45398157835006714, + "error": 0.2412109375, + "gradient_norm": 0.04607952758669853, + "elapsed": 707.903199672699 + }, + { + "step": 1008, + "loss": 0.3412189781665802, + "objective": 0.3412189781665802, + "error": 0.1513671875, + "gradient_norm": 0.0432075597345829, + "elapsed": 718.5662748813629 + }, + { + "step": 1024, + "loss": 0.4376429319381714, + "objective": 0.4376429319381714, + "error": 0.2275390625, + "gradient_norm": 0.07974351197481155, + "elapsed": 728.8954858779907 + }, + { + "step": 1040, + "loss": 0.33512815833091736, + "objective": 0.33512815833091736, + "error": 0.150390625, + "gradient_norm": 0.04476875811815262, + "elapsed": 744.0822694301605 + }, + { + "step": 1056, + "loss": 0.5214208364486694, + "objective": 0.5214208364486694, + "error": 0.283203125, + "gradient_norm": 0.08898192644119263, + "elapsed": 755.1484262943268 + }, + { + "step": 1072, + "loss": 0.13849599659442902, + "objective": 0.13849599659442902, + "error": 0.052734375, + "gradient_norm": 0.028359953314065933, + "elapsed": 764.3303108215332 + }, + { + "step": 1088, + "loss": 0.323838472366333, + "objective": 0.323838472366333, + "error": 0.1435546875, + "gradient_norm": 0.04081716760993004, + "elapsed": 773.2739362716675 + }, + { + "step": 1104, + "loss": 0.5627881288528442, + "objective": 0.5627881288528442, + "error": 0.3125, + "gradient_norm": 0.08322097361087799, + "elapsed": 784.7223973274231 + }, + { + "step": 1120, + "loss": 0.44111010432243347, + "objective": 0.44111010432243347, + "error": 0.2216796875, + "gradient_norm": 0.05700977146625519, + "elapsed": 795.085648059845 + }, + { + "step": 1136, + "loss": 0.6395992040634155, + "objective": 0.6395992040634155, + "error": 0.39453125, + "gradient_norm": 0.0744553729891777, + "elapsed": 805.7942585945129 + }, + { + "step": 1152, + "loss": 0.5433304309844971, + "objective": 0.5433304309844971, + "error": 0.287109375, + "gradient_norm": 0.04814797267317772, + "elapsed": 817.3382890224457 + }, + { + "step": 1168, + "loss": 0.5708576440811157, + "objective": 0.5708576440811157, + "error": 0.3203125, + "gradient_norm": 0.051331400871276855, + "elapsed": 829.288791179657 + }, + { + "step": 1184, + "loss": 0.5447035431861877, + "objective": 0.5447035431861877, + "error": 0.2939453125, + "gradient_norm": 0.10116687417030334, + "elapsed": 839.6822843551636 + }, + { + "step": 1200, + "loss": 0.6125671863555908, + "objective": 0.6125671863555908, + "error": 0.3642578125, + "gradient_norm": 0.04368080571293831, + "elapsed": 850.2262740135193 + }, + { + "step": 1216, + "loss": 0.5002380609512329, + "objective": 0.5002380609512329, + "error": 0.259765625, + "gradient_norm": 0.04939017817378044, + "elapsed": 862.3783452510834 + }, + { + "step": 1232, + "loss": 0.5698772668838501, + "objective": 0.5698772668838501, + "error": 0.3173828125, + "gradient_norm": 0.04916854575276375, + "elapsed": 871.4622664451599 + }, + { + "step": 1248, + "loss": 0.6046518683433533, + "objective": 0.6046518683433533, + "error": 0.341796875, + "gradient_norm": 0.04919794574379921, + "elapsed": 883.3905737400055 + }, + { + "step": 1264, + "loss": 0.5913128852844238, + "objective": 0.5913128852844238, + "error": 0.357421875, + "gradient_norm": 0.046917904168367386, + "elapsed": 892.4264807701111 + }, + { + "step": 1280, + "loss": 0.5027461051940918, + "objective": 0.5027461051940918, + "error": 0.2626953125, + "gradient_norm": 0.04705750197172165, + "elapsed": 902.5875842571259 + }, + { + "step": 1296, + "loss": 0.13519814610481262, + "objective": 0.13519814610481262, + "error": 0.052734375, + "gradient_norm": 0.02625490538775921, + "elapsed": 912.4087471961975 + }, + { + "step": 1312, + "loss": 0.5862359404563904, + "objective": 0.5862359404563904, + "error": 0.3271484375, + "gradient_norm": 0.05441493168473244, + "elapsed": 923.992555141449 + }, + { + "step": 1328, + "loss": 0.6031408309936523, + "objective": 0.6031408309936523, + "error": 0.3505859375, + "gradient_norm": 0.05901554971933365, + "elapsed": 933.3936491012573 + }, + { + "step": 1344, + "loss": 0.5823733806610107, + "objective": 0.5823733806610107, + "error": 0.3310546875, + "gradient_norm": 0.0842989832162857, + "elapsed": 941.979998588562 + }, + { + "step": 1360, + "loss": 0.6241492033004761, + "objective": 0.6241492033004761, + "error": 0.3720703125, + "gradient_norm": 0.04446673393249512, + "elapsed": 954.969649553299 + }, + { + "step": 1376, + "loss": 0.5829156637191772, + "objective": 0.5829156637191772, + "error": 0.361328125, + "gradient_norm": 0.06615480780601501, + "elapsed": 966.0245676040649 + }, + { + "step": 1392, + "loss": 0.5968320369720459, + "objective": 0.5968320369720459, + "error": 0.34765625, + "gradient_norm": 0.05093541368842125, + "elapsed": 975.1022663116455 + }, + { + "step": 1408, + "loss": 0.045559000223875046, + "objective": 0.045559000223875046, + "error": 0.01171875, + "gradient_norm": 0.02514980360865593, + "elapsed": 987.2391452789307 + }, + { + "step": 1424, + "loss": 0.22601813077926636, + "objective": 0.22601813077926636, + "error": 0.09765625, + "gradient_norm": 0.04834206402301788, + "elapsed": 996.4583384990692 + }, + { + "step": 1440, + "loss": 0.23011144995689392, + "objective": 0.23011144995689392, + "error": 0.111328125, + "gradient_norm": 0.050687842071056366, + "elapsed": 1007.1440904140472 + }, + { + "step": 1456, + "loss": 0.018240466713905334, + "objective": 0.018240466713905334, + "error": 0.0078125, + "gradient_norm": 0.005604141391813755, + "elapsed": 1016.4502851963043 + }, + { + "step": 1472, + "loss": 0.4498720169067383, + "objective": 0.4498720169067383, + "error": 0.232421875, + "gradient_norm": 0.08179625123739243, + "elapsed": 1028.8303294181824 + }, + { + "step": 1488, + "loss": 0.24151627719402313, + "objective": 0.24151627719402313, + "error": 0.107421875, + "gradient_norm": 0.03838668763637543, + "elapsed": 1037.8867321014404 + }, + { + "step": 1504, + "loss": 0.46122002601623535, + "objective": 0.46122002601623535, + "error": 0.232421875, + "gradient_norm": 0.0726623386144638, + "elapsed": 1047.7258644104004 + }, + { + "step": 1520, + "loss": 0.5085602402687073, + "objective": 0.5085602402687073, + "error": 0.2705078125, + "gradient_norm": 0.06673175096511841, + "elapsed": 1059.352120399475 + }, + { + "step": 1536, + "loss": 0.6105246543884277, + "objective": 0.6105246543884277, + "error": 0.3818359375, + "gradient_norm": 0.04271261766552925, + "elapsed": 1070.1413230895996 + }, + { + "step": 1552, + "loss": 0.4792126417160034, + "objective": 0.4792126417160034, + "error": 0.2578125, + "gradient_norm": 0.05200039595365524, + "elapsed": 1086.444006204605 + }, + { + "step": 1568, + "loss": 0.5814266204833984, + "objective": 0.5814266204833984, + "error": 0.330078125, + "gradient_norm": 0.05867309868335724, + "elapsed": 1097.2902619838715 + }, + { + "step": 1584, + "loss": 0.6321226358413696, + "objective": 0.6321226358413696, + "error": 0.3798828125, + "gradient_norm": 0.05418067052960396, + "elapsed": 1107.9767682552338 + }, + { + "step": 1600, + "loss": 0.5931253433227539, + "objective": 0.5931253433227539, + "error": 0.3603515625, + "gradient_norm": 0.06396215409040451, + "elapsed": 1121.782609462738 + }, + { + "step": 1616, + "loss": 0.6411516666412354, + "objective": 0.6411516666412354, + "error": 0.38671875, + "gradient_norm": 0.05035768821835518, + "elapsed": 1132.7197887897491 + }, + { + "step": 1632, + "loss": 0.4267754852771759, + "objective": 0.4267754852771759, + "error": 0.2080078125, + "gradient_norm": 0.09109894186258316, + "elapsed": 1139.1667578220367 + }, + { + "step": 1648, + "loss": 0.21246182918548584, + "objective": 0.21246182918548584, + "error": 0.095703125, + "gradient_norm": 0.04478950425982475, + "elapsed": 1149.1183021068573 + }, + { + "step": 1664, + "loss": 0.46360665559768677, + "objective": 0.46360665559768677, + "error": 0.251953125, + "gradient_norm": 0.07668188214302063, + "elapsed": 1161.1197745800018 + }, + { + "step": 1680, + "loss": 0.46281397342681885, + "objective": 0.46281397342681885, + "error": 0.236328125, + "gradient_norm": 0.07954126596450806, + "elapsed": 1171.8474535942078 + }, + { + "step": 1696, + "loss": 0.2484058141708374, + "objective": 0.2484058141708374, + "error": 0.12109375, + "gradient_norm": 0.047261305153369904, + "elapsed": 1185.6542596817017 + }, + { + "step": 1712, + "loss": 0.24310235679149628, + "objective": 0.24310235679149628, + "error": 0.1064453125, + "gradient_norm": 0.07262872904539108, + "elapsed": 1197.8986082077026 + }, + { + "step": 1728, + "loss": 0.009729458019137383, + "objective": 0.009729458019137383, + "error": 0.001953125, + "gradient_norm": 0.01146845705807209, + "elapsed": 1208.495581150055 + }, + { + "step": 1744, + "loss": 0.24568752944469452, + "objective": 0.24568752944469452, + "error": 0.10546875, + "gradient_norm": 0.05830742046236992, + "elapsed": 1219.9394850730896 + }, + { + "step": 1760, + "loss": 0.022546378895640373, + "objective": 0.022546378895640373, + "error": 0.0068359375, + "gradient_norm": 0.007667526602745056, + "elapsed": 1229.5703229904175 + }, + { + "step": 1776, + "loss": 0.5848401784896851, + "objective": 0.5848401784896851, + "error": 0.3271484375, + "gradient_norm": 0.061901818960905075, + "elapsed": 1238.750280380249 + }, + { + "step": 1792, + "loss": 0.6031335592269897, + "objective": 0.6031335592269897, + "error": 0.3671875, + "gradient_norm": 0.0676632970571518, + "elapsed": 1247.7468683719635 + }, + { + "step": 1808, + "loss": 0.6210961937904358, + "objective": 0.6210961937904358, + "error": 0.3603515625, + "gradient_norm": 0.0718468651175499, + "elapsed": 1256.1821897029877 + }, + { + "step": 1824, + "loss": 0.570877730846405, + "objective": 0.570877730846405, + "error": 0.3212890625, + "gradient_norm": 0.05575930327177048, + "elapsed": 1266.4091975688934 + }, + { + "step": 1840, + "loss": 0.5711429119110107, + "objective": 0.5711429119110107, + "error": 0.31640625, + "gradient_norm": 0.0691002607345581, + "elapsed": 1277.4722146987915 + }, + { + "step": 1856, + "loss": 0.36046335101127625, + "objective": 0.36046335101127625, + "error": 0.16796875, + "gradient_norm": 0.04694395884871483, + "elapsed": 1287.1420249938965 + }, + { + "step": 1872, + "loss": 0.4688999652862549, + "objective": 0.4688999652862549, + "error": 0.2216796875, + "gradient_norm": 0.07401346415281296, + "elapsed": 1297.3945078849792 + }, + { + "step": 1888, + "loss": 0.46385282278060913, + "objective": 0.46385282278060913, + "error": 0.2373046875, + "gradient_norm": 0.05608939751982689, + "elapsed": 1305.9779334068298 + }, + { + "step": 1904, + "loss": 0.60875403881073, + "objective": 0.60875403881073, + "error": 0.365234375, + "gradient_norm": 0.05085878074169159, + "elapsed": 1317.3097081184387 + }, + { + "step": 1920, + "loss": 0.12223530560731888, + "objective": 0.12223530560731888, + "error": 0.0458984375, + "gradient_norm": 0.024870412424206734, + "elapsed": 1328.6486887931824 + }, + { + "step": 1936, + "loss": 0.3486189544200897, + "objective": 0.3486189544200897, + "error": 0.16796875, + "gradient_norm": 0.04780663549900055, + "elapsed": 1336.6701011657715 + }, + { + "step": 1952, + "loss": 0.5777363777160645, + "objective": 0.5777363777160645, + "error": 0.3427734375, + "gradient_norm": 0.0571451336145401, + "elapsed": 1346.9158833026886 + }, + { + "step": 1968, + "loss": 0.39320266246795654, + "objective": 0.39320266246795654, + "error": 0.1884765625, + "gradient_norm": 0.05673858895897865, + "elapsed": 1354.9182631969452 + }, + { + "step": 1984, + "loss": 0.5900611281394958, + "objective": 0.5900611281394958, + "error": 0.3349609375, + "gradient_norm": 0.06593932211399078, + "elapsed": 1364.2754452228546 + }, + { + "step": 2000, + "loss": 0.6212430000305176, + "objective": 0.6212430000305176, + "error": 0.3857421875, + "gradient_norm": 0.040818918496370316, + "elapsed": 1374.7192046642303 + }, + { + "step": 2016, + "loss": 0.15605247020721436, + "objective": 0.15605247020721436, + "error": 0.0556640625, + "gradient_norm": 0.03108786791563034, + "elapsed": 1386.2740807533264 + }, + { + "step": 2032, + "loss": 0.22049596905708313, + "objective": 0.22049596905708313, + "error": 0.1015625, + "gradient_norm": 0.042733557522296906, + "elapsed": 1396.6422457695007 + }, + { + "step": 2048, + "loss": 0.5642613172531128, + "objective": 0.5642613172531128, + "error": 0.306640625, + "gradient_norm": 0.07527482509613037, + "elapsed": 1407.6688070297241 + } + ] + }, + "derived_checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + }, + "mean4": { + "checkpoint_label": "mean4", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 512, + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "512": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "512": { + "step": 512, + "training_samples": 524288, + "unique_training_rows_seen_in_this_phase": 324661, + "weights_sha256": "d4194b40470453e5df9b75e12326cbbd0e6845946870bb0d53a2cbbdd6ea32dc", + "complete": true + }, + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ff5a023ce2c18be7c29f810a3788a450e3ad3ad2237d6e9448923aa6a28c5074", + "complete": true + } + }, + "selection": "Predefined averages of the last3 or all4 saved noninitial full3_1 checkpoints; evaluate every validation condition before selecting", + "test_data_used": false, + "derivation_source_sha256": "08c498d6952b0380e001371df9a0461a483631a301f93747b821e529e72b349d" + }, + "training_source_snapshot": "training_sources/full3_swa", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23290264423076928, + "mean3": 0.2335186298076923, + "blend-mean3": 0.2325420673076923, + "mean4": 0.23326322115384618, + "blend-mean4": 0.23300781250000002 + }, + "selected": "blend-mean3" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.22017728365384615, + "mean3": 0.22037259615384613, + "blend-mean3": 0.22091346153846153, + "mean4": 0.2205528846153846, + "blend-mean4": 0.22100360576923078 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "mean3": { + "checkpoint_label": "mean3", + "kind": "uniform_parameter_average", + "optimizer_updates_in_derived_run": 0, + "source_run": "full3_1", + "source_optimizer_steps": [ + 1024, + 1536, + 2048 + ], + "source_weights_sha256": { + "1024": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "1536": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "2048": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5" + }, + "source_checkpoint_records": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 446179, + "weights_sha256": "22adf2425bbfb872e814227799b725f78618bccf68410935470e6c37d159a6b7", + "complete": true + }, + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 490266, + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "complete": true + }, + "2048": { + "step": 2048, + "training_samples": 2097152, + "unique_training_rows_seen_in_this_phase": 507282, + "weights_sha256": "b93c1367dfeb0e32b2add76b1abeb3f12d4d9f8145d0f13d8d5b17ca882ba3b5", + "complete": true + } + }, + "weights_sha256": "ce5951e7095a9912dc74719254f2fcf9654f219078392b7acf7a8545e6f9f3f4", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit logical tracking in intermediate passes when intermediate probabilities are unused.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false + }, + "checkpoints": { + "1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 467790, + "weights_sha256": "6ebe606c36cfd41862e589568878e67b2c2accafeb093b1fee3a0955d5948f0d", + "complete": true + } + }, + "selection": "Per-basis minimum full-validation mean over the incumbent and equal old/new neural probability averages, optionally blended with physical probability at fractions 0, .25, or .5. All 13 durations included.", + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.2319861778846154, + "0-physical-0": 0.23278245192307695, + "0-physical-0.25": 0.23291766826923077, + "0-physical-0.5": 0.23315805288461539, + "512-physical-0": 0.2319110576923077, + "512-physical-0.25": 0.23314302884615387, + "512-physical-0.5": 0.2329477163461538, + "1024-physical-0": 0.2325721153846154, + "1024-physical-0.25": 0.23218149038461536, + "1024-physical-0.5": 0.2329627403846154, + "1536-physical-0": 0.23186598557692306, + "1536-physical-0.25": 0.23234675480769235, + "1536-physical-0.5": 0.2330829326923077 + }, + "selected": "1536-physical-0", + "original_checkpoint": "full3_swa/mean3" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "0-physical-0": 0.22029747596153845, + "0-physical-0.25": 0.22067307692307694, + "0-physical-0.5": 0.22079326923076922, + "512-physical-0": 0.22034254807692305, + "512-physical-0.25": 0.22050781249999998, + "512-physical-0.5": 0.2203725961538462, + "1024-physical-0": 0.21998197115384613, + "1024-physical-0.25": 0.22049278846153844, + "1024-physical-0.5": 0.22031250000000002, + "1536-physical-0": 0.2204026442307692, + "1536-physical-0.25": 0.2201923076923077, + "1536-physical-0.5": 0.22061298076923078 + }, + "selected": "incumbent", + "original_checkpoint": "full3_1/1536" + } + ], + "control": { + "status": "passed", + "device": "cpu", + "source_sha256": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "reference_package": "/run-state/workspace/research/context_upgrades/short_categorical2/package", + "members": [ + { + "weights": "weights/neural-d5-neural_d5_full3_swa-mean3.npz", + "coefficient": 1.0 + }, + { + "weights": "weights/neural-d5-neural_d5_full3_1-1536.npz", + "coefficient": 3.0 + } + ], + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 1, + "single_path_exact": true, + "shared_mixture_exact": true, + "cpu_recomputed_vs_gpu_cached_prior_max_difference": null + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "single_path_exact": true, + "shared_mixture_exact": true, + "cpu_recomputed_vs_gpu_cached_prior_max_difference": 1.7881393432617188e-07 + } + ], + "seconds": 4.879673480987549, + "scope": "Runtime probability aggregation and prior reuse; no model fitting or validation selection." + }, + "test_data_used": false + }, + "neural_d5": { + "training": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 467790, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved2_warm/weights-512.npz", + "starting_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317635, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261274", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.2600052058696747, + "objective": 0.2600052058696747, + "error": 0.1123046875, + "gradient_norm": 0.06799795478582382, + "elapsed": 27.333195447921753 + }, + { + "step": 16, + "loss": 0.0312246885150671, + "objective": 0.0312246885150671, + "error": 0.01171875, + "gradient_norm": 0.004962741397321224, + "elapsed": 48.383540868759155 + }, + { + "step": 32, + "loss": 0.22698244452476501, + "objective": 0.22698244452476501, + "error": 0.08984375, + "gradient_norm": 0.06353150308132172, + "elapsed": 57.04609966278076 + }, + { + "step": 48, + "loss": 0.5861443281173706, + "objective": 0.5861443281173706, + "error": 0.3486328125, + "gradient_norm": 0.04095375910401344, + "elapsed": 69.08654689788818 + }, + { + "step": 64, + "loss": 0.6103856563568115, + "objective": 0.6103856563568115, + "error": 0.3662109375, + "gradient_norm": 0.04155975207686424, + "elapsed": 81.63970494270325 + }, + { + "step": 80, + "loss": 0.5673234462738037, + "objective": 0.5673234462738037, + "error": 0.3125, + "gradient_norm": 0.1773851364850998, + "elapsed": 92.5357596874237 + }, + { + "step": 96, + "loss": 0.3763846755027771, + "objective": 0.3763846755027771, + "error": 0.1875, + "gradient_norm": 0.0951203852891922, + "elapsed": 103.12279391288757 + }, + { + "step": 112, + "loss": 0.45539408922195435, + "objective": 0.45539408922195435, + "error": 0.22265625, + "gradient_norm": 0.056369006633758545, + "elapsed": 112.61882042884827 + }, + { + "step": 128, + "loss": 0.015473627485334873, + "objective": 0.015473627485334873, + "error": 0.005859375, + "gradient_norm": 0.005696057807654142, + "elapsed": 125.16960310935974 + }, + { + "step": 144, + "loss": 0.03449750319123268, + "objective": 0.03449750319123268, + "error": 0.0107421875, + "gradient_norm": 0.008358650840818882, + "elapsed": 135.8080232143402 + }, + { + "step": 160, + "loss": 0.5731935501098633, + "objective": 0.5731935501098633, + "error": 0.31640625, + "gradient_norm": 0.056162577122449875, + "elapsed": 145.0349259376526 + }, + { + "step": 176, + "loss": 0.5626271963119507, + "objective": 0.5626271963119507, + "error": 0.314453125, + "gradient_norm": 0.048817526549100876, + "elapsed": 154.84093379974365 + }, + { + "step": 192, + "loss": 0.5507581233978271, + "objective": 0.5507581233978271, + "error": 0.3173828125, + "gradient_norm": 0.06503377854824066, + "elapsed": 164.7195086479187 + }, + { + "step": 208, + "loss": 0.5725968480110168, + "objective": 0.5725968480110168, + "error": 0.3251953125, + "gradient_norm": 0.047704510390758514, + "elapsed": 175.38803815841675 + }, + { + "step": 224, + "loss": 0.5249365568161011, + "objective": 0.5249365568161011, + "error": 0.2802734375, + "gradient_norm": 0.10021239519119263, + "elapsed": 187.0162854194641 + }, + { + "step": 240, + "loss": 0.2526492476463318, + "objective": 0.2526492476463318, + "error": 0.1103515625, + "gradient_norm": 0.06751289963722229, + "elapsed": 196.51696944236755 + }, + { + "step": 256, + "loss": 0.5214780569076538, + "objective": 0.5214780569076538, + "error": 0.275390625, + "gradient_norm": 0.14627203345298767, + "elapsed": 208.2405219078064 + }, + { + "step": 272, + "loss": 0.59315025806427, + "objective": 0.59315025806427, + "error": 0.341796875, + "gradient_norm": 0.03693874180316925, + "elapsed": 224.87874341011047 + }, + { + "step": 288, + "loss": 0.37350377440452576, + "objective": 0.37350377440452576, + "error": 0.169921875, + "gradient_norm": 0.05035478249192238, + "elapsed": 235.2427306175232 + }, + { + "step": 304, + "loss": 0.6201726198196411, + "objective": 0.6201726198196411, + "error": 0.3798828125, + "gradient_norm": 0.04230104014277458, + "elapsed": 244.4733214378357 + }, + { + "step": 320, + "loss": 0.5781067609786987, + "objective": 0.5781067609786987, + "error": 0.3291015625, + "gradient_norm": 0.06764703243970871, + "elapsed": 256.96991300582886 + }, + { + "step": 336, + "loss": 0.13824111223220825, + "objective": 0.13824111223220825, + "error": 0.0556640625, + "gradient_norm": 0.02330971322953701, + "elapsed": 268.097412109375 + }, + { + "step": 352, + "loss": 0.6141752004623413, + "objective": 0.6141752004623413, + "error": 0.37890625, + "gradient_norm": 0.08660273998975754, + "elapsed": 282.79302310943604 + }, + { + "step": 368, + "loss": 0.3470626473426819, + "objective": 0.3470626473426819, + "error": 0.1611328125, + "gradient_norm": 0.05711895599961281, + "elapsed": 293.79467129707336 + }, + { + "step": 384, + "loss": 0.6023644208908081, + "objective": 0.6023644208908081, + "error": 0.3466796875, + "gradient_norm": 0.08649417012929916, + "elapsed": 305.9786322116852 + }, + { + "step": 400, + "loss": 0.03022841364145279, + "objective": 0.03022841364145279, + "error": 0.0087890625, + "gradient_norm": 0.009741511195898056, + "elapsed": 315.06104922294617 + }, + { + "step": 416, + "loss": 0.23827238380908966, + "objective": 0.23827238380908966, + "error": 0.1015625, + "gradient_norm": 0.03526044636964798, + "elapsed": 325.6410942077637 + }, + { + "step": 432, + "loss": 0.43375664949417114, + "objective": 0.43375664949417114, + "error": 0.201171875, + "gradient_norm": 0.03940205276012421, + "elapsed": 336.9890570640564 + }, + { + "step": 448, + "loss": 0.5915575623512268, + "objective": 0.5915575623512268, + "error": 0.3359375, + "gradient_norm": 0.04364592209458351, + "elapsed": 346.9254243373871 + }, + { + "step": 464, + "loss": 0.5641118288040161, + "objective": 0.5641118288040161, + "error": 0.3076171875, + "gradient_norm": 0.052896615117788315, + "elapsed": 356.9816539287567 + }, + { + "step": 480, + "loss": 0.5682889223098755, + "objective": 0.5682889223098755, + "error": 0.322265625, + "gradient_norm": 0.07130409777164459, + "elapsed": 369.16103172302246 + }, + { + "step": 496, + "loss": 0.37034764885902405, + "objective": 0.37034764885902405, + "error": 0.181640625, + "gradient_norm": 0.11464523524045944, + "elapsed": 381.041054725647 + }, + { + "step": 512, + "loss": 0.5398496389389038, + "objective": 0.5398496389389038, + "error": 0.3076171875, + "gradient_norm": 0.05673467367887497, + "elapsed": 394.5030150413513 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "db182d721768f832e1c83f6258b31bef0d8bf2ded239a8ab5a45cbb76378fd30", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317635, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.30839407444000244, + "objective": 0.30839407444000244, + "error": 0.130859375, + "gradient_norm": 0.053425733000040054, + "elapsed": 28.537403345108032 + }, + { + "step": 16, + "loss": 0.021987520158290863, + "objective": 0.021987520158290863, + "error": 0.0078125, + "gradient_norm": 0.01397851575165987, + "elapsed": 48.18276286125183 + }, + { + "step": 32, + "loss": 0.5041587352752686, + "objective": 0.5041587352752686, + "error": 0.2724609375, + "gradient_norm": 0.0528741292655468, + "elapsed": 58.27348470687866 + }, + { + "step": 48, + "loss": 0.4326452612876892, + "objective": 0.4326452612876892, + "error": 0.21484375, + "gradient_norm": 0.0559566393494606, + "elapsed": 68.90473222732544 + }, + { + "step": 64, + "loss": 0.4804917275905609, + "objective": 0.4804917275905609, + "error": 0.248046875, + "gradient_norm": 0.0669105276465416, + "elapsed": 77.87249231338501 + }, + { + "step": 80, + "loss": 0.2889654338359833, + "objective": 0.2889654338359833, + "error": 0.1328125, + "gradient_norm": 0.08293467015028, + "elapsed": 86.87973022460938 + }, + { + "step": 96, + "loss": 0.5135385990142822, + "objective": 0.5135385990142822, + "error": 0.271484375, + "gradient_norm": 0.06412295252084732, + "elapsed": 95.98773431777954 + }, + { + "step": 112, + "loss": 0.31248384714126587, + "objective": 0.31248384714126587, + "error": 0.1357421875, + "gradient_norm": 0.03881710395216942, + "elapsed": 106.47444081306458 + }, + { + "step": 128, + "loss": 0.23868557810783386, + "objective": 0.23868557810783386, + "error": 0.091796875, + "gradient_norm": 0.03896595537662506, + "elapsed": 117.72143626213074 + }, + { + "step": 144, + "loss": 0.5315916538238525, + "objective": 0.5315916538238525, + "error": 0.2890625, + "gradient_norm": 0.09184520691633224, + "elapsed": 126.97882843017578 + }, + { + "step": 160, + "loss": 0.604732096195221, + "objective": 0.604732096195221, + "error": 0.3603515625, + "gradient_norm": 0.044600710272789, + "elapsed": 137.403742313385 + }, + { + "step": 176, + "loss": 0.032417282462120056, + "objective": 0.032417282462120056, + "error": 0.0107421875, + "gradient_norm": 0.010968778282403946, + "elapsed": 147.58081603050232 + }, + { + "step": 192, + "loss": 0.24050910770893097, + "objective": 0.24050910770893097, + "error": 0.087890625, + "gradient_norm": 0.052534136921167374, + "elapsed": 156.545964717865 + }, + { + "step": 208, + "loss": 0.3183761537075043, + "objective": 0.3183761537075043, + "error": 0.1435546875, + "gradient_norm": 0.05253623053431511, + "elapsed": 166.62695455551147 + }, + { + "step": 224, + "loss": 0.6407097578048706, + "objective": 0.6407097578048706, + "error": 0.3837890625, + "gradient_norm": 0.08772490173578262, + "elapsed": 174.46970582008362 + }, + { + "step": 240, + "loss": 0.597212553024292, + "objective": 0.597212553024292, + "error": 0.36328125, + "gradient_norm": 0.13039150834083557, + "elapsed": 184.2768793106079 + }, + { + "step": 256, + "loss": 0.3317721486091614, + "objective": 0.3317721486091614, + "error": 0.14453125, + "gradient_norm": 0.03749232366681099, + "elapsed": 194.6345317363739 + }, + { + "step": 272, + "loss": 0.6330116987228394, + "objective": 0.6330116987228394, + "error": 0.3955078125, + "gradient_norm": 0.06468097865581512, + "elapsed": 205.8717017173767 + }, + { + "step": 288, + "loss": 0.3141757845878601, + "objective": 0.3141757845878601, + "error": 0.138671875, + "gradient_norm": 0.046496689319610596, + "elapsed": 215.2117359638214 + }, + { + "step": 304, + "loss": 0.5782994031906128, + "objective": 0.5782994031906128, + "error": 0.345703125, + "gradient_norm": 0.06487675756216049, + "elapsed": 225.47403240203857 + }, + { + "step": 320, + "loss": 0.45729100704193115, + "objective": 0.45729100704193115, + "error": 0.2255859375, + "gradient_norm": 0.04169687256217003, + "elapsed": 233.03686332702637 + }, + { + "step": 336, + "loss": 0.49350813031196594, + "objective": 0.49350813031196594, + "error": 0.24609375, + "gradient_norm": 0.08623651415109634, + "elapsed": 244.53246903419495 + }, + { + "step": 352, + "loss": 0.25660067796707153, + "objective": 0.25660067796707153, + "error": 0.1103515625, + "gradient_norm": 0.03029652312397957, + "elapsed": 254.88137793540955 + }, + { + "step": 368, + "loss": 0.2295728325843811, + "objective": 0.2295728325843811, + "error": 0.0966796875, + "gradient_norm": 0.042884912341833115, + "elapsed": 262.7415475845337 + }, + { + "step": 384, + "loss": 0.6214326620101929, + "objective": 0.6214326620101929, + "error": 0.3759765625, + "gradient_norm": 0.08176509290933609, + "elapsed": 271.72958397865295 + }, + { + "step": 400, + "loss": 0.6463049650192261, + "objective": 0.6463049650192261, + "error": 0.3984375, + "gradient_norm": 0.08226390928030014, + "elapsed": 281.51069259643555 + }, + { + "step": 416, + "loss": 0.024987798184156418, + "objective": 0.024987798184156418, + "error": 0.0078125, + "gradient_norm": 0.0075854891911149025, + "elapsed": 291.0118627548218 + }, + { + "step": 432, + "loss": 0.5520929098129272, + "objective": 0.5520929098129272, + "error": 0.3125, + "gradient_norm": 0.09755270183086395, + "elapsed": 301.23231768608093 + }, + { + "step": 448, + "loss": 0.6077401638031006, + "objective": 0.6077401638031006, + "error": 0.361328125, + "gradient_norm": 0.04908076301217079, + "elapsed": 312.93572759628296 + }, + { + "step": 464, + "loss": 0.016434211283922195, + "objective": 0.016434211283922195, + "error": 0.005859375, + "gradient_norm": 0.007213531993329525, + "elapsed": 323.8330478668213 + }, + { + "step": 480, + "loss": 0.1582300364971161, + "objective": 0.1582300364971161, + "error": 0.064453125, + "gradient_norm": 0.028335656970739365, + "elapsed": 334.6112554073334 + }, + { + "step": 496, + "loss": 0.5916742086410522, + "objective": 0.5916742086410522, + "error": 0.35546875, + "gradient_norm": 0.08213689178228378, + "elapsed": 345.8490369319916 + }, + { + "step": 512, + "loss": 0.11447565257549286, + "objective": 0.11447565257549286, + "error": 0.04296875, + "gradient_norm": 0.028994916006922722, + "elapsed": 358.71793270111084 + }, + { + "step": 528, + "loss": 0.3011414408683777, + "objective": 0.3011414408683777, + "error": 0.1435546875, + "gradient_norm": 0.04305516928434372, + "elapsed": 373.143226146698 + }, + { + "step": 544, + "loss": 0.3099900782108307, + "objective": 0.3099900782108307, + "error": 0.130859375, + "gradient_norm": 0.06152835488319397, + "elapsed": 380.42762184143066 + }, + { + "step": 560, + "loss": 0.42917633056640625, + "objective": 0.42917633056640625, + "error": 0.203125, + "gradient_norm": 0.051812849938869476, + "elapsed": 390.78397703170776 + }, + { + "step": 576, + "loss": 0.4895544648170471, + "objective": 0.4895544648170471, + "error": 0.2451171875, + "gradient_norm": 0.059052009135484695, + "elapsed": 400.29374146461487 + }, + { + "step": 592, + "loss": 0.5950886011123657, + "objective": 0.5950886011123657, + "error": 0.328125, + "gradient_norm": 0.1449151188135147, + "elapsed": 410.06920647621155 + }, + { + "step": 608, + "loss": 0.3282078504562378, + "objective": 0.3282078504562378, + "error": 0.1484375, + "gradient_norm": 0.06495015323162079, + "elapsed": 420.5240683555603 + }, + { + "step": 624, + "loss": 0.6034166812896729, + "objective": 0.6034166812896729, + "error": 0.3388671875, + "gradient_norm": 0.05658626928925514, + "elapsed": 430.7997169494629 + }, + { + "step": 640, + "loss": 0.590431809425354, + "objective": 0.590431809425354, + "error": 0.3447265625, + "gradient_norm": 0.046094730496406555, + "elapsed": 441.8197224140167 + }, + { + "step": 656, + "loss": 0.2260439246892929, + "objective": 0.2260439246892929, + "error": 0.1015625, + "gradient_norm": 0.06323576718568802, + "elapsed": 450.76086831092834 + }, + { + "step": 672, + "loss": 0.26158156991004944, + "objective": 0.26158156991004944, + "error": 0.1162109375, + "gradient_norm": 0.08324819058179855, + "elapsed": 459.1986529827118 + }, + { + "step": 688, + "loss": 0.4871026873588562, + "objective": 0.4871026873588562, + "error": 0.244140625, + "gradient_norm": 0.051720812916755676, + "elapsed": 470.4437210559845 + }, + { + "step": 704, + "loss": 0.5861694812774658, + "objective": 0.5861694812774658, + "error": 0.341796875, + "gradient_norm": 0.05766218528151512, + "elapsed": 483.85575103759766 + }, + { + "step": 720, + "loss": 0.4168863296508789, + "objective": 0.4168863296508789, + "error": 0.21484375, + "gradient_norm": 0.05056491494178772, + "elapsed": 494.63891077041626 + }, + { + "step": 736, + "loss": 0.42054638266563416, + "objective": 0.42054638266563416, + "error": 0.21875, + "gradient_norm": 0.07021808624267578, + "elapsed": 505.4899232387543 + }, + { + "step": 752, + "loss": 0.2022928148508072, + "objective": 0.2022928148508072, + "error": 0.0849609375, + "gradient_norm": 0.0765448734164238, + "elapsed": 516.2925503253937 + }, + { + "step": 768, + "loss": 0.026398655027151108, + "objective": 0.026398655027151108, + "error": 0.0068359375, + "gradient_norm": 0.00973521638661623, + "elapsed": 524.7940125465393 + }, + { + "step": 784, + "loss": 0.5843480825424194, + "objective": 0.5843480825424194, + "error": 0.345703125, + "gradient_norm": 0.04805552959442139, + "elapsed": 535.345025062561 + }, + { + "step": 800, + "loss": 0.3102012872695923, + "objective": 0.3102012872695923, + "error": 0.134765625, + "gradient_norm": 0.09761057049036026, + "elapsed": 544.4683487415314 + }, + { + "step": 816, + "loss": 0.5332639217376709, + "objective": 0.5332639217376709, + "error": 0.30078125, + "gradient_norm": 0.10398133844137192, + "elapsed": 554.8217175006866 + }, + { + "step": 832, + "loss": 0.4870310425758362, + "objective": 0.4870310425758362, + "error": 0.2685546875, + "gradient_norm": 0.05754273384809494, + "elapsed": 564.9130115509033 + }, + { + "step": 848, + "loss": 0.1336989849805832, + "objective": 0.1336989849805832, + "error": 0.0498046875, + "gradient_norm": 0.02862304449081421, + "elapsed": 573.6143791675568 + }, + { + "step": 864, + "loss": 0.5794297456741333, + "objective": 0.5794297456741333, + "error": 0.3427734375, + "gradient_norm": 0.05002075806260109, + "elapsed": 584.2565310001373 + }, + { + "step": 880, + "loss": 0.6150081753730774, + "objective": 0.6150081753730774, + "error": 0.341796875, + "gradient_norm": 0.0605069138109684, + "elapsed": 596.845867395401 + }, + { + "step": 896, + "loss": 0.3804032504558563, + "objective": 0.3804032504558563, + "error": 0.18359375, + "gradient_norm": 0.057405781000852585, + "elapsed": 606.0786938667297 + }, + { + "step": 912, + "loss": 0.5734928846359253, + "objective": 0.5734928846359253, + "error": 0.2958984375, + "gradient_norm": 0.06807747483253479, + "elapsed": 616.9755277633667 + }, + { + "step": 928, + "loss": 0.23615539073944092, + "objective": 0.23615539073944092, + "error": 0.107421875, + "gradient_norm": 0.04033413156867027, + "elapsed": 625.9104406833649 + }, + { + "step": 944, + "loss": 0.5668450593948364, + "objective": 0.5668450593948364, + "error": 0.3134765625, + "gradient_norm": 0.04825817048549652, + "elapsed": 635.4241654872894 + }, + { + "step": 960, + "loss": 0.1369795948266983, + "objective": 0.1369795948266983, + "error": 0.0537109375, + "gradient_norm": 0.029475854709744453, + "elapsed": 646.0763671398163 + }, + { + "step": 976, + "loss": 0.026218727231025696, + "objective": 0.026218727231025696, + "error": 0.009765625, + "gradient_norm": 0.0067830472253263, + "elapsed": 656.7150173187256 + }, + { + "step": 992, + "loss": 0.6016548871994019, + "objective": 0.6016548871994019, + "error": 0.3564453125, + "gradient_norm": 0.04935981705784798, + "elapsed": 668.9989516735077 + }, + { + "step": 1008, + "loss": 0.1370980143547058, + "objective": 0.1370980143547058, + "error": 0.0546875, + "gradient_norm": 0.04418199881911278, + "elapsed": 677.3821382522583 + }, + { + "step": 1024, + "loss": 0.4085504412651062, + "objective": 0.4085504412651062, + "error": 0.19921875, + "gradient_norm": 0.07943295687437057, + "elapsed": 688.8395888805389 + }, + { + "step": 1040, + "loss": 0.34129297733306885, + "objective": 0.34129297733306885, + "error": 0.15625, + "gradient_norm": 0.04551500454545021, + "elapsed": 703.4613966941833 + }, + { + "step": 1056, + "loss": 0.5297085046768188, + "objective": 0.5297085046768188, + "error": 0.2705078125, + "gradient_norm": 0.06177444010972977, + "elapsed": 714.0862259864807 + }, + { + "step": 1072, + "loss": 0.3833361268043518, + "objective": 0.3833361268043518, + "error": 0.185546875, + "gradient_norm": 0.053057629615068436, + "elapsed": 724.1480000019073 + }, + { + "step": 1088, + "loss": 0.6497273445129395, + "objective": 0.6497273445129395, + "error": 0.421875, + "gradient_norm": 0.10790837556123734, + "elapsed": 735.8740057945251 + }, + { + "step": 1104, + "loss": 0.5393906831741333, + "objective": 0.5393906831741333, + "error": 0.2998046875, + "gradient_norm": 0.06015805900096893, + "elapsed": 743.9961709976196 + }, + { + "step": 1120, + "loss": 0.38553956151008606, + "objective": 0.38553956151008606, + "error": 0.1875, + "gradient_norm": 0.05357081815600395, + "elapsed": 753.2208635807037 + }, + { + "step": 1136, + "loss": 0.5478834509849548, + "objective": 0.5478834509849548, + "error": 0.2900390625, + "gradient_norm": 0.05761478468775749, + "elapsed": 761.3359644412994 + }, + { + "step": 1152, + "loss": 0.5732287168502808, + "objective": 0.5732287168502808, + "error": 0.341796875, + "gradient_norm": 0.07881136238574982, + "elapsed": 771.133172750473 + }, + { + "step": 1168, + "loss": 0.5174047946929932, + "objective": 0.5174047946929932, + "error": 0.29296875, + "gradient_norm": 0.07794999331235886, + "elapsed": 783.7084786891937 + }, + { + "step": 1184, + "loss": 0.5022754669189453, + "objective": 0.5022754669189453, + "error": 0.265625, + "gradient_norm": 0.05175226181745529, + "elapsed": 793.499255657196 + }, + { + "step": 1200, + "loss": 0.5698775053024292, + "objective": 0.5698775053024292, + "error": 0.34375, + "gradient_norm": 0.06385946273803711, + "elapsed": 804.970814704895 + }, + { + "step": 1216, + "loss": 0.6203033924102783, + "objective": 0.6203033924102783, + "error": 0.37109375, + "gradient_norm": 0.07393646240234375, + "elapsed": 816.1773698329926 + }, + { + "step": 1232, + "loss": 0.6154648065567017, + "objective": 0.6154648065567017, + "error": 0.3857421875, + "gradient_norm": 0.04278155043721199, + "elapsed": 827.3619928359985 + }, + { + "step": 1248, + "loss": 0.5948328971862793, + "objective": 0.5948328971862793, + "error": 0.3291015625, + "gradient_norm": 0.062024734914302826, + "elapsed": 838.8370804786682 + }, + { + "step": 1264, + "loss": 0.5644958019256592, + "objective": 0.5644958019256592, + "error": 0.3212890625, + "gradient_norm": 0.12030917406082153, + "elapsed": 849.5000331401825 + }, + { + "step": 1280, + "loss": 0.028782427310943604, + "objective": 0.028782427310943604, + "error": 0.0087890625, + "gradient_norm": 0.009096251800656319, + "elapsed": 857.8837285041809 + }, + { + "step": 1296, + "loss": 0.5129679441452026, + "objective": 0.5129679441452026, + "error": 0.2626953125, + "gradient_norm": 0.12833116948604584, + "elapsed": 868.5195860862732 + }, + { + "step": 1312, + "loss": 0.4095553159713745, + "objective": 0.4095553159713745, + "error": 0.193359375, + "gradient_norm": 0.09977155178785324, + "elapsed": 877.4712297916412 + }, + { + "step": 1328, + "loss": 0.2850862741470337, + "objective": 0.2850862741470337, + "error": 0.1240234375, + "gradient_norm": 0.05365074798464775, + "elapsed": 887.5133347511292 + }, + { + "step": 1344, + "loss": 0.41809165477752686, + "objective": 0.41809165477752686, + "error": 0.19140625, + "gradient_norm": 0.10622142255306244, + "elapsed": 895.0828025341034 + }, + { + "step": 1360, + "loss": 0.3627069890499115, + "objective": 0.3627069890499115, + "error": 0.1650390625, + "gradient_norm": 0.049557290971279144, + "elapsed": 906.2595431804657 + }, + { + "step": 1376, + "loss": 0.023341629654169083, + "objective": 0.023341629654169083, + "error": 0.0068359375, + "gradient_norm": 0.008970360271632671, + "elapsed": 916.6110022068024 + }, + { + "step": 1392, + "loss": 0.519214391708374, + "objective": 0.519214391708374, + "error": 0.26953125, + "gradient_norm": 0.052287619560956955, + "elapsed": 926.660523891449 + }, + { + "step": 1408, + "loss": 0.6152850389480591, + "objective": 0.6152850389480591, + "error": 0.3662109375, + "gradient_norm": 0.049617987126111984, + "elapsed": 936.7533056735992 + }, + { + "step": 1424, + "loss": 0.020841240882873535, + "objective": 0.020841240882873535, + "error": 0.0068359375, + "gradient_norm": 0.008459246717393398, + "elapsed": 946.8231542110443 + }, + { + "step": 1440, + "loss": 0.5963407754898071, + "objective": 0.5963407754898071, + "error": 0.3525390625, + "gradient_norm": 0.08714025467634201, + "elapsed": 956.0344398021698 + }, + { + "step": 1456, + "loss": 0.44305220246315, + "objective": 0.44305220246315, + "error": 0.2099609375, + "gradient_norm": 0.061915796250104904, + "elapsed": 967.506050825119 + }, + { + "step": 1472, + "loss": 0.5292993783950806, + "objective": 0.5292993783950806, + "error": 0.2939453125, + "gradient_norm": 0.10089804977178574, + "elapsed": 977.855934381485 + }, + { + "step": 1488, + "loss": 0.6087026596069336, + "objective": 0.6087026596069336, + "error": 0.345703125, + "gradient_norm": 0.05276322737336159, + "elapsed": 986.2705359458923 + }, + { + "step": 1504, + "loss": 0.3670162558555603, + "objective": 0.3670162558555603, + "error": 0.1796875, + "gradient_norm": 0.0575372576713562, + "elapsed": 995.2220902442932 + }, + { + "step": 1520, + "loss": 0.33479321002960205, + "objective": 0.33479321002960205, + "error": 0.1435546875, + "gradient_norm": 0.056317709386348724, + "elapsed": 1005.2168045043945 + }, + { + "step": 1536, + "loss": 0.5869293212890625, + "objective": 0.5869293212890625, + "error": 0.337890625, + "gradient_norm": 0.07419256865978241, + "elapsed": 1016.8691458702087 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "0f5926c94bb1aa83840c6d257757b80c081835affc2cb34bf9246ba18e00266a", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 467790, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "training_source_snapshot": "training_sources/reserved2_full", + "selection": "Minimum full-validation condition-mean failure per basis group over incumbent, listed neural checkpoints and equal probability averages with the recorded physical decoder.", + "physical_prediction_reference": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "prior_pass": 3, + "history": [ + { + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23212139423076927, + "0": 0.23353365384615382, + "blend-0": 0.23306790865384613, + "512": 0.23380408653846152, + "blend-512": 0.23366887019230773, + "1024": 0.23197115384615388, + "blend-1024": 0.23299278846153842, + "1536": 0.23206129807692305, + "blend-1536": 0.2329326923076923 + }, + "selected": "1024" + }, + { + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "0": 0.22103365384615387, + "blend-0": 0.2211388221153846, + "512": 0.22092848557692304, + "blend-512": 0.22094350961538464, + "1024": 0.2204326923076923, + "blend-1024": 0.22046274038461539, + "1536": 0.22086838942307688, + "blend-1536": 0.22059795673076926 + }, + "selected": "incumbent" + } + ], + "checkpoints": { + "1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 428858, + "weights_sha256": "a346f535004381e2e0b628fac8ff7c58282a2447b9704638e46232dff46e511f", + "complete": true + } + }, + "runtime": "Share physical priors when the conditioning pass and regime agree; otherwise recompute the neural prior independently. Last-only physical branches omit unused intermediate logical tracking; raw neural branches also omit the unused final physical readout.", + "last_only_equivalence_controls": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "maximum_probability_difference": 7.450580596923828e-07 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "maximum_probability_difference": 5.960464477539063e-08 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "maximum_probability_difference": 1.7881393432617188e-07 + } + ], + "test_data_used": false, + "numerical_controls": { + "packaged_runtime_control_cpu": { + "device": "cpu", + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 7, + "same_cpu_old_vs_new_maximum_difference": 0.0, + "old_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "new_cpu_vs_original_gpu_evaluation_maximum_difference": 4.971027374267578e-05, + "cpu_vs_reconstructed_old_gpu_runtime_maximum_difference": 4.976987838745117e-05, + "original_gpu_evaluation_vs_reconstructed_gpu_runtime_maximum_difference": 7.748603820800781e-07, + "initial_failed_control": { + "comparison": "CPU runtime against original GPU evaluator", + "observed_maximum_difference": 4.971027374267578e-05, + "original_tolerance": 3e-06 + }, + "sources": { + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee", + "d5_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b" + }, + "scope": "Same-device compatibility check. Reconstructed GPU runtime removes the recorded equal physical blend; that reconstruction has floating-point rounding uncertainty.", + "status": "passed_same_device_compatibility" + }, + "dispatcher_control_cpu": { + "status": "passed", + "device": "cpu", + "sources": { + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee" + }, + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base64", + "weights_sha256": "fb250c19cf7bb00741b6d862b8f646a2c8ab88397bb03c7bafc9085f9347eca5", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "base128", + "weights_sha256": "2a21869e7669492fac8252131434b2e09c97f1def2714988382ab7f127371bd8", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "temporal", + "weights_sha256": "9446a1e6dc46e1bcae540531e4f124930bb151ebfa600746ca77bc8f5b2aaa7c", + "maximum_edge_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "architecture": "history", + "weights_sha256": "c508d8968ffa143be4219a207fb54ece3e1bfe144b8a880e4ed4f3d13f092c1e", + "maximum_edge_probability_difference": 0.0 + } + ], + "scope": "Routing and code-copy check against each direct model implementation, using training detector inputs without labels. Tiny trained temporal/history smoke weights test nonzero feature couplings; they are excluded from model selection and submission.", + "test_data_used": false + }, + "cpu_probability_precision": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "validation_syndromes": 7, + "logical_labels_used": false, + "parameter_updates": 0, + "reference": "Float64 neural forward and exact contraction from the same stored weights and fixed float32 input logits, on CPU", + "cpu_float32_vs_float64_maximum_difference": 7.624897924163321e-08, + "cpu_float32_edges_float64_contraction_vs_float64_maximum_difference": 4.725248914372315e-08, + "gpu_float32_vs_float64_maximum_difference": 4.964999121059854e-05, + "cpu_vs_gpu_float32_maximum_difference": 4.971027374267578e-05, + "maximum_neural_edge_probability_difference": 2.6330936014895556e-08, + "float32_edge_values_above_one_minus_1e6": 0, + "scope": "Precision diagnostic only; the published model is unchanged. Same-device old/new packaged-code compatibility was independently exact." + }, + "priors_only_control_cpu": { + "status": "passed", + "device": "cpu", + "source_sha256": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 2.7116777896881104, + "priors_only_seconds_warm": 0.13569164276123047 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "priors_bitwise_identical": true, + "normal_seconds_including_compilation": 3.557781457901001, + "priors_only_seconds_warm": 1.7711329460144043 + } + ], + "scope": "CPU numerical equivalence on supplied training syndromes; timings are not a controlled speed comparison." + } + } + }, + "reserved_data_mixture": { + "gate_training": { + "initialization": "Normal(0,.001) gate weights from independent NumPy seeds20261280(X),20261281(Z); feature center/scale fit only on gate rows", + "training": "Exactly512 reserved training-label rows per condition,6656 per basis,13312 total; both neural experts excluded these and the separate audit rows", + "training_expert_choices": [ + { + "expert": "reserved1", + "basis": "X", + "step": 1536, + "run": "reserved1_full", + "candidate_failures": { + "0": 0.2337439903846154, + "512": 0.23284254807692306, + "1024": 0.23356370192307693, + "1536": 0.23218149038461539 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved1_full-1536", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved1-X-1536" + }, + { + "expert": "reserved1", + "basis": "Z", + "step": 0, + "run": "reserved1_full", + "candidate_failures": { + "0": 0.2206580528846154, + "512": 0.22100360576923078, + "1024": 0.22104867788461538, + "1536": 0.22264122596153849 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved1_full/weights-0.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved1_full-0", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved1-Z-0" + }, + { + "expert": "reserved2", + "basis": "X", + "step": 1024, + "run": "reserved2_full", + "candidate_failures": { + "0": 0.23353365384615385, + "512": 0.23380408653846152, + "1024": 0.23197115384615388, + "1536": 0.23206129807692305 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved2_full/weights-1024.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved2_full-1024", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved2-X-1024" + }, + { + "expert": "reserved2", + "basis": "Z", + "step": 1024, + "run": "reserved2_full", + "candidate_failures": { + "0": 0.22103365384615387, + "512": 0.22092848557692304, + "1024": 0.2204326923076923, + "1536": 0.22086838942307688 + }, + "checkpoint": "/run-state/workspace/research/learned_d5/reserved2_full/weights-1024.npz", + "validation_predictions": "/run-state/workspace/research/learned_d5/validation-reserved2_full-1024", + "reserved_predictions": "/run-state/workspace/research/learned_d5/reserved-predictions-reserved2-Z-1024" + } + ], + "partition": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + }, + "loss": "Mean conditional logical BCE of the three-way mixture plus .5*lambda*sum(scaled weights squared); bias penalty multiplier .01; expert probabilities clipped to[1e-7,1-1e-7] inside fitting objective only", + "optimization": "Independent full-batch scipy L-BFGS-B fits per basis/lambda from the same declared random initialization; expert parameters frozen", + "runtime": "Pure NumPy gate with49 syndrome/confidence features and100 learned logit weights; third expert is raw physical pass3", + "feature_names": [ + "site_density_0", + "site_density_1", + "site_density_2", + "site_density_3", + "site_density_4", + "site_density_5", + "site_density_6", + "site_density_7", + "site_density_8", + "site_density_9", + "site_density_10", + "site_density_11", + "site_density_12", + "site_density_13", + "site_density_14", + "site_density_15", + "site_density_16", + "site_density_17", + "site_density_18", + "site_density_19", + "site_density_20", + "site_density_21", + "site_density_22", + "site_density_23", + "lag_1_coincidence", + "lag_1_covariance", + "lag_2_coincidence", + "lag_2_covariance", + "lag_4_coincidence", + "lag_4_covariance", + "lag_8_coincidence", + "lag_8_covariance", + "density_mean", + "density_std", + "density_max", + "frame_std", + "frame_max", + "half_change", + "round_fraction", + "round_fraction_squared", + "confidence_0", + "confidence_1", + "confidence_2", + "difference_0_1", + "difference_0_2", + "difference_1_2", + "disagreement_0_1", + "disagreement_0_2", + "disagreement_1_2" + ], + "declared_plan": { + "experts": [ + "reserved1 selected raw checkpoint", + "reserved2 selected raw checkpoint", + "fixed raw physical pass3" + ], + "gate": "Per-basis linear two-logit softmax gate with physical reference logit0;49 syndrome/confidence features; normalized on gate rows only; no IDs or shot positions", + "regularization": [ + 0.0001, + 0.001, + 0.01 + ], + "initial_seeds": { + "X": 20261280, + "Z": 20261281 + }, + "optimizer": "Independent L-BFGS-B from randomNormal(0,.001) weights per basis, shared initial weights acrosslambda values;500iterations max,gtol1e-8,ftol1e-12", + "selection": "Minimum full-validation mean failure per basis among incumbent,equal-neural-two,equal-all-three,three regularization fits. All13durations; retainincumbentties", + "diagnostic": "Freeze selection before calculating any independent audit-label metrics; diagnostic rows never fit/select parameters,checkpoints orhyperparameters", + "source_sha256": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1", + "test_data_used": false + }, + "fits": [ + { + "basis": "X", + "key": "lambda-0.0001", + "initial_seed": 20261280, + "regularization": 0.0001, + "initial_state_sha256": "878291ff26617c774c101f5ba4065c012d69681e75bc62c55bfce9944af827c0", + "optimization_iterations": 120, + "objective": 0.4248998654410383, + "gradient_max_abs": 5.001357802025369e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "5f3e5ce0b61e92dd9c1bb59c6c71b2c7dad4a12052c091e5eba1a69ed75b8d21", + "training_metrics": { + "failure": 0.232421875, + "negative_log_likelihood": 0.42348933238384107 + } + }, + { + "basis": "X", + "key": "lambda-0.001", + "initial_seed": 20261280, + "regularization": 0.001, + "initial_state_sha256": "878291ff26617c774c101f5ba4065c012d69681e75bc62c55bfce9944af827c0", + "optimization_iterations": 37, + "objective": 0.42758078400573485, + "gradient_max_abs": 2.996975726990283e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "2c9122e8724571db4c82f6038cb3ad6a8ec78374e29dc1da168e8622f8992655", + "training_metrics": { + "failure": 0.23302283653846154, + "negative_log_likelihood": 0.42682438653490845 + } + }, + { + "basis": "X", + "key": "lambda-0.01", + "initial_seed": 20261280, + "regularization": 0.01, + "initial_state_sha256": "878291ff26617c774c101f5ba4065c012d69681e75bc62c55bfce9944af827c0", + "optimization_iterations": 17, + "objective": 0.4285813488382606, + "gradient_max_abs": 5.950265786385314e-09, + "message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "weights_sha256": "6e3372b4091e0a444a05e9ae07da7cbe931658d4df2962f6de4a171d20a0fa0c", + "training_metrics": { + "failure": 0.23542668269230768, + "negative_log_likelihood": 0.4283422091344372 + } + }, + { + "basis": "Z", + "key": "lambda-0.0001", + "initial_seed": 20261281, + "regularization": 0.0001, + "initial_state_sha256": "97aa4b4f38041e478074e113efc62f5bd4e247064c794816fc3a91b303ba620c", + "optimization_iterations": 150, + "objective": 0.4103952219601839, + "gradient_max_abs": 2.1201928863013187e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "90110b89e17f546d4466b09fe4ed59fcfb670abad33ce56c81ecc91af091e5c9", + "training_metrics": { + "failure": 0.21198918269230768, + "negative_log_likelihood": 0.4090808023552111 + } + }, + { + "basis": "Z", + "key": "lambda-0.001", + "initial_seed": 20261281, + "regularization": 0.001, + "initial_state_sha256": "97aa4b4f38041e478074e113efc62f5bd4e247064c794816fc3a91b303ba620c", + "optimization_iterations": 32, + "objective": 0.41281385633709833, + "gradient_max_abs": 3.589896600174553e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "ea1ec9ac44d9f54f4db84f7aacebb4b1084b02e40cd0a3e1e1710b9083f95d5a", + "training_metrics": { + "failure": 0.21484375, + "negative_log_likelihood": 0.41208742770455026 + } + }, + { + "basis": "Z", + "key": "lambda-0.01", + "initial_seed": 20261281, + "regularization": 0.01, + "initial_state_sha256": "97aa4b4f38041e478074e113efc62f5bd4e247064c794816fc3a91b303ba620c", + "optimization_iterations": 20, + "objective": 0.4138027840487606, + "gradient_max_abs": 2.384420584767991e-08, + "message": "CONVERGENCE: RELATIVE REDUCTION OF F <= FACTR*EPSMCH", + "weights_sha256": "b3bdafcb3e4e0ee663a6dc1512d6d0fe7a407f3d1cc0548fb06b7a3eb06463fb", + "training_metrics": { + "failure": 0.2166466346153846, + "negative_log_likelihood": 0.41358458556572203 + } + } + ], + "numerical_control": { + "status": "passed", + "finite_difference_max_error": 1.8119141603767375e-11, + "independent_autodiff_max_error": 5.551115123125783e-17, + "feature_and_prediction_permutation_subset_complement_checks": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "features": 49, + "rows": 11 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "features": 49, + "rows": 11 + } + ], + "source_sha256": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1", + "labels_used": "Synthetic control labels only", + "test_data_used": false + }, + "reporting_control": { + "status": "passed", + "reason": "Unsigned labels converted to float before unary negation in diagnostic BCE", + "cases": [ + { + "source": "fit_reserved_gate.py", + "actual": { + "failure": 0.0, + "negative_log_likelihood": 0.16425202686327978 + }, + "expected_nll": 0.16425202686327978 + }, + { + "source": "audit_reserved_gate.py", + "actual": { + "failure": 0.0, + "negative_log_likelihood": 0.16425202686327978 + }, + "expected_nll": 0.16425202686327978 + } + ], + "test_data_used": false + }, + "selection": "Full supplied validation condition-mean failure per basis over incumbent,equal-two,equal-three,and the three declared regularization settings; ties retain incumbent", + "selection_history": [ + { + "basis": "X", + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23186598557692306, + "equal-two": 0.23185096153846155, + "equal-three": 0.23294771634615388, + "lambda-0.0001": 0.23278245192307698, + "lambda-0.001": 0.23230168269230772, + "lambda-0.01": 0.23240685096153849 + }, + "selected": "equal-two", + "selected_new_candidate_for_audit": "equal-two" + }, + { + "basis": "Z", + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "equal-two": 0.2203425480769231, + "equal-three": 0.22109374999999998, + "lambda-0.0001": 0.22137920673076922, + "lambda-0.001": 0.22077824519230765, + "lambda-0.01": 0.2204176682692308 + }, + "selected": "incumbent", + "selected_new_candidate_for_audit": "equal-two" + } + ], + "audit_labels_used": false, + "test_data_used": false, + "sources": { + "fit_reserved_gate.py": "f278d14aff60cb77c8a4de21523d9e71a7b84399122c865d27f7ddd415272086", + "reserved_gate.py": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1" + }, + "training_runtime_versions": { + "numpy": "2.3.3", + "scipy": "1.16.2" + }, + "seconds": 5.548679351806641 + }, + "selected_expert_training": { + "reserved1_full": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 466919, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved1_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved1_warm/weights-512.npz", + "starting_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317613, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261272", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.1412775069475174, + "objective": 0.1412775069475174, + "error": 0.0595703125, + "gradient_norm": 0.030735325068235397, + "elapsed": 28.457472801208496 + }, + { + "step": 16, + "loss": 0.6315727233886719, + "objective": 0.6315727233886719, + "error": 0.384765625, + "gradient_norm": 0.06563512235879898, + "elapsed": 47.886730670928955 + }, + { + "step": 32, + "loss": 0.5130410194396973, + "objective": 0.5130410194396973, + "error": 0.263671875, + "gradient_norm": 0.10626910626888275, + "elapsed": 60.16136598587036 + }, + { + "step": 48, + "loss": 0.6413166522979736, + "objective": 0.6413166522979736, + "error": 0.408203125, + "gradient_norm": 0.03790846839547157, + "elapsed": 70.9611382484436 + }, + { + "step": 64, + "loss": 0.5491592884063721, + "objective": 0.5491592884063721, + "error": 0.2939453125, + "gradient_norm": 0.093081034719944, + "elapsed": 81.46673464775085 + }, + { + "step": 80, + "loss": 0.6315242648124695, + "objective": 0.6315242648124695, + "error": 0.359375, + "gradient_norm": 0.0384257510304451, + "elapsed": 91.71172666549683 + }, + { + "step": 96, + "loss": 0.6311566829681396, + "objective": 0.6311566829681396, + "error": 0.3798828125, + "gradient_norm": 0.03731638938188553, + "elapsed": 100.83252763748169 + }, + { + "step": 112, + "loss": 0.5327925682067871, + "objective": 0.5327925682067871, + "error": 0.29296875, + "gradient_norm": 0.11202990263700485, + "elapsed": 111.35073852539062 + }, + { + "step": 128, + "loss": 0.6284654140472412, + "objective": 0.6284654140472412, + "error": 0.3740234375, + "gradient_norm": 0.03215613588690758, + "elapsed": 121.32994651794434 + }, + { + "step": 144, + "loss": 0.33964547514915466, + "objective": 0.33964547514915466, + "error": 0.1259765625, + "gradient_norm": 0.05133189633488655, + "elapsed": 131.2744882106781 + }, + { + "step": 160, + "loss": 0.14193454384803772, + "objective": 0.14193454384803772, + "error": 0.0478515625, + "gradient_norm": 0.03264402225613594, + "elapsed": 139.58473920822144 + }, + { + "step": 176, + "loss": 0.14203950762748718, + "objective": 0.14203950762748718, + "error": 0.0654296875, + "gradient_norm": 0.022548990324139595, + "elapsed": 148.9861602783203 + }, + { + "step": 192, + "loss": 0.6307225227355957, + "objective": 0.6307225227355957, + "error": 0.3955078125, + "gradient_norm": 0.08607082068920135, + "elapsed": 162.27514505386353 + }, + { + "step": 208, + "loss": 0.16193106770515442, + "objective": 0.16193106770515442, + "error": 0.064453125, + "gradient_norm": 0.023293493315577507, + "elapsed": 173.59824013710022 + }, + { + "step": 224, + "loss": 0.5426318049430847, + "objective": 0.5426318049430847, + "error": 0.3037109375, + "gradient_norm": 0.03944721072912216, + "elapsed": 182.70232272148132 + }, + { + "step": 240, + "loss": 0.6270365715026855, + "objective": 0.6270365715026855, + "error": 0.3896484375, + "gradient_norm": 0.14661568403244019, + "elapsed": 193.759183883667 + }, + { + "step": 256, + "loss": 0.4933152198791504, + "objective": 0.4933152198791504, + "error": 0.2724609375, + "gradient_norm": 0.1065438985824585, + "elapsed": 205.62959718704224 + }, + { + "step": 272, + "loss": 0.3671969473361969, + "objective": 0.3671969473361969, + "error": 0.177734375, + "gradient_norm": 0.05156548321247101, + "elapsed": 222.249596118927 + }, + { + "step": 288, + "loss": 0.5478869676589966, + "objective": 0.5478869676589966, + "error": 0.3203125, + "gradient_norm": 0.08357688039541245, + "elapsed": 232.2198715209961 + }, + { + "step": 304, + "loss": 0.21171918511390686, + "objective": 0.21171918511390686, + "error": 0.0849609375, + "gradient_norm": 0.06231697276234627, + "elapsed": 241.07631373405457 + }, + { + "step": 320, + "loss": 0.5333335995674133, + "objective": 0.5333335995674133, + "error": 0.2861328125, + "gradient_norm": 0.08931853622198105, + "elapsed": 251.28962755203247 + }, + { + "step": 336, + "loss": 0.12485946714878082, + "objective": 0.12485946714878082, + "error": 0.046875, + "gradient_norm": 0.018839582800865173, + "elapsed": 262.3605041503906 + }, + { + "step": 352, + "loss": 0.2334863245487213, + "objective": 0.2334863245487213, + "error": 0.09765625, + "gradient_norm": 0.03669576346874237, + "elapsed": 273.16373229026794 + }, + { + "step": 368, + "loss": 0.5818328857421875, + "objective": 0.5818328857421875, + "error": 0.3232421875, + "gradient_norm": 0.09833699464797974, + "elapsed": 282.8677294254303 + }, + { + "step": 384, + "loss": 0.6228232383728027, + "objective": 0.6228232383728027, + "error": 0.3671875, + "gradient_norm": 0.033418990671634674, + "elapsed": 295.04902839660645 + }, + { + "step": 400, + "loss": 0.5749450922012329, + "objective": 0.5749450922012329, + "error": 0.333984375, + "gradient_norm": 0.04644288495182991, + "elapsed": 306.67032837867737 + }, + { + "step": 416, + "loss": 0.46251457929611206, + "objective": 0.46251457929611206, + "error": 0.2216796875, + "gradient_norm": 0.06633804738521576, + "elapsed": 317.759464263916 + }, + { + "step": 432, + "loss": 0.5577508211135864, + "objective": 0.5577508211135864, + "error": 0.30859375, + "gradient_norm": 0.0970199704170227, + "elapsed": 327.4626543521881 + }, + { + "step": 448, + "loss": 0.11625733226537704, + "objective": 0.11625733226537704, + "error": 0.0419921875, + "gradient_norm": 0.020417485386133194, + "elapsed": 336.3522970676422 + }, + { + "step": 464, + "loss": 0.23657961189746857, + "objective": 0.23657961189746857, + "error": 0.1025390625, + "gradient_norm": 0.03908605873584747, + "elapsed": 344.3832321166992 + }, + { + "step": 480, + "loss": 0.011504358612000942, + "objective": 0.011504358612000942, + "error": 0.00390625, + "gradient_norm": 0.006708688102662563, + "elapsed": 355.18855381011963 + }, + { + "step": 496, + "loss": 0.3410624563694, + "objective": 0.3410624563694, + "error": 0.1533203125, + "gradient_norm": 0.05804387852549553, + "elapsed": 366.2978138923645 + }, + { + "step": 512, + "loss": 0.034005306661129, + "objective": 0.034005306661129, + "error": 0.0107421875, + "gradient_norm": 0.01019973959773779, + "elapsed": 375.73491764068604 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "b31e8f5ee2b5ea1b661e6bf8b5649bec45b7ab5da74fe9de46e4d06846356b87", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317613, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5523660182952881, + "objective": 0.5523660182952881, + "error": 0.30859375, + "gradient_norm": 0.05200070142745972, + "elapsed": 30.08410096168518 + }, + { + "step": 16, + "loss": 0.5380295515060425, + "objective": 0.5380295515060425, + "error": 0.306640625, + "gradient_norm": 0.0804876759648323, + "elapsed": 50.77648210525513 + }, + { + "step": 32, + "loss": 0.6359301805496216, + "objective": 0.6359301805496216, + "error": 0.3837890625, + "gradient_norm": 0.059380218386650085, + "elapsed": 59.453776836395264 + }, + { + "step": 48, + "loss": 0.2540435492992401, + "objective": 0.2540435492992401, + "error": 0.1083984375, + "gradient_norm": 0.04367281496524811, + "elapsed": 67.29314041137695 + }, + { + "step": 64, + "loss": 0.5867692232131958, + "objective": 0.5867692232131958, + "error": 0.3447265625, + "gradient_norm": 0.053885214030742645, + "elapsed": 78.74847197532654 + }, + { + "step": 80, + "loss": 0.6015321016311646, + "objective": 0.6015321016311646, + "error": 0.365234375, + "gradient_norm": 0.04807985574007034, + "elapsed": 90.48145818710327 + }, + { + "step": 96, + "loss": 0.49287766218185425, + "objective": 0.49287766218185425, + "error": 0.271484375, + "gradient_norm": 0.07899080961942673, + "elapsed": 101.65468978881836 + }, + { + "step": 112, + "loss": 0.3271353542804718, + "objective": 0.3271353542804718, + "error": 0.15234375, + "gradient_norm": 0.049542222172021866, + "elapsed": 111.14713263511658 + }, + { + "step": 128, + "loss": 0.50013667345047, + "objective": 0.50013667345047, + "error": 0.271484375, + "gradient_norm": 0.06454745680093765, + "elapsed": 121.21207547187805 + }, + { + "step": 144, + "loss": 0.028576843440532684, + "objective": 0.028576843440532684, + "error": 0.0087890625, + "gradient_norm": 0.010781333781778812, + "elapsed": 130.69302248954773 + }, + { + "step": 160, + "loss": 0.5668779015541077, + "objective": 0.5668779015541077, + "error": 0.330078125, + "gradient_norm": 0.06098390743136406, + "elapsed": 142.14290237426758 + }, + { + "step": 176, + "loss": 0.3986494839191437, + "objective": 0.3986494839191437, + "error": 0.1884765625, + "gradient_norm": 0.042795032262802124, + "elapsed": 152.75753688812256 + }, + { + "step": 192, + "loss": 0.31897079944610596, + "objective": 0.31897079944610596, + "error": 0.142578125, + "gradient_norm": 0.040675707161426544, + "elapsed": 160.04981398582458 + }, + { + "step": 208, + "loss": 0.5092275142669678, + "objective": 0.5092275142669678, + "error": 0.255859375, + "gradient_norm": 0.07929783314466476, + "elapsed": 169.85345673561096 + }, + { + "step": 224, + "loss": 0.35782667994499207, + "objective": 0.35782667994499207, + "error": 0.1748046875, + "gradient_norm": 0.05785144120454788, + "elapsed": 179.90323066711426 + }, + { + "step": 240, + "loss": 0.5660895109176636, + "objective": 0.5660895109176636, + "error": 0.3349609375, + "gradient_norm": 0.10684454441070557, + "elapsed": 191.3668942451477 + }, + { + "step": 256, + "loss": 0.6265910863876343, + "objective": 0.6265910863876343, + "error": 0.3779296875, + "gradient_norm": 0.034383758902549744, + "elapsed": 200.3055775165558 + }, + { + "step": 272, + "loss": 0.6210677623748779, + "objective": 0.6210677623748779, + "error": 0.369140625, + "gradient_norm": 0.04434216767549515, + "elapsed": 210.09376430511475 + }, + { + "step": 288, + "loss": 0.4892377257347107, + "objective": 0.4892377257347107, + "error": 0.2490234375, + "gradient_norm": 0.1040654331445694, + "elapsed": 220.45881819725037 + }, + { + "step": 304, + "loss": 0.6407739520072937, + "objective": 0.6407739520072937, + "error": 0.3916015625, + "gradient_norm": 0.07782924920320511, + "elapsed": 233.3719048500061 + }, + { + "step": 320, + "loss": 0.4752756953239441, + "objective": 0.4752756953239441, + "error": 0.263671875, + "gradient_norm": 0.051829319447278976, + "elapsed": 244.25844407081604 + }, + { + "step": 336, + "loss": 0.6482080221176147, + "objective": 0.6482080221176147, + "error": 0.41015625, + "gradient_norm": 0.04979892820119858, + "elapsed": 253.1897099018097 + }, + { + "step": 352, + "loss": 0.34022292494773865, + "objective": 0.34022292494773865, + "error": 0.1708984375, + "gradient_norm": 0.09951864182949066, + "elapsed": 264.0781395435333 + }, + { + "step": 368, + "loss": 0.3494992256164551, + "objective": 0.3494992256164551, + "error": 0.15625, + "gradient_norm": 0.10392706841230392, + "elapsed": 275.8111581802368 + }, + { + "step": 384, + "loss": 0.47191378474235535, + "objective": 0.47191378474235535, + "error": 0.25, + "gradient_norm": 0.07366786152124405, + "elapsed": 283.9459602832794 + }, + { + "step": 400, + "loss": 0.583655595779419, + "objective": 0.583655595779419, + "error": 0.3623046875, + "gradient_norm": 0.10394527018070221, + "elapsed": 294.3349726200104 + }, + { + "step": 416, + "loss": 0.6212975978851318, + "objective": 0.6212975978851318, + "error": 0.37109375, + "gradient_norm": 0.054796766489744186, + "elapsed": 304.7477548122406 + }, + { + "step": 432, + "loss": 0.4719577431678772, + "objective": 0.4719577431678772, + "error": 0.2431640625, + "gradient_norm": 0.05418012663722038, + "elapsed": 315.91914200782776 + }, + { + "step": 448, + "loss": 0.5696494579315186, + "objective": 0.5696494579315186, + "error": 0.3330078125, + "gradient_norm": 0.047046076506376266, + "elapsed": 324.96326184272766 + }, + { + "step": 464, + "loss": 0.613875687122345, + "objective": 0.613875687122345, + "error": 0.34765625, + "gradient_norm": 0.05237002298235893, + "elapsed": 334.7670781612396 + }, + { + "step": 480, + "loss": 0.28741705417633057, + "objective": 0.28741705417633057, + "error": 0.1240234375, + "gradient_norm": 0.05365394428372383, + "elapsed": 344.03080439567566 + }, + { + "step": 496, + "loss": 0.3729455769062042, + "objective": 0.3729455769062042, + "error": 0.1875, + "gradient_norm": 0.05905403569340706, + "elapsed": 356.01581716537476 + }, + { + "step": 512, + "loss": 0.38685142993927, + "objective": 0.38685142993927, + "error": 0.17578125, + "gradient_norm": 0.048455506563186646, + "elapsed": 367.7296392917633 + }, + { + "step": 528, + "loss": 0.6062720417976379, + "objective": 0.6062720417976379, + "error": 0.369140625, + "gradient_norm": 0.07544548809528351, + "elapsed": 385.4480962753296 + }, + { + "step": 544, + "loss": 0.520085871219635, + "objective": 0.520085871219635, + "error": 0.279296875, + "gradient_norm": 0.08394371718168259, + "elapsed": 397.71993708610535 + }, + { + "step": 560, + "loss": 0.5944540500640869, + "objective": 0.5944540500640869, + "error": 0.3544921875, + "gradient_norm": 0.05468091368675232, + "elapsed": 406.9417428970337 + }, + { + "step": 576, + "loss": 0.34102559089660645, + "objective": 0.34102559089660645, + "error": 0.1611328125, + "gradient_norm": 0.07333917915821075, + "elapsed": 417.0068130493164 + }, + { + "step": 592, + "loss": 0.47373664379119873, + "objective": 0.47373664379119873, + "error": 0.2412109375, + "gradient_norm": 0.05662858858704567, + "elapsed": 425.1176447868347 + }, + { + "step": 608, + "loss": 0.48517894744873047, + "objective": 0.48517894744873047, + "error": 0.25, + "gradient_norm": 0.08127480745315552, + "elapsed": 434.92080903053284 + }, + { + "step": 624, + "loss": 0.39865612983703613, + "objective": 0.39865612983703613, + "error": 0.1904296875, + "gradient_norm": 0.07332058995962143, + "elapsed": 446.6602101325989 + }, + { + "step": 640, + "loss": 0.41867297887802124, + "objective": 0.41867297887802124, + "error": 0.2177734375, + "gradient_norm": 0.07386308163404465, + "elapsed": 457.0243580341339 + }, + { + "step": 656, + "loss": 0.5108687877655029, + "objective": 0.5108687877655029, + "error": 0.2822265625, + "gradient_norm": 0.052080318331718445, + "elapsed": 469.5842761993408 + }, + { + "step": 672, + "loss": 0.5043742656707764, + "objective": 0.5043742656707764, + "error": 0.2734375, + "gradient_norm": 0.047204963862895966, + "elapsed": 479.356397151947 + }, + { + "step": 688, + "loss": 0.5550935864448547, + "objective": 0.5550935864448547, + "error": 0.30078125, + "gradient_norm": 0.04080262407660484, + "elapsed": 489.9912152290344 + }, + { + "step": 704, + "loss": 0.5698974132537842, + "objective": 0.5698974132537842, + "error": 0.322265625, + "gradient_norm": 0.10692963004112244, + "elapsed": 500.3283371925354 + }, + { + "step": 720, + "loss": 0.45870622992515564, + "objective": 0.45870622992515564, + "error": 0.2255859375, + "gradient_norm": 0.06705734878778458, + "elapsed": 509.82279753685 + }, + { + "step": 736, + "loss": 0.555386483669281, + "objective": 0.555386483669281, + "error": 0.31640625, + "gradient_norm": 0.05112688988447189, + "elapsed": 518.507036447525 + }, + { + "step": 752, + "loss": 0.14282986521720886, + "objective": 0.14282986521720886, + "error": 0.056640625, + "gradient_norm": 0.03209136053919792, + "elapsed": 529.1373023986816 + }, + { + "step": 768, + "loss": 0.5362129807472229, + "objective": 0.5362129807472229, + "error": 0.2841796875, + "gradient_norm": 0.049996186047792435, + "elapsed": 538.9186007976532 + }, + { + "step": 784, + "loss": 0.5071826577186584, + "objective": 0.5071826577186584, + "error": 0.2744140625, + "gradient_norm": 0.04826078191399574, + "elapsed": 549.5225830078125 + }, + { + "step": 800, + "loss": 0.24775367975234985, + "objective": 0.24775367975234985, + "error": 0.107421875, + "gradient_norm": 0.06889795511960983, + "elapsed": 560.7170543670654 + }, + { + "step": 816, + "loss": 0.17432856559753418, + "objective": 0.17432856559753418, + "error": 0.06640625, + "gradient_norm": 0.05147368833422661, + "elapsed": 570.7887880802155 + }, + { + "step": 832, + "loss": 0.5410823822021484, + "objective": 0.5410823822021484, + "error": 0.3115234375, + "gradient_norm": 0.11862928420305252, + "elapsed": 581.9721121788025 + }, + { + "step": 848, + "loss": 0.5555508732795715, + "objective": 0.5555508732795715, + "error": 0.296875, + "gradient_norm": 0.060369592159986496, + "elapsed": 592.2823219299316 + }, + { + "step": 864, + "loss": 0.31839215755462646, + "objective": 0.31839215755462646, + "error": 0.1552734375, + "gradient_norm": 0.063877172768116, + "elapsed": 603.1910541057587 + }, + { + "step": 880, + "loss": 0.481766939163208, + "objective": 0.481766939163208, + "error": 0.2470703125, + "gradient_norm": 0.1623816341161728, + "elapsed": 614.4277107715607 + }, + { + "step": 896, + "loss": 0.5780366659164429, + "objective": 0.5780366659164429, + "error": 0.3037109375, + "gradient_norm": 0.06694691628217697, + "elapsed": 623.9365792274475 + }, + { + "step": 912, + "loss": 0.4794909358024597, + "objective": 0.4794909358024597, + "error": 0.2314453125, + "gradient_norm": 0.07813122123479843, + "elapsed": 633.9845306873322 + }, + { + "step": 928, + "loss": 0.6279138922691345, + "objective": 0.6279138922691345, + "error": 0.380859375, + "gradient_norm": 0.047679927200078964, + "elapsed": 643.7766675949097 + }, + { + "step": 944, + "loss": 0.6401606798171997, + "objective": 0.6401606798171997, + "error": 0.3994140625, + "gradient_norm": 0.07329051941633224, + "elapsed": 655.2369928359985 + }, + { + "step": 960, + "loss": 0.4340277910232544, + "objective": 0.4340277910232544, + "error": 0.2158203125, + "gradient_norm": 0.11762503534555435, + "elapsed": 666.9884371757507 + }, + { + "step": 976, + "loss": 0.44496864080429077, + "objective": 0.44496864080429077, + "error": 0.2236328125, + "gradient_norm": 0.05260347202420235, + "elapsed": 677.3464586734772 + }, + { + "step": 992, + "loss": 0.13230293989181519, + "objective": 0.13230293989181519, + "error": 0.05078125, + "gradient_norm": 0.030240925028920174, + "elapsed": 685.7275724411011 + }, + { + "step": 1008, + "loss": 0.2971688508987427, + "objective": 0.2971688508987427, + "error": 0.1171875, + "gradient_norm": 0.05503479763865471, + "elapsed": 694.1270356178284 + }, + { + "step": 1024, + "loss": 0.5688735246658325, + "objective": 0.5688735246658325, + "error": 0.314453125, + "gradient_norm": 0.06526188552379608, + "elapsed": 703.9192817211151 + }, + { + "step": 1040, + "loss": 0.42805811762809753, + "objective": 0.42805811762809753, + "error": 0.2080078125, + "gradient_norm": 0.13000032305717468, + "elapsed": 720.145961523056 + }, + { + "step": 1056, + "loss": 0.5543602705001831, + "objective": 0.5543602705001831, + "error": 0.298828125, + "gradient_norm": 0.15922385454177856, + "elapsed": 733.5112845897675 + }, + { + "step": 1072, + "loss": 0.031130114570260048, + "objective": 0.031130114570260048, + "error": 0.013671875, + "gradient_norm": 0.008926023729145527, + "elapsed": 742.4467866420746 + }, + { + "step": 1088, + "loss": 0.14947748184204102, + "objective": 0.14947748184204102, + "error": 0.056640625, + "gradient_norm": 0.03975249081850052, + "elapsed": 751.8575854301453 + }, + { + "step": 1104, + "loss": 0.6275734901428223, + "objective": 0.6275734901428223, + "error": 0.3671875, + "gradient_norm": 0.08096148073673248, + "elapsed": 761.5625903606415 + }, + { + "step": 1120, + "loss": 0.23923414945602417, + "objective": 0.23923414945602417, + "error": 0.0966796875, + "gradient_norm": 0.03325376287102699, + "elapsed": 773.9633615016937 + }, + { + "step": 1136, + "loss": 0.570243239402771, + "objective": 0.570243239402771, + "error": 0.31640625, + "gradient_norm": 0.07534287869930267, + "elapsed": 783.1533136367798 + }, + { + "step": 1152, + "loss": 0.4264270067214966, + "objective": 0.4264270067214966, + "error": 0.2119140625, + "gradient_norm": 0.08900073170661926, + "elapsed": 792.1710996627808 + }, + { + "step": 1168, + "loss": 0.5958121418952942, + "objective": 0.5958121418952942, + "error": 0.3583984375, + "gradient_norm": 0.08239343762397766, + "elapsed": 803.1175289154053 + }, + { + "step": 1184, + "loss": 0.2909137010574341, + "objective": 0.2909137010574341, + "error": 0.1416015625, + "gradient_norm": 0.05281354859471321, + "elapsed": 812.6055159568787 + }, + { + "step": 1200, + "loss": 0.6119058728218079, + "objective": 0.6119058728218079, + "error": 0.36328125, + "gradient_norm": 0.056254416704177856, + "elapsed": 823.2276427745819 + }, + { + "step": 1216, + "loss": 0.13595536351203918, + "objective": 0.13595536351203918, + "error": 0.0556640625, + "gradient_norm": 0.04057573154568672, + "elapsed": 834.1696293354034 + }, + { + "step": 1232, + "loss": 0.5840731263160706, + "objective": 0.5840731263160706, + "error": 0.328125, + "gradient_norm": 0.054566267877817154, + "elapsed": 845.3501887321472 + }, + { + "step": 1248, + "loss": 0.3053072690963745, + "objective": 0.3053072690963745, + "error": 0.1337890625, + "gradient_norm": 0.04617297649383545, + "elapsed": 854.9564871788025 + }, + { + "step": 1264, + "loss": 0.6288673281669617, + "objective": 0.6288673281669617, + "error": 0.3994140625, + "gradient_norm": 0.08229745179414749, + "elapsed": 864.8914043903351 + }, + { + "step": 1280, + "loss": 0.5586361289024353, + "objective": 0.5586361289024353, + "error": 0.2958984375, + "gradient_norm": 0.05713959410786629, + "elapsed": 877.0349607467651 + }, + { + "step": 1296, + "loss": 0.3648858666419983, + "objective": 0.3648858666419983, + "error": 0.16796875, + "gradient_norm": 0.08502963185310364, + "elapsed": 888.5764675140381 + }, + { + "step": 1312, + "loss": 0.4747084081172943, + "objective": 0.4747084081172943, + "error": 0.244140625, + "gradient_norm": 0.08609883487224579, + "elapsed": 899.7598609924316 + }, + { + "step": 1328, + "loss": 0.15583917498588562, + "objective": 0.15583917498588562, + "error": 0.05859375, + "gradient_norm": 0.027793049812316895, + "elapsed": 909.47514295578 + }, + { + "step": 1344, + "loss": 0.47515708208084106, + "objective": 0.47515708208084106, + "error": 0.263671875, + "gradient_norm": 0.07668807357549667, + "elapsed": 919.7640328407288 + }, + { + "step": 1360, + "loss": 0.5173689126968384, + "objective": 0.5173689126968384, + "error": 0.2744140625, + "gradient_norm": 0.05054212734103203, + "elapsed": 930.6309463977814 + }, + { + "step": 1376, + "loss": 0.46629998087882996, + "objective": 0.46629998087882996, + "error": 0.24609375, + "gradient_norm": 0.051172077655792236, + "elapsed": 939.0202586650848 + }, + { + "step": 1392, + "loss": 0.11312969774007797, + "objective": 0.11312969774007797, + "error": 0.044921875, + "gradient_norm": 0.05863805115222931, + "elapsed": 949.1451416015625 + }, + { + "step": 1408, + "loss": 0.5750841498374939, + "objective": 0.5750841498374939, + "error": 0.322265625, + "gradient_norm": 0.051106806844472885, + "elapsed": 959.94162940979 + }, + { + "step": 1424, + "loss": 0.5937192440032959, + "objective": 0.5937192440032959, + "error": 0.3408203125, + "gradient_norm": 0.05014815554022789, + "elapsed": 969.5868306159973 + }, + { + "step": 1440, + "loss": 0.5292985439300537, + "objective": 0.5292985439300537, + "error": 0.2958984375, + "gradient_norm": 0.057068243622779846, + "elapsed": 982.6692054271698 + }, + { + "step": 1456, + "loss": 0.5959951877593994, + "objective": 0.5959951877593994, + "error": 0.3408203125, + "gradient_norm": 0.0703694075345993, + "elapsed": 995.0066986083984 + }, + { + "step": 1472, + "loss": 0.018453411757946014, + "objective": 0.018453411757946014, + "error": 0.00390625, + "gradient_norm": 0.012016087770462036, + "elapsed": 1004.0057821273804 + }, + { + "step": 1488, + "loss": 0.5711684823036194, + "objective": 0.5711684823036194, + "error": 0.3095703125, + "gradient_norm": 0.07746906578540802, + "elapsed": 1016.1701967716217 + }, + { + "step": 1504, + "loss": 0.3114882707595825, + "objective": 0.3114882707595825, + "error": 0.1455078125, + "gradient_norm": 0.05321609228849411, + "elapsed": 1026.6053586006165 + }, + { + "step": 1520, + "loss": 0.6433392763137817, + "objective": 0.6433392763137817, + "error": 0.4072265625, + "gradient_norm": 0.05683734640479088, + "elapsed": 1036.1535296440125 + }, + { + "step": 1536, + "loss": 0.38409170508384705, + "objective": 0.38409170508384705, + "error": 0.19140625, + "gradient_norm": 0.07577994465827942, + "elapsed": 1046.9508447647095 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "7b45252d6bb77a39c003c8f34f040d0d672e9dd1a1338a14126e1fe07a02c8c9", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 466919, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "reserved2_full": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 467790, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved2_warm/weights-512.npz", + "starting_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261273", + "prior_pass": 3, + "initial_seed": 20261273, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317635, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261274, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261274", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.2600052058696747, + "objective": 0.2600052058696747, + "error": 0.1123046875, + "gradient_norm": 0.06799795478582382, + "elapsed": 27.333195447921753 + }, + { + "step": 16, + "loss": 0.0312246885150671, + "objective": 0.0312246885150671, + "error": 0.01171875, + "gradient_norm": 0.004962741397321224, + "elapsed": 48.383540868759155 + }, + { + "step": 32, + "loss": 0.22698244452476501, + "objective": 0.22698244452476501, + "error": 0.08984375, + "gradient_norm": 0.06353150308132172, + "elapsed": 57.04609966278076 + }, + { + "step": 48, + "loss": 0.5861443281173706, + "objective": 0.5861443281173706, + "error": 0.3486328125, + "gradient_norm": 0.04095375910401344, + "elapsed": 69.08654689788818 + }, + { + "step": 64, + "loss": 0.6103856563568115, + "objective": 0.6103856563568115, + "error": 0.3662109375, + "gradient_norm": 0.04155975207686424, + "elapsed": 81.63970494270325 + }, + { + "step": 80, + "loss": 0.5673234462738037, + "objective": 0.5673234462738037, + "error": 0.3125, + "gradient_norm": 0.1773851364850998, + "elapsed": 92.5357596874237 + }, + { + "step": 96, + "loss": 0.3763846755027771, + "objective": 0.3763846755027771, + "error": 0.1875, + "gradient_norm": 0.0951203852891922, + "elapsed": 103.12279391288757 + }, + { + "step": 112, + "loss": 0.45539408922195435, + "objective": 0.45539408922195435, + "error": 0.22265625, + "gradient_norm": 0.056369006633758545, + "elapsed": 112.61882042884827 + }, + { + "step": 128, + "loss": 0.015473627485334873, + "objective": 0.015473627485334873, + "error": 0.005859375, + "gradient_norm": 0.005696057807654142, + "elapsed": 125.16960310935974 + }, + { + "step": 144, + "loss": 0.03449750319123268, + "objective": 0.03449750319123268, + "error": 0.0107421875, + "gradient_norm": 0.008358650840818882, + "elapsed": 135.8080232143402 + }, + { + "step": 160, + "loss": 0.5731935501098633, + "objective": 0.5731935501098633, + "error": 0.31640625, + "gradient_norm": 0.056162577122449875, + "elapsed": 145.0349259376526 + }, + { + "step": 176, + "loss": 0.5626271963119507, + "objective": 0.5626271963119507, + "error": 0.314453125, + "gradient_norm": 0.048817526549100876, + "elapsed": 154.84093379974365 + }, + { + "step": 192, + "loss": 0.5507581233978271, + "objective": 0.5507581233978271, + "error": 0.3173828125, + "gradient_norm": 0.06503377854824066, + "elapsed": 164.7195086479187 + }, + { + "step": 208, + "loss": 0.5725968480110168, + "objective": 0.5725968480110168, + "error": 0.3251953125, + "gradient_norm": 0.047704510390758514, + "elapsed": 175.38803815841675 + }, + { + "step": 224, + "loss": 0.5249365568161011, + "objective": 0.5249365568161011, + "error": 0.2802734375, + "gradient_norm": 0.10021239519119263, + "elapsed": 187.0162854194641 + }, + { + "step": 240, + "loss": 0.2526492476463318, + "objective": 0.2526492476463318, + "error": 0.1103515625, + "gradient_norm": 0.06751289963722229, + "elapsed": 196.51696944236755 + }, + { + "step": 256, + "loss": 0.5214780569076538, + "objective": 0.5214780569076538, + "error": 0.275390625, + "gradient_norm": 0.14627203345298767, + "elapsed": 208.2405219078064 + }, + { + "step": 272, + "loss": 0.59315025806427, + "objective": 0.59315025806427, + "error": 0.341796875, + "gradient_norm": 0.03693874180316925, + "elapsed": 224.87874341011047 + }, + { + "step": 288, + "loss": 0.37350377440452576, + "objective": 0.37350377440452576, + "error": 0.169921875, + "gradient_norm": 0.05035478249192238, + "elapsed": 235.2427306175232 + }, + { + "step": 304, + "loss": 0.6201726198196411, + "objective": 0.6201726198196411, + "error": 0.3798828125, + "gradient_norm": 0.04230104014277458, + "elapsed": 244.4733214378357 + }, + { + "step": 320, + "loss": 0.5781067609786987, + "objective": 0.5781067609786987, + "error": 0.3291015625, + "gradient_norm": 0.06764703243970871, + "elapsed": 256.96991300582886 + }, + { + "step": 336, + "loss": 0.13824111223220825, + "objective": 0.13824111223220825, + "error": 0.0556640625, + "gradient_norm": 0.02330971322953701, + "elapsed": 268.097412109375 + }, + { + "step": 352, + "loss": 0.6141752004623413, + "objective": 0.6141752004623413, + "error": 0.37890625, + "gradient_norm": 0.08660273998975754, + "elapsed": 282.79302310943604 + }, + { + "step": 368, + "loss": 0.3470626473426819, + "objective": 0.3470626473426819, + "error": 0.1611328125, + "gradient_norm": 0.05711895599961281, + "elapsed": 293.79467129707336 + }, + { + "step": 384, + "loss": 0.6023644208908081, + "objective": 0.6023644208908081, + "error": 0.3466796875, + "gradient_norm": 0.08649417012929916, + "elapsed": 305.9786322116852 + }, + { + "step": 400, + "loss": 0.03022841364145279, + "objective": 0.03022841364145279, + "error": 0.0087890625, + "gradient_norm": 0.009741511195898056, + "elapsed": 315.06104922294617 + }, + { + "step": 416, + "loss": 0.23827238380908966, + "objective": 0.23827238380908966, + "error": 0.1015625, + "gradient_norm": 0.03526044636964798, + "elapsed": 325.6410942077637 + }, + { + "step": 432, + "loss": 0.43375664949417114, + "objective": 0.43375664949417114, + "error": 0.201171875, + "gradient_norm": 0.03940205276012421, + "elapsed": 336.9890570640564 + }, + { + "step": 448, + "loss": 0.5915575623512268, + "objective": 0.5915575623512268, + "error": 0.3359375, + "gradient_norm": 0.04364592209458351, + "elapsed": 346.9254243373871 + }, + { + "step": 464, + "loss": 0.5641118288040161, + "objective": 0.5641118288040161, + "error": 0.3076171875, + "gradient_norm": 0.052896615117788315, + "elapsed": 356.9816539287567 + }, + { + "step": 480, + "loss": 0.5682889223098755, + "objective": 0.5682889223098755, + "error": 0.322265625, + "gradient_norm": 0.07130409777164459, + "elapsed": 369.16103172302246 + }, + { + "step": 496, + "loss": 0.37034764885902405, + "objective": 0.37034764885902405, + "error": 0.181640625, + "gradient_norm": 0.11464523524045944, + "elapsed": 381.041054725647 + }, + { + "step": 512, + "loss": 0.5398496389389038, + "objective": 0.5398496389389038, + "error": 0.3076171875, + "gradient_norm": 0.05673467367887497, + "elapsed": 394.5030150413513 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "db182d721768f832e1c83f6258b31bef0d8bf2ded239a8ab5a45cbb76378fd30", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317635, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 13700, + "surface_code_bX_d5_r03_center_5_5": 10036, + "surface_code_bX_d5_r05_center_5_5": 11768, + "surface_code_bX_d5_r07_center_5_5": 10917, + "surface_code_bX_d5_r09_center_5_5": 13458, + "surface_code_bX_d5_r11_center_5_5": 11764, + "surface_code_bX_d5_r13_center_5_5": 14018, + "surface_code_bX_d5_r15_center_5_5": 10968, + "surface_code_bX_d5_r17_center_5_5": 13469, + "surface_code_bX_d5_r19_center_5_5": 11340, + "surface_code_bX_d5_r21_center_5_5": 11327, + "surface_code_bX_d5_r23_center_5_5": 13970, + "surface_code_bX_d5_r25_center_5_5": 10500, + "surface_code_bZ_d5_r01_center_5_5": 12079, + "surface_code_bZ_d5_r03_center_5_5": 12160, + "surface_code_bZ_d5_r05_center_5_5": 9494, + "surface_code_bZ_d5_r07_center_5_5": 10910, + "surface_code_bZ_d5_r09_center_5_5": 10064, + "surface_code_bZ_d5_r11_center_5_5": 10969, + "surface_code_bZ_d5_r13_center_5_5": 13419, + "surface_code_bZ_d5_r15_center_5_5": 12842, + "surface_code_bZ_d5_r17_center_5_5": 13694, + "surface_code_bZ_d5_r19_center_5_5": 13449, + "surface_code_bZ_d5_r21_center_5_5": 13799, + "surface_code_bZ_d5_r23_center_5_5": 12754, + "surface_code_bZ_d5_r25_center_5_5": 14767 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.30839407444000244, + "objective": 0.30839407444000244, + "error": 0.130859375, + "gradient_norm": 0.053425733000040054, + "elapsed": 28.537403345108032 + }, + { + "step": 16, + "loss": 0.021987520158290863, + "objective": 0.021987520158290863, + "error": 0.0078125, + "gradient_norm": 0.01397851575165987, + "elapsed": 48.18276286125183 + }, + { + "step": 32, + "loss": 0.5041587352752686, + "objective": 0.5041587352752686, + "error": 0.2724609375, + "gradient_norm": 0.0528741292655468, + "elapsed": 58.27348470687866 + }, + { + "step": 48, + "loss": 0.4326452612876892, + "objective": 0.4326452612876892, + "error": 0.21484375, + "gradient_norm": 0.0559566393494606, + "elapsed": 68.90473222732544 + }, + { + "step": 64, + "loss": 0.4804917275905609, + "objective": 0.4804917275905609, + "error": 0.248046875, + "gradient_norm": 0.0669105276465416, + "elapsed": 77.87249231338501 + }, + { + "step": 80, + "loss": 0.2889654338359833, + "objective": 0.2889654338359833, + "error": 0.1328125, + "gradient_norm": 0.08293467015028, + "elapsed": 86.87973022460938 + }, + { + "step": 96, + "loss": 0.5135385990142822, + "objective": 0.5135385990142822, + "error": 0.271484375, + "gradient_norm": 0.06412295252084732, + "elapsed": 95.98773431777954 + }, + { + "step": 112, + "loss": 0.31248384714126587, + "objective": 0.31248384714126587, + "error": 0.1357421875, + "gradient_norm": 0.03881710395216942, + "elapsed": 106.47444081306458 + }, + { + "step": 128, + "loss": 0.23868557810783386, + "objective": 0.23868557810783386, + "error": 0.091796875, + "gradient_norm": 0.03896595537662506, + "elapsed": 117.72143626213074 + }, + { + "step": 144, + "loss": 0.5315916538238525, + "objective": 0.5315916538238525, + "error": 0.2890625, + "gradient_norm": 0.09184520691633224, + "elapsed": 126.97882843017578 + }, + { + "step": 160, + "loss": 0.604732096195221, + "objective": 0.604732096195221, + "error": 0.3603515625, + "gradient_norm": 0.044600710272789, + "elapsed": 137.403742313385 + }, + { + "step": 176, + "loss": 0.032417282462120056, + "objective": 0.032417282462120056, + "error": 0.0107421875, + "gradient_norm": 0.010968778282403946, + "elapsed": 147.58081603050232 + }, + { + "step": 192, + "loss": 0.24050910770893097, + "objective": 0.24050910770893097, + "error": 0.087890625, + "gradient_norm": 0.052534136921167374, + "elapsed": 156.545964717865 + }, + { + "step": 208, + "loss": 0.3183761537075043, + "objective": 0.3183761537075043, + "error": 0.1435546875, + "gradient_norm": 0.05253623053431511, + "elapsed": 166.62695455551147 + }, + { + "step": 224, + "loss": 0.6407097578048706, + "objective": 0.6407097578048706, + "error": 0.3837890625, + "gradient_norm": 0.08772490173578262, + "elapsed": 174.46970582008362 + }, + { + "step": 240, + "loss": 0.597212553024292, + "objective": 0.597212553024292, + "error": 0.36328125, + "gradient_norm": 0.13039150834083557, + "elapsed": 184.2768793106079 + }, + { + "step": 256, + "loss": 0.3317721486091614, + "objective": 0.3317721486091614, + "error": 0.14453125, + "gradient_norm": 0.03749232366681099, + "elapsed": 194.6345317363739 + }, + { + "step": 272, + "loss": 0.6330116987228394, + "objective": 0.6330116987228394, + "error": 0.3955078125, + "gradient_norm": 0.06468097865581512, + "elapsed": 205.8717017173767 + }, + { + "step": 288, + "loss": 0.3141757845878601, + "objective": 0.3141757845878601, + "error": 0.138671875, + "gradient_norm": 0.046496689319610596, + "elapsed": 215.2117359638214 + }, + { + "step": 304, + "loss": 0.5782994031906128, + "objective": 0.5782994031906128, + "error": 0.345703125, + "gradient_norm": 0.06487675756216049, + "elapsed": 225.47403240203857 + }, + { + "step": 320, + "loss": 0.45729100704193115, + "objective": 0.45729100704193115, + "error": 0.2255859375, + "gradient_norm": 0.04169687256217003, + "elapsed": 233.03686332702637 + }, + { + "step": 336, + "loss": 0.49350813031196594, + "objective": 0.49350813031196594, + "error": 0.24609375, + "gradient_norm": 0.08623651415109634, + "elapsed": 244.53246903419495 + }, + { + "step": 352, + "loss": 0.25660067796707153, + "objective": 0.25660067796707153, + "error": 0.1103515625, + "gradient_norm": 0.03029652312397957, + "elapsed": 254.88137793540955 + }, + { + "step": 368, + "loss": 0.2295728325843811, + "objective": 0.2295728325843811, + "error": 0.0966796875, + "gradient_norm": 0.042884912341833115, + "elapsed": 262.7415475845337 + }, + { + "step": 384, + "loss": 0.6214326620101929, + "objective": 0.6214326620101929, + "error": 0.3759765625, + "gradient_norm": 0.08176509290933609, + "elapsed": 271.72958397865295 + }, + { + "step": 400, + "loss": 0.6463049650192261, + "objective": 0.6463049650192261, + "error": 0.3984375, + "gradient_norm": 0.08226390928030014, + "elapsed": 281.51069259643555 + }, + { + "step": 416, + "loss": 0.024987798184156418, + "objective": 0.024987798184156418, + "error": 0.0078125, + "gradient_norm": 0.0075854891911149025, + "elapsed": 291.0118627548218 + }, + { + "step": 432, + "loss": 0.5520929098129272, + "objective": 0.5520929098129272, + "error": 0.3125, + "gradient_norm": 0.09755270183086395, + "elapsed": 301.23231768608093 + }, + { + "step": 448, + "loss": 0.6077401638031006, + "objective": 0.6077401638031006, + "error": 0.361328125, + "gradient_norm": 0.04908076301217079, + "elapsed": 312.93572759628296 + }, + { + "step": 464, + "loss": 0.016434211283922195, + "objective": 0.016434211283922195, + "error": 0.005859375, + "gradient_norm": 0.007213531993329525, + "elapsed": 323.8330478668213 + }, + { + "step": 480, + "loss": 0.1582300364971161, + "objective": 0.1582300364971161, + "error": 0.064453125, + "gradient_norm": 0.028335656970739365, + "elapsed": 334.6112554073334 + }, + { + "step": 496, + "loss": 0.5916742086410522, + "objective": 0.5916742086410522, + "error": 0.35546875, + "gradient_norm": 0.08213689178228378, + "elapsed": 345.8490369319916 + }, + { + "step": 512, + "loss": 0.11447565257549286, + "objective": 0.11447565257549286, + "error": 0.04296875, + "gradient_norm": 0.028994916006922722, + "elapsed": 358.71793270111084 + }, + { + "step": 528, + "loss": 0.3011414408683777, + "objective": 0.3011414408683777, + "error": 0.1435546875, + "gradient_norm": 0.04305516928434372, + "elapsed": 373.143226146698 + }, + { + "step": 544, + "loss": 0.3099900782108307, + "objective": 0.3099900782108307, + "error": 0.130859375, + "gradient_norm": 0.06152835488319397, + "elapsed": 380.42762184143066 + }, + { + "step": 560, + "loss": 0.42917633056640625, + "objective": 0.42917633056640625, + "error": 0.203125, + "gradient_norm": 0.051812849938869476, + "elapsed": 390.78397703170776 + }, + { + "step": 576, + "loss": 0.4895544648170471, + "objective": 0.4895544648170471, + "error": 0.2451171875, + "gradient_norm": 0.059052009135484695, + "elapsed": 400.29374146461487 + }, + { + "step": 592, + "loss": 0.5950886011123657, + "objective": 0.5950886011123657, + "error": 0.328125, + "gradient_norm": 0.1449151188135147, + "elapsed": 410.06920647621155 + }, + { + "step": 608, + "loss": 0.3282078504562378, + "objective": 0.3282078504562378, + "error": 0.1484375, + "gradient_norm": 0.06495015323162079, + "elapsed": 420.5240683555603 + }, + { + "step": 624, + "loss": 0.6034166812896729, + "objective": 0.6034166812896729, + "error": 0.3388671875, + "gradient_norm": 0.05658626928925514, + "elapsed": 430.7997169494629 + }, + { + "step": 640, + "loss": 0.590431809425354, + "objective": 0.590431809425354, + "error": 0.3447265625, + "gradient_norm": 0.046094730496406555, + "elapsed": 441.8197224140167 + }, + { + "step": 656, + "loss": 0.2260439246892929, + "objective": 0.2260439246892929, + "error": 0.1015625, + "gradient_norm": 0.06323576718568802, + "elapsed": 450.76086831092834 + }, + { + "step": 672, + "loss": 0.26158156991004944, + "objective": 0.26158156991004944, + "error": 0.1162109375, + "gradient_norm": 0.08324819058179855, + "elapsed": 459.1986529827118 + }, + { + "step": 688, + "loss": 0.4871026873588562, + "objective": 0.4871026873588562, + "error": 0.244140625, + "gradient_norm": 0.051720812916755676, + "elapsed": 470.4437210559845 + }, + { + "step": 704, + "loss": 0.5861694812774658, + "objective": 0.5861694812774658, + "error": 0.341796875, + "gradient_norm": 0.05766218528151512, + "elapsed": 483.85575103759766 + }, + { + "step": 720, + "loss": 0.4168863296508789, + "objective": 0.4168863296508789, + "error": 0.21484375, + "gradient_norm": 0.05056491494178772, + "elapsed": 494.63891077041626 + }, + { + "step": 736, + "loss": 0.42054638266563416, + "objective": 0.42054638266563416, + "error": 0.21875, + "gradient_norm": 0.07021808624267578, + "elapsed": 505.4899232387543 + }, + { + "step": 752, + "loss": 0.2022928148508072, + "objective": 0.2022928148508072, + "error": 0.0849609375, + "gradient_norm": 0.0765448734164238, + "elapsed": 516.2925503253937 + }, + { + "step": 768, + "loss": 0.026398655027151108, + "objective": 0.026398655027151108, + "error": 0.0068359375, + "gradient_norm": 0.00973521638661623, + "elapsed": 524.7940125465393 + }, + { + "step": 784, + "loss": 0.5843480825424194, + "objective": 0.5843480825424194, + "error": 0.345703125, + "gradient_norm": 0.04805552959442139, + "elapsed": 535.345025062561 + }, + { + "step": 800, + "loss": 0.3102012872695923, + "objective": 0.3102012872695923, + "error": 0.134765625, + "gradient_norm": 0.09761057049036026, + "elapsed": 544.4683487415314 + }, + { + "step": 816, + "loss": 0.5332639217376709, + "objective": 0.5332639217376709, + "error": 0.30078125, + "gradient_norm": 0.10398133844137192, + "elapsed": 554.8217175006866 + }, + { + "step": 832, + "loss": 0.4870310425758362, + "objective": 0.4870310425758362, + "error": 0.2685546875, + "gradient_norm": 0.05754273384809494, + "elapsed": 564.9130115509033 + }, + { + "step": 848, + "loss": 0.1336989849805832, + "objective": 0.1336989849805832, + "error": 0.0498046875, + "gradient_norm": 0.02862304449081421, + "elapsed": 573.6143791675568 + }, + { + "step": 864, + "loss": 0.5794297456741333, + "objective": 0.5794297456741333, + "error": 0.3427734375, + "gradient_norm": 0.05002075806260109, + "elapsed": 584.2565310001373 + }, + { + "step": 880, + "loss": 0.6150081753730774, + "objective": 0.6150081753730774, + "error": 0.341796875, + "gradient_norm": 0.0605069138109684, + "elapsed": 596.845867395401 + }, + { + "step": 896, + "loss": 0.3804032504558563, + "objective": 0.3804032504558563, + "error": 0.18359375, + "gradient_norm": 0.057405781000852585, + "elapsed": 606.0786938667297 + }, + { + "step": 912, + "loss": 0.5734928846359253, + "objective": 0.5734928846359253, + "error": 0.2958984375, + "gradient_norm": 0.06807747483253479, + "elapsed": 616.9755277633667 + }, + { + "step": 928, + "loss": 0.23615539073944092, + "objective": 0.23615539073944092, + "error": 0.107421875, + "gradient_norm": 0.04033413156867027, + "elapsed": 625.9104406833649 + }, + { + "step": 944, + "loss": 0.5668450593948364, + "objective": 0.5668450593948364, + "error": 0.3134765625, + "gradient_norm": 0.04825817048549652, + "elapsed": 635.4241654872894 + }, + { + "step": 960, + "loss": 0.1369795948266983, + "objective": 0.1369795948266983, + "error": 0.0537109375, + "gradient_norm": 0.029475854709744453, + "elapsed": 646.0763671398163 + }, + { + "step": 976, + "loss": 0.026218727231025696, + "objective": 0.026218727231025696, + "error": 0.009765625, + "gradient_norm": 0.0067830472253263, + "elapsed": 656.7150173187256 + }, + { + "step": 992, + "loss": 0.6016548871994019, + "objective": 0.6016548871994019, + "error": 0.3564453125, + "gradient_norm": 0.04935981705784798, + "elapsed": 668.9989516735077 + }, + { + "step": 1008, + "loss": 0.1370980143547058, + "objective": 0.1370980143547058, + "error": 0.0546875, + "gradient_norm": 0.04418199881911278, + "elapsed": 677.3821382522583 + }, + { + "step": 1024, + "loss": 0.4085504412651062, + "objective": 0.4085504412651062, + "error": 0.19921875, + "gradient_norm": 0.07943295687437057, + "elapsed": 688.8395888805389 + }, + { + "step": 1040, + "loss": 0.34129297733306885, + "objective": 0.34129297733306885, + "error": 0.15625, + "gradient_norm": 0.04551500454545021, + "elapsed": 703.4613966941833 + }, + { + "step": 1056, + "loss": 0.5297085046768188, + "objective": 0.5297085046768188, + "error": 0.2705078125, + "gradient_norm": 0.06177444010972977, + "elapsed": 714.0862259864807 + }, + { + "step": 1072, + "loss": 0.3833361268043518, + "objective": 0.3833361268043518, + "error": 0.185546875, + "gradient_norm": 0.053057629615068436, + "elapsed": 724.1480000019073 + }, + { + "step": 1088, + "loss": 0.6497273445129395, + "objective": 0.6497273445129395, + "error": 0.421875, + "gradient_norm": 0.10790837556123734, + "elapsed": 735.8740057945251 + }, + { + "step": 1104, + "loss": 0.5393906831741333, + "objective": 0.5393906831741333, + "error": 0.2998046875, + "gradient_norm": 0.06015805900096893, + "elapsed": 743.9961709976196 + }, + { + "step": 1120, + "loss": 0.38553956151008606, + "objective": 0.38553956151008606, + "error": 0.1875, + "gradient_norm": 0.05357081815600395, + "elapsed": 753.2208635807037 + }, + { + "step": 1136, + "loss": 0.5478834509849548, + "objective": 0.5478834509849548, + "error": 0.2900390625, + "gradient_norm": 0.05761478468775749, + "elapsed": 761.3359644412994 + }, + { + "step": 1152, + "loss": 0.5732287168502808, + "objective": 0.5732287168502808, + "error": 0.341796875, + "gradient_norm": 0.07881136238574982, + "elapsed": 771.133172750473 + }, + { + "step": 1168, + "loss": 0.5174047946929932, + "objective": 0.5174047946929932, + "error": 0.29296875, + "gradient_norm": 0.07794999331235886, + "elapsed": 783.7084786891937 + }, + { + "step": 1184, + "loss": 0.5022754669189453, + "objective": 0.5022754669189453, + "error": 0.265625, + "gradient_norm": 0.05175226181745529, + "elapsed": 793.499255657196 + }, + { + "step": 1200, + "loss": 0.5698775053024292, + "objective": 0.5698775053024292, + "error": 0.34375, + "gradient_norm": 0.06385946273803711, + "elapsed": 804.970814704895 + }, + { + "step": 1216, + "loss": 0.6203033924102783, + "objective": 0.6203033924102783, + "error": 0.37109375, + "gradient_norm": 0.07393646240234375, + "elapsed": 816.1773698329926 + }, + { + "step": 1232, + "loss": 0.6154648065567017, + "objective": 0.6154648065567017, + "error": 0.3857421875, + "gradient_norm": 0.04278155043721199, + "elapsed": 827.3619928359985 + }, + { + "step": 1248, + "loss": 0.5948328971862793, + "objective": 0.5948328971862793, + "error": 0.3291015625, + "gradient_norm": 0.062024734914302826, + "elapsed": 838.8370804786682 + }, + { + "step": 1264, + "loss": 0.5644958019256592, + "objective": 0.5644958019256592, + "error": 0.3212890625, + "gradient_norm": 0.12030917406082153, + "elapsed": 849.5000331401825 + }, + { + "step": 1280, + "loss": 0.028782427310943604, + "objective": 0.028782427310943604, + "error": 0.0087890625, + "gradient_norm": 0.009096251800656319, + "elapsed": 857.8837285041809 + }, + { + "step": 1296, + "loss": 0.5129679441452026, + "objective": 0.5129679441452026, + "error": 0.2626953125, + "gradient_norm": 0.12833116948604584, + "elapsed": 868.5195860862732 + }, + { + "step": 1312, + "loss": 0.4095553159713745, + "objective": 0.4095553159713745, + "error": 0.193359375, + "gradient_norm": 0.09977155178785324, + "elapsed": 877.4712297916412 + }, + { + "step": 1328, + "loss": 0.2850862741470337, + "objective": 0.2850862741470337, + "error": 0.1240234375, + "gradient_norm": 0.05365074798464775, + "elapsed": 887.5133347511292 + }, + { + "step": 1344, + "loss": 0.41809165477752686, + "objective": 0.41809165477752686, + "error": 0.19140625, + "gradient_norm": 0.10622142255306244, + "elapsed": 895.0828025341034 + }, + { + "step": 1360, + "loss": 0.3627069890499115, + "objective": 0.3627069890499115, + "error": 0.1650390625, + "gradient_norm": 0.049557290971279144, + "elapsed": 906.2595431804657 + }, + { + "step": 1376, + "loss": 0.023341629654169083, + "objective": 0.023341629654169083, + "error": 0.0068359375, + "gradient_norm": 0.008970360271632671, + "elapsed": 916.6110022068024 + }, + { + "step": 1392, + "loss": 0.519214391708374, + "objective": 0.519214391708374, + "error": 0.26953125, + "gradient_norm": 0.052287619560956955, + "elapsed": 926.660523891449 + }, + { + "step": 1408, + "loss": 0.6152850389480591, + "objective": 0.6152850389480591, + "error": 0.3662109375, + "gradient_norm": 0.049617987126111984, + "elapsed": 936.7533056735992 + }, + { + "step": 1424, + "loss": 0.020841240882873535, + "objective": 0.020841240882873535, + "error": 0.0068359375, + "gradient_norm": 0.008459246717393398, + "elapsed": 946.8231542110443 + }, + { + "step": 1440, + "loss": 0.5963407754898071, + "objective": 0.5963407754898071, + "error": 0.3525390625, + "gradient_norm": 0.08714025467634201, + "elapsed": 956.0344398021698 + }, + { + "step": 1456, + "loss": 0.44305220246315, + "objective": 0.44305220246315, + "error": 0.2099609375, + "gradient_norm": 0.061915796250104904, + "elapsed": 967.506050825119 + }, + { + "step": 1472, + "loss": 0.5292993783950806, + "objective": 0.5292993783950806, + "error": 0.2939453125, + "gradient_norm": 0.10089804977178574, + "elapsed": 977.855934381485 + }, + { + "step": 1488, + "loss": 0.6087026596069336, + "objective": 0.6087026596069336, + "error": 0.345703125, + "gradient_norm": 0.05276322737336159, + "elapsed": 986.2705359458923 + }, + { + "step": 1504, + "loss": 0.3670162558555603, + "objective": 0.3670162558555603, + "error": 0.1796875, + "gradient_norm": 0.0575372576713562, + "elapsed": 995.2220902442932 + }, + { + "step": 1520, + "loss": 0.33479321002960205, + "objective": 0.33479321002960205, + "error": 0.1435546875, + "gradient_norm": 0.056317709386348724, + "elapsed": 1005.2168045043945 + }, + { + "step": 1536, + "loss": 0.5869293212890625, + "objective": 0.5869293212890625, + "error": 0.337890625, + "gradient_norm": 0.07419256865978241, + "elapsed": 1016.8691458702087 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved2_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "0f5926c94bb1aa83840c6d257757b80c081835affc2cb34bf9246ba18e00266a", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 467790, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18254, + "surface_code_bX_d5_r03_center_5_5": 18525, + "surface_code_bX_d5_r05_center_5_5": 18175, + "surface_code_bX_d5_r07_center_5_5": 18005, + "surface_code_bX_d5_r09_center_5_5": 18067, + "surface_code_bX_d5_r11_center_5_5": 18445, + "surface_code_bX_d5_r13_center_5_5": 18673, + "surface_code_bX_d5_r15_center_5_5": 17345, + "surface_code_bX_d5_r17_center_5_5": 17898, + "surface_code_bX_d5_r19_center_5_5": 18359, + "surface_code_bX_d5_r21_center_5_5": 18036, + "surface_code_bX_d5_r23_center_5_5": 17255, + "surface_code_bX_d5_r25_center_5_5": 18057, + "surface_code_bZ_d5_r01_center_5_5": 17596, + "surface_code_bZ_d5_r03_center_5_5": 18333, + "surface_code_bZ_d5_r05_center_5_5": 18250, + "surface_code_bZ_d5_r07_center_5_5": 18210, + "surface_code_bZ_d5_r09_center_5_5": 17447, + "surface_code_bZ_d5_r11_center_5_5": 18120, + "surface_code_bZ_d5_r13_center_5_5": 18224, + "surface_code_bZ_d5_r15_center_5_5": 17857, + "surface_code_bZ_d5_r17_center_5_5": 18359, + "surface_code_bZ_d5_r19_center_5_5": 17398, + "surface_code_bZ_d5_r21_center_5_5": 18235, + "surface_code_bZ_d5_r23_center_5_5": 16653, + "surface_code_bZ_d5_r25_center_5_5": 18014 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "2b00e3f258886b5c4ecf69f36fd5463a205eefc84bd10c550acc391e84515c24", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + } + }, + "selected_expert_checkpoints": { + "reserved1_full/1536": { + "step": 1536, + "training_samples": 1572864, + "unique_training_rows_seen_in_this_phase": 466919, + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "complete": true + }, + "reserved2_full/1024": { + "step": 1024, + "training_samples": 1048576, + "unique_training_rows_seen_in_this_phase": 428858, + "weights_sha256": "a346f535004381e2e0b628fac8ff7c58282a2447b9704638e46232dff46e511f", + "complete": true + } + }, + "changed_groups": [ + "d5_bX_center_5_5" + ], + "runtime_control": { + "status": "passed", + "device": "CPU", + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 1, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 3, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 4.0745362639427185e-09 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "old_path_exact": true, + "cached_mixture_exact": true, + "permutation_subset_exact": true, + "cpu_recompute_vs_gpu_cache_max_difference": 4.76837158203125e-07 + } + ], + "seconds": 11.00676155090332, + "gate_parameters": "Synthetic random control state, excluded from fitting/selection/submission", + "sources": { + "contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "reserved_contextual.py": "8e3274896738f9dca23812b59676dcf3f96d15167a83702ee88a335af71ce2d1", + "reserved_gate.py": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1" + }, + "test_data_used": false + }, + "source_snapshot": "training_sources/reserved_gate1", + "selection_frozen_before_audit": true, + "independent_label_audit": { + "scope": "13312 randomly reserved supplied-training shots, excluded from both experts and the gate; all26d5 conditions", + "independence_scope": "Reserved logical labels are excluded from fitting and selection. The supplied even-fitted detector error models use all even syndromes, including these rows, as authorized by the benchmark.", + "selection_frozen_sha256": "99a5cdf3fa0258317d9dfbfeaf1ece2d9b33165968d5d82f1fdabd708fb8026d", + "selected_settings": { + "X": "equal-two", + "Z": "equal-two" + }, + "aggregate": { + "expert1": { + "failure": 0.22265625, + "negative_log_likelihood": 0.4219864913275091 + }, + "expert2": { + "failure": 0.2225060096153846, + "negative_log_likelihood": 0.42128344862713507 + }, + "physical": { + "failure": 0.22994290865384615, + "negative_log_likelihood": 0.43131594007437485 + }, + "equal-two": { + "failure": 0.22198016826923078, + "negative_log_likelihood": 0.4210906160117033 + }, + "equal-three": { + "failure": 0.22370793269230768, + "negative_log_likelihood": 0.4221742717028922 + }, + "validation-selected-new-mixture": { + "failure": 0.22198016826923078, + "negative_log_likelihood": 0.4210906160117033 + } + }, + "net_errors_saved_vs_equal_two": 0, + "paired_independent_shot_standard_error_of_failure_difference": 0.0, + "uncertainty": "Descriptive paired standard error ignores possible shot dependence; this is an independent training-period diagnostic, not benchmark test performance", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "basis": "X", + "rounds": 1, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017090894259712216 + }, + "expert2": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017530182758415357 + }, + "physical": { + "failure": 0.00390625, + "negative_log_likelihood": 0.018763942117481763 + }, + "equal-two": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017303048111761553 + }, + "equal-three": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017723361498233198 + }, + "validation-selected-new-mixture": { + "failure": 0.00390625, + "negative_log_likelihood": 0.017303048111761553 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "basis": "X", + "rounds": 3, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.0703125, + "negative_log_likelihood": 0.16951059581112987 + }, + "expert2": { + "failure": 0.072265625, + "negative_log_likelihood": 0.17178756570474207 + }, + "physical": { + "failure": 0.076171875, + "negative_log_likelihood": 0.1798030054727182 + }, + "equal-two": { + "failure": 0.07421875, + "negative_log_likelihood": 0.17044986332352885 + }, + "equal-three": { + "failure": 0.076171875, + "negative_log_likelihood": 0.17250924829385533 + }, + "validation-selected-new-mixture": { + "failure": 0.07421875, + "negative_log_likelihood": 0.17044986332352885 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "basis": "X", + "rounds": 5, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.125, + "negative_log_likelihood": 0.26702956175276915 + }, + "expert2": { + "failure": 0.134765625, + "negative_log_likelihood": 0.2720239127120352 + }, + "physical": { + "failure": 0.12890625, + "negative_log_likelihood": 0.26716168642720345 + }, + "equal-two": { + "failure": 0.130859375, + "negative_log_likelihood": 0.2689265402494294 + }, + "equal-three": { + "failure": 0.12890625, + "negative_log_likelihood": 0.2666494803871213 + }, + "validation-selected-new-mixture": { + "failure": 0.130859375, + "negative_log_likelihood": 0.2689265402494294 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "basis": "X", + "rounds": 7, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.119140625, + "negative_log_likelihood": 0.28393399589383805 + }, + "expert2": { + "failure": 0.115234375, + "negative_log_likelihood": 0.2840000544441788 + }, + "physical": { + "failure": 0.126953125, + "negative_log_likelihood": 0.2969495620179671 + }, + "equal-two": { + "failure": 0.11328125, + "negative_log_likelihood": 0.28365364452835035 + }, + "equal-three": { + "failure": 0.115234375, + "negative_log_likelihood": 0.28484553303444526 + }, + "validation-selected-new-mixture": { + "failure": 0.11328125, + "negative_log_likelihood": 0.28365364452835035 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "basis": "X", + "rounds": 9, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.15234375, + "negative_log_likelihood": 0.3574806876617698 + }, + "expert2": { + "failure": 0.16015625, + "negative_log_likelihood": 0.36484337562384905 + }, + "physical": { + "failure": 0.154296875, + "negative_log_likelihood": 0.3773754577932747 + }, + "equal-two": { + "failure": 0.15234375, + "negative_log_likelihood": 0.36069278441676156 + }, + "equal-three": { + "failure": 0.154296875, + "negative_log_likelihood": 0.3626910613965446 + }, + "validation-selected-new-mixture": { + "failure": 0.15234375, + "negative_log_likelihood": 0.36069278441676156 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "basis": "X", + "rounds": 11, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.232421875, + "negative_log_likelihood": 0.46124590270993926 + }, + "expert2": { + "failure": 0.2265625, + "negative_log_likelihood": 0.4613963481795015 + }, + "physical": { + "failure": 0.234375, + "negative_log_likelihood": 0.4722622135305079 + }, + "equal-two": { + "failure": 0.23046875, + "negative_log_likelihood": 0.4606735958370106 + }, + "equal-three": { + "failure": 0.22265625, + "negative_log_likelihood": 0.46133910500738035 + }, + "validation-selected-new-mixture": { + "failure": 0.23046875, + "negative_log_likelihood": 0.4606735958370106 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "basis": "X", + "rounds": 13, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.265625, + "negative_log_likelihood": 0.4750318522643912 + }, + "expert2": { + "failure": 0.2578125, + "negative_log_likelihood": 0.4769788330146994 + }, + "physical": { + "failure": 0.2578125, + "negative_log_likelihood": 0.4916785267143769 + }, + "equal-two": { + "failure": 0.259765625, + "negative_log_likelihood": 0.4753582401528184 + }, + "equal-three": { + "failure": 0.259765625, + "negative_log_likelihood": 0.4764091488487066 + }, + "validation-selected-new-mixture": { + "failure": 0.259765625, + "negative_log_likelihood": 0.4753582401528184 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "basis": "X", + "rounds": 15, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.291015625, + "negative_log_likelihood": 0.5275047416665599 + }, + "expert2": { + "failure": 0.296875, + "negative_log_likelihood": 0.5308153878240705 + }, + "physical": { + "failure": 0.29296875, + "negative_log_likelihood": 0.5538887122415014 + }, + "equal-two": { + "failure": 0.287109375, + "negative_log_likelihood": 0.528540517342001 + }, + "equal-three": { + "failure": 0.28125, + "negative_log_likelihood": 0.5333872322093647 + }, + "validation-selected-new-mixture": { + "failure": 0.287109375, + "negative_log_likelihood": 0.528540517342001 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "basis": "X", + "rounds": 17, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.291015625, + "negative_log_likelihood": 0.5444426881972075 + }, + "expert2": { + "failure": 0.314453125, + "negative_log_likelihood": 0.5403884740065296 + }, + "physical": { + "failure": 0.296875, + "negative_log_likelihood": 0.5452648658851407 + }, + "equal-two": { + "failure": 0.298828125, + "negative_log_likelihood": 0.5417565948446685 + }, + "equal-three": { + "failure": 0.310546875, + "negative_log_likelihood": 0.5396094226965553 + }, + "validation-selected-new-mixture": { + "failure": 0.298828125, + "negative_log_likelihood": 0.5417565948446685 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "basis": "X", + "rounds": 19, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.3359375, + "negative_log_likelihood": 0.5948284537365178 + }, + "expert2": { + "failure": 0.3359375, + "negative_log_likelihood": 0.5892668837248777 + }, + "physical": { + "failure": 0.34375, + "negative_log_likelihood": 0.5978877763854513 + }, + "equal-two": { + "failure": 0.33203125, + "negative_log_likelihood": 0.591497491689464 + }, + "equal-three": { + "failure": 0.341796875, + "negative_log_likelihood": 0.5905302738463256 + }, + "validation-selected-new-mixture": { + "failure": 0.33203125, + "negative_log_likelihood": 0.591497491689464 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "basis": "X", + "rounds": 21, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.322265625, + "negative_log_likelihood": 0.6106869085573896 + }, + "expert2": { + "failure": 0.3046875, + "negative_log_likelihood": 0.6069554627640222 + }, + "physical": { + "failure": 0.349609375, + "negative_log_likelihood": 0.6312240521835084 + }, + "equal-two": { + "failure": 0.31640625, + "negative_log_likelihood": 0.6082673941419213 + }, + "equal-three": { + "failure": 0.33203125, + "negative_log_likelihood": 0.611988588131164 + }, + "validation-selected-new-mixture": { + "failure": 0.31640625, + "negative_log_likelihood": 0.6082673941419213 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "basis": "X", + "rounds": 23, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.373046875, + "negative_log_likelihood": 0.6185610303038827 + }, + "expert2": { + "failure": 0.359375, + "negative_log_likelihood": 0.6190691020479929 + }, + "physical": { + "failure": 0.376953125, + "negative_log_likelihood": 0.6370231759455196 + }, + "equal-two": { + "failure": 0.369140625, + "negative_log_likelihood": 0.6183673885171153 + }, + "equal-three": { + "failure": 0.365234375, + "negative_log_likelihood": 0.6215949225722667 + }, + "validation-selected-new-mixture": { + "failure": 0.369140625, + "negative_log_likelihood": 0.6183673885171153 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "basis": "X", + "rounds": 25, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.376953125, + "negative_log_likelihood": 0.6148529971657384 + }, + "expert2": { + "failure": 0.37890625, + "negative_log_likelihood": 0.6128175575654213 + }, + "physical": { + "failure": 0.39453125, + "negative_log_likelihood": 0.6214592551904651 + }, + "equal-two": { + "failure": 0.37890625, + "negative_log_likelihood": 0.6134261125432341 + }, + "equal-three": { + "failure": 0.38671875, + "negative_log_likelihood": 0.6138887320756413 + }, + "validation-selected-new-mixture": { + "failure": 0.37890625, + "negative_log_likelihood": 0.6134261125432341 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "basis": "Z", + "rounds": 1, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.009765625, + "negative_log_likelihood": 0.038550540341371745 + }, + "expert2": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03797109655241983 + }, + "physical": { + "failure": 0.009765625, + "negative_log_likelihood": 0.040172127018857376 + }, + "equal-two": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03824321962665776 + }, + "equal-three": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03878602821028987 + }, + "validation-selected-new-mixture": { + "failure": 0.009765625, + "negative_log_likelihood": 0.03824321962665776 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "basis": "Z", + "rounds": 3, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.048828125, + "negative_log_likelihood": 0.13420470725766703 + }, + "expert2": { + "failure": 0.046875, + "negative_log_likelihood": 0.13194703132227217 + }, + "physical": { + "failure": 0.05078125, + "negative_log_likelihood": 0.1393875784610577 + }, + "equal-two": { + "failure": 0.048828125, + "negative_log_likelihood": 0.132766538296753 + }, + "equal-three": { + "failure": 0.05078125, + "negative_log_likelihood": 0.1343440297556426 + }, + "validation-selected-new-mixture": { + "failure": 0.048828125, + "negative_log_likelihood": 0.132766538296753 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "basis": "Z", + "rounds": 5, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.111328125, + "negative_log_likelihood": 0.2288585539609661 + }, + "expert2": { + "failure": 0.119140625, + "negative_log_likelihood": 0.22620558200243668 + }, + "physical": { + "failure": 0.11328125, + "negative_log_likelihood": 0.23821912848106855 + }, + "equal-two": { + "failure": 0.119140625, + "negative_log_likelihood": 0.22711330308351269 + }, + "equal-three": { + "failure": 0.11328125, + "negative_log_likelihood": 0.22935571518464187 + }, + "validation-selected-new-mixture": { + "failure": 0.119140625, + "negative_log_likelihood": 0.22711330308351269 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "basis": "Z", + "rounds": 7, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.1484375, + "negative_log_likelihood": 0.35045084350305566 + }, + "expert2": { + "failure": 0.142578125, + "negative_log_likelihood": 0.3410553629080602 + }, + "physical": { + "failure": 0.150390625, + "negative_log_likelihood": 0.3561979174511046 + }, + "equal-two": { + "failure": 0.14453125, + "negative_log_likelihood": 0.3445969625556094 + }, + "equal-three": { + "failure": 0.15234375, + "negative_log_likelihood": 0.3465247486817157 + }, + "validation-selected-new-mixture": { + "failure": 0.14453125, + "negative_log_likelihood": 0.3445969625556094 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "basis": "Z", + "rounds": 9, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.193359375, + "negative_log_likelihood": 0.3799049479130148 + }, + "expert2": { + "failure": 0.1953125, + "negative_log_likelihood": 0.3799510170481319 + }, + "physical": { + "failure": 0.205078125, + "negative_log_likelihood": 0.3858862521076333 + }, + "equal-two": { + "failure": 0.19140625, + "negative_log_likelihood": 0.37915749635591545 + }, + "equal-three": { + "failure": 0.19140625, + "negative_log_likelihood": 0.37935857276130736 + }, + "validation-selected-new-mixture": { + "failure": 0.19140625, + "negative_log_likelihood": 0.37915749635591545 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "basis": "Z", + "rounds": 11, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.228515625, + "negative_log_likelihood": 0.4795969526765531 + }, + "expert2": { + "failure": 0.234375, + "negative_log_likelihood": 0.4789140470085718 + }, + "physical": { + "failure": 0.236328125, + "negative_log_likelihood": 0.49341552659884924 + }, + "equal-two": { + "failure": 0.23828125, + "negative_log_likelihood": 0.4782844991105801 + }, + "equal-three": { + "failure": 0.234375, + "negative_log_likelihood": 0.47987928764039417 + }, + "validation-selected-new-mixture": { + "failure": 0.23828125, + "negative_log_likelihood": 0.4782844991105801 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "basis": "Z", + "rounds": 13, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.224609375, + "negative_log_likelihood": 0.43937554398477136 + }, + "expert2": { + "failure": 0.224609375, + "negative_log_likelihood": 0.4399126222895116 + }, + "physical": { + "failure": 0.236328125, + "negative_log_likelihood": 0.443789110862745 + }, + "equal-two": { + "failure": 0.2265625, + "negative_log_likelihood": 0.43901392764953234 + }, + "equal-three": { + "failure": 0.228515625, + "negative_log_likelihood": 0.43857847342118456 + }, + "validation-selected-new-mixture": { + "failure": 0.2265625, + "negative_log_likelihood": 0.43901392764953234 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "basis": "Z", + "rounds": 15, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.228515625, + "negative_log_likelihood": 0.48160554977293224 + }, + "expert2": { + "failure": 0.25, + "negative_log_likelihood": 0.4820924709840312 + }, + "physical": { + "failure": 0.234375, + "negative_log_likelihood": 0.4826623880733387 + }, + "equal-two": { + "failure": 0.24609375, + "negative_log_likelihood": 0.481233806415451 + }, + "equal-three": { + "failure": 0.2265625, + "negative_log_likelihood": 0.47960647657889843 + }, + "validation-selected-new-mixture": { + "failure": 0.24609375, + "negative_log_likelihood": 0.481233806415451 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "basis": "Z", + "rounds": 17, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.259765625, + "negative_log_likelihood": 0.5466166697019426 + }, + "expert2": { + "failure": 0.251953125, + "negative_log_likelihood": 0.5398671697628821 + }, + "physical": { + "failure": 0.294921875, + "negative_log_likelihood": 0.5660913072892866 + }, + "equal-two": { + "failure": 0.25, + "negative_log_likelihood": 0.5425301452794579 + }, + "equal-three": { + "failure": 0.275390625, + "negative_log_likelihood": 0.5478310998814211 + }, + "validation-selected-new-mixture": { + "failure": 0.25, + "negative_log_likelihood": 0.5425301452794579 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "basis": "Z", + "rounds": 19, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.30859375, + "negative_log_likelihood": 0.5655635506734258 + }, + "expert2": { + "failure": 0.310546875, + "negative_log_likelihood": 0.5681193038458382 + }, + "physical": { + "failure": 0.333984375, + "negative_log_likelihood": 0.5729767379746973 + }, + "equal-two": { + "failure": 0.30859375, + "negative_log_likelihood": 0.5661764057670509 + }, + "equal-three": { + "failure": 0.3046875, + "negative_log_likelihood": 0.5664520523054867 + }, + "validation-selected-new-mixture": { + "failure": 0.30859375, + "negative_log_likelihood": 0.5661764057670509 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "basis": "Z", + "rounds": 21, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.341796875, + "negative_log_likelihood": 0.5861600809583261 + }, + "expert2": { + "failure": 0.34375, + "negative_log_likelihood": 0.5787440828303073 + }, + "physical": { + "failure": 0.353515625, + "negative_log_likelihood": 0.6075796127135422 + }, + "equal-two": { + "failure": 0.353515625, + "negative_log_likelihood": 0.5817604918541285 + }, + "equal-three": { + "failure": 0.349609375, + "negative_log_likelihood": 0.5878103360696245 + }, + "validation-selected-new-mixture": { + "failure": 0.353515625, + "negative_log_likelihood": 0.5817604918541285 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "basis": "Z", + "rounds": 23, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.36328125, + "negative_log_likelihood": 0.5797032207789384 + }, + "expert2": { + "failure": 0.34765625, + "negative_log_likelihood": 0.5796550113024783 + }, + "physical": { + "failure": 0.3359375, + "negative_log_likelihood": 0.5773577505747061 + }, + "equal-two": { + "failure": 0.34765625, + "negative_log_likelihood": 0.5790676826897196 + }, + "equal-three": { + "failure": 0.33984375, + "negative_log_likelihood": 0.576848055206876 + }, + "validation-selected-new-mixture": { + "failure": 0.34765625, + "negative_log_likelihood": 0.5790676826897196 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "basis": "Z", + "rounds": 25, + "shots": 512, + "selected_on_supplied_validation": "equal-two", + "metrics": { + "expert1": { + "failure": 0.36328125, + "negative_log_likelihood": 0.6188573030114262 + }, + "expert2": { + "failure": 0.34765625, + "negative_log_likelihood": 0.6210617260782341 + }, + "physical": { + "failure": 0.38671875, + "negative_log_likelihood": 0.6197367724217436 + }, + "equal-two": { + "failure": 0.33984375, + "negative_log_likelihood": 0.6194983219218514 + }, + "equal-three": { + "failure": 0.361328125, + "negative_log_likelihood": 0.6179900785801107 + }, + "validation-selected-new-mixture": { + "failure": 0.33984375, + "negative_log_likelihood": 0.6194983219218514 + } + }, + "corrected_vs_equal_two": 0, + "introduced_vs_equal_two": 0 + } + ], + "used_for_fitting_or_selection": false, + "test_data_used": false, + "source_sha256": "7b8d03717f5fbfd28eec2cca0dd6a59ee7af63ee7bc7cc7c672022f9e96a6779" + }, + "test_data_used": false + }, + "package_validation": { + "performance": 0.7672475961538461, + "failure_by_distance": { + "d3": 0.2398212139423077, + "d5": 0.22568359375 + }, + "scorer": "Supplied qecbench.scoring on all 130 validation conditions and 665600 shots", + "contract_checks": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "shots": 1, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r25_center_5_3", + "shots": 37, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r13_center_5_7", + "shots": 1025, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 7, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 257, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 17, + "maximum_probability_difference": 0.0 + } + ], + "prediction_generation": "All26 d5 conditions replayed from the assembled package; unchanged d3 predictions retained. Full trusted scoring and relocated arbitrary-ID/subset checks.", + "runtime_evidence": "Full133120-shot d5 replay took 342.34s on one H100; d3 paths unchanged from the recorded incumbent.", + "d5_validation_runtime_seconds": 342.34057784080505, + "runtime_vs_cached": { + "scope": "Assembled runtime versus cached candidate predictions, including physical-prior recomputation and compilation/batching differences; descriptive, not a causal precision attribution", + "maximum_probability_difference": 6.0498714447021484e-05, + "decision_differences": 1, + "source_sha256": "2e3e81d122f9d626d486d050c38d86bfd3e55bc6cd8e0e270b9e8eabbf69539a" + }, + "contract_execution": { + "requested_verifier_uid": 10001, + "effective_uid": 1000, + "effective_gid": 1000, + "supplementary_groups": [], + "identity_status": "Development process is already unprivileged and cannot change UID; verifier UID10001 was not executed", + "model_and_input_copy": "Owned by development UID 1000,directories0555,files0444,relocated under a fresh accessible temporary parent", + "output_directory": "Owned by execution UID 1000,mode0700", + "PYTHONPATH": "", + "backend": "Runtime default; full selected subset cases", + "scope": "Local contract check; not a Docker/network/mount-isolation test" + } + } + }, + "selection": "Choose each group new raw checkpoint by full-validation mean failure, earlier listed checkpoint wins ties; compare incumbent with fixed equal old/new temporal average and its equal small-contextual blend across all13 durations", + "history": [ + { + "group": "d3_bX_center_3_5", + "new_raw_checkpoint_failures": { + "mean2": 0.24606370192307692, + "mean3": 0.2459735576923077 + }, + "new_raw_checkpoint": "mean3", + "candidates": { + "incumbent": 0.2444110576923077, + "equal-temporal": 0.24516225961538465, + "equal-temporal-small": 0.24615384615384617 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_3", + "new_raw_checkpoint_failures": { + "mean2": 0.25446213942307694, + "mean3": 0.25443209134615385 + }, + "new_raw_checkpoint": "mean3", + "candidates": { + "incumbent": 0.2526592548076923, + "equal-temporal": 0.2533954326923077, + "equal-temporal-small": 0.2537109375 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_5_7", + "new_raw_checkpoint_failures": { + "mean2": 0.23493088942307694, + "mean3": 0.23461538461538461 + }, + "new_raw_checkpoint": "mean3", + "candidates": { + "incumbent": 0.233203125, + "equal-temporal": 0.2339092548076923, + "equal-temporal-small": 0.2338641826923077 + }, + "selected": "incumbent" + }, + { + "group": "d3_bX_center_7_5", + "new_raw_checkpoint_failures": { + "mean2": 0.23937800480769234, + "mean3": 0.23886718750000002 + }, + "new_raw_checkpoint": "mean3", + "candidates": { + "incumbent": 0.23880709134615385, + "equal-temporal": 0.2385667067307692, + "equal-temporal-small": 0.23901742788461539 + }, + "selected": "equal-temporal" + }, + { + "group": "d3_bZ_center_3_5", + "new_raw_checkpoint_failures": { + "mean2": 0.2459435096153846, + "mean3": 0.24672475961538462 + }, + "new_raw_checkpoint": "mean2", + "candidates": { + "incumbent": 0.24447115384615387, + "equal-temporal": 0.24526742788461536, + "equal-temporal-small": 0.24586838942307693 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_3", + "new_raw_checkpoint_failures": { + "mean2": 0.23780048076923077, + "mean3": 0.23737980769230768 + }, + "new_raw_checkpoint": "mean3", + "candidates": { + "incumbent": 0.23652343749999996, + "equal-temporal": 0.2369441105769231, + "equal-temporal-small": 0.23743990384615382 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_5_7", + "new_raw_checkpoint_failures": { + "mean2": 0.23716947115384618, + "mean3": 0.2373497596153846 + }, + "new_raw_checkpoint": "mean2", + "candidates": { + "incumbent": 0.2356670673076923, + "equal-temporal": 0.23614783653846153, + "equal-temporal-small": 0.23659855769230773 + }, + "selected": "incumbent" + }, + { + "group": "d3_bZ_center_7_5", + "new_raw_checkpoint_failures": { + "mean2": 0.2333383413461538, + "mean3": 0.23312800480769236 + }, + "new_raw_checkpoint": "mean3", + "candidates": { + "incumbent": 0.23266225961538464, + "equal-temporal": 0.23317307692307693, + "equal-temporal-small": 0.2332481971153846 + }, + "selected": "incumbent" + } + ], + "runtime_control": { + "status": "passed", + "device": "CPU", + "cases": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "shots": 1, + "old_path_exact": true, + "mixture_exact": true, + "order_and_singleton_exact": true + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 7, + "old_path_exact": true, + "mixture_exact": true, + "order_and_singleton_exact": true + }, + { + "condition": "surface_code_bX_d3_r25_center_3_5", + "shots": 3, + "old_path_exact": true, + "mixture_exact": true, + "order_and_singleton_exact": true + } + ], + "sources": { + "temporal_contextual.py": "5cdd9c9bdaf0bb526cd7922ce1a990d1206a4bfba72dc76751cd3a09964ad95d", + "temporal_ensemble_contextual.py": "0ecb0608637d040b2d167953403a230f659886663df884348011959427edec98", + "temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186" + }, + "test_data_used": false + }, + "test_data_used": false + }, + "joint_mixture1": { + "declared_plan": { + "hypothesis": "Joint logical-likelihood training may learn useful shot-dependent complementarity beyond frozen independent expert averages", + "parents": [ + "fresh2_full/weights-1536.npz", + "reserved1_full/weights-1536.npz" + ], + "initialization": "Both experts retain their session-trained parameters and exact Adam moments/count2048; new41-input32-hidden SiLU gate has random hidden weights(seed20261310),zero output and bias,giving equal mixture", + "features": "Gate uses only24site densities,lag1/2/4/8coincidence/covariance,6density/frame summaries,duration/duration_squared/basis;fixed numeric scales,no fitted normalization,no IDs/labels/shot positions/expert probabilities", + "loss": "Logical BCE of two-expert probability mixture; expert BCE adjoints weighted by posterior responsibility,free gate-logit adjoint=coefficient-responsibility; gradients controlled against independent autodiff", + "training": "2048updates B1024;uniform sampling over all516880training rows/26conditions(seed20261311);sharedphysicalpass3 priors;expertLR.0001,gateLR.001;separate AdamW clocks,moments restored for experts,freshgate count0;one joint norm1 clip,decay1e-4", + "selection_steps": [ + 0, + 512, + 1024, + 2048 + ], + "validation": "Full133120 supplied validation shots per listed checkpoint; perbasis choose incumbent or rawjoint/equalphysical,all13durations; tiesretainincumbent. Step0 is fixedmean of trainedparents.1536has screening only and is not a full-selection checkpoint.", + "audit_scope": "All training labels are eligible; no independent reserved-training-label audit claim. Parent initialization provenance retained.", + "controls": "CPUscalar finite differences,exactchain autodiff,feature order/subset checks; two-update serialization/resume/sampling/Adam controls; portableCPUruntime;GPUactualgeometrygradient control before training", + "runtime": "Two exact neural passes share one physical-prior computation; preserve all retained incumbent dispatches;fullreplay/scoring/readonlyrelocation/projection before any publication", + "interpretation": "Learned branches are not identified physical noise regimes; this is a joint model recipe,not an isolated causal test of gating", + "gpu": "One H100,serialized afterfresh_temporal1_finished", + "test_data_used": false, + "parameter_counts": { + "expert0": 29505, + "expert1": 29505, + "gate": 1377, + "total": 60387 + }, + "physical_blend_clarification_before_training": "Equal physical blends use the existing calibrated/ensemble physical pass3 decoder output from turbo1/predictions, checked against runtime config and DEM/plans/weights. Raw feedback5_cache pass3 is only the neural conditioning prior/diagnostic. Corrected before any GPU training or selection in this study." + }, + "physical_blend_reference": { + "package": "/run-state/workspace/research/context_upgrades/turbo1/package", + "predictions": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "component": "Existing physical pass3 decoder output, including its training-fitted calibration/ensemble; exactly the hybrid3.py blend_turbo path", + "verified_config": "turbo settings equal; physical DEM/plans and calibration/ensemble weights have identical SHA256", + "verified_files": [ + "dems/surface_code_bX_d5_r01_center_5_5.dem", + "dems/surface_code_bX_d5_r03_center_5_5.dem", + "dems/surface_code_bX_d5_r05_center_5_5.dem", + "dems/surface_code_bX_d5_r07_center_5_5.dem", + "dems/surface_code_bX_d5_r09_center_5_5.dem", + "dems/surface_code_bX_d5_r11_center_5_5.dem", + "dems/surface_code_bX_d5_r13_center_5_5.dem", + "dems/surface_code_bX_d5_r15_center_5_5.dem", + "dems/surface_code_bX_d5_r17_center_5_5.dem", + "dems/surface_code_bX_d5_r19_center_5_5.dem", + "dems/surface_code_bX_d5_r21_center_5_5.dem", + "dems/surface_code_bX_d5_r23_center_5_5.dem", + "dems/surface_code_bX_d5_r25_center_5_5.dem", + "dems/surface_code_bZ_d5_r01_center_5_5.dem", + "dems/surface_code_bZ_d5_r03_center_5_5.dem", + "dems/surface_code_bZ_d5_r05_center_5_5.dem", + "dems/surface_code_bZ_d5_r07_center_5_5.dem", + "dems/surface_code_bZ_d5_r09_center_5_5.dem", + "dems/surface_code_bZ_d5_r11_center_5_5.dem", + "dems/surface_code_bZ_d5_r13_center_5_5.dem", + "dems/surface_code_bZ_d5_r15_center_5_5.dem", + "dems/surface_code_bZ_d5_r17_center_5_5.dem", + "dems/surface_code_bZ_d5_r19_center_5_5.dem", + "dems/surface_code_bZ_d5_r21_center_5_5.dem", + "dems/surface_code_bZ_d5_r23_center_5_5.dem", + "dems/surface_code_bZ_d5_r25_center_5_5.dem", + "plans/surface_code_bX_d5_r01_center_5_5.npz", + "plans/surface_code_bZ_d5_r01_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r03_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r05_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r07_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r09_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r11_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r13_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r15_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r17_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r19_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r21_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r23_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r25_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r05_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r07_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r09_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r11_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r13_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r15_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r17_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r19_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r21_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r23_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r25_center_5_5.npz", + "weights/turbo1-d5_bX_center_5_5.npz", + "weights/turbo1-d5_bZ_center_5_5.npz" + ], + "clarification": "Use these ID-aligned probabilities, not the raw pass3 column in feedback5_cache. Physical priors supplied to neural networks remain unchanged." + }, + "selection_history": [ + { + "basis": "X", + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23183593749999998, + "0-physical0": 0.23249699519230768, + "0-physical0.5": 0.2334435096153846, + "512-physical0": 0.23225661057692307, + "512-physical0.5": 0.23267728365384616, + "1024-physical0": 0.23168569711538464, + "1024-physical0.5": 0.2324669471153846, + "2048-physical0": 0.2327824519230769, + "2048-physical0.5": 0.23300781249999997 + }, + "selected": "1024-physical0" + }, + { + "basis": "Z", + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "0-physical0": 0.2207481971153846, + "0-physical0.5": 0.2204176682692308, + "512-physical0": 0.2205378605769231, + "512-physical0.5": 0.2205528846153846, + "1024-physical0": 0.22104867788461538, + "1024-physical0.5": 0.2200420673076923, + "2048-physical0": 0.22035757211538462, + "2048-physical0.5": 0.2203876201923077 + }, + "selected": "incumbent" + } + ], + "selected_checkpoints": { + "1024": { + "step": 1024, + "training_draws": 1048576, + "adam_counts": { + "expert0": 3072, + "expert1": 3072, + "gate": 1024 + }, + "distinct_phase_rows": 446971, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 17445, + "surface_code_bX_d5_r03_center_5_5": 17875, + "surface_code_bX_d5_r05_center_5_5": 16246, + "surface_code_bX_d5_r07_center_5_5": 16070, + "surface_code_bX_d5_r09_center_5_5": 16429, + "surface_code_bX_d5_r11_center_5_5": 17791, + "surface_code_bX_d5_r13_center_5_5": 17193, + "surface_code_bX_d5_r15_center_5_5": 17571, + "surface_code_bX_d5_r17_center_5_5": 17502, + "surface_code_bX_d5_r19_center_5_5": 17754, + "surface_code_bX_d5_r21_center_5_5": 17567, + "surface_code_bX_d5_r23_center_5_5": 16091, + "surface_code_bX_d5_r25_center_5_5": 17260, + "surface_code_bZ_d5_r01_center_5_5": 16790, + "surface_code_bZ_d5_r03_center_5_5": 17857, + "surface_code_bZ_d5_r05_center_5_5": 17484, + "surface_code_bZ_d5_r07_center_5_5": 17491, + "surface_code_bZ_d5_r09_center_5_5": 16204, + "surface_code_bZ_d5_r11_center_5_5": 17217, + "surface_code_bZ_d5_r13_center_5_5": 18278, + "surface_code_bZ_d5_r15_center_5_5": 17617, + "surface_code_bZ_d5_r17_center_5_5": 16049, + "surface_code_bZ_d5_r19_center_5_5": 17173, + "surface_code_bZ_d5_r21_center_5_5": 17037, + "surface_code_bZ_d5_r23_center_5_5": 17805, + "surface_code_bZ_d5_r25_center_5_5": 17175 + }, + "weights_sha256": "d3193fe31df6de065d5f9c45edccb24076c9635c52711920feabfc03cf82c8e3", + "complete": true + } + }, + "training": { + "run_config": { + "parents": [ + "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz" + ], + "output": "/run-state/workspace/research/learned_d5/joint_mixture1", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "resume": null, + "steps": 2048, + "batch": 1024, + "expert_lr": 0.0001, + "gate_lr": 0.001, + "gate_seed": 20261310, + "seed": 20261311, + "eval_every": 512, + "validation_shots": 1024, + "validation_batch": 512, + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "learned_d5__joint_mixture_state.py": "44e6815f769c02cf2d19e3ad1e33e6f287df8b5ea33f5c87b747361ea41f3dc6", + "learned_d5__joint_mixture_train.py": "048eb44389f53acc00d51da4914ef9404f6d774b915f8805a0102d707599c483", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "initialization": "Both experts copied with exact Adam state from declared session-trained parents; new gate has random hidden weights and zero output, giving equal initial mixture", + "sampling": "Fresh seed for joint study; resumed phases restore only their own saved sampling state", + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3" + } + }, + "parent_provenance": [ + { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 491030, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18670, + "surface_code_bX_d5_r03_center_5_5": 18940, + "surface_code_bX_d5_r05_center_5_5": 19128, + "surface_code_bX_d5_r07_center_5_5": 18988, + "surface_code_bX_d5_r09_center_5_5": 18523, + "surface_code_bX_d5_r11_center_5_5": 19227, + "surface_code_bX_d5_r13_center_5_5": 18816, + "surface_code_bX_d5_r15_center_5_5": 18107, + "surface_code_bX_d5_r17_center_5_5": 18728, + "surface_code_bX_d5_r19_center_5_5": 18983, + "surface_code_bX_d5_r21_center_5_5": 18959, + "surface_code_bX_d5_r23_center_5_5": 19079, + "surface_code_bX_d5_r25_center_5_5": 19193, + "surface_code_bZ_d5_r01_center_5_5": 18828, + "surface_code_bZ_d5_r03_center_5_5": 18896, + "surface_code_bZ_d5_r05_center_5_5": 19011, + "surface_code_bZ_d5_r07_center_5_5": 18806, + "surface_code_bZ_d5_r09_center_5_5": 18268, + "surface_code_bZ_d5_r11_center_5_5": 18927, + "surface_code_bZ_d5_r13_center_5_5": 19399, + "surface_code_bZ_d5_r15_center_5_5": 19358, + "surface_code_bZ_d5_r17_center_5_5": 18634, + "surface_code_bZ_d5_r19_center_5_5": 19126, + "surface_code_bZ_d5_r21_center_5_5": 18603, + "surface_code_bZ_d5_r23_center_5_5": 18626, + "surface_code_bZ_d5_r25_center_5_5": 19207 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/fresh2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_warm/weights-512.npz", + "starting_checkpoint_sha256": "d3e3abba07693bd7fd3d17be2dd981d5b803a496e76ba230ed94afeb51f26f4f", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 325678, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 11962, + "surface_code_bX_d5_r03_center_5_5": 10232, + "surface_code_bX_d5_r05_center_5_5": 14014, + "surface_code_bX_d5_r07_center_5_5": 11594, + "surface_code_bX_d5_r09_center_5_5": 12805, + "surface_code_bX_d5_r11_center_5_5": 11644, + "surface_code_bX_d5_r13_center_5_5": 13845, + "surface_code_bX_d5_r15_center_5_5": 10703, + "surface_code_bX_d5_r17_center_5_5": 15460, + "surface_code_bX_d5_r19_center_5_5": 14156, + "surface_code_bX_d5_r21_center_5_5": 11568, + "surface_code_bX_d5_r23_center_5_5": 14156, + "surface_code_bX_d5_r25_center_5_5": 12021, + "surface_code_bZ_d5_r01_center_5_5": 10601, + "surface_code_bZ_d5_r03_center_5_5": 14135, + "surface_code_bZ_d5_r05_center_5_5": 11975, + "surface_code_bZ_d5_r07_center_5_5": 13841, + "surface_code_bZ_d5_r09_center_5_5": 12024, + "surface_code_bZ_d5_r11_center_5_5": 11151, + "surface_code_bZ_d5_r13_center_5_5": 10640, + "surface_code_bZ_d5_r15_center_5_5": 11089, + "surface_code_bZ_d5_r17_center_5_5": 13788, + "surface_code_bZ_d5_r19_center_5_5": 12350, + "surface_code_bZ_d5_r21_center_5_5": 12797, + "surface_code_bZ_d5_r23_center_5_5": 12809, + "surface_code_bZ_d5_r25_center_5_5": 14318 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261135", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6522030830383301, + "objective": 0.6522030830383301, + "error": 0.375, + "gradient_norm": 0.11649785190820694, + "elapsed": 30.089841604232788 + }, + { + "step": 16, + "loss": 0.5927819609642029, + "objective": 0.5927819609642029, + "error": 0.3466796875, + "gradient_norm": 0.07945127785205841, + "elapsed": 48.85365080833435 + }, + { + "step": 32, + "loss": 0.3115929663181305, + "objective": 0.3115929663181305, + "error": 0.13671875, + "gradient_norm": 0.039320655167102814, + "elapsed": 63.60312819480896 + }, + { + "step": 48, + "loss": 0.2456369698047638, + "objective": 0.2456369698047638, + "error": 0.1015625, + "gradient_norm": 0.029398636892437935, + "elapsed": 73.71074151992798 + }, + { + "step": 64, + "loss": 0.6231744885444641, + "objective": 0.6231744885444641, + "error": 0.3759765625, + "gradient_norm": 0.06867238879203796, + "elapsed": 83.75580954551697 + }, + { + "step": 80, + "loss": 0.3674217164516449, + "objective": 0.3674217164516449, + "error": 0.1572265625, + "gradient_norm": 0.0557992123067379, + "elapsed": 94.6383364200592 + }, + { + "step": 96, + "loss": 0.5152362585067749, + "objective": 0.5152362585067749, + "error": 0.2568359375, + "gradient_norm": 0.08284599334001541, + "elapsed": 106.90000939369202 + }, + { + "step": 112, + "loss": 0.020773420110344887, + "objective": 0.020773420110344887, + "error": 0.0048828125, + "gradient_norm": 0.008813572116196156, + "elapsed": 117.77558088302612 + }, + { + "step": 128, + "loss": 0.02593131735920906, + "objective": 0.02593131735920906, + "error": 0.0087890625, + "gradient_norm": 0.00872033555060625, + "elapsed": 128.93439435958862 + }, + { + "step": 144, + "loss": 0.5852900743484497, + "objective": 0.5852900743484497, + "error": 0.3291015625, + "gradient_norm": 0.04771002382040024, + "elapsed": 139.5588686466217 + }, + { + "step": 160, + "loss": 0.46074625849723816, + "objective": 0.46074625849723816, + "error": 0.232421875, + "gradient_norm": 0.08834747970104218, + "elapsed": 151.5595977306366 + }, + { + "step": 176, + "loss": 0.6310865879058838, + "objective": 0.6310865879058838, + "error": 0.376953125, + "gradient_norm": 0.14084596931934357, + "elapsed": 163.7892107963562 + }, + { + "step": 192, + "loss": 0.246865376830101, + "objective": 0.246865376830101, + "error": 0.1103515625, + "gradient_norm": 0.041402049362659454, + "elapsed": 174.28971648216248 + }, + { + "step": 208, + "loss": 0.3103577196598053, + "objective": 0.3103577196598053, + "error": 0.15625, + "gradient_norm": 0.04525696486234665, + "elapsed": 187.03909611701965 + }, + { + "step": 224, + "loss": 0.4523138999938965, + "objective": 0.4523138999938965, + "error": 0.208984375, + "gradient_norm": 0.09180521965026855, + "elapsed": 199.56195068359375 + }, + { + "step": 240, + "loss": 0.02241751179099083, + "objective": 0.02241751179099083, + "error": 0.009765625, + "gradient_norm": 0.009998111054301262, + "elapsed": 212.35500597953796 + }, + { + "step": 256, + "loss": 0.5487150549888611, + "objective": 0.5487150549888611, + "error": 0.294921875, + "gradient_norm": 0.12748055160045624, + "elapsed": 223.03854608535767 + }, + { + "step": 272, + "loss": 0.023057367652654648, + "objective": 0.023057367652654648, + "error": 0.0078125, + "gradient_norm": 0.006953821517527103, + "elapsed": 244.6508972644806 + }, + { + "step": 288, + "loss": 0.5845386981964111, + "objective": 0.5845386981964111, + "error": 0.330078125, + "gradient_norm": 0.06542652100324631, + "elapsed": 256.78167748451233 + }, + { + "step": 304, + "loss": 0.442532479763031, + "objective": 0.442532479763031, + "error": 0.232421875, + "gradient_norm": 0.10874580591917038, + "elapsed": 269.1364529132843 + }, + { + "step": 320, + "loss": 0.3264174163341522, + "objective": 0.3264174163341522, + "error": 0.15625, + "gradient_norm": 0.06276191771030426, + "elapsed": 282.38969564437866 + }, + { + "step": 336, + "loss": 0.386960506439209, + "objective": 0.386960506439209, + "error": 0.177734375, + "gradient_norm": 0.06561421602964401, + "elapsed": 292.9079031944275 + }, + { + "step": 352, + "loss": 0.23919886350631714, + "objective": 0.23919886350631714, + "error": 0.107421875, + "gradient_norm": 0.02755703590810299, + "elapsed": 304.16068935394287 + }, + { + "step": 368, + "loss": 0.5029175281524658, + "objective": 0.5029175281524658, + "error": 0.259765625, + "gradient_norm": 0.0378776490688324, + "elapsed": 315.11088514328003 + }, + { + "step": 384, + "loss": 0.565666675567627, + "objective": 0.565666675567627, + "error": 0.322265625, + "gradient_norm": 0.11368246376514435, + "elapsed": 324.3651068210602 + }, + { + "step": 400, + "loss": 0.5846428275108337, + "objective": 0.5846428275108337, + "error": 0.3408203125, + "gradient_norm": 0.08116643130779266, + "elapsed": 334.70786476135254 + }, + { + "step": 416, + "loss": 0.025111017748713493, + "objective": 0.025111017748713493, + "error": 0.0078125, + "gradient_norm": 0.008838560432195663, + "elapsed": 345.56963562965393 + }, + { + "step": 432, + "loss": 0.628488302230835, + "objective": 0.628488302230835, + "error": 0.3818359375, + "gradient_norm": 0.04001976177096367, + "elapsed": 355.3310384750366 + }, + { + "step": 448, + "loss": 0.4569575786590576, + "objective": 0.4569575786590576, + "error": 0.2578125, + "gradient_norm": 0.06344135850667953, + "elapsed": 367.05255675315857 + }, + { + "step": 464, + "loss": 0.49193111062049866, + "objective": 0.49193111062049866, + "error": 0.24609375, + "gradient_norm": 0.06022385507822037, + "elapsed": 377.38399291038513 + }, + { + "step": 480, + "loss": 0.5920064449310303, + "objective": 0.5920064449310303, + "error": 0.3466796875, + "gradient_norm": 0.036063045263290405, + "elapsed": 387.7266733646393 + }, + { + "step": 496, + "loss": 0.22157302498817444, + "objective": 0.22157302498817444, + "error": 0.09375, + "gradient_norm": 0.04071022942662239, + "elapsed": 397.78643012046814 + }, + { + "step": 512, + "loss": 0.39216887950897217, + "objective": 0.39216887950897217, + "error": 0.1728515625, + "gradient_norm": 0.09079446643590927, + "elapsed": 407.0137679576874 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6092928647994995, + "objective": 0.6092928647994995, + "error": 0.3583984375, + "gradient_norm": 0.08161187171936035, + "elapsed": 27.421262741088867 + }, + { + "step": 16, + "loss": 0.4709879755973816, + "objective": 0.4709879755973816, + "error": 0.2529296875, + "gradient_norm": 0.0541619211435318, + "elapsed": 48.74575757980347 + }, + { + "step": 32, + "loss": 0.5842419862747192, + "objective": 0.5842419862747192, + "error": 0.34375, + "gradient_norm": 0.09450904279947281, + "elapsed": 60.68022179603577 + }, + { + "step": 48, + "loss": 0.5840846300125122, + "objective": 0.5840846300125122, + "error": 0.32421875, + "gradient_norm": 0.04569687321782112, + "elapsed": 74.63272476196289 + }, + { + "step": 64, + "loss": 0.5139708518981934, + "objective": 0.5139708518981934, + "error": 0.2646484375, + "gradient_norm": 0.16111725568771362, + "elapsed": 91.88426613807678 + }, + { + "step": 80, + "loss": 0.49099838733673096, + "objective": 0.49099838733673096, + "error": 0.251953125, + "gradient_norm": 0.04431874305009842, + "elapsed": 105.08457684516907 + }, + { + "step": 96, + "loss": 0.30287861824035645, + "objective": 0.30287861824035645, + "error": 0.14453125, + "gradient_norm": 0.03792181238532066, + "elapsed": 118.16054177284241 + }, + { + "step": 112, + "loss": 0.6026535630226135, + "objective": 0.6026535630226135, + "error": 0.359375, + "gradient_norm": 0.043088704347610474, + "elapsed": 134.6414511203766 + }, + { + "step": 128, + "loss": 0.5983598828315735, + "objective": 0.5983598828315735, + "error": 0.328125, + "gradient_norm": 0.06492504477500916, + "elapsed": 148.38875198364258 + }, + { + "step": 144, + "loss": 0.616276204586029, + "objective": 0.616276204586029, + "error": 0.3857421875, + "gradient_norm": 0.05420554056763649, + "elapsed": 164.11315298080444 + }, + { + "step": 160, + "loss": 0.017882924526929855, + "objective": 0.017882924526929855, + "error": 0.0048828125, + "gradient_norm": 0.004682278726249933, + "elapsed": 178.31525373458862 + }, + { + "step": 176, + "loss": 0.5279660820960999, + "objective": 0.5279660820960999, + "error": 0.271484375, + "gradient_norm": 0.03895021602511406, + "elapsed": 192.20261907577515 + }, + { + "step": 192, + "loss": 0.5794406533241272, + "objective": 0.5794406533241272, + "error": 0.34375, + "gradient_norm": 0.041880734264850616, + "elapsed": 200.32051873207092 + }, + { + "step": 208, + "loss": 0.3353561758995056, + "objective": 0.3353561758995056, + "error": 0.1513671875, + "gradient_norm": 0.07022152841091156, + "elapsed": 212.5193521976471 + }, + { + "step": 224, + "loss": 0.47239983081817627, + "objective": 0.47239983081817627, + "error": 0.23828125, + "gradient_norm": 0.044771477580070496, + "elapsed": 223.36571788787842 + }, + { + "step": 240, + "loss": 0.6235381364822388, + "objective": 0.6235381364822388, + "error": 0.3779296875, + "gradient_norm": 0.047636937350034714, + "elapsed": 233.90032649040222 + }, + { + "step": 256, + "loss": 0.516319751739502, + "objective": 0.516319751739502, + "error": 0.271484375, + "gradient_norm": 0.087476447224617, + "elapsed": 245.52193427085876 + }, + { + "step": 272, + "loss": 0.23385891318321228, + "objective": 0.23385891318321228, + "error": 0.091796875, + "gradient_norm": 0.05921977758407593, + "elapsed": 254.38622951507568 + }, + { + "step": 288, + "loss": 0.31280556321144104, + "objective": 0.31280556321144104, + "error": 0.1318359375, + "gradient_norm": 0.03548427298665047, + "elapsed": 263.25871300697327 + }, + { + "step": 304, + "loss": 0.6208417415618896, + "objective": 0.6208417415618896, + "error": 0.361328125, + "gradient_norm": 0.10255666077136993, + "elapsed": 273.5115919113159 + }, + { + "step": 320, + "loss": 0.5985375642776489, + "objective": 0.5985375642776489, + "error": 0.3603515625, + "gradient_norm": 0.04024764895439148, + "elapsed": 285.4135670661926 + }, + { + "step": 336, + "loss": 0.028151696547865868, + "objective": 0.028151696547865868, + "error": 0.009765625, + "gradient_norm": 0.008847440592944622, + "elapsed": 295.0800693035126 + }, + { + "step": 352, + "loss": 0.6147637963294983, + "objective": 0.6147637963294983, + "error": 0.3603515625, + "gradient_norm": 0.05709920823574066, + "elapsed": 305.32019686698914 + }, + { + "step": 368, + "loss": 0.5955979824066162, + "objective": 0.5955979824066162, + "error": 0.3486328125, + "gradient_norm": 0.04276399686932564, + "elapsed": 316.3869025707245 + }, + { + "step": 384, + "loss": 0.23504304885864258, + "objective": 0.23504304885864258, + "error": 0.1025390625, + "gradient_norm": 0.03205326199531555, + "elapsed": 325.7849349975586 + }, + { + "step": 400, + "loss": 0.13460804522037506, + "objective": 0.13460804522037506, + "error": 0.0546875, + "gradient_norm": 0.03109711967408657, + "elapsed": 335.72691917419434 + }, + { + "step": 416, + "loss": 0.5798783302307129, + "objective": 0.5798783302307129, + "error": 0.322265625, + "gradient_norm": 0.053542010486125946, + "elapsed": 345.7052640914917 + }, + { + "step": 432, + "loss": 0.3892784118652344, + "objective": 0.3892784118652344, + "error": 0.19140625, + "gradient_norm": 0.052194178104400635, + "elapsed": 357.38475036621094 + }, + { + "step": 448, + "loss": 0.23582103848457336, + "objective": 0.23582103848457336, + "error": 0.1181640625, + "gradient_norm": 0.032037943601608276, + "elapsed": 369.5841510295868 + }, + { + "step": 464, + "loss": 0.5408849716186523, + "objective": 0.5408849716186523, + "error": 0.2900390625, + "gradient_norm": 0.07508285343647003, + "elapsed": 379.84099793434143 + }, + { + "step": 480, + "loss": 0.3894873559474945, + "objective": 0.3894873559474945, + "error": 0.19140625, + "gradient_norm": 0.03977999836206436, + "elapsed": 390.9687530994415 + }, + { + "step": 496, + "loss": 0.6059300899505615, + "objective": 0.6059300899505615, + "error": 0.361328125, + "gradient_norm": 0.06041429564356804, + "elapsed": 403.2380111217499 + }, + { + "step": 512, + "loss": 0.2117740511894226, + "objective": 0.2117740511894226, + "error": 0.0908203125, + "gradient_norm": 0.05693414434790611, + "elapsed": 414.4854781627655 + }, + { + "step": 528, + "loss": 0.4666211009025574, + "objective": 0.4666211009025574, + "error": 0.2470703125, + "gradient_norm": 0.0764947235584259, + "elapsed": 433.42368054389954 + }, + { + "step": 544, + "loss": 0.22636458277702332, + "objective": 0.22636458277702332, + "error": 0.1083984375, + "gradient_norm": 0.03683016076683998, + "elapsed": 442.92575907707214 + }, + { + "step": 560, + "loss": 0.23172692954540253, + "objective": 0.23172692954540253, + "error": 0.1083984375, + "gradient_norm": 0.034071482717990875, + "elapsed": 453.3129711151123 + }, + { + "step": 576, + "loss": 0.4768703579902649, + "objective": 0.4768703579902649, + "error": 0.2529296875, + "gradient_norm": 0.06308378279209137, + "elapsed": 462.4127457141876 + }, + { + "step": 592, + "loss": 0.5165150165557861, + "objective": 0.5165150165557861, + "error": 0.291015625, + "gradient_norm": 0.07674732059240341, + "elapsed": 473.8309862613678 + }, + { + "step": 608, + "loss": 0.5919064283370972, + "objective": 0.5919064283370972, + "error": 0.3359375, + "gradient_norm": 0.06379934400320053, + "elapsed": 484.3733870983124 + }, + { + "step": 624, + "loss": 0.01804366335272789, + "objective": 0.01804366335272789, + "error": 0.0068359375, + "gradient_norm": 0.005318541545420885, + "elapsed": 495.94076347351074 + }, + { + "step": 640, + "loss": 0.41747498512268066, + "objective": 0.41747498512268066, + "error": 0.1962890625, + "gradient_norm": 0.052116431295871735, + "elapsed": 506.73559165000916 + }, + { + "step": 656, + "loss": 0.6140056848526001, + "objective": 0.6140056848526001, + "error": 0.3896484375, + "gradient_norm": 0.05376415699720383, + "elapsed": 517.2397899627686 + }, + { + "step": 672, + "loss": 0.4098930358886719, + "objective": 0.4098930358886719, + "error": 0.197265625, + "gradient_norm": 0.04737741872668266, + "elapsed": 525.7957897186279 + }, + { + "step": 688, + "loss": 0.3499884009361267, + "objective": 0.3499884009361267, + "error": 0.1650390625, + "gradient_norm": 0.0714973583817482, + "elapsed": 534.9302124977112 + }, + { + "step": 704, + "loss": 0.552291989326477, + "objective": 0.552291989326477, + "error": 0.3095703125, + "gradient_norm": 0.10188189148902893, + "elapsed": 545.4470670223236 + }, + { + "step": 720, + "loss": 0.4040689468383789, + "objective": 0.4040689468383789, + "error": 0.1943359375, + "gradient_norm": 0.06630362570285797, + "elapsed": 554.2920794487 + }, + { + "step": 736, + "loss": 0.3191133439540863, + "objective": 0.3191133439540863, + "error": 0.15625, + "gradient_norm": 0.060587506741285324, + "elapsed": 562.335791349411 + }, + { + "step": 752, + "loss": 0.5949387550354004, + "objective": 0.5949387550354004, + "error": 0.330078125, + "gradient_norm": 0.051291145384311676, + "elapsed": 570.9363489151001 + }, + { + "step": 768, + "loss": 0.4783790409564972, + "objective": 0.4783790409564972, + "error": 0.244140625, + "gradient_norm": 0.08808670938014984, + "elapsed": 581.1555306911469 + }, + { + "step": 784, + "loss": 0.4414710998535156, + "objective": 0.4414710998535156, + "error": 0.20703125, + "gradient_norm": 0.06632383912801743, + "elapsed": 590.4109175205231 + }, + { + "step": 800, + "loss": 0.2536136507987976, + "objective": 0.2536136507987976, + "error": 0.1142578125, + "gradient_norm": 0.03191893920302391, + "elapsed": 601.43274974823 + }, + { + "step": 816, + "loss": 0.22448071837425232, + "objective": 0.22448071837425232, + "error": 0.1015625, + "gradient_norm": 0.04966023191809654, + "elapsed": 612.7252013683319 + }, + { + "step": 832, + "loss": 0.5342355966567993, + "objective": 0.5342355966567993, + "error": 0.2783203125, + "gradient_norm": 0.05757307633757591, + "elapsed": 623.6647284030914 + }, + { + "step": 848, + "loss": 0.2506354749202728, + "objective": 0.2506354749202728, + "error": 0.109375, + "gradient_norm": 0.03991081938147545, + "elapsed": 635.1636409759521 + }, + { + "step": 864, + "loss": 0.40698009729385376, + "objective": 0.40698009729385376, + "error": 0.1953125, + "gradient_norm": 0.09155476838350296, + "elapsed": 645.2128469944 + }, + { + "step": 880, + "loss": 0.563283383846283, + "objective": 0.563283383846283, + "error": 0.3134765625, + "gradient_norm": 0.11409252882003784, + "elapsed": 659.2946681976318 + }, + { + "step": 896, + "loss": 0.13591040670871735, + "objective": 0.13591040670871735, + "error": 0.064453125, + "gradient_norm": 0.02692740224301815, + "elapsed": 668.6167254447937 + }, + { + "step": 912, + "loss": 0.5798318982124329, + "objective": 0.5798318982124329, + "error": 0.3310546875, + "gradient_norm": 0.06674209237098694, + "elapsed": 680.6492185592651 + }, + { + "step": 928, + "loss": 0.6140691041946411, + "objective": 0.6140691041946411, + "error": 0.3857421875, + "gradient_norm": 0.06117575615644455, + "elapsed": 693.1704411506653 + }, + { + "step": 944, + "loss": 0.3964633643627167, + "objective": 0.3964633643627167, + "error": 0.1865234375, + "gradient_norm": 0.08617512136697769, + "elapsed": 708.2128443717957 + }, + { + "step": 960, + "loss": 0.5512299537658691, + "objective": 0.5512299537658691, + "error": 0.2861328125, + "gradient_norm": 0.05705108866095543, + "elapsed": 720.2417063713074 + }, + { + "step": 976, + "loss": 0.454137921333313, + "objective": 0.454137921333313, + "error": 0.216796875, + "gradient_norm": 0.07962293922901154, + "elapsed": 730.2567391395569 + }, + { + "step": 992, + "loss": 0.5681213140487671, + "objective": 0.5681213140487671, + "error": 0.3017578125, + "gradient_norm": 0.09802286326885223, + "elapsed": 742.7380962371826 + }, + { + "step": 1008, + "loss": 0.13060352206230164, + "objective": 0.13060352206230164, + "error": 0.0537109375, + "gradient_norm": 0.04271279275417328, + "elapsed": 750.8077793121338 + }, + { + "step": 1024, + "loss": 0.6129879355430603, + "objective": 0.6129879355430603, + "error": 0.3603515625, + "gradient_norm": 0.04127912223339081, + "elapsed": 761.0585849285126 + }, + { + "step": 1040, + "loss": 0.31361687183380127, + "objective": 0.31361687183380127, + "error": 0.1455078125, + "gradient_norm": 0.04341907799243927, + "elapsed": 776.3491418361664 + }, + { + "step": 1056, + "loss": 0.6326502561569214, + "objective": 0.6326502561569214, + "error": 0.365234375, + "gradient_norm": 0.07518075406551361, + "elapsed": 786.0424168109894 + }, + { + "step": 1072, + "loss": 0.537599503993988, + "objective": 0.537599503993988, + "error": 0.2958984375, + "gradient_norm": 0.08455493301153183, + "elapsed": 795.1607735157013 + }, + { + "step": 1088, + "loss": 0.5953108072280884, + "objective": 0.5953108072280884, + "error": 0.337890625, + "gradient_norm": 0.06973882764577866, + "elapsed": 804.0053510665894 + }, + { + "step": 1104, + "loss": 0.36860400438308716, + "objective": 0.36860400438308716, + "error": 0.1923828125, + "gradient_norm": 0.04828036576509476, + "elapsed": 813.4029138088226 + }, + { + "step": 1120, + "loss": 0.5423247218132019, + "objective": 0.5423247218132019, + "error": 0.28125, + "gradient_norm": 0.04841453209519386, + "elapsed": 823.626978635788 + }, + { + "step": 1136, + "loss": 0.4766136407852173, + "objective": 0.4766136407852173, + "error": 0.236328125, + "gradient_norm": 0.07564551383256912, + "elapsed": 832.4641265869141 + }, + { + "step": 1152, + "loss": 0.5473434925079346, + "objective": 0.5473434925079346, + "error": 0.2958984375, + "gradient_norm": 0.13677075505256653, + "elapsed": 844.9307618141174 + }, + { + "step": 1168, + "loss": 0.3040686249732971, + "objective": 0.3040686249732971, + "error": 0.150390625, + "gradient_norm": 0.045926257967948914, + "elapsed": 854.336992263794 + }, + { + "step": 1184, + "loss": 0.6298375129699707, + "objective": 0.6298375129699707, + "error": 0.3798828125, + "gradient_norm": 0.06807851791381836, + "elapsed": 864.5731596946716 + }, + { + "step": 1200, + "loss": 0.6272540092468262, + "objective": 0.6272540092468262, + "error": 0.37890625, + "gradient_norm": 0.139838308095932, + "elapsed": 877.8357374668121 + }, + { + "step": 1216, + "loss": 0.5224937200546265, + "objective": 0.5224937200546265, + "error": 0.287109375, + "gradient_norm": 0.0647057592868805, + "elapsed": 887.8107197284698 + }, + { + "step": 1232, + "loss": 0.02408422902226448, + "objective": 0.02408422902226448, + "error": 0.0107421875, + "gradient_norm": 0.007562167476862669, + "elapsed": 902.201171875 + }, + { + "step": 1248, + "loss": 0.01936865597963333, + "objective": 0.01936865597963333, + "error": 0.0048828125, + "gradient_norm": 0.006423021201044321, + "elapsed": 914.0247437953949 + }, + { + "step": 1264, + "loss": 0.47522181272506714, + "objective": 0.47522181272506714, + "error": 0.2490234375, + "gradient_norm": 0.04962826892733574, + "elapsed": 927.0462884902954 + }, + { + "step": 1280, + "loss": 0.019577551633119583, + "objective": 0.019577551633119583, + "error": 0.0068359375, + "gradient_norm": 0.008308992721140385, + "elapsed": 939.3647270202637 + }, + { + "step": 1296, + "loss": 0.5085430145263672, + "objective": 0.5085430145263672, + "error": 0.2734375, + "gradient_norm": 0.06214233115315437, + "elapsed": 949.4259700775146 + }, + { + "step": 1312, + "loss": 0.23232896625995636, + "objective": 0.23232896625995636, + "error": 0.1015625, + "gradient_norm": 0.05894213914871216, + "elapsed": 961.3636543750763 + }, + { + "step": 1328, + "loss": 0.5330536365509033, + "objective": 0.5330536365509033, + "error": 0.2861328125, + "gradient_norm": 0.11579663306474686, + "elapsed": 972.1607241630554 + }, + { + "step": 1344, + "loss": 0.019525721669197083, + "objective": 0.019525721669197083, + "error": 0.0087890625, + "gradient_norm": 0.008134250529110432, + "elapsed": 983.0828921794891 + }, + { + "step": 1360, + "loss": 0.22790294885635376, + "objective": 0.22790294885635376, + "error": 0.103515625, + "gradient_norm": 0.04187086224555969, + "elapsed": 991.3167304992676 + }, + { + "step": 1376, + "loss": 0.48713046312332153, + "objective": 0.48713046312332153, + "error": 0.2666015625, + "gradient_norm": 0.06267429888248444, + "elapsed": 1003.5033710002899 + }, + { + "step": 1392, + "loss": 0.6043434143066406, + "objective": 0.6043434143066406, + "error": 0.369140625, + "gradient_norm": 0.037880122661590576, + "elapsed": 1017.8567223548889 + }, + { + "step": 1408, + "loss": 0.034499723464250565, + "objective": 0.034499723464250565, + "error": 0.0068359375, + "gradient_norm": 0.013505477458238602, + "elapsed": 1027.3547134399414 + }, + { + "step": 1424, + "loss": 0.5320160388946533, + "objective": 0.5320160388946533, + "error": 0.306640625, + "gradient_norm": 0.07510018348693848, + "elapsed": 1036.9454221725464 + }, + { + "step": 1440, + "loss": 0.3451523780822754, + "objective": 0.3451523780822754, + "error": 0.171875, + "gradient_norm": 0.06453985720872879, + "elapsed": 1046.1805095672607 + }, + { + "step": 1456, + "loss": 0.21541815996170044, + "objective": 0.21541815996170044, + "error": 0.08984375, + "gradient_norm": 0.043503839522600174, + "elapsed": 1055.850379705429 + }, + { + "step": 1472, + "loss": 0.43667086958885193, + "objective": 0.43667086958885193, + "error": 0.22265625, + "gradient_norm": 0.07311506569385529, + "elapsed": 1066.6324400901794 + }, + { + "step": 1488, + "loss": 0.6163139939308167, + "objective": 0.6163139939308167, + "error": 0.3779296875, + "gradient_norm": 0.06406569480895996, + "elapsed": 1075.7883398532867 + }, + { + "step": 1504, + "loss": 0.23901250958442688, + "objective": 0.23901250958442688, + "error": 0.10546875, + "gradient_norm": 0.04792191833257675, + "elapsed": 1085.4756922721863 + }, + { + "step": 1520, + "loss": 0.3817014694213867, + "objective": 0.3817014694213867, + "error": 0.18359375, + "gradient_norm": 0.046061187982559204, + "elapsed": 1095.974383354187 + }, + { + "step": 1536, + "loss": 0.5593156814575195, + "objective": 0.5593156814575195, + "error": 0.3017578125, + "gradient_norm": 0.0735388696193695, + "elapsed": 1105.913155078888 + } + ] + }, + { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 466919, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved1_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved1_warm/weights-512.npz", + "starting_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317613, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261272", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.1412775069475174, + "objective": 0.1412775069475174, + "error": 0.0595703125, + "gradient_norm": 0.030735325068235397, + "elapsed": 28.457472801208496 + }, + { + "step": 16, + "loss": 0.6315727233886719, + "objective": 0.6315727233886719, + "error": 0.384765625, + "gradient_norm": 0.06563512235879898, + "elapsed": 47.886730670928955 + }, + { + "step": 32, + "loss": 0.5130410194396973, + "objective": 0.5130410194396973, + "error": 0.263671875, + "gradient_norm": 0.10626910626888275, + "elapsed": 60.16136598587036 + }, + { + "step": 48, + "loss": 0.6413166522979736, + "objective": 0.6413166522979736, + "error": 0.408203125, + "gradient_norm": 0.03790846839547157, + "elapsed": 70.9611382484436 + }, + { + "step": 64, + "loss": 0.5491592884063721, + "objective": 0.5491592884063721, + "error": 0.2939453125, + "gradient_norm": 0.093081034719944, + "elapsed": 81.46673464775085 + }, + { + "step": 80, + "loss": 0.6315242648124695, + "objective": 0.6315242648124695, + "error": 0.359375, + "gradient_norm": 0.0384257510304451, + "elapsed": 91.71172666549683 + }, + { + "step": 96, + "loss": 0.6311566829681396, + "objective": 0.6311566829681396, + "error": 0.3798828125, + "gradient_norm": 0.03731638938188553, + "elapsed": 100.83252763748169 + }, + { + "step": 112, + "loss": 0.5327925682067871, + "objective": 0.5327925682067871, + "error": 0.29296875, + "gradient_norm": 0.11202990263700485, + "elapsed": 111.35073852539062 + }, + { + "step": 128, + "loss": 0.6284654140472412, + "objective": 0.6284654140472412, + "error": 0.3740234375, + "gradient_norm": 0.03215613588690758, + "elapsed": 121.32994651794434 + }, + { + "step": 144, + "loss": 0.33964547514915466, + "objective": 0.33964547514915466, + "error": 0.1259765625, + "gradient_norm": 0.05133189633488655, + "elapsed": 131.2744882106781 + }, + { + "step": 160, + "loss": 0.14193454384803772, + "objective": 0.14193454384803772, + "error": 0.0478515625, + "gradient_norm": 0.03264402225613594, + "elapsed": 139.58473920822144 + }, + { + "step": 176, + "loss": 0.14203950762748718, + "objective": 0.14203950762748718, + "error": 0.0654296875, + "gradient_norm": 0.022548990324139595, + "elapsed": 148.9861602783203 + }, + { + "step": 192, + "loss": 0.6307225227355957, + "objective": 0.6307225227355957, + "error": 0.3955078125, + "gradient_norm": 0.08607082068920135, + "elapsed": 162.27514505386353 + }, + { + "step": 208, + "loss": 0.16193106770515442, + "objective": 0.16193106770515442, + "error": 0.064453125, + "gradient_norm": 0.023293493315577507, + "elapsed": 173.59824013710022 + }, + { + "step": 224, + "loss": 0.5426318049430847, + "objective": 0.5426318049430847, + "error": 0.3037109375, + "gradient_norm": 0.03944721072912216, + "elapsed": 182.70232272148132 + }, + { + "step": 240, + "loss": 0.6270365715026855, + "objective": 0.6270365715026855, + "error": 0.3896484375, + "gradient_norm": 0.14661568403244019, + "elapsed": 193.759183883667 + }, + { + "step": 256, + "loss": 0.4933152198791504, + "objective": 0.4933152198791504, + "error": 0.2724609375, + "gradient_norm": 0.1065438985824585, + "elapsed": 205.62959718704224 + }, + { + "step": 272, + "loss": 0.3671969473361969, + "objective": 0.3671969473361969, + "error": 0.177734375, + "gradient_norm": 0.05156548321247101, + "elapsed": 222.249596118927 + }, + { + "step": 288, + "loss": 0.5478869676589966, + "objective": 0.5478869676589966, + "error": 0.3203125, + "gradient_norm": 0.08357688039541245, + "elapsed": 232.2198715209961 + }, + { + "step": 304, + "loss": 0.21171918511390686, + "objective": 0.21171918511390686, + "error": 0.0849609375, + "gradient_norm": 0.06231697276234627, + "elapsed": 241.07631373405457 + }, + { + "step": 320, + "loss": 0.5333335995674133, + "objective": 0.5333335995674133, + "error": 0.2861328125, + "gradient_norm": 0.08931853622198105, + "elapsed": 251.28962755203247 + }, + { + "step": 336, + "loss": 0.12485946714878082, + "objective": 0.12485946714878082, + "error": 0.046875, + "gradient_norm": 0.018839582800865173, + "elapsed": 262.3605041503906 + }, + { + "step": 352, + "loss": 0.2334863245487213, + "objective": 0.2334863245487213, + "error": 0.09765625, + "gradient_norm": 0.03669576346874237, + "elapsed": 273.16373229026794 + }, + { + "step": 368, + "loss": 0.5818328857421875, + "objective": 0.5818328857421875, + "error": 0.3232421875, + "gradient_norm": 0.09833699464797974, + "elapsed": 282.8677294254303 + }, + { + "step": 384, + "loss": 0.6228232383728027, + "objective": 0.6228232383728027, + "error": 0.3671875, + "gradient_norm": 0.033418990671634674, + "elapsed": 295.04902839660645 + }, + { + "step": 400, + "loss": 0.5749450922012329, + "objective": 0.5749450922012329, + "error": 0.333984375, + "gradient_norm": 0.04644288495182991, + "elapsed": 306.67032837867737 + }, + { + "step": 416, + "loss": 0.46251457929611206, + "objective": 0.46251457929611206, + "error": 0.2216796875, + "gradient_norm": 0.06633804738521576, + "elapsed": 317.759464263916 + }, + { + "step": 432, + "loss": 0.5577508211135864, + "objective": 0.5577508211135864, + "error": 0.30859375, + "gradient_norm": 0.0970199704170227, + "elapsed": 327.4626543521881 + }, + { + "step": 448, + "loss": 0.11625733226537704, + "objective": 0.11625733226537704, + "error": 0.0419921875, + "gradient_norm": 0.020417485386133194, + "elapsed": 336.3522970676422 + }, + { + "step": 464, + "loss": 0.23657961189746857, + "objective": 0.23657961189746857, + "error": 0.1025390625, + "gradient_norm": 0.03908605873584747, + "elapsed": 344.3832321166992 + }, + { + "step": 480, + "loss": 0.011504358612000942, + "objective": 0.011504358612000942, + "error": 0.00390625, + "gradient_norm": 0.006708688102662563, + "elapsed": 355.18855381011963 + }, + { + "step": 496, + "loss": 0.3410624563694, + "objective": 0.3410624563694, + "error": 0.1533203125, + "gradient_norm": 0.05804387852549553, + "elapsed": 366.2978138923645 + }, + { + "step": 512, + "loss": 0.034005306661129, + "objective": 0.034005306661129, + "error": 0.0107421875, + "gradient_norm": 0.01019973959773779, + "elapsed": 375.73491764068604 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "b31e8f5ee2b5ea1b661e6bf8b5649bec45b7ab5da74fe9de46e4d06846356b87", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317613, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5523660182952881, + "objective": 0.5523660182952881, + "error": 0.30859375, + "gradient_norm": 0.05200070142745972, + "elapsed": 30.08410096168518 + }, + { + "step": 16, + "loss": 0.5380295515060425, + "objective": 0.5380295515060425, + "error": 0.306640625, + "gradient_norm": 0.0804876759648323, + "elapsed": 50.77648210525513 + }, + { + "step": 32, + "loss": 0.6359301805496216, + "objective": 0.6359301805496216, + "error": 0.3837890625, + "gradient_norm": 0.059380218386650085, + "elapsed": 59.453776836395264 + }, + { + "step": 48, + "loss": 0.2540435492992401, + "objective": 0.2540435492992401, + "error": 0.1083984375, + "gradient_norm": 0.04367281496524811, + "elapsed": 67.29314041137695 + }, + { + "step": 64, + "loss": 0.5867692232131958, + "objective": 0.5867692232131958, + "error": 0.3447265625, + "gradient_norm": 0.053885214030742645, + "elapsed": 78.74847197532654 + }, + { + "step": 80, + "loss": 0.6015321016311646, + "objective": 0.6015321016311646, + "error": 0.365234375, + "gradient_norm": 0.04807985574007034, + "elapsed": 90.48145818710327 + }, + { + "step": 96, + "loss": 0.49287766218185425, + "objective": 0.49287766218185425, + "error": 0.271484375, + "gradient_norm": 0.07899080961942673, + "elapsed": 101.65468978881836 + }, + { + "step": 112, + "loss": 0.3271353542804718, + "objective": 0.3271353542804718, + "error": 0.15234375, + "gradient_norm": 0.049542222172021866, + "elapsed": 111.14713263511658 + }, + { + "step": 128, + "loss": 0.50013667345047, + "objective": 0.50013667345047, + "error": 0.271484375, + "gradient_norm": 0.06454745680093765, + "elapsed": 121.21207547187805 + }, + { + "step": 144, + "loss": 0.028576843440532684, + "objective": 0.028576843440532684, + "error": 0.0087890625, + "gradient_norm": 0.010781333781778812, + "elapsed": 130.69302248954773 + }, + { + "step": 160, + "loss": 0.5668779015541077, + "objective": 0.5668779015541077, + "error": 0.330078125, + "gradient_norm": 0.06098390743136406, + "elapsed": 142.14290237426758 + }, + { + "step": 176, + "loss": 0.3986494839191437, + "objective": 0.3986494839191437, + "error": 0.1884765625, + "gradient_norm": 0.042795032262802124, + "elapsed": 152.75753688812256 + }, + { + "step": 192, + "loss": 0.31897079944610596, + "objective": 0.31897079944610596, + "error": 0.142578125, + "gradient_norm": 0.040675707161426544, + "elapsed": 160.04981398582458 + }, + { + "step": 208, + "loss": 0.5092275142669678, + "objective": 0.5092275142669678, + "error": 0.255859375, + "gradient_norm": 0.07929783314466476, + "elapsed": 169.85345673561096 + }, + { + "step": 224, + "loss": 0.35782667994499207, + "objective": 0.35782667994499207, + "error": 0.1748046875, + "gradient_norm": 0.05785144120454788, + "elapsed": 179.90323066711426 + }, + { + "step": 240, + "loss": 0.5660895109176636, + "objective": 0.5660895109176636, + "error": 0.3349609375, + "gradient_norm": 0.10684454441070557, + "elapsed": 191.3668942451477 + }, + { + "step": 256, + "loss": 0.6265910863876343, + "objective": 0.6265910863876343, + "error": 0.3779296875, + "gradient_norm": 0.034383758902549744, + "elapsed": 200.3055775165558 + }, + { + "step": 272, + "loss": 0.6210677623748779, + "objective": 0.6210677623748779, + "error": 0.369140625, + "gradient_norm": 0.04434216767549515, + "elapsed": 210.09376430511475 + }, + { + "step": 288, + "loss": 0.4892377257347107, + "objective": 0.4892377257347107, + "error": 0.2490234375, + "gradient_norm": 0.1040654331445694, + "elapsed": 220.45881819725037 + }, + { + "step": 304, + "loss": 0.6407739520072937, + "objective": 0.6407739520072937, + "error": 0.3916015625, + "gradient_norm": 0.07782924920320511, + "elapsed": 233.3719048500061 + }, + { + "step": 320, + "loss": 0.4752756953239441, + "objective": 0.4752756953239441, + "error": 0.263671875, + "gradient_norm": 0.051829319447278976, + "elapsed": 244.25844407081604 + }, + { + "step": 336, + "loss": 0.6482080221176147, + "objective": 0.6482080221176147, + "error": 0.41015625, + "gradient_norm": 0.04979892820119858, + "elapsed": 253.1897099018097 + }, + { + "step": 352, + "loss": 0.34022292494773865, + "objective": 0.34022292494773865, + "error": 0.1708984375, + "gradient_norm": 0.09951864182949066, + "elapsed": 264.0781395435333 + }, + { + "step": 368, + "loss": 0.3494992256164551, + "objective": 0.3494992256164551, + "error": 0.15625, + "gradient_norm": 0.10392706841230392, + "elapsed": 275.8111581802368 + }, + { + "step": 384, + "loss": 0.47191378474235535, + "objective": 0.47191378474235535, + "error": 0.25, + "gradient_norm": 0.07366786152124405, + "elapsed": 283.9459602832794 + }, + { + "step": 400, + "loss": 0.583655595779419, + "objective": 0.583655595779419, + "error": 0.3623046875, + "gradient_norm": 0.10394527018070221, + "elapsed": 294.3349726200104 + }, + { + "step": 416, + "loss": 0.6212975978851318, + "objective": 0.6212975978851318, + "error": 0.37109375, + "gradient_norm": 0.054796766489744186, + "elapsed": 304.7477548122406 + }, + { + "step": 432, + "loss": 0.4719577431678772, + "objective": 0.4719577431678772, + "error": 0.2431640625, + "gradient_norm": 0.05418012663722038, + "elapsed": 315.91914200782776 + }, + { + "step": 448, + "loss": 0.5696494579315186, + "objective": 0.5696494579315186, + "error": 0.3330078125, + "gradient_norm": 0.047046076506376266, + "elapsed": 324.96326184272766 + }, + { + "step": 464, + "loss": 0.613875687122345, + "objective": 0.613875687122345, + "error": 0.34765625, + "gradient_norm": 0.05237002298235893, + "elapsed": 334.7670781612396 + }, + { + "step": 480, + "loss": 0.28741705417633057, + "objective": 0.28741705417633057, + "error": 0.1240234375, + "gradient_norm": 0.05365394428372383, + "elapsed": 344.03080439567566 + }, + { + "step": 496, + "loss": 0.3729455769062042, + "objective": 0.3729455769062042, + "error": 0.1875, + "gradient_norm": 0.05905403569340706, + "elapsed": 356.01581716537476 + }, + { + "step": 512, + "loss": 0.38685142993927, + "objective": 0.38685142993927, + "error": 0.17578125, + "gradient_norm": 0.048455506563186646, + "elapsed": 367.7296392917633 + }, + { + "step": 528, + "loss": 0.6062720417976379, + "objective": 0.6062720417976379, + "error": 0.369140625, + "gradient_norm": 0.07544548809528351, + "elapsed": 385.4480962753296 + }, + { + "step": 544, + "loss": 0.520085871219635, + "objective": 0.520085871219635, + "error": 0.279296875, + "gradient_norm": 0.08394371718168259, + "elapsed": 397.71993708610535 + }, + { + "step": 560, + "loss": 0.5944540500640869, + "objective": 0.5944540500640869, + "error": 0.3544921875, + "gradient_norm": 0.05468091368675232, + "elapsed": 406.9417428970337 + }, + { + "step": 576, + "loss": 0.34102559089660645, + "objective": 0.34102559089660645, + "error": 0.1611328125, + "gradient_norm": 0.07333917915821075, + "elapsed": 417.0068130493164 + }, + { + "step": 592, + "loss": 0.47373664379119873, + "objective": 0.47373664379119873, + "error": 0.2412109375, + "gradient_norm": 0.05662858858704567, + "elapsed": 425.1176447868347 + }, + { + "step": 608, + "loss": 0.48517894744873047, + "objective": 0.48517894744873047, + "error": 0.25, + "gradient_norm": 0.08127480745315552, + "elapsed": 434.92080903053284 + }, + { + "step": 624, + "loss": 0.39865612983703613, + "objective": 0.39865612983703613, + "error": 0.1904296875, + "gradient_norm": 0.07332058995962143, + "elapsed": 446.6602101325989 + }, + { + "step": 640, + "loss": 0.41867297887802124, + "objective": 0.41867297887802124, + "error": 0.2177734375, + "gradient_norm": 0.07386308163404465, + "elapsed": 457.0243580341339 + }, + { + "step": 656, + "loss": 0.5108687877655029, + "objective": 0.5108687877655029, + "error": 0.2822265625, + "gradient_norm": 0.052080318331718445, + "elapsed": 469.5842761993408 + }, + { + "step": 672, + "loss": 0.5043742656707764, + "objective": 0.5043742656707764, + "error": 0.2734375, + "gradient_norm": 0.047204963862895966, + "elapsed": 479.356397151947 + }, + { + "step": 688, + "loss": 0.5550935864448547, + "objective": 0.5550935864448547, + "error": 0.30078125, + "gradient_norm": 0.04080262407660484, + "elapsed": 489.9912152290344 + }, + { + "step": 704, + "loss": 0.5698974132537842, + "objective": 0.5698974132537842, + "error": 0.322265625, + "gradient_norm": 0.10692963004112244, + "elapsed": 500.3283371925354 + }, + { + "step": 720, + "loss": 0.45870622992515564, + "objective": 0.45870622992515564, + "error": 0.2255859375, + "gradient_norm": 0.06705734878778458, + "elapsed": 509.82279753685 + }, + { + "step": 736, + "loss": 0.555386483669281, + "objective": 0.555386483669281, + "error": 0.31640625, + "gradient_norm": 0.05112688988447189, + "elapsed": 518.507036447525 + }, + { + "step": 752, + "loss": 0.14282986521720886, + "objective": 0.14282986521720886, + "error": 0.056640625, + "gradient_norm": 0.03209136053919792, + "elapsed": 529.1373023986816 + }, + { + "step": 768, + "loss": 0.5362129807472229, + "objective": 0.5362129807472229, + "error": 0.2841796875, + "gradient_norm": 0.049996186047792435, + "elapsed": 538.9186007976532 + }, + { + "step": 784, + "loss": 0.5071826577186584, + "objective": 0.5071826577186584, + "error": 0.2744140625, + "gradient_norm": 0.04826078191399574, + "elapsed": 549.5225830078125 + }, + { + "step": 800, + "loss": 0.24775367975234985, + "objective": 0.24775367975234985, + "error": 0.107421875, + "gradient_norm": 0.06889795511960983, + "elapsed": 560.7170543670654 + }, + { + "step": 816, + "loss": 0.17432856559753418, + "objective": 0.17432856559753418, + "error": 0.06640625, + "gradient_norm": 0.05147368833422661, + "elapsed": 570.7887880802155 + }, + { + "step": 832, + "loss": 0.5410823822021484, + "objective": 0.5410823822021484, + "error": 0.3115234375, + "gradient_norm": 0.11862928420305252, + "elapsed": 581.9721121788025 + }, + { + "step": 848, + "loss": 0.5555508732795715, + "objective": 0.5555508732795715, + "error": 0.296875, + "gradient_norm": 0.060369592159986496, + "elapsed": 592.2823219299316 + }, + { + "step": 864, + "loss": 0.31839215755462646, + "objective": 0.31839215755462646, + "error": 0.1552734375, + "gradient_norm": 0.063877172768116, + "elapsed": 603.1910541057587 + }, + { + "step": 880, + "loss": 0.481766939163208, + "objective": 0.481766939163208, + "error": 0.2470703125, + "gradient_norm": 0.1623816341161728, + "elapsed": 614.4277107715607 + }, + { + "step": 896, + "loss": 0.5780366659164429, + "objective": 0.5780366659164429, + "error": 0.3037109375, + "gradient_norm": 0.06694691628217697, + "elapsed": 623.9365792274475 + }, + { + "step": 912, + "loss": 0.4794909358024597, + "objective": 0.4794909358024597, + "error": 0.2314453125, + "gradient_norm": 0.07813122123479843, + "elapsed": 633.9845306873322 + }, + { + "step": 928, + "loss": 0.6279138922691345, + "objective": 0.6279138922691345, + "error": 0.380859375, + "gradient_norm": 0.047679927200078964, + "elapsed": 643.7766675949097 + }, + { + "step": 944, + "loss": 0.6401606798171997, + "objective": 0.6401606798171997, + "error": 0.3994140625, + "gradient_norm": 0.07329051941633224, + "elapsed": 655.2369928359985 + }, + { + "step": 960, + "loss": 0.4340277910232544, + "objective": 0.4340277910232544, + "error": 0.2158203125, + "gradient_norm": 0.11762503534555435, + "elapsed": 666.9884371757507 + }, + { + "step": 976, + "loss": 0.44496864080429077, + "objective": 0.44496864080429077, + "error": 0.2236328125, + "gradient_norm": 0.05260347202420235, + "elapsed": 677.3464586734772 + }, + { + "step": 992, + "loss": 0.13230293989181519, + "objective": 0.13230293989181519, + "error": 0.05078125, + "gradient_norm": 0.030240925028920174, + "elapsed": 685.7275724411011 + }, + { + "step": 1008, + "loss": 0.2971688508987427, + "objective": 0.2971688508987427, + "error": 0.1171875, + "gradient_norm": 0.05503479763865471, + "elapsed": 694.1270356178284 + }, + { + "step": 1024, + "loss": 0.5688735246658325, + "objective": 0.5688735246658325, + "error": 0.314453125, + "gradient_norm": 0.06526188552379608, + "elapsed": 703.9192817211151 + }, + { + "step": 1040, + "loss": 0.42805811762809753, + "objective": 0.42805811762809753, + "error": 0.2080078125, + "gradient_norm": 0.13000032305717468, + "elapsed": 720.145961523056 + }, + { + "step": 1056, + "loss": 0.5543602705001831, + "objective": 0.5543602705001831, + "error": 0.298828125, + "gradient_norm": 0.15922385454177856, + "elapsed": 733.5112845897675 + }, + { + "step": 1072, + "loss": 0.031130114570260048, + "objective": 0.031130114570260048, + "error": 0.013671875, + "gradient_norm": 0.008926023729145527, + "elapsed": 742.4467866420746 + }, + { + "step": 1088, + "loss": 0.14947748184204102, + "objective": 0.14947748184204102, + "error": 0.056640625, + "gradient_norm": 0.03975249081850052, + "elapsed": 751.8575854301453 + }, + { + "step": 1104, + "loss": 0.6275734901428223, + "objective": 0.6275734901428223, + "error": 0.3671875, + "gradient_norm": 0.08096148073673248, + "elapsed": 761.5625903606415 + }, + { + "step": 1120, + "loss": 0.23923414945602417, + "objective": 0.23923414945602417, + "error": 0.0966796875, + "gradient_norm": 0.03325376287102699, + "elapsed": 773.9633615016937 + }, + { + "step": 1136, + "loss": 0.570243239402771, + "objective": 0.570243239402771, + "error": 0.31640625, + "gradient_norm": 0.07534287869930267, + "elapsed": 783.1533136367798 + }, + { + "step": 1152, + "loss": 0.4264270067214966, + "objective": 0.4264270067214966, + "error": 0.2119140625, + "gradient_norm": 0.08900073170661926, + "elapsed": 792.1710996627808 + }, + { + "step": 1168, + "loss": 0.5958121418952942, + "objective": 0.5958121418952942, + "error": 0.3583984375, + "gradient_norm": 0.08239343762397766, + "elapsed": 803.1175289154053 + }, + { + "step": 1184, + "loss": 0.2909137010574341, + "objective": 0.2909137010574341, + "error": 0.1416015625, + "gradient_norm": 0.05281354859471321, + "elapsed": 812.6055159568787 + }, + { + "step": 1200, + "loss": 0.6119058728218079, + "objective": 0.6119058728218079, + "error": 0.36328125, + "gradient_norm": 0.056254416704177856, + "elapsed": 823.2276427745819 + }, + { + "step": 1216, + "loss": 0.13595536351203918, + "objective": 0.13595536351203918, + "error": 0.0556640625, + "gradient_norm": 0.04057573154568672, + "elapsed": 834.1696293354034 + }, + { + "step": 1232, + "loss": 0.5840731263160706, + "objective": 0.5840731263160706, + "error": 0.328125, + "gradient_norm": 0.054566267877817154, + "elapsed": 845.3501887321472 + }, + { + "step": 1248, + "loss": 0.3053072690963745, + "objective": 0.3053072690963745, + "error": 0.1337890625, + "gradient_norm": 0.04617297649383545, + "elapsed": 854.9564871788025 + }, + { + "step": 1264, + "loss": 0.6288673281669617, + "objective": 0.6288673281669617, + "error": 0.3994140625, + "gradient_norm": 0.08229745179414749, + "elapsed": 864.8914043903351 + }, + { + "step": 1280, + "loss": 0.5586361289024353, + "objective": 0.5586361289024353, + "error": 0.2958984375, + "gradient_norm": 0.05713959410786629, + "elapsed": 877.0349607467651 + }, + { + "step": 1296, + "loss": 0.3648858666419983, + "objective": 0.3648858666419983, + "error": 0.16796875, + "gradient_norm": 0.08502963185310364, + "elapsed": 888.5764675140381 + }, + { + "step": 1312, + "loss": 0.4747084081172943, + "objective": 0.4747084081172943, + "error": 0.244140625, + "gradient_norm": 0.08609883487224579, + "elapsed": 899.7598609924316 + }, + { + "step": 1328, + "loss": 0.15583917498588562, + "objective": 0.15583917498588562, + "error": 0.05859375, + "gradient_norm": 0.027793049812316895, + "elapsed": 909.47514295578 + }, + { + "step": 1344, + "loss": 0.47515708208084106, + "objective": 0.47515708208084106, + "error": 0.263671875, + "gradient_norm": 0.07668807357549667, + "elapsed": 919.7640328407288 + }, + { + "step": 1360, + "loss": 0.5173689126968384, + "objective": 0.5173689126968384, + "error": 0.2744140625, + "gradient_norm": 0.05054212734103203, + "elapsed": 930.6309463977814 + }, + { + "step": 1376, + "loss": 0.46629998087882996, + "objective": 0.46629998087882996, + "error": 0.24609375, + "gradient_norm": 0.051172077655792236, + "elapsed": 939.0202586650848 + }, + { + "step": 1392, + "loss": 0.11312969774007797, + "objective": 0.11312969774007797, + "error": 0.044921875, + "gradient_norm": 0.05863805115222931, + "elapsed": 949.1451416015625 + }, + { + "step": 1408, + "loss": 0.5750841498374939, + "objective": 0.5750841498374939, + "error": 0.322265625, + "gradient_norm": 0.051106806844472885, + "elapsed": 959.94162940979 + }, + { + "step": 1424, + "loss": 0.5937192440032959, + "objective": 0.5937192440032959, + "error": 0.3408203125, + "gradient_norm": 0.05014815554022789, + "elapsed": 969.5868306159973 + }, + { + "step": 1440, + "loss": 0.5292985439300537, + "objective": 0.5292985439300537, + "error": 0.2958984375, + "gradient_norm": 0.057068243622779846, + "elapsed": 982.6692054271698 + }, + { + "step": 1456, + "loss": 0.5959951877593994, + "objective": 0.5959951877593994, + "error": 0.3408203125, + "gradient_norm": 0.0703694075345993, + "elapsed": 995.0066986083984 + }, + { + "step": 1472, + "loss": 0.018453411757946014, + "objective": 0.018453411757946014, + "error": 0.00390625, + "gradient_norm": 0.012016087770462036, + "elapsed": 1004.0057821273804 + }, + { + "step": 1488, + "loss": 0.5711684823036194, + "objective": 0.5711684823036194, + "error": 0.3095703125, + "gradient_norm": 0.07746906578540802, + "elapsed": 1016.1701967716217 + }, + { + "step": 1504, + "loss": 0.3114882707595825, + "objective": 0.3114882707595825, + "error": 0.1455078125, + "gradient_norm": 0.05321609228849411, + "elapsed": 1026.6053586006165 + }, + { + "step": 1520, + "loss": 0.6433392763137817, + "objective": 0.6433392763137817, + "error": 0.4072265625, + "gradient_norm": 0.05683734640479088, + "elapsed": 1036.1535296440125 + }, + { + "step": 1536, + "loss": 0.38409170508384705, + "objective": 0.38409170508384705, + "error": 0.19140625, + "gradient_norm": 0.07577994465827942, + "elapsed": 1046.9508447647095 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "7b45252d6bb77a39c003c8f34f040d0d672e9dd1a1338a14126e1fe07a02c8c9", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 466919, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + } + ], + "training": "All516880 supplied d5 training rows eligible; uniform condition and row sampling with replacement", + "training_shots": 516880, + "distinct_phase_rows": 507134, + "loss": "Conditional logical BCE of two trainable exact-decoder probabilities; responsibilities scale expert BCE gradients; syndrome-only gate gradient is coefficient minus responsibility", + "optimizer": "Separate restored expert AdamW states and fresh gate AdamW; one global norm1 clipping over the full joint gradient, weight_decay1e-4; rates in run_config", + "gate": "41 fixed-scale syndrome/basis/duration features,32-unit SiLU hidden layer,one free logit,other logit zero; no label/ID/position/expert-confidence features", + "validation": "Uniform1024-shot per-condition screens by default, seed20261102; full validation required for checkpoint selection", + "independence": "This joint model uses all training rows; it does not retain the reserved-parent training-label holdout claim", + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4036223292350769, + "error": 0.2216796875, + "gradient_norm": 0.057130008935928345, + "mean_coefficients": [ + 0.5, + 0.5 + ], + "elapsed": 40.89025521278381 + }, + { + "step": 16, + "loss": 0.3341269791126251, + "error": 0.1513671875, + "gradient_norm": 0.04194090887904167, + "mean_coefficients": [ + 0.48442864418029785, + 0.5155713558197021 + ], + "elapsed": 75.96262431144714 + }, + { + "step": 32, + "loss": 0.5103148221969604, + "error": 0.2578125, + "gradient_norm": 0.0415002703666687, + "mean_coefficients": [ + 0.4874333441257477, + 0.5125666856765747 + ], + "elapsed": 97.34089732170105 + }, + { + "step": 48, + "loss": 0.4725187420845032, + "error": 0.2587890625, + "gradient_norm": 0.0680275708436966, + "mean_coefficients": [ + 0.47893714904785156, + 0.5210628509521484 + ], + "elapsed": 118.16778039932251 + }, + { + "step": 64, + "loss": 0.6120783090591431, + "error": 0.3671875, + "gradient_norm": 0.0358140654861927, + "mean_coefficients": [ + 0.4769505262374878, + 0.5230494737625122 + ], + "elapsed": 137.34904408454895 + }, + { + "step": 80, + "loss": 0.5546625852584839, + "error": 0.3037109375, + "gradient_norm": 0.056485772132873535, + "mean_coefficients": [ + 0.4823176860809326, + 0.5176823139190674 + ], + "elapsed": 155.42735648155212 + }, + { + "step": 96, + "loss": 0.6412051320075989, + "error": 0.3740234375, + "gradient_norm": 0.039855338633060455, + "mean_coefficients": [ + 0.47127240896224976, + 0.5287275910377502 + ], + "elapsed": 177.39524245262146 + }, + { + "step": 112, + "loss": 0.3109489977359772, + "error": 0.142578125, + "gradient_norm": 0.0388655886054039, + "mean_coefficients": [ + 0.4498932361602783, + 0.5501067638397217 + ], + "elapsed": 200.48573231697083 + }, + { + "step": 128, + "loss": 0.23736518621444702, + "error": 0.0927734375, + "gradient_norm": 0.03215935826301575, + "mean_coefficients": [ + 0.42610985040664673, + 0.573890209197998 + ], + "elapsed": 218.17016458511353 + }, + { + "step": 144, + "loss": 0.4813964068889618, + "error": 0.2578125, + "gradient_norm": 0.05487911403179169, + "mean_coefficients": [ + 0.3922170102596283, + 0.6077829599380493 + ], + "elapsed": 238.55671858787537 + }, + { + "step": 160, + "loss": 0.3278219997882843, + "error": 0.1474609375, + "gradient_norm": 0.04150420427322388, + "mean_coefficients": [ + 0.3980315625667572, + 0.6019684076309204 + ], + "elapsed": 261.1414167881012 + }, + { + "step": 176, + "loss": 0.5885685086250305, + "error": 0.333984375, + "gradient_norm": 0.035754330456256866, + "mean_coefficients": [ + 0.4095921516418457, + 0.5904078483581543 + ], + "elapsed": 280.4117953777313 + }, + { + "step": 192, + "loss": 0.4211200475692749, + "error": 0.2099609375, + "gradient_norm": 0.045698583126068115, + "mean_coefficients": [ + 0.4314090609550476, + 0.5685908794403076 + ], + "elapsed": 299.1174387931824 + }, + { + "step": 208, + "loss": 0.5783671140670776, + "error": 0.3193359375, + "gradient_norm": 0.042599014937877655, + "mean_coefficients": [ + 0.45120924711227417, + 0.5487907528877258 + ], + "elapsed": 319.4998824596405 + }, + { + "step": 224, + "loss": 0.5515865087509155, + "error": 0.3203125, + "gradient_norm": 0.03870227932929993, + "mean_coefficients": [ + 0.43399181962013245, + 0.5660082101821899 + ], + "elapsed": 337.1067805290222 + }, + { + "step": 240, + "loss": 0.3223415017127991, + "error": 0.146484375, + "gradient_norm": 0.04187055304646492, + "mean_coefficients": [ + 0.43565210700035095, + 0.5643478631973267 + ], + "elapsed": 360.23490476608276 + }, + { + "step": 256, + "loss": 0.14871305227279663, + "error": 0.064453125, + "gradient_norm": 0.023555928841233253, + "mean_coefficients": [ + 0.4496843218803406, + 0.5503156781196594 + ], + "elapsed": 380.6055603027344 + }, + { + "step": 272, + "loss": 0.016909560188651085, + "error": 0.005859375, + "gradient_norm": 0.007025144528597593, + "mean_coefficients": [ + 0.47316980361938477, + 0.5268301963806152 + ], + "elapsed": 400.4117109775543 + }, + { + "step": 288, + "loss": 0.03126583620905876, + "error": 0.0107421875, + "gradient_norm": 0.00677987327799201, + "mean_coefficients": [ + 0.48647376894950867, + 0.513526201248169 + ], + "elapsed": 421.32721424102783 + }, + { + "step": 304, + "loss": 0.015056228265166283, + "error": 0.00390625, + "gradient_norm": 0.004391203168779612, + "mean_coefficients": [ + 0.4802752137184143, + 0.5197247862815857 + ], + "elapsed": 440.02484107017517 + }, + { + "step": 320, + "loss": 0.6543335318565369, + "error": 0.3984375, + "gradient_norm": 0.043641772121191025, + "mean_coefficients": [ + 0.46137332916259766, + 0.5386266708374023 + ], + "elapsed": 461.4827136993408 + }, + { + "step": 336, + "loss": 0.43366891145706177, + "error": 0.2236328125, + "gradient_norm": 0.052468180656433105, + "mean_coefficients": [ + 0.4561651349067688, + 0.5438348650932312 + ], + "elapsed": 476.9050533771515 + }, + { + "step": 352, + "loss": 0.4712753891944885, + "error": 0.2578125, + "gradient_norm": 0.0850258395075798, + "mean_coefficients": [ + 0.47329187393188477, + 0.5267081260681152 + ], + "elapsed": 498.3318154811859 + }, + { + "step": 368, + "loss": 0.5800390243530273, + "error": 0.333984375, + "gradient_norm": 0.04926278814673424, + "mean_coefficients": [ + 0.47176501154899597, + 0.5282349586486816 + ], + "elapsed": 517.5981040000916 + }, + { + "step": 384, + "loss": 0.2240307629108429, + "error": 0.09375, + "gradient_norm": 0.028688540682196617, + "mean_coefficients": [ + 0.5045000910758972, + 0.4954999089241028 + ], + "elapsed": 534.63458943367 + }, + { + "step": 400, + "loss": 0.597924530506134, + "error": 0.3642578125, + "gradient_norm": 0.041638799011707306, + "mean_coefficients": [ + 0.49713680148124695, + 0.5028631687164307 + ], + "elapsed": 554.4411277770996 + }, + { + "step": 416, + "loss": 0.5437486171722412, + "error": 0.2783203125, + "gradient_norm": 0.040762074291706085, + "mean_coefficients": [ + 0.5308403968811035, + 0.46915963292121887 + ], + "elapsed": 570.4008054733276 + }, + { + "step": 432, + "loss": 0.47453391551971436, + "error": 0.2529296875, + "gradient_norm": 0.04694828391075134, + "mean_coefficients": [ + 0.5293633937835693, + 0.47063660621643066 + ], + "elapsed": 589.7109427452087 + }, + { + "step": 448, + "loss": 0.6348706483840942, + "error": 0.384765625, + "gradient_norm": 0.03518350049853325, + "mean_coefficients": [ + 0.5176522731781006, + 0.4823477268218994 + ], + "elapsed": 608.4390025138855 + }, + { + "step": 464, + "loss": 0.020331814885139465, + "error": 0.009765625, + "gradient_norm": 0.006898671388626099, + "mean_coefficients": [ + 0.5043070316314697, + 0.49569302797317505 + ], + "elapsed": 628.7866444587708 + }, + { + "step": 480, + "loss": 0.12150328606367111, + "error": 0.0400390625, + "gradient_norm": 0.02066878229379654, + "mean_coefficients": [ + 0.47933268547058105, + 0.520667314529419 + ], + "elapsed": 649.15460896492 + }, + { + "step": 496, + "loss": 0.5669755935668945, + "error": 0.3212890625, + "gradient_norm": 0.0533452145755291, + "mean_coefficients": [ + 0.5110207796096802, + 0.48897919058799744 + ], + "elapsed": 669.5327253341675 + }, + { + "step": 512, + "loss": 0.48904645442962646, + "error": 0.2431640625, + "gradient_norm": 0.06111208349466324, + "mean_coefficients": [ + 0.4747602343559265, + 0.5252398252487183 + ], + "elapsed": 688.7857129573822 + }, + { + "step": 528, + "loss": 0.5006762742996216, + "error": 0.267578125, + "gradient_norm": 0.06278064846992493, + "mean_coefficients": [ + 0.46502402424812317, + 0.5349759459495544 + ], + "elapsed": 722.3683931827545 + }, + { + "step": 544, + "loss": 0.4780538082122803, + "error": 0.2421875, + "gradient_norm": 0.0510331355035305, + "mean_coefficients": [ + 0.4474865794181824, + 0.5525134205818176 + ], + "elapsed": 742.790007352829 + }, + { + "step": 560, + "loss": 0.5480368137359619, + "error": 0.3125, + "gradient_norm": 0.04929737746715546, + "mean_coefficients": [ + 0.4511070251464844, + 0.5488929748535156 + ], + "elapsed": 762.0487098693848 + }, + { + "step": 576, + "loss": 0.16029930114746094, + "error": 0.0615234375, + "gradient_norm": 0.025595247745513916, + "mean_coefficients": [ + 0.439511775970459, + 0.560488224029541 + ], + "elapsed": 780.7311539649963 + }, + { + "step": 592, + "loss": 0.3186679482460022, + "error": 0.150390625, + "gradient_norm": 0.048987504094839096, + "mean_coefficients": [ + 0.4394666254520416, + 0.5605334043502808 + ], + "elapsed": 801.6919455528259 + }, + { + "step": 608, + "loss": 0.5188161730766296, + "error": 0.2919921875, + "gradient_norm": 0.042723916471004486, + "mean_coefficients": [ + 0.4649806618690491, + 0.5350192785263062 + ], + "elapsed": 823.6975173950195 + }, + { + "step": 624, + "loss": 0.5420911312103271, + "error": 0.3017578125, + "gradient_norm": 0.07124848663806915, + "mean_coefficients": [ + 0.4770982563495636, + 0.5229017734527588 + ], + "elapsed": 842.9545094966888 + }, + { + "step": 640, + "loss": 0.514599084854126, + "error": 0.2724609375, + "gradient_norm": 0.042226750403642654, + "mean_coefficients": [ + 0.5077712535858154, + 0.49222877621650696 + ], + "elapsed": 865.542462348938 + }, + { + "step": 656, + "loss": 0.54783034324646, + "error": 0.2998046875, + "gradient_norm": 0.043302036821842194, + "mean_coefficients": [ + 0.5116667151451111, + 0.48833325505256653 + ], + "elapsed": 886.4461476802826 + }, + { + "step": 672, + "loss": 0.580764889717102, + "error": 0.31640625, + "gradient_norm": 0.05445221811532974, + "mean_coefficients": [ + 0.5066379308700562, + 0.49336206912994385 + ], + "elapsed": 910.1314296722412 + }, + { + "step": 688, + "loss": 0.5923768281936646, + "error": 0.33984375, + "gradient_norm": 0.053689390420913696, + "mean_coefficients": [ + 0.505064845085144, + 0.49493518471717834 + ], + "elapsed": 934.9332280158997 + }, + { + "step": 704, + "loss": 0.6142730712890625, + "error": 0.3232421875, + "gradient_norm": 0.0523676872253418, + "mean_coefficients": [ + 0.51506507396698, + 0.48493492603302 + ], + "elapsed": 955.2821652889252 + }, + { + "step": 720, + "loss": 0.027360184118151665, + "error": 0.0087890625, + "gradient_norm": 0.005057274829596281, + "mean_coefficients": [ + 0.4945293664932251, + 0.5054706335067749 + ], + "elapsed": 971.782705783844 + }, + { + "step": 736, + "loss": 0.019292084500193596, + "error": 0.0048828125, + "gradient_norm": 0.012131650932133198, + "mean_coefficients": [ + 0.46814921498298645, + 0.5318508148193359 + ], + "elapsed": 995.4411764144897 + }, + { + "step": 752, + "loss": 0.28370219469070435, + "error": 0.1162109375, + "gradient_norm": 0.043570809066295624, + "mean_coefficients": [ + 0.4533402621746063, + 0.5466597080230713 + ], + "elapsed": 1016.3589010238647 + }, + { + "step": 768, + "loss": 0.4945998191833496, + "error": 0.287109375, + "gradient_norm": 0.042133282870054245, + "mean_coefficients": [ + 0.48534777760505676, + 0.5146522521972656 + ], + "elapsed": 1037.8080792427063 + }, + { + "step": 784, + "loss": 0.48455703258514404, + "error": 0.2646484375, + "gradient_norm": 0.05964742228388786, + "mean_coefficients": [ + 0.46901020407676697, + 0.5309897661209106 + ], + "elapsed": 1058.1542754173279 + }, + { + "step": 800, + "loss": 0.14743734896183014, + "error": 0.0537109375, + "gradient_norm": 0.02483040653169155, + "mean_coefficients": [ + 0.5056599378585815, + 0.49434009194374084 + ], + "elapsed": 1076.379721403122 + }, + { + "step": 816, + "loss": 0.5364817380905151, + "error": 0.2900390625, + "gradient_norm": 0.04801176115870476, + "mean_coefficients": [ + 0.4571455717086792, + 0.5428544282913208 + ], + "elapsed": 1092.3855652809143 + }, + { + "step": 832, + "loss": 0.6114806532859802, + "error": 0.3603515625, + "gradient_norm": 0.0635533481836319, + "mean_coefficients": [ + 0.44957223534584045, + 0.5504277944564819 + ], + "elapsed": 1112.2118809223175 + }, + { + "step": 848, + "loss": 0.13529899716377258, + "error": 0.05078125, + "gradient_norm": 0.03418346866965294, + "mean_coefficients": [ + 0.4930901527404785, + 0.5069098472595215 + ], + "elapsed": 1134.8346536159515 + }, + { + "step": 864, + "loss": 0.6020746231079102, + "error": 0.37109375, + "gradient_norm": 0.03793048486113548, + "mean_coefficients": [ + 0.5026386976242065, + 0.49736130237579346 + ], + "elapsed": 1153.6004371643066 + }, + { + "step": 880, + "loss": 0.46639662981033325, + "error": 0.244140625, + "gradient_norm": 0.05182372033596039, + "mean_coefficients": [ + 0.49176716804504395, + 0.508232831954956 + ], + "elapsed": 1175.66051197052 + }, + { + "step": 896, + "loss": 0.35056495666503906, + "error": 0.1796875, + "gradient_norm": 0.045919932425022125, + "mean_coefficients": [ + 0.47237810492515564, + 0.5276219248771667 + ], + "elapsed": 1194.3687541484833 + }, + { + "step": 912, + "loss": 0.5886671543121338, + "error": 0.3447265625, + "gradient_norm": 0.045302897691726685, + "mean_coefficients": [ + 0.41737082600593567, + 0.5826291441917419 + ], + "elapsed": 1212.5627307891846 + }, + { + "step": 928, + "loss": 0.6051279306411743, + "error": 0.3408203125, + "gradient_norm": 0.05024299770593643, + "mean_coefficients": [ + 0.4480603337287903, + 0.5519396662712097 + ], + "elapsed": 1237.9728314876556 + }, + { + "step": 944, + "loss": 0.3430662155151367, + "error": 0.1611328125, + "gradient_norm": 0.04460357874631882, + "mean_coefficients": [ + 0.4968012571334839, + 0.5031987428665161 + ], + "elapsed": 1260.0267882347107 + }, + { + "step": 960, + "loss": 0.6355502605438232, + "error": 0.37890625, + "gradient_norm": 0.04846864566206932, + "mean_coefficients": [ + 0.4808691442012787, + 0.5191308259963989 + ], + "elapsed": 1279.905223608017 + }, + { + "step": 976, + "loss": 0.5717797875404358, + "error": 0.3349609375, + "gradient_norm": 0.03617243841290474, + "mean_coefficients": [ + 0.4623255133628845, + 0.5376745462417603 + ], + "elapsed": 1303.0697026252747 + }, + { + "step": 992, + "loss": 0.3269988000392914, + "error": 0.1494140625, + "gradient_norm": 0.05313565954566002, + "mean_coefficients": [ + 0.42171281576156616, + 0.5782871246337891 + ], + "elapsed": 1326.251710176468 + }, + { + "step": 1008, + "loss": 0.6329490542411804, + "error": 0.375, + "gradient_norm": 0.036122437566518784, + "mean_coefficients": [ + 0.4546102285385132, + 0.5453897714614868 + ], + "elapsed": 1347.1945130825043 + }, + { + "step": 1024, + "loss": 0.6227849125862122, + "error": 0.3798828125, + "gradient_norm": 0.048661671578884125, + "mean_coefficients": [ + 0.41305357217788696, + 0.586946427822113 + ], + "elapsed": 1367.592843055725 + }, + { + "step": 1040, + "loss": 0.4212121367454529, + "error": 0.1875, + "gradient_norm": 0.06082203611731529, + "mean_coefficients": [ + 0.45314377546310425, + 0.546856164932251 + ], + "elapsed": 1396.2453150749207 + }, + { + "step": 1056, + "loss": 0.5631591081619263, + "error": 0.3212890625, + "gradient_norm": 0.055875614285469055, + "mean_coefficients": [ + 0.5330983400344849, + 0.4669017195701599 + ], + "elapsed": 1417.7443659305573 + }, + { + "step": 1072, + "loss": 0.10821939259767532, + "error": 0.033203125, + "gradient_norm": 0.03529331088066101, + "mean_coefficients": [ + 0.5035846829414368, + 0.49641531705856323 + ], + "elapsed": 1436.489075422287 + }, + { + "step": 1088, + "loss": 0.5265036821365356, + "error": 0.265625, + "gradient_norm": 0.04223688319325447, + "mean_coefficients": [ + 0.5079262256622314, + 0.49207377433776855 + ], + "elapsed": 1461.3186690807343 + }, + { + "step": 1104, + "loss": 0.4087736904621124, + "error": 0.2109375, + "gradient_norm": 0.0357368029654026, + "mean_coefficients": [ + 0.5090406537055969, + 0.49095937609672546 + ], + "elapsed": 1480.0224187374115 + }, + { + "step": 1120, + "loss": 0.13441112637519836, + "error": 0.0556640625, + "gradient_norm": 0.02240554802119732, + "mean_coefficients": [ + 0.4391622543334961, + 0.5608377456665039 + ], + "elapsed": 1504.261332988739 + }, + { + "step": 1136, + "loss": 0.545034646987915, + "error": 0.3115234375, + "gradient_norm": 0.06524547934532166, + "mean_coefficients": [ + 0.4625178575515747, + 0.5374821424484253 + ], + "elapsed": 1528.559550523758 + }, + { + "step": 1152, + "loss": 0.3058270514011383, + "error": 0.1376953125, + "gradient_norm": 0.04590972512960434, + "mean_coefficients": [ + 0.41034021973609924, + 0.5896598100662231 + ], + "elapsed": 1550.5981769561768 + }, + { + "step": 1168, + "loss": 0.5833588242530823, + "error": 0.33203125, + "gradient_norm": 0.04596199840307236, + "mean_coefficients": [ + 0.456938773393631, + 0.5430612564086914 + ], + "elapsed": 1573.731043100357 + }, + { + "step": 1184, + "loss": 0.5287269353866577, + "error": 0.2763671875, + "gradient_norm": 0.04873070865869522, + "mean_coefficients": [ + 0.5495302081108093, + 0.4504697918891907 + ], + "elapsed": 1593.5648920536041 + }, + { + "step": 1200, + "loss": 0.5420668125152588, + "error": 0.2978515625, + "gradient_norm": 0.042190760374069214, + "mean_coefficients": [ + 0.45947563648223877, + 0.5405243635177612 + ], + "elapsed": 1611.212196111679 + }, + { + "step": 1216, + "loss": 0.5781879425048828, + "error": 0.322265625, + "gradient_norm": 0.0392482727766037, + "mean_coefficients": [ + 0.4420161247253418, + 0.5579838752746582 + ], + "elapsed": 1633.2575182914734 + }, + { + "step": 1232, + "loss": 0.026123439893126488, + "error": 0.0107421875, + "gradient_norm": 0.007018120959401131, + "mean_coefficients": [ + 0.46772003173828125, + 0.532279908657074 + ], + "elapsed": 1653.0733880996704 + }, + { + "step": 1248, + "loss": 0.029043272137641907, + "error": 0.0078125, + "gradient_norm": 0.009661108255386353, + "mean_coefficients": [ + 0.47005489468574524, + 0.5299451351165771 + ], + "elapsed": 1671.2404634952545 + }, + { + "step": 1264, + "loss": 0.582717776298523, + "error": 0.3291015625, + "gradient_norm": 0.06634271144866943, + "mean_coefficients": [ + 0.5097807049751282, + 0.4902192950248718 + ], + "elapsed": 1692.2314596176147 + }, + { + "step": 1280, + "loss": 0.31173962354660034, + "error": 0.14453125, + "gradient_norm": 0.039092399179935455, + "mean_coefficients": [ + 0.4196550250053406, + 0.5803449749946594 + ], + "elapsed": 1713.194138765335 + }, + { + "step": 1296, + "loss": 0.5949922800064087, + "error": 0.357421875, + "gradient_norm": 0.034312762320041656, + "mean_coefficients": [ + 0.4419449269771576, + 0.55805504322052 + ], + "elapsed": 1733.0129091739655 + }, + { + "step": 1312, + "loss": 0.3603796362876892, + "error": 0.16796875, + "gradient_norm": 0.05415824428200722, + "mean_coefficients": [ + 0.41266000270843506, + 0.5873400568962097 + ], + "elapsed": 1757.786653995514 + }, + { + "step": 1328, + "loss": 0.13598129153251648, + "error": 0.0478515625, + "gradient_norm": 0.024467356503009796, + "mean_coefficients": [ + 0.3836991786956787, + 0.6163008213043213 + ], + "elapsed": 1779.825397491455 + }, + { + "step": 1344, + "loss": 0.5115128755569458, + "error": 0.2822265625, + "gradient_norm": 0.053328439593315125, + "mean_coefficients": [ + 0.40296074748039246, + 0.5970393419265747 + ], + "elapsed": 1796.8633427619934 + }, + { + "step": 1360, + "loss": 0.6190367341041565, + "error": 0.3779296875, + "gradient_norm": 0.04020882770419121, + "mean_coefficients": [ + 0.40149205923080444, + 0.5985079407691956 + ], + "elapsed": 1813.90576171875 + }, + { + "step": 1376, + "loss": 0.21154341101646423, + "error": 0.08984375, + "gradient_norm": 0.0423702634871006, + "mean_coefficients": [ + 0.4674369692802429, + 0.5325630307197571 + ], + "elapsed": 1832.588074207306 + }, + { + "step": 1392, + "loss": 0.018975114449858665, + "error": 0.0087890625, + "gradient_norm": 0.005260550882667303, + "mean_coefficients": [ + 0.46262064576148987, + 0.5373793840408325 + ], + "elapsed": 1854.5863862037659 + }, + { + "step": 1408, + "loss": 0.6291724443435669, + "error": 0.3740234375, + "gradient_norm": 0.036437831819057465, + "mean_coefficients": [ + 0.5162137746810913, + 0.4837862253189087 + ], + "elapsed": 1875.442207813263 + }, + { + "step": 1424, + "loss": 0.5361799001693726, + "error": 0.294921875, + "gradient_norm": 0.06118213012814522, + "mean_coefficients": [ + 0.4530576169490814, + 0.5469423532485962 + ], + "elapsed": 1895.730218887329 + }, + { + "step": 1440, + "loss": 0.13184601068496704, + "error": 0.0537109375, + "gradient_norm": 0.0366254597902298, + "mean_coefficients": [ + 0.456234335899353, + 0.543765664100647 + ], + "elapsed": 1918.2103044986725 + }, + { + "step": 1456, + "loss": 0.12348794937133789, + "error": 0.044921875, + "gradient_norm": 0.026519156992435455, + "mean_coefficients": [ + 0.33625853061676025, + 0.6637414693832397 + ], + "elapsed": 1935.9983472824097 + }, + { + "step": 1472, + "loss": 0.13811883330345154, + "error": 0.0615234375, + "gradient_norm": 0.02696700394153595, + "mean_coefficients": [ + 0.4929874837398529, + 0.5070125460624695 + ], + "elapsed": 1957.4508769512177 + }, + { + "step": 1488, + "loss": 0.13847771286964417, + "error": 0.0537109375, + "gradient_norm": 0.030008114874362946, + "mean_coefficients": [ + 0.39965277910232544, + 0.6003471612930298 + ], + "elapsed": 1976.7007565498352 + }, + { + "step": 1504, + "loss": 0.5583300590515137, + "error": 0.310546875, + "gradient_norm": 0.04946867376565933, + "mean_coefficients": [ + 0.5022081136703491, + 0.4977918863296509 + ], + "elapsed": 1998.7133693695068 + }, + { + "step": 1520, + "loss": 0.4180712401866913, + "error": 0.193359375, + "gradient_norm": 0.04930788651108742, + "mean_coefficients": [ + 0.3789001703262329, + 0.6210998296737671 + ], + "elapsed": 2020.1941475868225 + }, + { + "step": 1536, + "loss": 0.573837161064148, + "error": 0.3349609375, + "gradient_norm": 0.040077853947877884, + "mean_coefficients": [ + 0.38551098108291626, + 0.6144890189170837 + ], + "elapsed": 2042.7438170909882 + }, + { + "step": 1552, + "loss": 0.15159833431243896, + "error": 0.0625, + "gradient_norm": 0.025620637461543083, + "mean_coefficients": [ + 0.45392143726348877, + 0.5460785627365112 + ], + "elapsed": 2070.7468621730804 + }, + { + "step": 1568, + "loss": 0.3654119372367859, + "error": 0.1796875, + "gradient_norm": 0.04743841663002968, + "mean_coefficients": [ + 0.3550558388233185, + 0.6449441909790039 + ], + "elapsed": 2089.376792192459 + }, + { + "step": 1584, + "loss": 0.6101510524749756, + "error": 0.3623046875, + "gradient_norm": 0.06323248893022537, + "mean_coefficients": [ + 0.37972599267959595, + 0.620274007320404 + ], + "elapsed": 2109.1351883411407 + }, + { + "step": 1600, + "loss": 0.5123001337051392, + "error": 0.271484375, + "gradient_norm": 0.04863261431455612, + "mean_coefficients": [ + 0.45421111583709717, + 0.5457888841629028 + ], + "elapsed": 2132.400375366211 + }, + { + "step": 1616, + "loss": 0.421336829662323, + "error": 0.2177734375, + "gradient_norm": 0.041021984070539474, + "mean_coefficients": [ + 0.4929773807525635, + 0.5070226192474365 + ], + "elapsed": 2151.1066596508026 + }, + { + "step": 1632, + "loss": 0.5365814566612244, + "error": 0.30078125, + "gradient_norm": 0.037577010691165924, + "mean_coefficients": [ + 0.5444948077201843, + 0.4555051922798157 + ], + "elapsed": 2171.4190695285797 + }, + { + "step": 1648, + "loss": 0.5968600511550903, + "error": 0.3544921875, + "gradient_norm": 0.04259928688406944, + "mean_coefficients": [ + 0.5608794689178467, + 0.4391205310821533 + ], + "elapsed": 2189.533290863037 + }, + { + "step": 1664, + "loss": 0.01629689335823059, + "error": 0.0048828125, + "gradient_norm": 0.009090352803468704, + "mean_coefficients": [ + 0.4871402382850647, + 0.5128598213195801 + ], + "elapsed": 2213.112939119339 + }, + { + "step": 1680, + "loss": 0.4757354259490967, + "error": 0.248046875, + "gradient_norm": 0.0469970703125, + "mean_coefficients": [ + 0.5250517129898071, + 0.47494831681251526 + ], + "elapsed": 2232.9879083633423 + }, + { + "step": 1696, + "loss": 0.6343755125999451, + "error": 0.390625, + "gradient_norm": 0.038207508623600006, + "mean_coefficients": [ + 0.5461910963058472, + 0.4538089632987976 + ], + "elapsed": 2254.4620490074158 + }, + { + "step": 1712, + "loss": 0.14172980189323425, + "error": 0.0537109375, + "gradient_norm": 0.03144967183470726, + "mean_coefficients": [ + 0.4126092791557312, + 0.5873907804489136 + ], + "elapsed": 2274.760455608368 + }, + { + "step": 1728, + "loss": 0.43767249584198, + "error": 0.2236328125, + "gradient_norm": 0.04490065574645996, + "mean_coefficients": [ + 0.5525646209716797, + 0.4474353790283203 + ], + "elapsed": 2292.8783674240112 + }, + { + "step": 1744, + "loss": 0.3858981132507324, + "error": 0.189453125, + "gradient_norm": 0.047112803906202316, + "mean_coefficients": [ + 0.5345168113708496, + 0.46548324823379517 + ], + "elapsed": 2313.2062649726868 + }, + { + "step": 1760, + "loss": 0.026521675288677216, + "error": 0.0078125, + "gradient_norm": 0.008044665679335594, + "mean_coefficients": [ + 0.4988538324832916, + 0.5011461973190308 + ], + "elapsed": 2336.282013654709 + }, + { + "step": 1776, + "loss": 0.02684793435037136, + "error": 0.0087890625, + "gradient_norm": 0.008621076121926308, + "mean_coefficients": [ + 0.4812018871307373, + 0.5187981128692627 + ], + "elapsed": 2354.5700285434723 + }, + { + "step": 1792, + "loss": 0.4362499415874481, + "error": 0.2236328125, + "gradient_norm": 0.05823780596256256, + "mean_coefficients": [ + 0.47490841150283813, + 0.5250915884971619 + ], + "elapsed": 2372.1857488155365 + }, + { + "step": 1808, + "loss": 0.5943711400032043, + "error": 0.361328125, + "gradient_norm": 0.0680852085351944, + "mean_coefficients": [ + 0.47086262702941895, + 0.529137372970581 + ], + "elapsed": 2392.6065361499786 + }, + { + "step": 1824, + "loss": 0.4363088309764862, + "error": 0.216796875, + "gradient_norm": 0.07410386204719543, + "mean_coefficients": [ + 0.37843573093414307, + 0.6215642690658569 + ], + "elapsed": 2411.8226177692413 + }, + { + "step": 1840, + "loss": 0.3196601867675781, + "error": 0.1494140625, + "gradient_norm": 0.05553024634718895, + "mean_coefficients": [ + 0.3391280770301819, + 0.6608718633651733 + ], + "elapsed": 2431.0497477054596 + }, + { + "step": 1856, + "loss": 0.37508872151374817, + "error": 0.1826171875, + "gradient_norm": 0.07089140266180038, + "mean_coefficients": [ + 0.3326033055782318, + 0.6673966646194458 + ], + "elapsed": 2453.021736383438 + }, + { + "step": 1872, + "loss": 0.1499984860420227, + "error": 0.0615234375, + "gradient_norm": 0.03733578324317932, + "mean_coefficients": [ + 0.44182807207107544, + 0.5581719279289246 + ], + "elapsed": 2470.192109823227 + }, + { + "step": 1888, + "loss": 0.4416685104370117, + "error": 0.2265625, + "gradient_norm": 0.07857565581798553, + "mean_coefficients": [ + 0.3767402172088623, + 0.6232597827911377 + ], + "elapsed": 2491.662375688553 + }, + { + "step": 1904, + "loss": 0.4437134861946106, + "error": 0.2158203125, + "gradient_norm": 0.06356606632471085, + "mean_coefficients": [ + 0.47958987951278687, + 0.5204101204872131 + ], + "elapsed": 2512.6289751529694 + }, + { + "step": 1920, + "loss": 0.4932388663291931, + "error": 0.25, + "gradient_norm": 0.05904463678598404, + "mean_coefficients": [ + 0.48851683735847473, + 0.5114831924438477 + ], + "elapsed": 2530.8037297725677 + }, + { + "step": 1936, + "loss": 0.6059780716896057, + "error": 0.3701171875, + "gradient_norm": 0.04947994649410248, + "mean_coefficients": [ + 0.4990648627281189, + 0.5009350776672363 + ], + "elapsed": 2554.520874977112 + }, + { + "step": 1952, + "loss": 0.48124009370803833, + "error": 0.248046875, + "gradient_norm": 0.05768373981118202, + "mean_coefficients": [ + 0.5284570455551147, + 0.47154295444488525 + ], + "elapsed": 2572.1566245555878 + }, + { + "step": 1968, + "loss": 0.09479989111423492, + "error": 0.033203125, + "gradient_norm": 0.02639523521065712, + "mean_coefficients": [ + 0.3885442912578583, + 0.6114556789398193 + ], + "elapsed": 2594.7533991336823 + }, + { + "step": 1984, + "loss": 0.4216057062149048, + "error": 0.1982421875, + "gradient_norm": 0.05092155188322067, + "mean_coefficients": [ + 0.41849398612976074, + 0.5815060138702393 + ], + "elapsed": 2618.397775888443 + }, + { + "step": 2000, + "loss": 0.1493990123271942, + "error": 0.0673828125, + "gradient_norm": 0.026132037863135338, + "mean_coefficients": [ + 0.5240117311477661, + 0.4759882688522339 + ], + "elapsed": 2634.8473727703094 + }, + { + "step": 2016, + "loss": 0.022406509146094322, + "error": 0.0068359375, + "gradient_norm": 0.009604685008525848, + "mean_coefficients": [ + 0.5113526582717896, + 0.48864734172821045 + ], + "elapsed": 2657.3628783226013 + }, + { + "step": 2032, + "loss": 0.5801821947097778, + "error": 0.32421875, + "gradient_norm": 0.0684855505824089, + "mean_coefficients": [ + 0.5880363583564758, + 0.4119635820388794 + ], + "elapsed": 2679.3364017009735 + }, + { + "step": 2048, + "loss": 0.309080570936203, + "error": 0.1357421875, + "gradient_norm": 0.043055612593889236, + "mean_coefficients": [ + 0.3990344703197479, + 0.6009654998779297 + ], + "elapsed": 2698.5810737609863 + } + ], + "seconds": 2709.3174657821655, + "declared_plan": { + "hypothesis": "Joint logical-likelihood training may learn useful shot-dependent complementarity beyond frozen independent expert averages", + "parents": [ + "fresh2_full/weights-1536.npz", + "reserved1_full/weights-1536.npz" + ], + "initialization": "Both experts retain their session-trained parameters and exact Adam moments/count2048; new41-input32-hidden SiLU gate has random hidden weights(seed20261310),zero output and bias,giving equal mixture", + "features": "Gate uses only24site densities,lag1/2/4/8coincidence/covariance,6density/frame summaries,duration/duration_squared/basis;fixed numeric scales,no fitted normalization,no IDs/labels/shot positions/expert probabilities", + "loss": "Logical BCE of two-expert probability mixture; expert BCE adjoints weighted by posterior responsibility,free gate-logit adjoint=coefficient-responsibility; gradients controlled against independent autodiff", + "training": "2048updates B1024;uniform sampling over all516880training rows/26conditions(seed20261311);sharedphysicalpass3 priors;expertLR.0001,gateLR.001;separate AdamW clocks,moments restored for experts,freshgate count0;one joint norm1 clip,decay1e-4", + "selection_steps": [ + 0, + 512, + 1024, + 2048 + ], + "validation": "Full133120 supplied validation shots per listed checkpoint; perbasis choose incumbent or rawjoint/equalphysical,all13durations; tiesretainincumbent. Step0 is fixedmean of trainedparents.1536has screening only and is not a full-selection checkpoint.", + "audit_scope": "All training labels are eligible; no independent reserved-training-label audit claim. Parent initialization provenance retained.", + "controls": "CPUscalar finite differences,exactchain autodiff,feature order/subset checks; two-update serialization/resume/sampling/Adam controls; portableCPUruntime;GPUactualgeometrygradient control before training", + "runtime": "Two exact neural passes share one physical-prior computation; preserve all retained incumbent dispatches;fullreplay/scoring/readonlyrelocation/projection before any publication", + "interpretation": "Learned branches are not identified physical noise regimes; this is a joint model recipe,not an isolated causal test of gating", + "gpu": "One H100,serialized afterfresh_temporal1_finished", + "test_data_used": false, + "parameter_counts": { + "expert0": 29505, + "expert1": 29505, + "gate": 1377, + "total": 60387 + }, + "physical_blend_clarification_before_training": "Equal physical blends use the existing calibrated/ensemble physical pass3 decoder output from turbo1/predictions, checked against runtime config and DEM/plans/weights. Raw feedback5_cache pass3 is only the neural conditioning prior/diagnostic. Corrected before any GPU training or selection in this study." + }, + "sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 512, + 1024, + 1536, + 2048 + ], + "training_draws": 2097152, + "distinct_phase_rows": 507134, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 4096, + "expert1": 4096, + "gate": 2048 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + "pipeline_control": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 runs; no selection or submission", + "expert_parent_state_exact": true, + "new_gate_initialization_exact": true, + "new_gate_zero_adam": true, + "all_three_parts_updated": true, + "resume_weights_optimizer_rng_exact": true, + "sampling_audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture_smoke1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture_smoke2", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "final_adam_counts": { + "expert0": 2050, + "expert1": 2050, + "gate": 2 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + } + ], + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "learned_d5__joint_mixture_state.py": "44e6815f769c02cf2d19e3ad1e33e6f287df8b5ea33f5c87b747361ea41f3dc6", + "learned_d5__joint_mixture_train.py": "048eb44389f53acc00d51da4914ef9404f6d774b915f8805a0102d707599c483", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "source_sha256": "024bd22f8e02257e94ba2c90e8449ce9053bf3a15a852367ac4a260a1cacfa82" + } + }, + "controls": { + "joint_mixture_control_cpu.json": { + "status": "passed", + "device": "CPU", + "parameters": "Discarded synthetic control only; no fitting or checkpoint selection", + "finite_difference_max_abs_error": 8.478551194457395e-11, + "exact_chain_relative_l2_error": 3.588605068216566e-06, + "exact_loss_abs_error": 0.0, + "feature_checks": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "max_abs_error": 2.6654335572029453e-08, + "subset_and_order_exact": true + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "max_abs_error": 1.3308192670091756e-07, + "subset_and_order_exact": true + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "max_abs_error": 1.4485734878277867e-07, + "subset_and_order_exact": true + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "max_abs_error": 7.246140598660133e-08, + "subset_and_order_exact": true + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "max_abs_error": 7.347728192552694e-08, + "subset_and_order_exact": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "max_abs_error": 8.354839098334566e-08, + "subset_and_order_exact": true + } + ], + "initial_function": "Equal expert probabilities exactly; hidden gate gradient zero and output gradient nonzero", + "source_sha256": { + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "joint_mixture_control.py": "627f3b1a7c95173fb498d5a953852043d6a386f26a64a143770f699153bdee5e" + } + }, + "joint_mixture_control_gpu.json": { + "status": "passed", + "device": "cuda:0", + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 2, + "gradient_relative_l2_error": 4.558519322017673e-06, + "loss_abs_error": 5.960464477539063e-08, + "neutral_mixture_max_abs_error": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 2, + "gradient_relative_l2_error": 1.5920244550216012e-05, + "loss_abs_error": 5.960464477539063e-08, + "neutral_mixture_max_abs_error": 1.1920928955078125e-07 + } + ], + "optimizer_updates": 0, + "test_data_used": false, + "source_sha256": { + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb" + } + }, + "joint_mixture_pipeline_control_cpu.json": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 runs; no selection or submission", + "expert_parent_state_exact": true, + "new_gate_initialization_exact": true, + "new_gate_zero_adam": true, + "all_three_parts_updated": true, + "resume_weights_optimizer_rng_exact": true, + "sampling_audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture_smoke1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture_smoke2", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "final_adam_counts": { + "expert0": 2050, + "expert1": 2050, + "gate": 2 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + } + ], + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "learned_d5__joint_mixture_state.py": "44e6815f769c02cf2d19e3ad1e33e6f287df8b5ea33f5c87b747361ea41f3dc6", + "learned_d5__joint_mixture_train.py": "048eb44389f53acc00d51da4914ef9404f6d774b915f8805a0102d707599c483", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "source_sha256": "024bd22f8e02257e94ba2c90e8449ce9053bf3a15a852367ac4a260a1cacfa82" + }, + "joint_mixture_runtime_control_cpu.json": { + "status": "passed", + "device": "CPU", + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 1, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 0.0, + "cpu_recompute_vs_gpu_cached_max_abs_error": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 3, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 0.0, + "cpu_recompute_vs_gpu_cached_max_abs_error": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 1.1641532182693481e-10, + "cpu_recompute_vs_gpu_cached_max_abs_error": 4.423782229423523e-09 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 5.960464477539063e-08, + "cpu_recompute_vs_gpu_cached_max_abs_error": 3.5762786865234375e-07 + } + ], + "weights": "Discarded two-update pipeline control, excluded from selection/submission", + "source_sha256": { + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "joint_mixture_contextual.py": "76c4f2ad404018ab18e3919fc46c4983110cd336133f09551dce4e94ad7021ca" + }, + "previous_runtime_sha256": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550" + } + }, + "test_data_used": false + }, + "joint_branch_extraction": { + "declared_followup_plan": { + "status": "launching follow-up after completed diagnostics", + "created_utc": "2026-10-21T16:03:44.722831+00:00", + "motivation": "Full validation diagnostic showed joint1024 expert0 Zfailure.2192007211538462 versus incumbent.21953125; existing dynamic X remains stronger than the inspected raw/equal branches", + "selection_design": "Adaptively proposed after observing completed1024/2048 branch diagnostics; not a predeclared independent confirmation. All13durations perbasis, incumbent retained on ties.", + "steps": [ + 1024, + 2048 + ], + "methods": [ + "expert0", + "expert1", + "equal" + ], + "excluded": "Condition-mean gate is transductive diagnostic only and is never a runtime candidate", + "new_optimizer_updates": 0, + "initialization": "Exact extraction from this session jointly trained random-initialization parents; no external or pretrained weights", + "runtime": "Reuse already supported raw/equal neural decoder dispatch; full d5replay,all130scoring,relocation and runtimeprojection before atomicpublication", + "test_data_used": false, + "source_sha256": { + "package_joint_branches.py": "be607462bafb2212da96328f4fe2c08d77400a52b0e1aac6f43fb14dd5d83205", + "joint_gate_ablation.py": "ea765d87c0c7495f3871bec5abe05200c866c6dcd52493f6068c99ac9ebfa818" + } + }, + "selection_history": [ + { + "basis": "X", + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23168569711538464, + "1024-expert0": 0.23360877403846156, + "1024-expert1": 0.23266225961538461, + "1024-equal": 0.23189603365384615, + "2048-expert0": 0.23291766826923072, + "2048-expert1": 0.23276742788461538, + "2048-equal": 0.2326923076923077 + }, + "selected": "incumbent" + }, + { + "basis": "Z", + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21953124999999998, + "1024-expert0": 0.2192007211538462, + "1024-expert1": 0.22241586538461536, + "1024-equal": 0.22068810096153843, + "2048-expert0": 0.22067307692307692, + "2048-expert1": 0.22277644230769228, + "2048-equal": 0.2205078125 + }, + "selected": "1024-expert0" + } + ], + "extractions": { + "1024/expert0": { + "source_weights_sha256": "d3193fe31df6de065d5f9c45edccb24076c9635c52711920feabfc03cf82c8e3", + "relative_path": "weights/joint-branch-extract1-1024-expert0.npz", + "weights_sha256": "591a29ec303b429688277aa34f00fc22c2c7a24a3bdd0b572af323f42c9fe22a", + "new_optimizer_updates": 0, + "extraction": "Exact named expert tensors from the jointly trained checkpoint, without changing any parameter", + "training_checkpoint": { + "step": 1024, + "training_draws": 1048576, + "adam_counts": { + "expert0": 3072, + "expert1": 3072, + "gate": 1024 + }, + "distinct_phase_rows": 446971, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 17445, + "surface_code_bX_d5_r03_center_5_5": 17875, + "surface_code_bX_d5_r05_center_5_5": 16246, + "surface_code_bX_d5_r07_center_5_5": 16070, + "surface_code_bX_d5_r09_center_5_5": 16429, + "surface_code_bX_d5_r11_center_5_5": 17791, + "surface_code_bX_d5_r13_center_5_5": 17193, + "surface_code_bX_d5_r15_center_5_5": 17571, + "surface_code_bX_d5_r17_center_5_5": 17502, + "surface_code_bX_d5_r19_center_5_5": 17754, + "surface_code_bX_d5_r21_center_5_5": 17567, + "surface_code_bX_d5_r23_center_5_5": 16091, + "surface_code_bX_d5_r25_center_5_5": 17260, + "surface_code_bZ_d5_r01_center_5_5": 16790, + "surface_code_bZ_d5_r03_center_5_5": 17857, + "surface_code_bZ_d5_r05_center_5_5": 17484, + "surface_code_bZ_d5_r07_center_5_5": 17491, + "surface_code_bZ_d5_r09_center_5_5": 16204, + "surface_code_bZ_d5_r11_center_5_5": 17217, + "surface_code_bZ_d5_r13_center_5_5": 18278, + "surface_code_bZ_d5_r15_center_5_5": 17617, + "surface_code_bZ_d5_r17_center_5_5": 16049, + "surface_code_bZ_d5_r19_center_5_5": 17173, + "surface_code_bZ_d5_r21_center_5_5": 17037, + "surface_code_bZ_d5_r23_center_5_5": 17805, + "surface_code_bZ_d5_r25_center_5_5": 17175 + }, + "weights_sha256": "d3193fe31df6de065d5f9c45edccb24076c9635c52711920feabfc03cf82c8e3", + "complete": true + } + } + }, + "joint_training_provenance": { + "run_config": { + "parents": [ + "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz" + ], + "output": "/run-state/workspace/research/learned_d5/joint_mixture1", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "resume": null, + "steps": 2048, + "batch": 1024, + "expert_lr": 0.0001, + "gate_lr": 0.001, + "gate_seed": 20261310, + "seed": 20261311, + "eval_every": 512, + "validation_shots": 1024, + "validation_batch": 512, + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "learned_d5__joint_mixture_state.py": "44e6815f769c02cf2d19e3ad1e33e6f287df8b5ea33f5c87b747361ea41f3dc6", + "learned_d5__joint_mixture_train.py": "048eb44389f53acc00d51da4914ef9404f6d774b915f8805a0102d707599c483", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "initialization": "Both experts copied with exact Adam state from declared session-trained parents; new gate has random hidden weights and zero output, giving equal initial mixture", + "sampling": "Fresh seed for joint study; resumed phases restore only their own saved sampling state", + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3" + } + }, + "parent_provenance": [ + { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 491030, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18670, + "surface_code_bX_d5_r03_center_5_5": 18940, + "surface_code_bX_d5_r05_center_5_5": 19128, + "surface_code_bX_d5_r07_center_5_5": 18988, + "surface_code_bX_d5_r09_center_5_5": 18523, + "surface_code_bX_d5_r11_center_5_5": 19227, + "surface_code_bX_d5_r13_center_5_5": 18816, + "surface_code_bX_d5_r15_center_5_5": 18107, + "surface_code_bX_d5_r17_center_5_5": 18728, + "surface_code_bX_d5_r19_center_5_5": 18983, + "surface_code_bX_d5_r21_center_5_5": 18959, + "surface_code_bX_d5_r23_center_5_5": 19079, + "surface_code_bX_d5_r25_center_5_5": 19193, + "surface_code_bZ_d5_r01_center_5_5": 18828, + "surface_code_bZ_d5_r03_center_5_5": 18896, + "surface_code_bZ_d5_r05_center_5_5": 19011, + "surface_code_bZ_d5_r07_center_5_5": 18806, + "surface_code_bZ_d5_r09_center_5_5": 18268, + "surface_code_bZ_d5_r11_center_5_5": 18927, + "surface_code_bZ_d5_r13_center_5_5": 19399, + "surface_code_bZ_d5_r15_center_5_5": 19358, + "surface_code_bZ_d5_r17_center_5_5": 18634, + "surface_code_bZ_d5_r19_center_5_5": 19126, + "surface_code_bZ_d5_r21_center_5_5": 18603, + "surface_code_bZ_d5_r23_center_5_5": 18626, + "surface_code_bZ_d5_r25_center_5_5": 19207 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/fresh2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_warm/weights-512.npz", + "starting_checkpoint_sha256": "d3e3abba07693bd7fd3d17be2dd981d5b803a496e76ba230ed94afeb51f26f4f", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 325678, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 11962, + "surface_code_bX_d5_r03_center_5_5": 10232, + "surface_code_bX_d5_r05_center_5_5": 14014, + "surface_code_bX_d5_r07_center_5_5": 11594, + "surface_code_bX_d5_r09_center_5_5": 12805, + "surface_code_bX_d5_r11_center_5_5": 11644, + "surface_code_bX_d5_r13_center_5_5": 13845, + "surface_code_bX_d5_r15_center_5_5": 10703, + "surface_code_bX_d5_r17_center_5_5": 15460, + "surface_code_bX_d5_r19_center_5_5": 14156, + "surface_code_bX_d5_r21_center_5_5": 11568, + "surface_code_bX_d5_r23_center_5_5": 14156, + "surface_code_bX_d5_r25_center_5_5": 12021, + "surface_code_bZ_d5_r01_center_5_5": 10601, + "surface_code_bZ_d5_r03_center_5_5": 14135, + "surface_code_bZ_d5_r05_center_5_5": 11975, + "surface_code_bZ_d5_r07_center_5_5": 13841, + "surface_code_bZ_d5_r09_center_5_5": 12024, + "surface_code_bZ_d5_r11_center_5_5": 11151, + "surface_code_bZ_d5_r13_center_5_5": 10640, + "surface_code_bZ_d5_r15_center_5_5": 11089, + "surface_code_bZ_d5_r17_center_5_5": 13788, + "surface_code_bZ_d5_r19_center_5_5": 12350, + "surface_code_bZ_d5_r21_center_5_5": 12797, + "surface_code_bZ_d5_r23_center_5_5": 12809, + "surface_code_bZ_d5_r25_center_5_5": 14318 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261135", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6522030830383301, + "objective": 0.6522030830383301, + "error": 0.375, + "gradient_norm": 0.11649785190820694, + "elapsed": 30.089841604232788 + }, + { + "step": 16, + "loss": 0.5927819609642029, + "objective": 0.5927819609642029, + "error": 0.3466796875, + "gradient_norm": 0.07945127785205841, + "elapsed": 48.85365080833435 + }, + { + "step": 32, + "loss": 0.3115929663181305, + "objective": 0.3115929663181305, + "error": 0.13671875, + "gradient_norm": 0.039320655167102814, + "elapsed": 63.60312819480896 + }, + { + "step": 48, + "loss": 0.2456369698047638, + "objective": 0.2456369698047638, + "error": 0.1015625, + "gradient_norm": 0.029398636892437935, + "elapsed": 73.71074151992798 + }, + { + "step": 64, + "loss": 0.6231744885444641, + "objective": 0.6231744885444641, + "error": 0.3759765625, + "gradient_norm": 0.06867238879203796, + "elapsed": 83.75580954551697 + }, + { + "step": 80, + "loss": 0.3674217164516449, + "objective": 0.3674217164516449, + "error": 0.1572265625, + "gradient_norm": 0.0557992123067379, + "elapsed": 94.6383364200592 + }, + { + "step": 96, + "loss": 0.5152362585067749, + "objective": 0.5152362585067749, + "error": 0.2568359375, + "gradient_norm": 0.08284599334001541, + "elapsed": 106.90000939369202 + }, + { + "step": 112, + "loss": 0.020773420110344887, + "objective": 0.020773420110344887, + "error": 0.0048828125, + "gradient_norm": 0.008813572116196156, + "elapsed": 117.77558088302612 + }, + { + "step": 128, + "loss": 0.02593131735920906, + "objective": 0.02593131735920906, + "error": 0.0087890625, + "gradient_norm": 0.00872033555060625, + "elapsed": 128.93439435958862 + }, + { + "step": 144, + "loss": 0.5852900743484497, + "objective": 0.5852900743484497, + "error": 0.3291015625, + "gradient_norm": 0.04771002382040024, + "elapsed": 139.5588686466217 + }, + { + "step": 160, + "loss": 0.46074625849723816, + "objective": 0.46074625849723816, + "error": 0.232421875, + "gradient_norm": 0.08834747970104218, + "elapsed": 151.5595977306366 + }, + { + "step": 176, + "loss": 0.6310865879058838, + "objective": 0.6310865879058838, + "error": 0.376953125, + "gradient_norm": 0.14084596931934357, + "elapsed": 163.7892107963562 + }, + { + "step": 192, + "loss": 0.246865376830101, + "objective": 0.246865376830101, + "error": 0.1103515625, + "gradient_norm": 0.041402049362659454, + "elapsed": 174.28971648216248 + }, + { + "step": 208, + "loss": 0.3103577196598053, + "objective": 0.3103577196598053, + "error": 0.15625, + "gradient_norm": 0.04525696486234665, + "elapsed": 187.03909611701965 + }, + { + "step": 224, + "loss": 0.4523138999938965, + "objective": 0.4523138999938965, + "error": 0.208984375, + "gradient_norm": 0.09180521965026855, + "elapsed": 199.56195068359375 + }, + { + "step": 240, + "loss": 0.02241751179099083, + "objective": 0.02241751179099083, + "error": 0.009765625, + "gradient_norm": 0.009998111054301262, + "elapsed": 212.35500597953796 + }, + { + "step": 256, + "loss": 0.5487150549888611, + "objective": 0.5487150549888611, + "error": 0.294921875, + "gradient_norm": 0.12748055160045624, + "elapsed": 223.03854608535767 + }, + { + "step": 272, + "loss": 0.023057367652654648, + "objective": 0.023057367652654648, + "error": 0.0078125, + "gradient_norm": 0.006953821517527103, + "elapsed": 244.6508972644806 + }, + { + "step": 288, + "loss": 0.5845386981964111, + "objective": 0.5845386981964111, + "error": 0.330078125, + "gradient_norm": 0.06542652100324631, + "elapsed": 256.78167748451233 + }, + { + "step": 304, + "loss": 0.442532479763031, + "objective": 0.442532479763031, + "error": 0.232421875, + "gradient_norm": 0.10874580591917038, + "elapsed": 269.1364529132843 + }, + { + "step": 320, + "loss": 0.3264174163341522, + "objective": 0.3264174163341522, + "error": 0.15625, + "gradient_norm": 0.06276191771030426, + "elapsed": 282.38969564437866 + }, + { + "step": 336, + "loss": 0.386960506439209, + "objective": 0.386960506439209, + "error": 0.177734375, + "gradient_norm": 0.06561421602964401, + "elapsed": 292.9079031944275 + }, + { + "step": 352, + "loss": 0.23919886350631714, + "objective": 0.23919886350631714, + "error": 0.107421875, + "gradient_norm": 0.02755703590810299, + "elapsed": 304.16068935394287 + }, + { + "step": 368, + "loss": 0.5029175281524658, + "objective": 0.5029175281524658, + "error": 0.259765625, + "gradient_norm": 0.0378776490688324, + "elapsed": 315.11088514328003 + }, + { + "step": 384, + "loss": 0.565666675567627, + "objective": 0.565666675567627, + "error": 0.322265625, + "gradient_norm": 0.11368246376514435, + "elapsed": 324.3651068210602 + }, + { + "step": 400, + "loss": 0.5846428275108337, + "objective": 0.5846428275108337, + "error": 0.3408203125, + "gradient_norm": 0.08116643130779266, + "elapsed": 334.70786476135254 + }, + { + "step": 416, + "loss": 0.025111017748713493, + "objective": 0.025111017748713493, + "error": 0.0078125, + "gradient_norm": 0.008838560432195663, + "elapsed": 345.56963562965393 + }, + { + "step": 432, + "loss": 0.628488302230835, + "objective": 0.628488302230835, + "error": 0.3818359375, + "gradient_norm": 0.04001976177096367, + "elapsed": 355.3310384750366 + }, + { + "step": 448, + "loss": 0.4569575786590576, + "objective": 0.4569575786590576, + "error": 0.2578125, + "gradient_norm": 0.06344135850667953, + "elapsed": 367.05255675315857 + }, + { + "step": 464, + "loss": 0.49193111062049866, + "objective": 0.49193111062049866, + "error": 0.24609375, + "gradient_norm": 0.06022385507822037, + "elapsed": 377.38399291038513 + }, + { + "step": 480, + "loss": 0.5920064449310303, + "objective": 0.5920064449310303, + "error": 0.3466796875, + "gradient_norm": 0.036063045263290405, + "elapsed": 387.7266733646393 + }, + { + "step": 496, + "loss": 0.22157302498817444, + "objective": 0.22157302498817444, + "error": 0.09375, + "gradient_norm": 0.04071022942662239, + "elapsed": 397.78643012046814 + }, + { + "step": 512, + "loss": 0.39216887950897217, + "objective": 0.39216887950897217, + "error": 0.1728515625, + "gradient_norm": 0.09079446643590927, + "elapsed": 407.0137679576874 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6092928647994995, + "objective": 0.6092928647994995, + "error": 0.3583984375, + "gradient_norm": 0.08161187171936035, + "elapsed": 27.421262741088867 + }, + { + "step": 16, + "loss": 0.4709879755973816, + "objective": 0.4709879755973816, + "error": 0.2529296875, + "gradient_norm": 0.0541619211435318, + "elapsed": 48.74575757980347 + }, + { + "step": 32, + "loss": 0.5842419862747192, + "objective": 0.5842419862747192, + "error": 0.34375, + "gradient_norm": 0.09450904279947281, + "elapsed": 60.68022179603577 + }, + { + "step": 48, + "loss": 0.5840846300125122, + "objective": 0.5840846300125122, + "error": 0.32421875, + "gradient_norm": 0.04569687321782112, + "elapsed": 74.63272476196289 + }, + { + "step": 64, + "loss": 0.5139708518981934, + "objective": 0.5139708518981934, + "error": 0.2646484375, + "gradient_norm": 0.16111725568771362, + "elapsed": 91.88426613807678 + }, + { + "step": 80, + "loss": 0.49099838733673096, + "objective": 0.49099838733673096, + "error": 0.251953125, + "gradient_norm": 0.04431874305009842, + "elapsed": 105.08457684516907 + }, + { + "step": 96, + "loss": 0.30287861824035645, + "objective": 0.30287861824035645, + "error": 0.14453125, + "gradient_norm": 0.03792181238532066, + "elapsed": 118.16054177284241 + }, + { + "step": 112, + "loss": 0.6026535630226135, + "objective": 0.6026535630226135, + "error": 0.359375, + "gradient_norm": 0.043088704347610474, + "elapsed": 134.6414511203766 + }, + { + "step": 128, + "loss": 0.5983598828315735, + "objective": 0.5983598828315735, + "error": 0.328125, + "gradient_norm": 0.06492504477500916, + "elapsed": 148.38875198364258 + }, + { + "step": 144, + "loss": 0.616276204586029, + "objective": 0.616276204586029, + "error": 0.3857421875, + "gradient_norm": 0.05420554056763649, + "elapsed": 164.11315298080444 + }, + { + "step": 160, + "loss": 0.017882924526929855, + "objective": 0.017882924526929855, + "error": 0.0048828125, + "gradient_norm": 0.004682278726249933, + "elapsed": 178.31525373458862 + }, + { + "step": 176, + "loss": 0.5279660820960999, + "objective": 0.5279660820960999, + "error": 0.271484375, + "gradient_norm": 0.03895021602511406, + "elapsed": 192.20261907577515 + }, + { + "step": 192, + "loss": 0.5794406533241272, + "objective": 0.5794406533241272, + "error": 0.34375, + "gradient_norm": 0.041880734264850616, + "elapsed": 200.32051873207092 + }, + { + "step": 208, + "loss": 0.3353561758995056, + "objective": 0.3353561758995056, + "error": 0.1513671875, + "gradient_norm": 0.07022152841091156, + "elapsed": 212.5193521976471 + }, + { + "step": 224, + "loss": 0.47239983081817627, + "objective": 0.47239983081817627, + "error": 0.23828125, + "gradient_norm": 0.044771477580070496, + "elapsed": 223.36571788787842 + }, + { + "step": 240, + "loss": 0.6235381364822388, + "objective": 0.6235381364822388, + "error": 0.3779296875, + "gradient_norm": 0.047636937350034714, + "elapsed": 233.90032649040222 + }, + { + "step": 256, + "loss": 0.516319751739502, + "objective": 0.516319751739502, + "error": 0.271484375, + "gradient_norm": 0.087476447224617, + "elapsed": 245.52193427085876 + }, + { + "step": 272, + "loss": 0.23385891318321228, + "objective": 0.23385891318321228, + "error": 0.091796875, + "gradient_norm": 0.05921977758407593, + "elapsed": 254.38622951507568 + }, + { + "step": 288, + "loss": 0.31280556321144104, + "objective": 0.31280556321144104, + "error": 0.1318359375, + "gradient_norm": 0.03548427298665047, + "elapsed": 263.25871300697327 + }, + { + "step": 304, + "loss": 0.6208417415618896, + "objective": 0.6208417415618896, + "error": 0.361328125, + "gradient_norm": 0.10255666077136993, + "elapsed": 273.5115919113159 + }, + { + "step": 320, + "loss": 0.5985375642776489, + "objective": 0.5985375642776489, + "error": 0.3603515625, + "gradient_norm": 0.04024764895439148, + "elapsed": 285.4135670661926 + }, + { + "step": 336, + "loss": 0.028151696547865868, + "objective": 0.028151696547865868, + "error": 0.009765625, + "gradient_norm": 0.008847440592944622, + "elapsed": 295.0800693035126 + }, + { + "step": 352, + "loss": 0.6147637963294983, + "objective": 0.6147637963294983, + "error": 0.3603515625, + "gradient_norm": 0.05709920823574066, + "elapsed": 305.32019686698914 + }, + { + "step": 368, + "loss": 0.5955979824066162, + "objective": 0.5955979824066162, + "error": 0.3486328125, + "gradient_norm": 0.04276399686932564, + "elapsed": 316.3869025707245 + }, + { + "step": 384, + "loss": 0.23504304885864258, + "objective": 0.23504304885864258, + "error": 0.1025390625, + "gradient_norm": 0.03205326199531555, + "elapsed": 325.7849349975586 + }, + { + "step": 400, + "loss": 0.13460804522037506, + "objective": 0.13460804522037506, + "error": 0.0546875, + "gradient_norm": 0.03109711967408657, + "elapsed": 335.72691917419434 + }, + { + "step": 416, + "loss": 0.5798783302307129, + "objective": 0.5798783302307129, + "error": 0.322265625, + "gradient_norm": 0.053542010486125946, + "elapsed": 345.7052640914917 + }, + { + "step": 432, + "loss": 0.3892784118652344, + "objective": 0.3892784118652344, + "error": 0.19140625, + "gradient_norm": 0.052194178104400635, + "elapsed": 357.38475036621094 + }, + { + "step": 448, + "loss": 0.23582103848457336, + "objective": 0.23582103848457336, + "error": 0.1181640625, + "gradient_norm": 0.032037943601608276, + "elapsed": 369.5841510295868 + }, + { + "step": 464, + "loss": 0.5408849716186523, + "objective": 0.5408849716186523, + "error": 0.2900390625, + "gradient_norm": 0.07508285343647003, + "elapsed": 379.84099793434143 + }, + { + "step": 480, + "loss": 0.3894873559474945, + "objective": 0.3894873559474945, + "error": 0.19140625, + "gradient_norm": 0.03977999836206436, + "elapsed": 390.9687530994415 + }, + { + "step": 496, + "loss": 0.6059300899505615, + "objective": 0.6059300899505615, + "error": 0.361328125, + "gradient_norm": 0.06041429564356804, + "elapsed": 403.2380111217499 + }, + { + "step": 512, + "loss": 0.2117740511894226, + "objective": 0.2117740511894226, + "error": 0.0908203125, + "gradient_norm": 0.05693414434790611, + "elapsed": 414.4854781627655 + }, + { + "step": 528, + "loss": 0.4666211009025574, + "objective": 0.4666211009025574, + "error": 0.2470703125, + "gradient_norm": 0.0764947235584259, + "elapsed": 433.42368054389954 + }, + { + "step": 544, + "loss": 0.22636458277702332, + "objective": 0.22636458277702332, + "error": 0.1083984375, + "gradient_norm": 0.03683016076683998, + "elapsed": 442.92575907707214 + }, + { + "step": 560, + "loss": 0.23172692954540253, + "objective": 0.23172692954540253, + "error": 0.1083984375, + "gradient_norm": 0.034071482717990875, + "elapsed": 453.3129711151123 + }, + { + "step": 576, + "loss": 0.4768703579902649, + "objective": 0.4768703579902649, + "error": 0.2529296875, + "gradient_norm": 0.06308378279209137, + "elapsed": 462.4127457141876 + }, + { + "step": 592, + "loss": 0.5165150165557861, + "objective": 0.5165150165557861, + "error": 0.291015625, + "gradient_norm": 0.07674732059240341, + "elapsed": 473.8309862613678 + }, + { + "step": 608, + "loss": 0.5919064283370972, + "objective": 0.5919064283370972, + "error": 0.3359375, + "gradient_norm": 0.06379934400320053, + "elapsed": 484.3733870983124 + }, + { + "step": 624, + "loss": 0.01804366335272789, + "objective": 0.01804366335272789, + "error": 0.0068359375, + "gradient_norm": 0.005318541545420885, + "elapsed": 495.94076347351074 + }, + { + "step": 640, + "loss": 0.41747498512268066, + "objective": 0.41747498512268066, + "error": 0.1962890625, + "gradient_norm": 0.052116431295871735, + "elapsed": 506.73559165000916 + }, + { + "step": 656, + "loss": 0.6140056848526001, + "objective": 0.6140056848526001, + "error": 0.3896484375, + "gradient_norm": 0.05376415699720383, + "elapsed": 517.2397899627686 + }, + { + "step": 672, + "loss": 0.4098930358886719, + "objective": 0.4098930358886719, + "error": 0.197265625, + "gradient_norm": 0.04737741872668266, + "elapsed": 525.7957897186279 + }, + { + "step": 688, + "loss": 0.3499884009361267, + "objective": 0.3499884009361267, + "error": 0.1650390625, + "gradient_norm": 0.0714973583817482, + "elapsed": 534.9302124977112 + }, + { + "step": 704, + "loss": 0.552291989326477, + "objective": 0.552291989326477, + "error": 0.3095703125, + "gradient_norm": 0.10188189148902893, + "elapsed": 545.4470670223236 + }, + { + "step": 720, + "loss": 0.4040689468383789, + "objective": 0.4040689468383789, + "error": 0.1943359375, + "gradient_norm": 0.06630362570285797, + "elapsed": 554.2920794487 + }, + { + "step": 736, + "loss": 0.3191133439540863, + "objective": 0.3191133439540863, + "error": 0.15625, + "gradient_norm": 0.060587506741285324, + "elapsed": 562.335791349411 + }, + { + "step": 752, + "loss": 0.5949387550354004, + "objective": 0.5949387550354004, + "error": 0.330078125, + "gradient_norm": 0.051291145384311676, + "elapsed": 570.9363489151001 + }, + { + "step": 768, + "loss": 0.4783790409564972, + "objective": 0.4783790409564972, + "error": 0.244140625, + "gradient_norm": 0.08808670938014984, + "elapsed": 581.1555306911469 + }, + { + "step": 784, + "loss": 0.4414710998535156, + "objective": 0.4414710998535156, + "error": 0.20703125, + "gradient_norm": 0.06632383912801743, + "elapsed": 590.4109175205231 + }, + { + "step": 800, + "loss": 0.2536136507987976, + "objective": 0.2536136507987976, + "error": 0.1142578125, + "gradient_norm": 0.03191893920302391, + "elapsed": 601.43274974823 + }, + { + "step": 816, + "loss": 0.22448071837425232, + "objective": 0.22448071837425232, + "error": 0.1015625, + "gradient_norm": 0.04966023191809654, + "elapsed": 612.7252013683319 + }, + { + "step": 832, + "loss": 0.5342355966567993, + "objective": 0.5342355966567993, + "error": 0.2783203125, + "gradient_norm": 0.05757307633757591, + "elapsed": 623.6647284030914 + }, + { + "step": 848, + "loss": 0.2506354749202728, + "objective": 0.2506354749202728, + "error": 0.109375, + "gradient_norm": 0.03991081938147545, + "elapsed": 635.1636409759521 + }, + { + "step": 864, + "loss": 0.40698009729385376, + "objective": 0.40698009729385376, + "error": 0.1953125, + "gradient_norm": 0.09155476838350296, + "elapsed": 645.2128469944 + }, + { + "step": 880, + "loss": 0.563283383846283, + "objective": 0.563283383846283, + "error": 0.3134765625, + "gradient_norm": 0.11409252882003784, + "elapsed": 659.2946681976318 + }, + { + "step": 896, + "loss": 0.13591040670871735, + "objective": 0.13591040670871735, + "error": 0.064453125, + "gradient_norm": 0.02692740224301815, + "elapsed": 668.6167254447937 + }, + { + "step": 912, + "loss": 0.5798318982124329, + "objective": 0.5798318982124329, + "error": 0.3310546875, + "gradient_norm": 0.06674209237098694, + "elapsed": 680.6492185592651 + }, + { + "step": 928, + "loss": 0.6140691041946411, + "objective": 0.6140691041946411, + "error": 0.3857421875, + "gradient_norm": 0.06117575615644455, + "elapsed": 693.1704411506653 + }, + { + "step": 944, + "loss": 0.3964633643627167, + "objective": 0.3964633643627167, + "error": 0.1865234375, + "gradient_norm": 0.08617512136697769, + "elapsed": 708.2128443717957 + }, + { + "step": 960, + "loss": 0.5512299537658691, + "objective": 0.5512299537658691, + "error": 0.2861328125, + "gradient_norm": 0.05705108866095543, + "elapsed": 720.2417063713074 + }, + { + "step": 976, + "loss": 0.454137921333313, + "objective": 0.454137921333313, + "error": 0.216796875, + "gradient_norm": 0.07962293922901154, + "elapsed": 730.2567391395569 + }, + { + "step": 992, + "loss": 0.5681213140487671, + "objective": 0.5681213140487671, + "error": 0.3017578125, + "gradient_norm": 0.09802286326885223, + "elapsed": 742.7380962371826 + }, + { + "step": 1008, + "loss": 0.13060352206230164, + "objective": 0.13060352206230164, + "error": 0.0537109375, + "gradient_norm": 0.04271279275417328, + "elapsed": 750.8077793121338 + }, + { + "step": 1024, + "loss": 0.6129879355430603, + "objective": 0.6129879355430603, + "error": 0.3603515625, + "gradient_norm": 0.04127912223339081, + "elapsed": 761.0585849285126 + }, + { + "step": 1040, + "loss": 0.31361687183380127, + "objective": 0.31361687183380127, + "error": 0.1455078125, + "gradient_norm": 0.04341907799243927, + "elapsed": 776.3491418361664 + }, + { + "step": 1056, + "loss": 0.6326502561569214, + "objective": 0.6326502561569214, + "error": 0.365234375, + "gradient_norm": 0.07518075406551361, + "elapsed": 786.0424168109894 + }, + { + "step": 1072, + "loss": 0.537599503993988, + "objective": 0.537599503993988, + "error": 0.2958984375, + "gradient_norm": 0.08455493301153183, + "elapsed": 795.1607735157013 + }, + { + "step": 1088, + "loss": 0.5953108072280884, + "objective": 0.5953108072280884, + "error": 0.337890625, + "gradient_norm": 0.06973882764577866, + "elapsed": 804.0053510665894 + }, + { + "step": 1104, + "loss": 0.36860400438308716, + "objective": 0.36860400438308716, + "error": 0.1923828125, + "gradient_norm": 0.04828036576509476, + "elapsed": 813.4029138088226 + }, + { + "step": 1120, + "loss": 0.5423247218132019, + "objective": 0.5423247218132019, + "error": 0.28125, + "gradient_norm": 0.04841453209519386, + "elapsed": 823.626978635788 + }, + { + "step": 1136, + "loss": 0.4766136407852173, + "objective": 0.4766136407852173, + "error": 0.236328125, + "gradient_norm": 0.07564551383256912, + "elapsed": 832.4641265869141 + }, + { + "step": 1152, + "loss": 0.5473434925079346, + "objective": 0.5473434925079346, + "error": 0.2958984375, + "gradient_norm": 0.13677075505256653, + "elapsed": 844.9307618141174 + }, + { + "step": 1168, + "loss": 0.3040686249732971, + "objective": 0.3040686249732971, + "error": 0.150390625, + "gradient_norm": 0.045926257967948914, + "elapsed": 854.336992263794 + }, + { + "step": 1184, + "loss": 0.6298375129699707, + "objective": 0.6298375129699707, + "error": 0.3798828125, + "gradient_norm": 0.06807851791381836, + "elapsed": 864.5731596946716 + }, + { + "step": 1200, + "loss": 0.6272540092468262, + "objective": 0.6272540092468262, + "error": 0.37890625, + "gradient_norm": 0.139838308095932, + "elapsed": 877.8357374668121 + }, + { + "step": 1216, + "loss": 0.5224937200546265, + "objective": 0.5224937200546265, + "error": 0.287109375, + "gradient_norm": 0.0647057592868805, + "elapsed": 887.8107197284698 + }, + { + "step": 1232, + "loss": 0.02408422902226448, + "objective": 0.02408422902226448, + "error": 0.0107421875, + "gradient_norm": 0.007562167476862669, + "elapsed": 902.201171875 + }, + { + "step": 1248, + "loss": 0.01936865597963333, + "objective": 0.01936865597963333, + "error": 0.0048828125, + "gradient_norm": 0.006423021201044321, + "elapsed": 914.0247437953949 + }, + { + "step": 1264, + "loss": 0.47522181272506714, + "objective": 0.47522181272506714, + "error": 0.2490234375, + "gradient_norm": 0.04962826892733574, + "elapsed": 927.0462884902954 + }, + { + "step": 1280, + "loss": 0.019577551633119583, + "objective": 0.019577551633119583, + "error": 0.0068359375, + "gradient_norm": 0.008308992721140385, + "elapsed": 939.3647270202637 + }, + { + "step": 1296, + "loss": 0.5085430145263672, + "objective": 0.5085430145263672, + "error": 0.2734375, + "gradient_norm": 0.06214233115315437, + "elapsed": 949.4259700775146 + }, + { + "step": 1312, + "loss": 0.23232896625995636, + "objective": 0.23232896625995636, + "error": 0.1015625, + "gradient_norm": 0.05894213914871216, + "elapsed": 961.3636543750763 + }, + { + "step": 1328, + "loss": 0.5330536365509033, + "objective": 0.5330536365509033, + "error": 0.2861328125, + "gradient_norm": 0.11579663306474686, + "elapsed": 972.1607241630554 + }, + { + "step": 1344, + "loss": 0.019525721669197083, + "objective": 0.019525721669197083, + "error": 0.0087890625, + "gradient_norm": 0.008134250529110432, + "elapsed": 983.0828921794891 + }, + { + "step": 1360, + "loss": 0.22790294885635376, + "objective": 0.22790294885635376, + "error": 0.103515625, + "gradient_norm": 0.04187086224555969, + "elapsed": 991.3167304992676 + }, + { + "step": 1376, + "loss": 0.48713046312332153, + "objective": 0.48713046312332153, + "error": 0.2666015625, + "gradient_norm": 0.06267429888248444, + "elapsed": 1003.5033710002899 + }, + { + "step": 1392, + "loss": 0.6043434143066406, + "objective": 0.6043434143066406, + "error": 0.369140625, + "gradient_norm": 0.037880122661590576, + "elapsed": 1017.8567223548889 + }, + { + "step": 1408, + "loss": 0.034499723464250565, + "objective": 0.034499723464250565, + "error": 0.0068359375, + "gradient_norm": 0.013505477458238602, + "elapsed": 1027.3547134399414 + }, + { + "step": 1424, + "loss": 0.5320160388946533, + "objective": 0.5320160388946533, + "error": 0.306640625, + "gradient_norm": 0.07510018348693848, + "elapsed": 1036.9454221725464 + }, + { + "step": 1440, + "loss": 0.3451523780822754, + "objective": 0.3451523780822754, + "error": 0.171875, + "gradient_norm": 0.06453985720872879, + "elapsed": 1046.1805095672607 + }, + { + "step": 1456, + "loss": 0.21541815996170044, + "objective": 0.21541815996170044, + "error": 0.08984375, + "gradient_norm": 0.043503839522600174, + "elapsed": 1055.850379705429 + }, + { + "step": 1472, + "loss": 0.43667086958885193, + "objective": 0.43667086958885193, + "error": 0.22265625, + "gradient_norm": 0.07311506569385529, + "elapsed": 1066.6324400901794 + }, + { + "step": 1488, + "loss": 0.6163139939308167, + "objective": 0.6163139939308167, + "error": 0.3779296875, + "gradient_norm": 0.06406569480895996, + "elapsed": 1075.7883398532867 + }, + { + "step": 1504, + "loss": 0.23901250958442688, + "objective": 0.23901250958442688, + "error": 0.10546875, + "gradient_norm": 0.04792191833257675, + "elapsed": 1085.4756922721863 + }, + { + "step": 1520, + "loss": 0.3817014694213867, + "objective": 0.3817014694213867, + "error": 0.18359375, + "gradient_norm": 0.046061187982559204, + "elapsed": 1095.974383354187 + }, + { + "step": 1536, + "loss": 0.5593156814575195, + "objective": 0.5593156814575195, + "error": 0.3017578125, + "gradient_norm": 0.0735388696193695, + "elapsed": 1105.913155078888 + } + ] + }, + { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 466919, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved1_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved1_warm/weights-512.npz", + "starting_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317613, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261272", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.1412775069475174, + "objective": 0.1412775069475174, + "error": 0.0595703125, + "gradient_norm": 0.030735325068235397, + "elapsed": 28.457472801208496 + }, + { + "step": 16, + "loss": 0.6315727233886719, + "objective": 0.6315727233886719, + "error": 0.384765625, + "gradient_norm": 0.06563512235879898, + "elapsed": 47.886730670928955 + }, + { + "step": 32, + "loss": 0.5130410194396973, + "objective": 0.5130410194396973, + "error": 0.263671875, + "gradient_norm": 0.10626910626888275, + "elapsed": 60.16136598587036 + }, + { + "step": 48, + "loss": 0.6413166522979736, + "objective": 0.6413166522979736, + "error": 0.408203125, + "gradient_norm": 0.03790846839547157, + "elapsed": 70.9611382484436 + }, + { + "step": 64, + "loss": 0.5491592884063721, + "objective": 0.5491592884063721, + "error": 0.2939453125, + "gradient_norm": 0.093081034719944, + "elapsed": 81.46673464775085 + }, + { + "step": 80, + "loss": 0.6315242648124695, + "objective": 0.6315242648124695, + "error": 0.359375, + "gradient_norm": 0.0384257510304451, + "elapsed": 91.71172666549683 + }, + { + "step": 96, + "loss": 0.6311566829681396, + "objective": 0.6311566829681396, + "error": 0.3798828125, + "gradient_norm": 0.03731638938188553, + "elapsed": 100.83252763748169 + }, + { + "step": 112, + "loss": 0.5327925682067871, + "objective": 0.5327925682067871, + "error": 0.29296875, + "gradient_norm": 0.11202990263700485, + "elapsed": 111.35073852539062 + }, + { + "step": 128, + "loss": 0.6284654140472412, + "objective": 0.6284654140472412, + "error": 0.3740234375, + "gradient_norm": 0.03215613588690758, + "elapsed": 121.32994651794434 + }, + { + "step": 144, + "loss": 0.33964547514915466, + "objective": 0.33964547514915466, + "error": 0.1259765625, + "gradient_norm": 0.05133189633488655, + "elapsed": 131.2744882106781 + }, + { + "step": 160, + "loss": 0.14193454384803772, + "objective": 0.14193454384803772, + "error": 0.0478515625, + "gradient_norm": 0.03264402225613594, + "elapsed": 139.58473920822144 + }, + { + "step": 176, + "loss": 0.14203950762748718, + "objective": 0.14203950762748718, + "error": 0.0654296875, + "gradient_norm": 0.022548990324139595, + "elapsed": 148.9861602783203 + }, + { + "step": 192, + "loss": 0.6307225227355957, + "objective": 0.6307225227355957, + "error": 0.3955078125, + "gradient_norm": 0.08607082068920135, + "elapsed": 162.27514505386353 + }, + { + "step": 208, + "loss": 0.16193106770515442, + "objective": 0.16193106770515442, + "error": 0.064453125, + "gradient_norm": 0.023293493315577507, + "elapsed": 173.59824013710022 + }, + { + "step": 224, + "loss": 0.5426318049430847, + "objective": 0.5426318049430847, + "error": 0.3037109375, + "gradient_norm": 0.03944721072912216, + "elapsed": 182.70232272148132 + }, + { + "step": 240, + "loss": 0.6270365715026855, + "objective": 0.6270365715026855, + "error": 0.3896484375, + "gradient_norm": 0.14661568403244019, + "elapsed": 193.759183883667 + }, + { + "step": 256, + "loss": 0.4933152198791504, + "objective": 0.4933152198791504, + "error": 0.2724609375, + "gradient_norm": 0.1065438985824585, + "elapsed": 205.62959718704224 + }, + { + "step": 272, + "loss": 0.3671969473361969, + "objective": 0.3671969473361969, + "error": 0.177734375, + "gradient_norm": 0.05156548321247101, + "elapsed": 222.249596118927 + }, + { + "step": 288, + "loss": 0.5478869676589966, + "objective": 0.5478869676589966, + "error": 0.3203125, + "gradient_norm": 0.08357688039541245, + "elapsed": 232.2198715209961 + }, + { + "step": 304, + "loss": 0.21171918511390686, + "objective": 0.21171918511390686, + "error": 0.0849609375, + "gradient_norm": 0.06231697276234627, + "elapsed": 241.07631373405457 + }, + { + "step": 320, + "loss": 0.5333335995674133, + "objective": 0.5333335995674133, + "error": 0.2861328125, + "gradient_norm": 0.08931853622198105, + "elapsed": 251.28962755203247 + }, + { + "step": 336, + "loss": 0.12485946714878082, + "objective": 0.12485946714878082, + "error": 0.046875, + "gradient_norm": 0.018839582800865173, + "elapsed": 262.3605041503906 + }, + { + "step": 352, + "loss": 0.2334863245487213, + "objective": 0.2334863245487213, + "error": 0.09765625, + "gradient_norm": 0.03669576346874237, + "elapsed": 273.16373229026794 + }, + { + "step": 368, + "loss": 0.5818328857421875, + "objective": 0.5818328857421875, + "error": 0.3232421875, + "gradient_norm": 0.09833699464797974, + "elapsed": 282.8677294254303 + }, + { + "step": 384, + "loss": 0.6228232383728027, + "objective": 0.6228232383728027, + "error": 0.3671875, + "gradient_norm": 0.033418990671634674, + "elapsed": 295.04902839660645 + }, + { + "step": 400, + "loss": 0.5749450922012329, + "objective": 0.5749450922012329, + "error": 0.333984375, + "gradient_norm": 0.04644288495182991, + "elapsed": 306.67032837867737 + }, + { + "step": 416, + "loss": 0.46251457929611206, + "objective": 0.46251457929611206, + "error": 0.2216796875, + "gradient_norm": 0.06633804738521576, + "elapsed": 317.759464263916 + }, + { + "step": 432, + "loss": 0.5577508211135864, + "objective": 0.5577508211135864, + "error": 0.30859375, + "gradient_norm": 0.0970199704170227, + "elapsed": 327.4626543521881 + }, + { + "step": 448, + "loss": 0.11625733226537704, + "objective": 0.11625733226537704, + "error": 0.0419921875, + "gradient_norm": 0.020417485386133194, + "elapsed": 336.3522970676422 + }, + { + "step": 464, + "loss": 0.23657961189746857, + "objective": 0.23657961189746857, + "error": 0.1025390625, + "gradient_norm": 0.03908605873584747, + "elapsed": 344.3832321166992 + }, + { + "step": 480, + "loss": 0.011504358612000942, + "objective": 0.011504358612000942, + "error": 0.00390625, + "gradient_norm": 0.006708688102662563, + "elapsed": 355.18855381011963 + }, + { + "step": 496, + "loss": 0.3410624563694, + "objective": 0.3410624563694, + "error": 0.1533203125, + "gradient_norm": 0.05804387852549553, + "elapsed": 366.2978138923645 + }, + { + "step": 512, + "loss": 0.034005306661129, + "objective": 0.034005306661129, + "error": 0.0107421875, + "gradient_norm": 0.01019973959773779, + "elapsed": 375.73491764068604 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "b31e8f5ee2b5ea1b661e6bf8b5649bec45b7ab5da74fe9de46e4d06846356b87", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317613, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5523660182952881, + "objective": 0.5523660182952881, + "error": 0.30859375, + "gradient_norm": 0.05200070142745972, + "elapsed": 30.08410096168518 + }, + { + "step": 16, + "loss": 0.5380295515060425, + "objective": 0.5380295515060425, + "error": 0.306640625, + "gradient_norm": 0.0804876759648323, + "elapsed": 50.77648210525513 + }, + { + "step": 32, + "loss": 0.6359301805496216, + "objective": 0.6359301805496216, + "error": 0.3837890625, + "gradient_norm": 0.059380218386650085, + "elapsed": 59.453776836395264 + }, + { + "step": 48, + "loss": 0.2540435492992401, + "objective": 0.2540435492992401, + "error": 0.1083984375, + "gradient_norm": 0.04367281496524811, + "elapsed": 67.29314041137695 + }, + { + "step": 64, + "loss": 0.5867692232131958, + "objective": 0.5867692232131958, + "error": 0.3447265625, + "gradient_norm": 0.053885214030742645, + "elapsed": 78.74847197532654 + }, + { + "step": 80, + "loss": 0.6015321016311646, + "objective": 0.6015321016311646, + "error": 0.365234375, + "gradient_norm": 0.04807985574007034, + "elapsed": 90.48145818710327 + }, + { + "step": 96, + "loss": 0.49287766218185425, + "objective": 0.49287766218185425, + "error": 0.271484375, + "gradient_norm": 0.07899080961942673, + "elapsed": 101.65468978881836 + }, + { + "step": 112, + "loss": 0.3271353542804718, + "objective": 0.3271353542804718, + "error": 0.15234375, + "gradient_norm": 0.049542222172021866, + "elapsed": 111.14713263511658 + }, + { + "step": 128, + "loss": 0.50013667345047, + "objective": 0.50013667345047, + "error": 0.271484375, + "gradient_norm": 0.06454745680093765, + "elapsed": 121.21207547187805 + }, + { + "step": 144, + "loss": 0.028576843440532684, + "objective": 0.028576843440532684, + "error": 0.0087890625, + "gradient_norm": 0.010781333781778812, + "elapsed": 130.69302248954773 + }, + { + "step": 160, + "loss": 0.5668779015541077, + "objective": 0.5668779015541077, + "error": 0.330078125, + "gradient_norm": 0.06098390743136406, + "elapsed": 142.14290237426758 + }, + { + "step": 176, + "loss": 0.3986494839191437, + "objective": 0.3986494839191437, + "error": 0.1884765625, + "gradient_norm": 0.042795032262802124, + "elapsed": 152.75753688812256 + }, + { + "step": 192, + "loss": 0.31897079944610596, + "objective": 0.31897079944610596, + "error": 0.142578125, + "gradient_norm": 0.040675707161426544, + "elapsed": 160.04981398582458 + }, + { + "step": 208, + "loss": 0.5092275142669678, + "objective": 0.5092275142669678, + "error": 0.255859375, + "gradient_norm": 0.07929783314466476, + "elapsed": 169.85345673561096 + }, + { + "step": 224, + "loss": 0.35782667994499207, + "objective": 0.35782667994499207, + "error": 0.1748046875, + "gradient_norm": 0.05785144120454788, + "elapsed": 179.90323066711426 + }, + { + "step": 240, + "loss": 0.5660895109176636, + "objective": 0.5660895109176636, + "error": 0.3349609375, + "gradient_norm": 0.10684454441070557, + "elapsed": 191.3668942451477 + }, + { + "step": 256, + "loss": 0.6265910863876343, + "objective": 0.6265910863876343, + "error": 0.3779296875, + "gradient_norm": 0.034383758902549744, + "elapsed": 200.3055775165558 + }, + { + "step": 272, + "loss": 0.6210677623748779, + "objective": 0.6210677623748779, + "error": 0.369140625, + "gradient_norm": 0.04434216767549515, + "elapsed": 210.09376430511475 + }, + { + "step": 288, + "loss": 0.4892377257347107, + "objective": 0.4892377257347107, + "error": 0.2490234375, + "gradient_norm": 0.1040654331445694, + "elapsed": 220.45881819725037 + }, + { + "step": 304, + "loss": 0.6407739520072937, + "objective": 0.6407739520072937, + "error": 0.3916015625, + "gradient_norm": 0.07782924920320511, + "elapsed": 233.3719048500061 + }, + { + "step": 320, + "loss": 0.4752756953239441, + "objective": 0.4752756953239441, + "error": 0.263671875, + "gradient_norm": 0.051829319447278976, + "elapsed": 244.25844407081604 + }, + { + "step": 336, + "loss": 0.6482080221176147, + "objective": 0.6482080221176147, + "error": 0.41015625, + "gradient_norm": 0.04979892820119858, + "elapsed": 253.1897099018097 + }, + { + "step": 352, + "loss": 0.34022292494773865, + "objective": 0.34022292494773865, + "error": 0.1708984375, + "gradient_norm": 0.09951864182949066, + "elapsed": 264.0781395435333 + }, + { + "step": 368, + "loss": 0.3494992256164551, + "objective": 0.3494992256164551, + "error": 0.15625, + "gradient_norm": 0.10392706841230392, + "elapsed": 275.8111581802368 + }, + { + "step": 384, + "loss": 0.47191378474235535, + "objective": 0.47191378474235535, + "error": 0.25, + "gradient_norm": 0.07366786152124405, + "elapsed": 283.9459602832794 + }, + { + "step": 400, + "loss": 0.583655595779419, + "objective": 0.583655595779419, + "error": 0.3623046875, + "gradient_norm": 0.10394527018070221, + "elapsed": 294.3349726200104 + }, + { + "step": 416, + "loss": 0.6212975978851318, + "objective": 0.6212975978851318, + "error": 0.37109375, + "gradient_norm": 0.054796766489744186, + "elapsed": 304.7477548122406 + }, + { + "step": 432, + "loss": 0.4719577431678772, + "objective": 0.4719577431678772, + "error": 0.2431640625, + "gradient_norm": 0.05418012663722038, + "elapsed": 315.91914200782776 + }, + { + "step": 448, + "loss": 0.5696494579315186, + "objective": 0.5696494579315186, + "error": 0.3330078125, + "gradient_norm": 0.047046076506376266, + "elapsed": 324.96326184272766 + }, + { + "step": 464, + "loss": 0.613875687122345, + "objective": 0.613875687122345, + "error": 0.34765625, + "gradient_norm": 0.05237002298235893, + "elapsed": 334.7670781612396 + }, + { + "step": 480, + "loss": 0.28741705417633057, + "objective": 0.28741705417633057, + "error": 0.1240234375, + "gradient_norm": 0.05365394428372383, + "elapsed": 344.03080439567566 + }, + { + "step": 496, + "loss": 0.3729455769062042, + "objective": 0.3729455769062042, + "error": 0.1875, + "gradient_norm": 0.05905403569340706, + "elapsed": 356.01581716537476 + }, + { + "step": 512, + "loss": 0.38685142993927, + "objective": 0.38685142993927, + "error": 0.17578125, + "gradient_norm": 0.048455506563186646, + "elapsed": 367.7296392917633 + }, + { + "step": 528, + "loss": 0.6062720417976379, + "objective": 0.6062720417976379, + "error": 0.369140625, + "gradient_norm": 0.07544548809528351, + "elapsed": 385.4480962753296 + }, + { + "step": 544, + "loss": 0.520085871219635, + "objective": 0.520085871219635, + "error": 0.279296875, + "gradient_norm": 0.08394371718168259, + "elapsed": 397.71993708610535 + }, + { + "step": 560, + "loss": 0.5944540500640869, + "objective": 0.5944540500640869, + "error": 0.3544921875, + "gradient_norm": 0.05468091368675232, + "elapsed": 406.9417428970337 + }, + { + "step": 576, + "loss": 0.34102559089660645, + "objective": 0.34102559089660645, + "error": 0.1611328125, + "gradient_norm": 0.07333917915821075, + "elapsed": 417.0068130493164 + }, + { + "step": 592, + "loss": 0.47373664379119873, + "objective": 0.47373664379119873, + "error": 0.2412109375, + "gradient_norm": 0.05662858858704567, + "elapsed": 425.1176447868347 + }, + { + "step": 608, + "loss": 0.48517894744873047, + "objective": 0.48517894744873047, + "error": 0.25, + "gradient_norm": 0.08127480745315552, + "elapsed": 434.92080903053284 + }, + { + "step": 624, + "loss": 0.39865612983703613, + "objective": 0.39865612983703613, + "error": 0.1904296875, + "gradient_norm": 0.07332058995962143, + "elapsed": 446.6602101325989 + }, + { + "step": 640, + "loss": 0.41867297887802124, + "objective": 0.41867297887802124, + "error": 0.2177734375, + "gradient_norm": 0.07386308163404465, + "elapsed": 457.0243580341339 + }, + { + "step": 656, + "loss": 0.5108687877655029, + "objective": 0.5108687877655029, + "error": 0.2822265625, + "gradient_norm": 0.052080318331718445, + "elapsed": 469.5842761993408 + }, + { + "step": 672, + "loss": 0.5043742656707764, + "objective": 0.5043742656707764, + "error": 0.2734375, + "gradient_norm": 0.047204963862895966, + "elapsed": 479.356397151947 + }, + { + "step": 688, + "loss": 0.5550935864448547, + "objective": 0.5550935864448547, + "error": 0.30078125, + "gradient_norm": 0.04080262407660484, + "elapsed": 489.9912152290344 + }, + { + "step": 704, + "loss": 0.5698974132537842, + "objective": 0.5698974132537842, + "error": 0.322265625, + "gradient_norm": 0.10692963004112244, + "elapsed": 500.3283371925354 + }, + { + "step": 720, + "loss": 0.45870622992515564, + "objective": 0.45870622992515564, + "error": 0.2255859375, + "gradient_norm": 0.06705734878778458, + "elapsed": 509.82279753685 + }, + { + "step": 736, + "loss": 0.555386483669281, + "objective": 0.555386483669281, + "error": 0.31640625, + "gradient_norm": 0.05112688988447189, + "elapsed": 518.507036447525 + }, + { + "step": 752, + "loss": 0.14282986521720886, + "objective": 0.14282986521720886, + "error": 0.056640625, + "gradient_norm": 0.03209136053919792, + "elapsed": 529.1373023986816 + }, + { + "step": 768, + "loss": 0.5362129807472229, + "objective": 0.5362129807472229, + "error": 0.2841796875, + "gradient_norm": 0.049996186047792435, + "elapsed": 538.9186007976532 + }, + { + "step": 784, + "loss": 0.5071826577186584, + "objective": 0.5071826577186584, + "error": 0.2744140625, + "gradient_norm": 0.04826078191399574, + "elapsed": 549.5225830078125 + }, + { + "step": 800, + "loss": 0.24775367975234985, + "objective": 0.24775367975234985, + "error": 0.107421875, + "gradient_norm": 0.06889795511960983, + "elapsed": 560.7170543670654 + }, + { + "step": 816, + "loss": 0.17432856559753418, + "objective": 0.17432856559753418, + "error": 0.06640625, + "gradient_norm": 0.05147368833422661, + "elapsed": 570.7887880802155 + }, + { + "step": 832, + "loss": 0.5410823822021484, + "objective": 0.5410823822021484, + "error": 0.3115234375, + "gradient_norm": 0.11862928420305252, + "elapsed": 581.9721121788025 + }, + { + "step": 848, + "loss": 0.5555508732795715, + "objective": 0.5555508732795715, + "error": 0.296875, + "gradient_norm": 0.060369592159986496, + "elapsed": 592.2823219299316 + }, + { + "step": 864, + "loss": 0.31839215755462646, + "objective": 0.31839215755462646, + "error": 0.1552734375, + "gradient_norm": 0.063877172768116, + "elapsed": 603.1910541057587 + }, + { + "step": 880, + "loss": 0.481766939163208, + "objective": 0.481766939163208, + "error": 0.2470703125, + "gradient_norm": 0.1623816341161728, + "elapsed": 614.4277107715607 + }, + { + "step": 896, + "loss": 0.5780366659164429, + "objective": 0.5780366659164429, + "error": 0.3037109375, + "gradient_norm": 0.06694691628217697, + "elapsed": 623.9365792274475 + }, + { + "step": 912, + "loss": 0.4794909358024597, + "objective": 0.4794909358024597, + "error": 0.2314453125, + "gradient_norm": 0.07813122123479843, + "elapsed": 633.9845306873322 + }, + { + "step": 928, + "loss": 0.6279138922691345, + "objective": 0.6279138922691345, + "error": 0.380859375, + "gradient_norm": 0.047679927200078964, + "elapsed": 643.7766675949097 + }, + { + "step": 944, + "loss": 0.6401606798171997, + "objective": 0.6401606798171997, + "error": 0.3994140625, + "gradient_norm": 0.07329051941633224, + "elapsed": 655.2369928359985 + }, + { + "step": 960, + "loss": 0.4340277910232544, + "objective": 0.4340277910232544, + "error": 0.2158203125, + "gradient_norm": 0.11762503534555435, + "elapsed": 666.9884371757507 + }, + { + "step": 976, + "loss": 0.44496864080429077, + "objective": 0.44496864080429077, + "error": 0.2236328125, + "gradient_norm": 0.05260347202420235, + "elapsed": 677.3464586734772 + }, + { + "step": 992, + "loss": 0.13230293989181519, + "objective": 0.13230293989181519, + "error": 0.05078125, + "gradient_norm": 0.030240925028920174, + "elapsed": 685.7275724411011 + }, + { + "step": 1008, + "loss": 0.2971688508987427, + "objective": 0.2971688508987427, + "error": 0.1171875, + "gradient_norm": 0.05503479763865471, + "elapsed": 694.1270356178284 + }, + { + "step": 1024, + "loss": 0.5688735246658325, + "objective": 0.5688735246658325, + "error": 0.314453125, + "gradient_norm": 0.06526188552379608, + "elapsed": 703.9192817211151 + }, + { + "step": 1040, + "loss": 0.42805811762809753, + "objective": 0.42805811762809753, + "error": 0.2080078125, + "gradient_norm": 0.13000032305717468, + "elapsed": 720.145961523056 + }, + { + "step": 1056, + "loss": 0.5543602705001831, + "objective": 0.5543602705001831, + "error": 0.298828125, + "gradient_norm": 0.15922385454177856, + "elapsed": 733.5112845897675 + }, + { + "step": 1072, + "loss": 0.031130114570260048, + "objective": 0.031130114570260048, + "error": 0.013671875, + "gradient_norm": 0.008926023729145527, + "elapsed": 742.4467866420746 + }, + { + "step": 1088, + "loss": 0.14947748184204102, + "objective": 0.14947748184204102, + "error": 0.056640625, + "gradient_norm": 0.03975249081850052, + "elapsed": 751.8575854301453 + }, + { + "step": 1104, + "loss": 0.6275734901428223, + "objective": 0.6275734901428223, + "error": 0.3671875, + "gradient_norm": 0.08096148073673248, + "elapsed": 761.5625903606415 + }, + { + "step": 1120, + "loss": 0.23923414945602417, + "objective": 0.23923414945602417, + "error": 0.0966796875, + "gradient_norm": 0.03325376287102699, + "elapsed": 773.9633615016937 + }, + { + "step": 1136, + "loss": 0.570243239402771, + "objective": 0.570243239402771, + "error": 0.31640625, + "gradient_norm": 0.07534287869930267, + "elapsed": 783.1533136367798 + }, + { + "step": 1152, + "loss": 0.4264270067214966, + "objective": 0.4264270067214966, + "error": 0.2119140625, + "gradient_norm": 0.08900073170661926, + "elapsed": 792.1710996627808 + }, + { + "step": 1168, + "loss": 0.5958121418952942, + "objective": 0.5958121418952942, + "error": 0.3583984375, + "gradient_norm": 0.08239343762397766, + "elapsed": 803.1175289154053 + }, + { + "step": 1184, + "loss": 0.2909137010574341, + "objective": 0.2909137010574341, + "error": 0.1416015625, + "gradient_norm": 0.05281354859471321, + "elapsed": 812.6055159568787 + }, + { + "step": 1200, + "loss": 0.6119058728218079, + "objective": 0.6119058728218079, + "error": 0.36328125, + "gradient_norm": 0.056254416704177856, + "elapsed": 823.2276427745819 + }, + { + "step": 1216, + "loss": 0.13595536351203918, + "objective": 0.13595536351203918, + "error": 0.0556640625, + "gradient_norm": 0.04057573154568672, + "elapsed": 834.1696293354034 + }, + { + "step": 1232, + "loss": 0.5840731263160706, + "objective": 0.5840731263160706, + "error": 0.328125, + "gradient_norm": 0.054566267877817154, + "elapsed": 845.3501887321472 + }, + { + "step": 1248, + "loss": 0.3053072690963745, + "objective": 0.3053072690963745, + "error": 0.1337890625, + "gradient_norm": 0.04617297649383545, + "elapsed": 854.9564871788025 + }, + { + "step": 1264, + "loss": 0.6288673281669617, + "objective": 0.6288673281669617, + "error": 0.3994140625, + "gradient_norm": 0.08229745179414749, + "elapsed": 864.8914043903351 + }, + { + "step": 1280, + "loss": 0.5586361289024353, + "objective": 0.5586361289024353, + "error": 0.2958984375, + "gradient_norm": 0.05713959410786629, + "elapsed": 877.0349607467651 + }, + { + "step": 1296, + "loss": 0.3648858666419983, + "objective": 0.3648858666419983, + "error": 0.16796875, + "gradient_norm": 0.08502963185310364, + "elapsed": 888.5764675140381 + }, + { + "step": 1312, + "loss": 0.4747084081172943, + "objective": 0.4747084081172943, + "error": 0.244140625, + "gradient_norm": 0.08609883487224579, + "elapsed": 899.7598609924316 + }, + { + "step": 1328, + "loss": 0.15583917498588562, + "objective": 0.15583917498588562, + "error": 0.05859375, + "gradient_norm": 0.027793049812316895, + "elapsed": 909.47514295578 + }, + { + "step": 1344, + "loss": 0.47515708208084106, + "objective": 0.47515708208084106, + "error": 0.263671875, + "gradient_norm": 0.07668807357549667, + "elapsed": 919.7640328407288 + }, + { + "step": 1360, + "loss": 0.5173689126968384, + "objective": 0.5173689126968384, + "error": 0.2744140625, + "gradient_norm": 0.05054212734103203, + "elapsed": 930.6309463977814 + }, + { + "step": 1376, + "loss": 0.46629998087882996, + "objective": 0.46629998087882996, + "error": 0.24609375, + "gradient_norm": 0.051172077655792236, + "elapsed": 939.0202586650848 + }, + { + "step": 1392, + "loss": 0.11312969774007797, + "objective": 0.11312969774007797, + "error": 0.044921875, + "gradient_norm": 0.05863805115222931, + "elapsed": 949.1451416015625 + }, + { + "step": 1408, + "loss": 0.5750841498374939, + "objective": 0.5750841498374939, + "error": 0.322265625, + "gradient_norm": 0.051106806844472885, + "elapsed": 959.94162940979 + }, + { + "step": 1424, + "loss": 0.5937192440032959, + "objective": 0.5937192440032959, + "error": 0.3408203125, + "gradient_norm": 0.05014815554022789, + "elapsed": 969.5868306159973 + }, + { + "step": 1440, + "loss": 0.5292985439300537, + "objective": 0.5292985439300537, + "error": 0.2958984375, + "gradient_norm": 0.057068243622779846, + "elapsed": 982.6692054271698 + }, + { + "step": 1456, + "loss": 0.5959951877593994, + "objective": 0.5959951877593994, + "error": 0.3408203125, + "gradient_norm": 0.0703694075345993, + "elapsed": 995.0066986083984 + }, + { + "step": 1472, + "loss": 0.018453411757946014, + "objective": 0.018453411757946014, + "error": 0.00390625, + "gradient_norm": 0.012016087770462036, + "elapsed": 1004.0057821273804 + }, + { + "step": 1488, + "loss": 0.5711684823036194, + "objective": 0.5711684823036194, + "error": 0.3095703125, + "gradient_norm": 0.07746906578540802, + "elapsed": 1016.1701967716217 + }, + { + "step": 1504, + "loss": 0.3114882707595825, + "objective": 0.3114882707595825, + "error": 0.1455078125, + "gradient_norm": 0.05321609228849411, + "elapsed": 1026.6053586006165 + }, + { + "step": 1520, + "loss": 0.6433392763137817, + "objective": 0.6433392763137817, + "error": 0.4072265625, + "gradient_norm": 0.05683734640479088, + "elapsed": 1036.1535296440125 + }, + { + "step": 1536, + "loss": 0.38409170508384705, + "objective": 0.38409170508384705, + "error": 0.19140625, + "gradient_norm": 0.07577994465827942, + "elapsed": 1046.9508447647095 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "7b45252d6bb77a39c003c8f34f040d0d672e9dd1a1338a14126e1fe07a02c8c9", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 466919, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + } + ], + "training": "All516880 supplied d5 training rows eligible; uniform condition and row sampling with replacement", + "training_shots": 516880, + "distinct_phase_rows": 507134, + "loss": "Conditional logical BCE of two trainable exact-decoder probabilities; responsibilities scale expert BCE gradients; syndrome-only gate gradient is coefficient minus responsibility", + "optimizer": "Separate restored expert AdamW states and fresh gate AdamW; one global norm1 clipping over the full joint gradient, weight_decay1e-4; rates in run_config", + "gate": "41 fixed-scale syndrome/basis/duration features,32-unit SiLU hidden layer,one free logit,other logit zero; no label/ID/position/expert-confidence features", + "validation": "Uniform1024-shot per-condition screens by default, seed20261102; full validation required for checkpoint selection", + "independence": "This joint model uses all training rows; it does not retain the reserved-parent training-label holdout claim", + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4036223292350769, + "error": 0.2216796875, + "gradient_norm": 0.057130008935928345, + "mean_coefficients": [ + 0.5, + 0.5 + ], + "elapsed": 40.89025521278381 + }, + { + "step": 16, + "loss": 0.3341269791126251, + "error": 0.1513671875, + "gradient_norm": 0.04194090887904167, + "mean_coefficients": [ + 0.48442864418029785, + 0.5155713558197021 + ], + "elapsed": 75.96262431144714 + }, + { + "step": 32, + "loss": 0.5103148221969604, + "error": 0.2578125, + "gradient_norm": 0.0415002703666687, + "mean_coefficients": [ + 0.4874333441257477, + 0.5125666856765747 + ], + "elapsed": 97.34089732170105 + }, + { + "step": 48, + "loss": 0.4725187420845032, + "error": 0.2587890625, + "gradient_norm": 0.0680275708436966, + "mean_coefficients": [ + 0.47893714904785156, + 0.5210628509521484 + ], + "elapsed": 118.16778039932251 + }, + { + "step": 64, + "loss": 0.6120783090591431, + "error": 0.3671875, + "gradient_norm": 0.0358140654861927, + "mean_coefficients": [ + 0.4769505262374878, + 0.5230494737625122 + ], + "elapsed": 137.34904408454895 + }, + { + "step": 80, + "loss": 0.5546625852584839, + "error": 0.3037109375, + "gradient_norm": 0.056485772132873535, + "mean_coefficients": [ + 0.4823176860809326, + 0.5176823139190674 + ], + "elapsed": 155.42735648155212 + }, + { + "step": 96, + "loss": 0.6412051320075989, + "error": 0.3740234375, + "gradient_norm": 0.039855338633060455, + "mean_coefficients": [ + 0.47127240896224976, + 0.5287275910377502 + ], + "elapsed": 177.39524245262146 + }, + { + "step": 112, + "loss": 0.3109489977359772, + "error": 0.142578125, + "gradient_norm": 0.0388655886054039, + "mean_coefficients": [ + 0.4498932361602783, + 0.5501067638397217 + ], + "elapsed": 200.48573231697083 + }, + { + "step": 128, + "loss": 0.23736518621444702, + "error": 0.0927734375, + "gradient_norm": 0.03215935826301575, + "mean_coefficients": [ + 0.42610985040664673, + 0.573890209197998 + ], + "elapsed": 218.17016458511353 + }, + { + "step": 144, + "loss": 0.4813964068889618, + "error": 0.2578125, + "gradient_norm": 0.05487911403179169, + "mean_coefficients": [ + 0.3922170102596283, + 0.6077829599380493 + ], + "elapsed": 238.55671858787537 + }, + { + "step": 160, + "loss": 0.3278219997882843, + "error": 0.1474609375, + "gradient_norm": 0.04150420427322388, + "mean_coefficients": [ + 0.3980315625667572, + 0.6019684076309204 + ], + "elapsed": 261.1414167881012 + }, + { + "step": 176, + "loss": 0.5885685086250305, + "error": 0.333984375, + "gradient_norm": 0.035754330456256866, + "mean_coefficients": [ + 0.4095921516418457, + 0.5904078483581543 + ], + "elapsed": 280.4117953777313 + }, + { + "step": 192, + "loss": 0.4211200475692749, + "error": 0.2099609375, + "gradient_norm": 0.045698583126068115, + "mean_coefficients": [ + 0.4314090609550476, + 0.5685908794403076 + ], + "elapsed": 299.1174387931824 + }, + { + "step": 208, + "loss": 0.5783671140670776, + "error": 0.3193359375, + "gradient_norm": 0.042599014937877655, + "mean_coefficients": [ + 0.45120924711227417, + 0.5487907528877258 + ], + "elapsed": 319.4998824596405 + }, + { + "step": 224, + "loss": 0.5515865087509155, + "error": 0.3203125, + "gradient_norm": 0.03870227932929993, + "mean_coefficients": [ + 0.43399181962013245, + 0.5660082101821899 + ], + "elapsed": 337.1067805290222 + }, + { + "step": 240, + "loss": 0.3223415017127991, + "error": 0.146484375, + "gradient_norm": 0.04187055304646492, + "mean_coefficients": [ + 0.43565210700035095, + 0.5643478631973267 + ], + "elapsed": 360.23490476608276 + }, + { + "step": 256, + "loss": 0.14871305227279663, + "error": 0.064453125, + "gradient_norm": 0.023555928841233253, + "mean_coefficients": [ + 0.4496843218803406, + 0.5503156781196594 + ], + "elapsed": 380.6055603027344 + }, + { + "step": 272, + "loss": 0.016909560188651085, + "error": 0.005859375, + "gradient_norm": 0.007025144528597593, + "mean_coefficients": [ + 0.47316980361938477, + 0.5268301963806152 + ], + "elapsed": 400.4117109775543 + }, + { + "step": 288, + "loss": 0.03126583620905876, + "error": 0.0107421875, + "gradient_norm": 0.00677987327799201, + "mean_coefficients": [ + 0.48647376894950867, + 0.513526201248169 + ], + "elapsed": 421.32721424102783 + }, + { + "step": 304, + "loss": 0.015056228265166283, + "error": 0.00390625, + "gradient_norm": 0.004391203168779612, + "mean_coefficients": [ + 0.4802752137184143, + 0.5197247862815857 + ], + "elapsed": 440.02484107017517 + }, + { + "step": 320, + "loss": 0.6543335318565369, + "error": 0.3984375, + "gradient_norm": 0.043641772121191025, + "mean_coefficients": [ + 0.46137332916259766, + 0.5386266708374023 + ], + "elapsed": 461.4827136993408 + }, + { + "step": 336, + "loss": 0.43366891145706177, + "error": 0.2236328125, + "gradient_norm": 0.052468180656433105, + "mean_coefficients": [ + 0.4561651349067688, + 0.5438348650932312 + ], + "elapsed": 476.9050533771515 + }, + { + "step": 352, + "loss": 0.4712753891944885, + "error": 0.2578125, + "gradient_norm": 0.0850258395075798, + "mean_coefficients": [ + 0.47329187393188477, + 0.5267081260681152 + ], + "elapsed": 498.3318154811859 + }, + { + "step": 368, + "loss": 0.5800390243530273, + "error": 0.333984375, + "gradient_norm": 0.04926278814673424, + "mean_coefficients": [ + 0.47176501154899597, + 0.5282349586486816 + ], + "elapsed": 517.5981040000916 + }, + { + "step": 384, + "loss": 0.2240307629108429, + "error": 0.09375, + "gradient_norm": 0.028688540682196617, + "mean_coefficients": [ + 0.5045000910758972, + 0.4954999089241028 + ], + "elapsed": 534.63458943367 + }, + { + "step": 400, + "loss": 0.597924530506134, + "error": 0.3642578125, + "gradient_norm": 0.041638799011707306, + "mean_coefficients": [ + 0.49713680148124695, + 0.5028631687164307 + ], + "elapsed": 554.4411277770996 + }, + { + "step": 416, + "loss": 0.5437486171722412, + "error": 0.2783203125, + "gradient_norm": 0.040762074291706085, + "mean_coefficients": [ + 0.5308403968811035, + 0.46915963292121887 + ], + "elapsed": 570.4008054733276 + }, + { + "step": 432, + "loss": 0.47453391551971436, + "error": 0.2529296875, + "gradient_norm": 0.04694828391075134, + "mean_coefficients": [ + 0.5293633937835693, + 0.47063660621643066 + ], + "elapsed": 589.7109427452087 + }, + { + "step": 448, + "loss": 0.6348706483840942, + "error": 0.384765625, + "gradient_norm": 0.03518350049853325, + "mean_coefficients": [ + 0.5176522731781006, + 0.4823477268218994 + ], + "elapsed": 608.4390025138855 + }, + { + "step": 464, + "loss": 0.020331814885139465, + "error": 0.009765625, + "gradient_norm": 0.006898671388626099, + "mean_coefficients": [ + 0.5043070316314697, + 0.49569302797317505 + ], + "elapsed": 628.7866444587708 + }, + { + "step": 480, + "loss": 0.12150328606367111, + "error": 0.0400390625, + "gradient_norm": 0.02066878229379654, + "mean_coefficients": [ + 0.47933268547058105, + 0.520667314529419 + ], + "elapsed": 649.15460896492 + }, + { + "step": 496, + "loss": 0.5669755935668945, + "error": 0.3212890625, + "gradient_norm": 0.0533452145755291, + "mean_coefficients": [ + 0.5110207796096802, + 0.48897919058799744 + ], + "elapsed": 669.5327253341675 + }, + { + "step": 512, + "loss": 0.48904645442962646, + "error": 0.2431640625, + "gradient_norm": 0.06111208349466324, + "mean_coefficients": [ + 0.4747602343559265, + 0.5252398252487183 + ], + "elapsed": 688.7857129573822 + }, + { + "step": 528, + "loss": 0.5006762742996216, + "error": 0.267578125, + "gradient_norm": 0.06278064846992493, + "mean_coefficients": [ + 0.46502402424812317, + 0.5349759459495544 + ], + "elapsed": 722.3683931827545 + }, + { + "step": 544, + "loss": 0.4780538082122803, + "error": 0.2421875, + "gradient_norm": 0.0510331355035305, + "mean_coefficients": [ + 0.4474865794181824, + 0.5525134205818176 + ], + "elapsed": 742.790007352829 + }, + { + "step": 560, + "loss": 0.5480368137359619, + "error": 0.3125, + "gradient_norm": 0.04929737746715546, + "mean_coefficients": [ + 0.4511070251464844, + 0.5488929748535156 + ], + "elapsed": 762.0487098693848 + }, + { + "step": 576, + "loss": 0.16029930114746094, + "error": 0.0615234375, + "gradient_norm": 0.025595247745513916, + "mean_coefficients": [ + 0.439511775970459, + 0.560488224029541 + ], + "elapsed": 780.7311539649963 + }, + { + "step": 592, + "loss": 0.3186679482460022, + "error": 0.150390625, + "gradient_norm": 0.048987504094839096, + "mean_coefficients": [ + 0.4394666254520416, + 0.5605334043502808 + ], + "elapsed": 801.6919455528259 + }, + { + "step": 608, + "loss": 0.5188161730766296, + "error": 0.2919921875, + "gradient_norm": 0.042723916471004486, + "mean_coefficients": [ + 0.4649806618690491, + 0.5350192785263062 + ], + "elapsed": 823.6975173950195 + }, + { + "step": 624, + "loss": 0.5420911312103271, + "error": 0.3017578125, + "gradient_norm": 0.07124848663806915, + "mean_coefficients": [ + 0.4770982563495636, + 0.5229017734527588 + ], + "elapsed": 842.9545094966888 + }, + { + "step": 640, + "loss": 0.514599084854126, + "error": 0.2724609375, + "gradient_norm": 0.042226750403642654, + "mean_coefficients": [ + 0.5077712535858154, + 0.49222877621650696 + ], + "elapsed": 865.542462348938 + }, + { + "step": 656, + "loss": 0.54783034324646, + "error": 0.2998046875, + "gradient_norm": 0.043302036821842194, + "mean_coefficients": [ + 0.5116667151451111, + 0.48833325505256653 + ], + "elapsed": 886.4461476802826 + }, + { + "step": 672, + "loss": 0.580764889717102, + "error": 0.31640625, + "gradient_norm": 0.05445221811532974, + "mean_coefficients": [ + 0.5066379308700562, + 0.49336206912994385 + ], + "elapsed": 910.1314296722412 + }, + { + "step": 688, + "loss": 0.5923768281936646, + "error": 0.33984375, + "gradient_norm": 0.053689390420913696, + "mean_coefficients": [ + 0.505064845085144, + 0.49493518471717834 + ], + "elapsed": 934.9332280158997 + }, + { + "step": 704, + "loss": 0.6142730712890625, + "error": 0.3232421875, + "gradient_norm": 0.0523676872253418, + "mean_coefficients": [ + 0.51506507396698, + 0.48493492603302 + ], + "elapsed": 955.2821652889252 + }, + { + "step": 720, + "loss": 0.027360184118151665, + "error": 0.0087890625, + "gradient_norm": 0.005057274829596281, + "mean_coefficients": [ + 0.4945293664932251, + 0.5054706335067749 + ], + "elapsed": 971.782705783844 + }, + { + "step": 736, + "loss": 0.019292084500193596, + "error": 0.0048828125, + "gradient_norm": 0.012131650932133198, + "mean_coefficients": [ + 0.46814921498298645, + 0.5318508148193359 + ], + "elapsed": 995.4411764144897 + }, + { + "step": 752, + "loss": 0.28370219469070435, + "error": 0.1162109375, + "gradient_norm": 0.043570809066295624, + "mean_coefficients": [ + 0.4533402621746063, + 0.5466597080230713 + ], + "elapsed": 1016.3589010238647 + }, + { + "step": 768, + "loss": 0.4945998191833496, + "error": 0.287109375, + "gradient_norm": 0.042133282870054245, + "mean_coefficients": [ + 0.48534777760505676, + 0.5146522521972656 + ], + "elapsed": 1037.8080792427063 + }, + { + "step": 784, + "loss": 0.48455703258514404, + "error": 0.2646484375, + "gradient_norm": 0.05964742228388786, + "mean_coefficients": [ + 0.46901020407676697, + 0.5309897661209106 + ], + "elapsed": 1058.1542754173279 + }, + { + "step": 800, + "loss": 0.14743734896183014, + "error": 0.0537109375, + "gradient_norm": 0.02483040653169155, + "mean_coefficients": [ + 0.5056599378585815, + 0.49434009194374084 + ], + "elapsed": 1076.379721403122 + }, + { + "step": 816, + "loss": 0.5364817380905151, + "error": 0.2900390625, + "gradient_norm": 0.04801176115870476, + "mean_coefficients": [ + 0.4571455717086792, + 0.5428544282913208 + ], + "elapsed": 1092.3855652809143 + }, + { + "step": 832, + "loss": 0.6114806532859802, + "error": 0.3603515625, + "gradient_norm": 0.0635533481836319, + "mean_coefficients": [ + 0.44957223534584045, + 0.5504277944564819 + ], + "elapsed": 1112.2118809223175 + }, + { + "step": 848, + "loss": 0.13529899716377258, + "error": 0.05078125, + "gradient_norm": 0.03418346866965294, + "mean_coefficients": [ + 0.4930901527404785, + 0.5069098472595215 + ], + "elapsed": 1134.8346536159515 + }, + { + "step": 864, + "loss": 0.6020746231079102, + "error": 0.37109375, + "gradient_norm": 0.03793048486113548, + "mean_coefficients": [ + 0.5026386976242065, + 0.49736130237579346 + ], + "elapsed": 1153.6004371643066 + }, + { + "step": 880, + "loss": 0.46639662981033325, + "error": 0.244140625, + "gradient_norm": 0.05182372033596039, + "mean_coefficients": [ + 0.49176716804504395, + 0.508232831954956 + ], + "elapsed": 1175.66051197052 + }, + { + "step": 896, + "loss": 0.35056495666503906, + "error": 0.1796875, + "gradient_norm": 0.045919932425022125, + "mean_coefficients": [ + 0.47237810492515564, + 0.5276219248771667 + ], + "elapsed": 1194.3687541484833 + }, + { + "step": 912, + "loss": 0.5886671543121338, + "error": 0.3447265625, + "gradient_norm": 0.045302897691726685, + "mean_coefficients": [ + 0.41737082600593567, + 0.5826291441917419 + ], + "elapsed": 1212.5627307891846 + }, + { + "step": 928, + "loss": 0.6051279306411743, + "error": 0.3408203125, + "gradient_norm": 0.05024299770593643, + "mean_coefficients": [ + 0.4480603337287903, + 0.5519396662712097 + ], + "elapsed": 1237.9728314876556 + }, + { + "step": 944, + "loss": 0.3430662155151367, + "error": 0.1611328125, + "gradient_norm": 0.04460357874631882, + "mean_coefficients": [ + 0.4968012571334839, + 0.5031987428665161 + ], + "elapsed": 1260.0267882347107 + }, + { + "step": 960, + "loss": 0.6355502605438232, + "error": 0.37890625, + "gradient_norm": 0.04846864566206932, + "mean_coefficients": [ + 0.4808691442012787, + 0.5191308259963989 + ], + "elapsed": 1279.905223608017 + }, + { + "step": 976, + "loss": 0.5717797875404358, + "error": 0.3349609375, + "gradient_norm": 0.03617243841290474, + "mean_coefficients": [ + 0.4623255133628845, + 0.5376745462417603 + ], + "elapsed": 1303.0697026252747 + }, + { + "step": 992, + "loss": 0.3269988000392914, + "error": 0.1494140625, + "gradient_norm": 0.05313565954566002, + "mean_coefficients": [ + 0.42171281576156616, + 0.5782871246337891 + ], + "elapsed": 1326.251710176468 + }, + { + "step": 1008, + "loss": 0.6329490542411804, + "error": 0.375, + "gradient_norm": 0.036122437566518784, + "mean_coefficients": [ + 0.4546102285385132, + 0.5453897714614868 + ], + "elapsed": 1347.1945130825043 + }, + { + "step": 1024, + "loss": 0.6227849125862122, + "error": 0.3798828125, + "gradient_norm": 0.048661671578884125, + "mean_coefficients": [ + 0.41305357217788696, + 0.586946427822113 + ], + "elapsed": 1367.592843055725 + }, + { + "step": 1040, + "loss": 0.4212121367454529, + "error": 0.1875, + "gradient_norm": 0.06082203611731529, + "mean_coefficients": [ + 0.45314377546310425, + 0.546856164932251 + ], + "elapsed": 1396.2453150749207 + }, + { + "step": 1056, + "loss": 0.5631591081619263, + "error": 0.3212890625, + "gradient_norm": 0.055875614285469055, + "mean_coefficients": [ + 0.5330983400344849, + 0.4669017195701599 + ], + "elapsed": 1417.7443659305573 + }, + { + "step": 1072, + "loss": 0.10821939259767532, + "error": 0.033203125, + "gradient_norm": 0.03529331088066101, + "mean_coefficients": [ + 0.5035846829414368, + 0.49641531705856323 + ], + "elapsed": 1436.489075422287 + }, + { + "step": 1088, + "loss": 0.5265036821365356, + "error": 0.265625, + "gradient_norm": 0.04223688319325447, + "mean_coefficients": [ + 0.5079262256622314, + 0.49207377433776855 + ], + "elapsed": 1461.3186690807343 + }, + { + "step": 1104, + "loss": 0.4087736904621124, + "error": 0.2109375, + "gradient_norm": 0.0357368029654026, + "mean_coefficients": [ + 0.5090406537055969, + 0.49095937609672546 + ], + "elapsed": 1480.0224187374115 + }, + { + "step": 1120, + "loss": 0.13441112637519836, + "error": 0.0556640625, + "gradient_norm": 0.02240554802119732, + "mean_coefficients": [ + 0.4391622543334961, + 0.5608377456665039 + ], + "elapsed": 1504.261332988739 + }, + { + "step": 1136, + "loss": 0.545034646987915, + "error": 0.3115234375, + "gradient_norm": 0.06524547934532166, + "mean_coefficients": [ + 0.4625178575515747, + 0.5374821424484253 + ], + "elapsed": 1528.559550523758 + }, + { + "step": 1152, + "loss": 0.3058270514011383, + "error": 0.1376953125, + "gradient_norm": 0.04590972512960434, + "mean_coefficients": [ + 0.41034021973609924, + 0.5896598100662231 + ], + "elapsed": 1550.5981769561768 + }, + { + "step": 1168, + "loss": 0.5833588242530823, + "error": 0.33203125, + "gradient_norm": 0.04596199840307236, + "mean_coefficients": [ + 0.456938773393631, + 0.5430612564086914 + ], + "elapsed": 1573.731043100357 + }, + { + "step": 1184, + "loss": 0.5287269353866577, + "error": 0.2763671875, + "gradient_norm": 0.04873070865869522, + "mean_coefficients": [ + 0.5495302081108093, + 0.4504697918891907 + ], + "elapsed": 1593.5648920536041 + }, + { + "step": 1200, + "loss": 0.5420668125152588, + "error": 0.2978515625, + "gradient_norm": 0.042190760374069214, + "mean_coefficients": [ + 0.45947563648223877, + 0.5405243635177612 + ], + "elapsed": 1611.212196111679 + }, + { + "step": 1216, + "loss": 0.5781879425048828, + "error": 0.322265625, + "gradient_norm": 0.0392482727766037, + "mean_coefficients": [ + 0.4420161247253418, + 0.5579838752746582 + ], + "elapsed": 1633.2575182914734 + }, + { + "step": 1232, + "loss": 0.026123439893126488, + "error": 0.0107421875, + "gradient_norm": 0.007018120959401131, + "mean_coefficients": [ + 0.46772003173828125, + 0.532279908657074 + ], + "elapsed": 1653.0733880996704 + }, + { + "step": 1248, + "loss": 0.029043272137641907, + "error": 0.0078125, + "gradient_norm": 0.009661108255386353, + "mean_coefficients": [ + 0.47005489468574524, + 0.5299451351165771 + ], + "elapsed": 1671.2404634952545 + }, + { + "step": 1264, + "loss": 0.582717776298523, + "error": 0.3291015625, + "gradient_norm": 0.06634271144866943, + "mean_coefficients": [ + 0.5097807049751282, + 0.4902192950248718 + ], + "elapsed": 1692.2314596176147 + }, + { + "step": 1280, + "loss": 0.31173962354660034, + "error": 0.14453125, + "gradient_norm": 0.039092399179935455, + "mean_coefficients": [ + 0.4196550250053406, + 0.5803449749946594 + ], + "elapsed": 1713.194138765335 + }, + { + "step": 1296, + "loss": 0.5949922800064087, + "error": 0.357421875, + "gradient_norm": 0.034312762320041656, + "mean_coefficients": [ + 0.4419449269771576, + 0.55805504322052 + ], + "elapsed": 1733.0129091739655 + }, + { + "step": 1312, + "loss": 0.3603796362876892, + "error": 0.16796875, + "gradient_norm": 0.05415824428200722, + "mean_coefficients": [ + 0.41266000270843506, + 0.5873400568962097 + ], + "elapsed": 1757.786653995514 + }, + { + "step": 1328, + "loss": 0.13598129153251648, + "error": 0.0478515625, + "gradient_norm": 0.024467356503009796, + "mean_coefficients": [ + 0.3836991786956787, + 0.6163008213043213 + ], + "elapsed": 1779.825397491455 + }, + { + "step": 1344, + "loss": 0.5115128755569458, + "error": 0.2822265625, + "gradient_norm": 0.053328439593315125, + "mean_coefficients": [ + 0.40296074748039246, + 0.5970393419265747 + ], + "elapsed": 1796.8633427619934 + }, + { + "step": 1360, + "loss": 0.6190367341041565, + "error": 0.3779296875, + "gradient_norm": 0.04020882770419121, + "mean_coefficients": [ + 0.40149205923080444, + 0.5985079407691956 + ], + "elapsed": 1813.90576171875 + }, + { + "step": 1376, + "loss": 0.21154341101646423, + "error": 0.08984375, + "gradient_norm": 0.0423702634871006, + "mean_coefficients": [ + 0.4674369692802429, + 0.5325630307197571 + ], + "elapsed": 1832.588074207306 + }, + { + "step": 1392, + "loss": 0.018975114449858665, + "error": 0.0087890625, + "gradient_norm": 0.005260550882667303, + "mean_coefficients": [ + 0.46262064576148987, + 0.5373793840408325 + ], + "elapsed": 1854.5863862037659 + }, + { + "step": 1408, + "loss": 0.6291724443435669, + "error": 0.3740234375, + "gradient_norm": 0.036437831819057465, + "mean_coefficients": [ + 0.5162137746810913, + 0.4837862253189087 + ], + "elapsed": 1875.442207813263 + }, + { + "step": 1424, + "loss": 0.5361799001693726, + "error": 0.294921875, + "gradient_norm": 0.06118213012814522, + "mean_coefficients": [ + 0.4530576169490814, + 0.5469423532485962 + ], + "elapsed": 1895.730218887329 + }, + { + "step": 1440, + "loss": 0.13184601068496704, + "error": 0.0537109375, + "gradient_norm": 0.0366254597902298, + "mean_coefficients": [ + 0.456234335899353, + 0.543765664100647 + ], + "elapsed": 1918.2103044986725 + }, + { + "step": 1456, + "loss": 0.12348794937133789, + "error": 0.044921875, + "gradient_norm": 0.026519156992435455, + "mean_coefficients": [ + 0.33625853061676025, + 0.6637414693832397 + ], + "elapsed": 1935.9983472824097 + }, + { + "step": 1472, + "loss": 0.13811883330345154, + "error": 0.0615234375, + "gradient_norm": 0.02696700394153595, + "mean_coefficients": [ + 0.4929874837398529, + 0.5070125460624695 + ], + "elapsed": 1957.4508769512177 + }, + { + "step": 1488, + "loss": 0.13847771286964417, + "error": 0.0537109375, + "gradient_norm": 0.030008114874362946, + "mean_coefficients": [ + 0.39965277910232544, + 0.6003471612930298 + ], + "elapsed": 1976.7007565498352 + }, + { + "step": 1504, + "loss": 0.5583300590515137, + "error": 0.310546875, + "gradient_norm": 0.04946867376565933, + "mean_coefficients": [ + 0.5022081136703491, + 0.4977918863296509 + ], + "elapsed": 1998.7133693695068 + }, + { + "step": 1520, + "loss": 0.4180712401866913, + "error": 0.193359375, + "gradient_norm": 0.04930788651108742, + "mean_coefficients": [ + 0.3789001703262329, + 0.6210998296737671 + ], + "elapsed": 2020.1941475868225 + }, + { + "step": 1536, + "loss": 0.573837161064148, + "error": 0.3349609375, + "gradient_norm": 0.040077853947877884, + "mean_coefficients": [ + 0.38551098108291626, + 0.6144890189170837 + ], + "elapsed": 2042.7438170909882 + }, + { + "step": 1552, + "loss": 0.15159833431243896, + "error": 0.0625, + "gradient_norm": 0.025620637461543083, + "mean_coefficients": [ + 0.45392143726348877, + 0.5460785627365112 + ], + "elapsed": 2070.7468621730804 + }, + { + "step": 1568, + "loss": 0.3654119372367859, + "error": 0.1796875, + "gradient_norm": 0.04743841663002968, + "mean_coefficients": [ + 0.3550558388233185, + 0.6449441909790039 + ], + "elapsed": 2089.376792192459 + }, + { + "step": 1584, + "loss": 0.6101510524749756, + "error": 0.3623046875, + "gradient_norm": 0.06323248893022537, + "mean_coefficients": [ + 0.37972599267959595, + 0.620274007320404 + ], + "elapsed": 2109.1351883411407 + }, + { + "step": 1600, + "loss": 0.5123001337051392, + "error": 0.271484375, + "gradient_norm": 0.04863261431455612, + "mean_coefficients": [ + 0.45421111583709717, + 0.5457888841629028 + ], + "elapsed": 2132.400375366211 + }, + { + "step": 1616, + "loss": 0.421336829662323, + "error": 0.2177734375, + "gradient_norm": 0.041021984070539474, + "mean_coefficients": [ + 0.4929773807525635, + 0.5070226192474365 + ], + "elapsed": 2151.1066596508026 + }, + { + "step": 1632, + "loss": 0.5365814566612244, + "error": 0.30078125, + "gradient_norm": 0.037577010691165924, + "mean_coefficients": [ + 0.5444948077201843, + 0.4555051922798157 + ], + "elapsed": 2171.4190695285797 + }, + { + "step": 1648, + "loss": 0.5968600511550903, + "error": 0.3544921875, + "gradient_norm": 0.04259928688406944, + "mean_coefficients": [ + 0.5608794689178467, + 0.4391205310821533 + ], + "elapsed": 2189.533290863037 + }, + { + "step": 1664, + "loss": 0.01629689335823059, + "error": 0.0048828125, + "gradient_norm": 0.009090352803468704, + "mean_coefficients": [ + 0.4871402382850647, + 0.5128598213195801 + ], + "elapsed": 2213.112939119339 + }, + { + "step": 1680, + "loss": 0.4757354259490967, + "error": 0.248046875, + "gradient_norm": 0.0469970703125, + "mean_coefficients": [ + 0.5250517129898071, + 0.47494831681251526 + ], + "elapsed": 2232.9879083633423 + }, + { + "step": 1696, + "loss": 0.6343755125999451, + "error": 0.390625, + "gradient_norm": 0.038207508623600006, + "mean_coefficients": [ + 0.5461910963058472, + 0.4538089632987976 + ], + "elapsed": 2254.4620490074158 + }, + { + "step": 1712, + "loss": 0.14172980189323425, + "error": 0.0537109375, + "gradient_norm": 0.03144967183470726, + "mean_coefficients": [ + 0.4126092791557312, + 0.5873907804489136 + ], + "elapsed": 2274.760455608368 + }, + { + "step": 1728, + "loss": 0.43767249584198, + "error": 0.2236328125, + "gradient_norm": 0.04490065574645996, + "mean_coefficients": [ + 0.5525646209716797, + 0.4474353790283203 + ], + "elapsed": 2292.8783674240112 + }, + { + "step": 1744, + "loss": 0.3858981132507324, + "error": 0.189453125, + "gradient_norm": 0.047112803906202316, + "mean_coefficients": [ + 0.5345168113708496, + 0.46548324823379517 + ], + "elapsed": 2313.2062649726868 + }, + { + "step": 1760, + "loss": 0.026521675288677216, + "error": 0.0078125, + "gradient_norm": 0.008044665679335594, + "mean_coefficients": [ + 0.4988538324832916, + 0.5011461973190308 + ], + "elapsed": 2336.282013654709 + }, + { + "step": 1776, + "loss": 0.02684793435037136, + "error": 0.0087890625, + "gradient_norm": 0.008621076121926308, + "mean_coefficients": [ + 0.4812018871307373, + 0.5187981128692627 + ], + "elapsed": 2354.5700285434723 + }, + { + "step": 1792, + "loss": 0.4362499415874481, + "error": 0.2236328125, + "gradient_norm": 0.05823780596256256, + "mean_coefficients": [ + 0.47490841150283813, + 0.5250915884971619 + ], + "elapsed": 2372.1857488155365 + }, + { + "step": 1808, + "loss": 0.5943711400032043, + "error": 0.361328125, + "gradient_norm": 0.0680852085351944, + "mean_coefficients": [ + 0.47086262702941895, + 0.529137372970581 + ], + "elapsed": 2392.6065361499786 + }, + { + "step": 1824, + "loss": 0.4363088309764862, + "error": 0.216796875, + "gradient_norm": 0.07410386204719543, + "mean_coefficients": [ + 0.37843573093414307, + 0.6215642690658569 + ], + "elapsed": 2411.8226177692413 + }, + { + "step": 1840, + "loss": 0.3196601867675781, + "error": 0.1494140625, + "gradient_norm": 0.05553024634718895, + "mean_coefficients": [ + 0.3391280770301819, + 0.6608718633651733 + ], + "elapsed": 2431.0497477054596 + }, + { + "step": 1856, + "loss": 0.37508872151374817, + "error": 0.1826171875, + "gradient_norm": 0.07089140266180038, + "mean_coefficients": [ + 0.3326033055782318, + 0.6673966646194458 + ], + "elapsed": 2453.021736383438 + }, + { + "step": 1872, + "loss": 0.1499984860420227, + "error": 0.0615234375, + "gradient_norm": 0.03733578324317932, + "mean_coefficients": [ + 0.44182807207107544, + 0.5581719279289246 + ], + "elapsed": 2470.192109823227 + }, + { + "step": 1888, + "loss": 0.4416685104370117, + "error": 0.2265625, + "gradient_norm": 0.07857565581798553, + "mean_coefficients": [ + 0.3767402172088623, + 0.6232597827911377 + ], + "elapsed": 2491.662375688553 + }, + { + "step": 1904, + "loss": 0.4437134861946106, + "error": 0.2158203125, + "gradient_norm": 0.06356606632471085, + "mean_coefficients": [ + 0.47958987951278687, + 0.5204101204872131 + ], + "elapsed": 2512.6289751529694 + }, + { + "step": 1920, + "loss": 0.4932388663291931, + "error": 0.25, + "gradient_norm": 0.05904463678598404, + "mean_coefficients": [ + 0.48851683735847473, + 0.5114831924438477 + ], + "elapsed": 2530.8037297725677 + }, + { + "step": 1936, + "loss": 0.6059780716896057, + "error": 0.3701171875, + "gradient_norm": 0.04947994649410248, + "mean_coefficients": [ + 0.4990648627281189, + 0.5009350776672363 + ], + "elapsed": 2554.520874977112 + }, + { + "step": 1952, + "loss": 0.48124009370803833, + "error": 0.248046875, + "gradient_norm": 0.05768373981118202, + "mean_coefficients": [ + 0.5284570455551147, + 0.47154295444488525 + ], + "elapsed": 2572.1566245555878 + }, + { + "step": 1968, + "loss": 0.09479989111423492, + "error": 0.033203125, + "gradient_norm": 0.02639523521065712, + "mean_coefficients": [ + 0.3885442912578583, + 0.6114556789398193 + ], + "elapsed": 2594.7533991336823 + }, + { + "step": 1984, + "loss": 0.4216057062149048, + "error": 0.1982421875, + "gradient_norm": 0.05092155188322067, + "mean_coefficients": [ + 0.41849398612976074, + 0.5815060138702393 + ], + "elapsed": 2618.397775888443 + }, + { + "step": 2000, + "loss": 0.1493990123271942, + "error": 0.0673828125, + "gradient_norm": 0.026132037863135338, + "mean_coefficients": [ + 0.5240117311477661, + 0.4759882688522339 + ], + "elapsed": 2634.8473727703094 + }, + { + "step": 2016, + "loss": 0.022406509146094322, + "error": 0.0068359375, + "gradient_norm": 0.009604685008525848, + "mean_coefficients": [ + 0.5113526582717896, + 0.48864734172821045 + ], + "elapsed": 2657.3628783226013 + }, + { + "step": 2032, + "loss": 0.5801821947097778, + "error": 0.32421875, + "gradient_norm": 0.0684855505824089, + "mean_coefficients": [ + 0.5880363583564758, + 0.4119635820388794 + ], + "elapsed": 2679.3364017009735 + }, + { + "step": 2048, + "loss": 0.309080570936203, + "error": 0.1357421875, + "gradient_norm": 0.043055612593889236, + "mean_coefficients": [ + 0.3990344703197479, + 0.6009654998779297 + ], + "elapsed": 2698.5810737609863 + } + ], + "seconds": 2709.3174657821655, + "declared_plan": { + "hypothesis": "Joint logical-likelihood training may learn useful shot-dependent complementarity beyond frozen independent expert averages", + "parents": [ + "fresh2_full/weights-1536.npz", + "reserved1_full/weights-1536.npz" + ], + "initialization": "Both experts retain their session-trained parameters and exact Adam moments/count2048; new41-input32-hidden SiLU gate has random hidden weights(seed20261310),zero output and bias,giving equal mixture", + "features": "Gate uses only24site densities,lag1/2/4/8coincidence/covariance,6density/frame summaries,duration/duration_squared/basis;fixed numeric scales,no fitted normalization,no IDs/labels/shot positions/expert probabilities", + "loss": "Logical BCE of two-expert probability mixture; expert BCE adjoints weighted by posterior responsibility,free gate-logit adjoint=coefficient-responsibility; gradients controlled against independent autodiff", + "training": "2048updates B1024;uniform sampling over all516880training rows/26conditions(seed20261311);sharedphysicalpass3 priors;expertLR.0001,gateLR.001;separate AdamW clocks,moments restored for experts,freshgate count0;one joint norm1 clip,decay1e-4", + "selection_steps": [ + 0, + 512, + 1024, + 2048 + ], + "validation": "Full133120 supplied validation shots per listed checkpoint; perbasis choose incumbent or rawjoint/equalphysical,all13durations; tiesretainincumbent. Step0 is fixedmean of trainedparents.1536has screening only and is not a full-selection checkpoint.", + "audit_scope": "All training labels are eligible; no independent reserved-training-label audit claim. Parent initialization provenance retained.", + "controls": "CPUscalar finite differences,exactchain autodiff,feature order/subset checks; two-update serialization/resume/sampling/Adam controls; portableCPUruntime;GPUactualgeometrygradient control before training", + "runtime": "Two exact neural passes share one physical-prior computation; preserve all retained incumbent dispatches;fullreplay/scoring/readonlyrelocation/projection before any publication", + "interpretation": "Learned branches are not identified physical noise regimes; this is a joint model recipe,not an isolated causal test of gating", + "gpu": "One H100,serialized afterfresh_temporal1_finished", + "test_data_used": false, + "parameter_counts": { + "expert0": 29505, + "expert1": 29505, + "gate": 1377, + "total": 60387 + }, + "physical_blend_clarification_before_training": "Equal physical blends use the existing calibrated/ensemble physical pass3 decoder output from turbo1/predictions, checked against runtime config and DEM/plans/weights. Raw feedback5_cache pass3 is only the neural conditioning prior/diagnostic. Corrected before any GPU training or selection in this study." + }, + "sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 512, + 1024, + 1536, + 2048 + ], + "training_draws": 2097152, + "distinct_phase_rows": 507134, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 4096, + "expert1": 4096, + "gate": 2048 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + "pipeline_control": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 runs; no selection or submission", + "expert_parent_state_exact": true, + "new_gate_initialization_exact": true, + "new_gate_zero_adam": true, + "all_three_parts_updated": true, + "resume_weights_optimizer_rng_exact": true, + "sampling_audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture_smoke1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/joint_mixture_smoke2", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "final_adam_counts": { + "expert0": 2050, + "expert1": 2050, + "gate": 2 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + } + ], + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "learned_d5__joint_mixture_state.py": "44e6815f769c02cf2d19e3ad1e33e6f287df8b5ea33f5c87b747361ea41f3dc6", + "learned_d5__joint_mixture_train.py": "048eb44389f53acc00d51da4914ef9404f6d774b915f8805a0102d707599c483", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "source_sha256": "024bd22f8e02257e94ba2c90e8449ce9053bf3a15a852367ac4a260a1cacfa82" + } + }, + "diagnostic_reports": { + "1024": { + "scope": "All133120 validation shots, trained branches and mixture held fixed. Diagnostic only, not an additional checkpoint or deployment selection.", + "weights": "/run-state/workspace/research/learned_d5/joint_mixture1/weights-1024.npz", + "weights_sha256": "d3193fe31df6de065d5f9c45edccb24076c9635c52711920feabfc03cf82c8e3", + "condition_mean_gate": "Uses full validation detector-dependent coefficients, without labels, to diagnose shot dependence. Transductive comparison only, excluded from runtime candidates.", + "numeric_comparison": "New branch-output graph compared with existing full joint outputs; any decision changes are numerical differences, not evidence for a learned gating effect.", + "reference_predictions": "/run-state/workspace/research/learned_d5/validation-joint_mixture1-1024", + "reference_decision_differences": 0, + "summary": { + "all": { + "expert0": { + "failure": 0.2264047475961538, + "nll": 0.42000085827526024 + }, + "expert1": { + "failure": 0.22753906250000003, + "nll": 0.4204083056283482 + }, + "equal_trained_experts": { + "failure": 0.22629206730769227, + "nll": 0.41957256143976174 + }, + "dynamic_gate": { + "failure": 0.2263671875, + "nll": 0.41962111320008444 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.22638221153846153, + "nll": 0.419619395356122 + }, + "gate_net_errors_saved_over_equal": -10 + }, + "X": { + "expert0": { + "failure": 0.23360877403846156, + "nll": 0.42791732959454054 + }, + "expert1": { + "failure": 0.23266225961538461, + "nll": 0.42781502246849024 + }, + "equal_trained_experts": { + "failure": 0.23189603365384615, + "nll": 0.4272714276315763 + }, + "dynamic_gate": { + "failure": 0.23168569711538464, + "nll": 0.4272769827698689 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.23194110576923072, + "nll": 0.4272713933698842 + }, + "gate_net_errors_saved_over_equal": 14 + }, + "Z": { + "expert0": { + "failure": 0.2192007211538462, + "nll": 0.41208438695598004 + }, + "expert1": { + "failure": 0.22241586538461536, + "nll": 0.41300158878820603 + }, + "equal_trained_experts": { + "failure": 0.22068810096153843, + "nll": 0.41187369524794715 + }, + "dynamic_gate": { + "failure": 0.22104867788461538, + "nll": 0.4119652436303 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.22082331730769228, + "nll": 0.41196739734235976 + }, + "gate_net_errors_saved_over_equal": -24 + } + }, + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "basis": "X", + "rounds": 1, + "shots": 5120, + "expert0": { + "failure": 0.0078125, + "nll": 0.021167033343135612 + }, + "expert1": { + "failure": 0.0078125, + "nll": 0.021066061521213646 + }, + "equal_trained_experts": { + "failure": 0.0078125, + "nll": 0.021098029312316514 + }, + "dynamic_gate": { + "failure": 0.0078125, + "nll": 0.021091082581725255 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.0078125, + "nll": 0.02109357806900939 + }, + "gate_corrected_equal_errors": 0, + "gate_introduced_equal_errors": 0, + "mean_expert0_coefficient": 0.45402097702026367, + "std_expert0_coefficient": 0.061466656625270844, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 6.023043632507324 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "basis": "X", + "rounds": 3, + "shots": 5120, + "expert0": { + "failure": 0.0517578125, + "nll": 0.13910630975819896 + }, + "expert1": { + "failure": 0.0517578125, + "nll": 0.13862455079972766 + }, + "equal_trained_experts": { + "failure": 0.0513671875, + "nll": 0.13857218645291697 + }, + "dynamic_gate": { + "failure": 0.0515625, + "nll": 0.1386424845835647 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.0513671875, + "nll": 0.13855845264106442 + }, + "gate_corrected_equal_errors": 0, + "gate_introduced_equal_errors": 1, + "mean_expert0_coefficient": 0.4678618907928467, + "std_expert0_coefficient": 0.06334442645311356, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 6.856982946395874 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "basis": "X", + "rounds": 5, + "shots": 5120, + "expert0": { + "failure": 0.109765625, + "nll": 0.24606666642665403 + }, + "expert1": { + "failure": 0.1060546875, + "nll": 0.24482116672082052 + }, + "equal_trained_experts": { + "failure": 0.1076171875, + "nll": 0.2448788391287157 + }, + "dynamic_gate": { + "failure": 0.107421875, + "nll": 0.24476977507260772 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.107421875, + "nll": 0.2448298521887465 + }, + "gate_corrected_equal_errors": 3, + "gate_introduced_equal_errors": 2, + "mean_expert0_coefficient": 0.45631542801856995, + "std_expert0_coefficient": 0.05329982563853264, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 7.69296669960022 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "basis": "X", + "rounds": 7, + "shots": 5120, + "expert0": { + "failure": 0.158203125, + "nll": 0.33968746601025435 + }, + "expert1": { + "failure": 0.1537109375, + "nll": 0.3390459658135197 + }, + "equal_trained_experts": { + "failure": 0.1546875, + "nll": 0.3387149333128951 + }, + "dynamic_gate": { + "failure": 0.1546875, + "nll": 0.3387405260182847 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1552734375, + "nll": 0.33869318945682925 + }, + "gate_corrected_equal_errors": 2, + "gate_introduced_equal_errors": 2, + "mean_expert0_coefficient": 0.4569645822048187, + "std_expert0_coefficient": 0.04633341357111931, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 8.544772863388062 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "basis": "X", + "rounds": 9, + "shots": 5120, + "expert0": { + "failure": 0.1890625, + "nll": 0.3941334810271752 + }, + "expert1": { + "failure": 0.187109375, + "nll": 0.3960814097442839 + }, + "equal_trained_experts": { + "failure": 0.186328125, + "nll": 0.39438948924061745 + }, + "dynamic_gate": { + "failure": 0.1861328125, + "nll": 0.3944103200060819 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1865234375, + "nll": 0.39446997171129017 + }, + "gate_corrected_equal_errors": 5, + "gate_introduced_equal_errors": 4, + "mean_expert0_coefficient": 0.46087026596069336, + "std_expert0_coefficient": 0.04125645011663437, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 13.304802894592285 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "basis": "X", + "rounds": 11, + "shots": 5120, + "expert0": { + "failure": 0.2255859375, + "nll": 0.44412653506590144 + }, + "expert1": { + "failure": 0.2240234375, + "nll": 0.44334679796066717 + }, + "equal_trained_experts": { + "failure": 0.222265625, + "nll": 0.442992165124275 + }, + "dynamic_gate": { + "failure": 0.2232421875, + "nll": 0.4430618942439482 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.223046875, + "nll": 0.4429679804868222 + }, + "gate_corrected_equal_errors": 2, + "gate_introduced_equal_errors": 7, + "mean_expert0_coefficient": 0.4635888636112213, + "std_expert0_coefficient": 0.03771386668086052, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 15.02279019355774 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "basis": "X", + "rounds": 13, + "shots": 5120, + "expert0": { + "failure": 0.2466796875, + "nll": 0.4752914206931965 + }, + "expert1": { + "failure": 0.24296875, + "nll": 0.4747359043838625 + }, + "equal_trained_experts": { + "failure": 0.2427734375, + "nll": 0.4742486283043652 + }, + "dynamic_gate": { + "failure": 0.2419921875, + "nll": 0.47417866515912693 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2423828125, + "nll": 0.4742338742088748 + }, + "gate_corrected_equal_errors": 7, + "gate_introduced_equal_errors": 3, + "mean_expert0_coefficient": 0.46476468443870544, + "std_expert0_coefficient": 0.03629279509186745, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 16.765040159225464 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "basis": "X", + "rounds": 15, + "shots": 5120, + "expert0": { + "failure": 0.2765625, + "nll": 0.5168404176760979 + }, + "expert1": { + "failure": 0.28046875, + "nll": 0.5160851427546307 + }, + "equal_trained_experts": { + "failure": 0.2751953125, + "nll": 0.5157297683280424 + }, + "dynamic_gate": { + "failure": 0.2755859375, + "nll": 0.5157745918451779 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.276171875, + "nll": 0.5157068320307976 + }, + "gate_corrected_equal_errors": 4, + "gate_introduced_equal_errors": 6, + "mean_expert0_coefficient": 0.46386680006980896, + "std_expert0_coefficient": 0.03404103219509125, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 22.48501682281494 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "basis": "X", + "rounds": 17, + "shots": 5120, + "expert0": { + "failure": 0.316796875, + "nll": 0.5565403818045906 + }, + "expert1": { + "failure": 0.3134765625, + "nll": 0.5574895747175549 + }, + "equal_trained_experts": { + "failure": 0.3134765625, + "nll": 0.556202170752879 + }, + "dynamic_gate": { + "failure": 0.312890625, + "nll": 0.5562355213561607 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3130859375, + "nll": 0.556241279106721 + }, + "gate_corrected_equal_errors": 8, + "gate_introduced_equal_errors": 5, + "mean_expert0_coefficient": 0.4638591706752777, + "std_expert0_coefficient": 0.03352941945195198, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 25.062374114990234 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "basis": "X", + "rounds": 19, + "shots": 5120, + "expert0": { + "failure": 0.33828125, + "nll": 0.5829903851923376 + }, + "expert1": { + "failure": 0.340625, + "nll": 0.5844361793373638 + }, + "equal_trained_experts": { + "failure": 0.3404296875, + "nll": 0.5830776228282906 + }, + "dynamic_gate": { + "failure": 0.3384765625, + "nll": 0.5831242166522763 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3396484375, + "nll": 0.5831456608993933 + }, + "gate_corrected_equal_errors": 16, + "gate_introduced_equal_errors": 6, + "mean_expert0_coefficient": 0.45674705505371094, + "std_expert0_coefficient": 0.03289216756820679, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 27.6448814868927 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "basis": "X", + "rounds": 21, + "shots": 5120, + "expert0": { + "failure": 0.3671875, + "nll": 0.6064041501158648 + }, + "expert1": { + "failure": 0.3705078125, + "nll": 0.6068810963876093 + }, + "equal_trained_experts": { + "failure": 0.3681640625, + "nll": 0.6059549160263933 + }, + "dynamic_gate": { + "failure": 0.36796875, + "nll": 0.6059818373135968 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.369140625, + "nll": 0.6059772752510763 + }, + "gate_corrected_equal_errors": 11, + "gate_introduced_equal_errors": 10, + "mean_expert0_coefficient": 0.46253538131713867, + "std_expert0_coefficient": 0.03098812699317932, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 30.23663306236267 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "basis": "X", + "rounds": 23, + "shots": 5120, + "expert0": { + "failure": 0.3728515625, + "nll": 0.615598752399971 + }, + "expert1": { + "failure": 0.3705078125, + "nll": 0.6147418932197647 + }, + "equal_trained_experts": { + "failure": 0.3685546875, + "nll": 0.6145708354441923 + }, + "dynamic_gate": { + "failure": 0.3689453125, + "nll": 0.6145556648040028 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3677734375, + "nll": 0.6145391148502316 + }, + "gate_corrected_equal_errors": 9, + "gate_introduced_equal_errors": 11, + "mean_expert0_coefficient": 0.4566752314567566, + "std_expert0_coefficient": 0.02875932678580284, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 36.79638338088989 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "basis": "X", + "rounds": 25, + "shots": 5120, + "expert0": { + "failure": 0.3763671875, + "nll": 0.6249722852156487 + }, + "expert1": { + "failure": 0.3755859375, + "nll": 0.6242395487293549 + }, + "equal_trained_experts": { + "failure": 0.3759765625, + "nll": 0.6240989749545915 + }, + "dynamic_gate": { + "failure": 0.3751953125, + "nll": 0.6240341963717408 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3755859375, + "nll": 0.624071052907639 + }, + "gate_corrected_equal_errors": 17, + "gate_introduced_equal_errors": 13, + "mean_expert0_coefficient": 0.45500659942626953, + "std_expert0_coefficient": 0.02797979675233364, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 40.21456027030945 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "basis": "Z", + "rounds": 1, + "shots": 5120, + "expert0": { + "failure": 0.0076171875, + "nll": 0.021219258421315775 + }, + "expert1": { + "failure": 0.0076171875, + "nll": 0.021408783718598216 + }, + "equal_trained_experts": { + "failure": 0.0076171875, + "nll": 0.021286307302344883 + }, + "dynamic_gate": { + "failure": 0.0076171875, + "nll": 0.021275187675314982 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.0076171875, + "nll": 0.021289900983587517 + }, + "gate_corrected_equal_errors": 0, + "gate_introduced_equal_errors": 0, + "mean_expert0_coefficient": 0.4813924729824066, + "std_expert0_coefficient": 0.03631594032049179, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 41.04611778259277 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "basis": "Z", + "rounds": 3, + "shots": 5120, + "expert0": { + "failure": 0.0478515625, + "nll": 0.12468847931109177 + }, + "expert1": { + "failure": 0.0482421875, + "nll": 0.12382717397579981 + }, + "equal_trained_experts": { + "failure": 0.0478515625, + "nll": 0.12398507416630675 + }, + "dynamic_gate": { + "failure": 0.048046875, + "nll": 0.12392777263732058 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.0478515625, + "nll": 0.12391103373760326 + }, + "gate_corrected_equal_errors": 1, + "gate_introduced_equal_errors": 2, + "mean_expert0_coefficient": 0.3988422751426697, + "std_expert0_coefficient": 0.07017820328474045, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 41.88027834892273 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "basis": "Z", + "rounds": 5, + "shots": 5120, + "expert0": { + "failure": 0.100390625, + "nll": 0.23194021837879628 + }, + "expert1": { + "failure": 0.101953125, + "nll": 0.23358024100970187 + }, + "equal_trained_experts": { + "failure": 0.1015625, + "nll": 0.2322105066268802 + }, + "dynamic_gate": { + "failure": 0.1015625, + "nll": 0.23239366181323845 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.101171875, + "nll": 0.2323864547332078 + }, + "gate_corrected_equal_errors": 2, + "gate_introduced_equal_errors": 2, + "mean_expert0_coefficient": 0.4034428596496582, + "std_expert0_coefficient": 0.05592481419444084, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 42.73507261276245 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "basis": "Z", + "rounds": 7, + "shots": 5120, + "expert0": { + "failure": 0.1462890625, + "nll": 0.3210623450894091 + }, + "expert1": { + "failure": 0.1462890625, + "nll": 0.32211613256531646 + }, + "equal_trained_experts": { + "failure": 0.146484375, + "nll": 0.3208127604911416 + }, + "dynamic_gate": { + "failure": 0.146484375, + "nll": 0.3208343470093459 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1462890625, + "nll": 0.3209350176233047 + }, + "gate_corrected_equal_errors": 4, + "gate_introduced_equal_errors": 4, + "mean_expert0_coefficient": 0.4073472023010254, + "std_expert0_coefficient": 0.04724162071943283, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 43.58378767967224 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "basis": "Z", + "rounds": 9, + "shots": 5120, + "expert0": { + "failure": 0.171875, + "nll": 0.356991017886619 + }, + "expert1": { + "failure": 0.1734375, + "nll": 0.35839359050965797 + }, + "equal_trained_experts": { + "failure": 0.17421875, + "nll": 0.3568590293379149 + }, + "dynamic_gate": { + "failure": 0.1744140625, + "nll": 0.3569689949336513 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1740234375, + "nll": 0.35699919283238896 + }, + "gate_corrected_equal_errors": 7, + "gate_introduced_equal_errors": 8, + "mean_expert0_coefficient": 0.41523876786231995, + "std_expert0_coefficient": 0.043424684554338455, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 45.30166578292847 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "basis": "Z", + "rounds": 11, + "shots": 5120, + "expert0": { + "failure": 0.2072265625, + "nll": 0.4285300243152431 + }, + "expert1": { + "failure": 0.2099609375, + "nll": 0.43142730786711725 + }, + "equal_trained_experts": { + "failure": 0.2091796875, + "nll": 0.42912877575695374 + }, + "dynamic_gate": { + "failure": 0.21015625, + "nll": 0.429396092354034 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2091796875, + "nll": 0.4293816843978277 + }, + "gate_corrected_equal_errors": 4, + "gate_introduced_equal_errors": 9, + "mean_expert0_coefficient": 0.4192377030849457, + "std_expert0_coefficient": 0.0399007685482502, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 47.01710510253906 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "basis": "Z", + "rounds": 13, + "shots": 5120, + "expert0": { + "failure": 0.23046875, + "nll": 0.45770938820316437 + }, + "expert1": { + "failure": 0.2353515625, + "nll": 0.4588378809912266 + }, + "equal_trained_experts": { + "failure": 0.233203125, + "nll": 0.4574139805887249 + }, + "dynamic_gate": { + "failure": 0.2333984375, + "nll": 0.457487262863958 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.233203125, + "nll": 0.457518831140043 + }, + "gate_corrected_equal_errors": 10, + "gate_introduced_equal_errors": 11, + "mean_expert0_coefficient": 0.4237867295742035, + "std_expert0_coefficient": 0.03606785461306572, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 48.74562644958496 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "basis": "Z", + "rounds": 15, + "shots": 5120, + "expert0": { + "failure": 0.2583984375, + "nll": 0.49750581421130374 + }, + "expert1": { + "failure": 0.26484375, + "nll": 0.49821684615523776 + }, + "equal_trained_experts": { + "failure": 0.26015625, + "nll": 0.4970474377648385 + }, + "dynamic_gate": { + "failure": 0.2607421875, + "nll": 0.4971909154986916 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2607421875, + "nll": 0.49712648823219485 + }, + "gate_corrected_equal_errors": 6, + "gate_introduced_equal_errors": 9, + "mean_expert0_coefficient": 0.4213683009147644, + "std_expert0_coefficient": 0.03425368666648865, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 51.326762676239014 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "basis": "Z", + "rounds": 17, + "shots": 5120, + "expert0": { + "failure": 0.30234375, + "nll": 0.5405165611091232 + }, + "expert1": { + "failure": 0.2974609375, + "nll": 0.5409100301362176 + }, + "equal_trained_experts": { + "failure": 0.300390625, + "nll": 0.5398573410119722 + }, + "dynamic_gate": { + "failure": 0.3001953125, + "nll": 0.5399112638663238 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3005859375, + "nll": 0.5399084956332544 + }, + "gate_corrected_equal_errors": 12, + "gate_introduced_equal_errors": 11, + "mean_expert0_coefficient": 0.42234840989112854, + "std_expert0_coefficient": 0.03240479528903961, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 53.886895179748535 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "basis": "Z", + "rounds": 19, + "shots": 5120, + "expert0": { + "failure": 0.322265625, + "nll": 0.570221662278298 + }, + "expert1": { + "failure": 0.333203125, + "nll": 0.5722930672625883 + }, + "equal_trained_experts": { + "failure": 0.32578125, + "nll": 0.570423623523231 + }, + "dynamic_gate": { + "failure": 0.328125, + "nll": 0.570632012597947 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3275390625, + "nll": 0.5706217883774091 + }, + "gate_corrected_equal_errors": 14, + "gate_introduced_equal_errors": 26, + "mean_expert0_coefficient": 0.41600197553634644, + "std_expert0_coefficient": 0.030945109203457832, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 56.47732734680176 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "basis": "Z", + "rounds": 21, + "shots": 5120, + "expert0": { + "failure": 0.3357421875, + "nll": 0.5828709701523518 + }, + "expert1": { + "failure": 0.3427734375, + "nll": 0.58450897831671 + }, + "equal_trained_experts": { + "failure": 0.33828125, + "nll": 0.5829710894795508 + }, + "dynamic_gate": { + "failure": 0.33828125, + "nll": 0.5831376598455293 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3380859375, + "nll": 0.5831223122782454 + }, + "gate_corrected_equal_errors": 12, + "gate_introduced_equal_errors": 12, + "mean_expert0_coefficient": 0.41970911622047424, + "std_expert0_coefficient": 0.030097631737589836, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 59.06368565559387 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "basis": "Z", + "rounds": 23, + "shots": 5120, + "expert0": { + "failure": 0.3490234375, + "nll": 0.5987703401401195 + }, + "expert1": { + "failure": 0.353125, + "nll": 0.5987259344133493 + }, + "equal_trained_experts": { + "failure": 0.3529296875, + "nll": 0.59809424241741 + }, + "dynamic_gate": { + "failure": 0.3509765625, + "nll": 0.5980946071525266 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.351171875, + "nll": 0.5981110441173687 + }, + "gate_corrected_equal_errors": 20, + "gate_introduced_equal_errors": 10, + "mean_expert0_coefficient": 0.41478872299194336, + "std_expert0_coefficient": 0.02912638895213604, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 62.47765350341797 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "basis": "Z", + "rounds": 25, + "shots": 5120, + "expert0": { + "failure": 0.3701171875, + "nll": 0.6250709509309049 + }, + "expert1": { + "failure": 0.3771484375, + "nll": 0.624774687325157 + }, + "equal_trained_experts": { + "failure": 0.3712890625, + "nll": 0.6242678697560431 + }, + "dynamic_gate": { + "failure": 0.3736328125, + "nll": 0.6242983889460181 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3732421875, + "nll": 0.6242639213642418 + }, + "gate_corrected_equal_errors": 13, + "gate_introduced_equal_errors": 25, + "mean_expert0_coefficient": 0.4105871319770813, + "std_expert0_coefficient": 0.02780328504741192, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 65.88549780845642 + } + ], + "seconds": 65.89384269714355, + "test_data_used": false, + "source_sha256": { + "joint_gate_ablation.py": "ea765d87c0c7495f3871bec5abe05200c866c6dcd52493f6068c99ac9ebfa818", + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb" + } + }, + "2048": { + "scope": "All133120 validation shots, trained branches and mixture held fixed. Diagnostic only, not an additional checkpoint or deployment selection.", + "weights": "/run-state/workspace/research/learned_d5/joint_mixture1/weights-2048.npz", + "weights_sha256": "4028019c643772f3e887c0e51a0420b2e92024fff6bbdd8644c2805934da1745", + "condition_mean_gate": "Uses full validation detector-dependent coefficients, without labels, to diagnose shot dependence. Transductive comparison only, excluded from runtime candidates.", + "numeric_comparison": "New branch-output graph compared with existing full joint outputs; any decision changes are numerical differences, not evidence for a learned gating effect.", + "reference_predictions": "/run-state/workspace/research/learned_d5/validation-joint_mixture1-2048", + "reference_decision_differences": 0, + "summary": { + "all": { + "expert0": { + "failure": 0.22679537259615384, + "nll": 0.4206989848701434 + }, + "expert1": { + "failure": 0.22777193509615384, + "nll": 0.4204929881882445 + }, + "equal_trained_experts": { + "failure": 0.2266000600961538, + "nll": 0.41968248565398797 + }, + "dynamic_gate": { + "failure": 0.22657001201923077, + "nll": 0.4197460288840158 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2266000600961538, + "nll": 0.4197187293066426 + }, + "gate_net_errors_saved_over_equal": 4 + }, + "X": { + "expert0": { + "failure": 0.23291766826923072, + "nll": 0.42842830853655123 + }, + "expert1": { + "failure": 0.23276742788461538, + "nll": 0.4277827840750544 + }, + "equal_trained_experts": { + "failure": 0.2326923076923077, + "nll": 0.4272230046442665 + }, + "dynamic_gate": { + "failure": 0.2327824519230769, + "nll": 0.42728210252376225 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2324669471153846, + "nll": 0.42724863849557504 + }, + "gate_net_errors_saved_over_equal": -6 + }, + "Z": { + "expert0": { + "failure": 0.22067307692307692, + "nll": 0.41296966120373546 + }, + "expert1": { + "failure": 0.22277644230769228, + "nll": 0.4132031923014346 + }, + "equal_trained_experts": { + "failure": 0.2205078125, + "nll": 0.4121419666637095 + }, + "dynamic_gate": { + "failure": 0.22035757211538462, + "nll": 0.41220995524426934 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2207331730769231, + "nll": 0.4121888201177101 + }, + "gate_net_errors_saved_over_equal": 10 + } + }, + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "basis": "X", + "rounds": 1, + "shots": 5120, + "expert0": { + "failure": 0.0078125, + "nll": 0.021171954521832872 + }, + "expert1": { + "failure": 0.0078125, + "nll": 0.021062150853037413 + }, + "equal_trained_experts": { + "failure": 0.0078125, + "nll": 0.021085362595340263 + }, + "dynamic_gate": { + "failure": 0.0078125, + "nll": 0.021072190472393067 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.0078125, + "nll": 0.02108445658299425 + }, + "gate_corrected_equal_errors": 0, + "gate_introduced_equal_errors": 0, + "mean_expert0_coefficient": 0.49159136414527893, + "std_expert0_coefficient": 0.09587571769952774, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 5.864789247512817 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "basis": "X", + "rounds": 3, + "shots": 5120, + "expert0": { + "failure": 0.0515625, + "nll": 0.13962798613874308 + }, + "expert1": { + "failure": 0.0505859375, + "nll": 0.13870898469832676 + }, + "equal_trained_experts": { + "failure": 0.0513671875, + "nll": 0.13871628265067654 + }, + "dynamic_gate": { + "failure": 0.051171875, + "nll": 0.13895111871153748 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.0513671875, + "nll": 0.1387542827277033 + }, + "gate_corrected_equal_errors": 1, + "gate_introduced_equal_errors": 0, + "mean_expert0_coefficient": 0.5399016737937927, + "std_expert0_coefficient": 0.10459891706705093, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 6.708195447921753 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "basis": "X", + "rounds": 5, + "shots": 5120, + "expert0": { + "failure": 0.1080078125, + "nll": 0.2461885414820144 + }, + "expert1": { + "failure": 0.1060546875, + "nll": 0.244642919164174 + }, + "equal_trained_experts": { + "failure": 0.1064453125, + "nll": 0.24459042787764326 + }, + "dynamic_gate": { + "failure": 0.1064453125, + "nll": 0.24463803420403485 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1068359375, + "nll": 0.24462116483534652 + }, + "gate_corrected_equal_errors": 3, + "gate_introduced_equal_errors": 3, + "mean_expert0_coefficient": 0.5198917388916016, + "std_expert0_coefficient": 0.08855775743722916, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 7.559297561645508 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "basis": "X", + "rounds": 7, + "shots": 5120, + "expert0": { + "failure": 0.158203125, + "nll": 0.3403817479844436 + }, + "expert1": { + "failure": 0.15546875, + "nll": 0.339656613384179 + }, + "equal_trained_experts": { + "failure": 0.1560546875, + "nll": 0.33903316161397895 + }, + "dynamic_gate": { + "failure": 0.155078125, + "nll": 0.33911503213350486 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1560546875, + "nll": 0.3390474391351289 + }, + "gate_corrected_equal_errors": 6, + "gate_introduced_equal_errors": 1, + "mean_expert0_coefficient": 0.5193408727645874, + "std_expert0_coefficient": 0.07602831721305847, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 8.433751106262207 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "basis": "X", + "rounds": 9, + "shots": 5120, + "expert0": { + "failure": 0.187890625, + "nll": 0.39433654897529447 + }, + "expert1": { + "failure": 0.1869140625, + "nll": 0.3962058050591619 + }, + "equal_trained_experts": { + "failure": 0.1884765625, + "nll": 0.3941952837101824 + }, + "dynamic_gate": { + "failure": 0.1900390625, + "nll": 0.39416916380565187 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1888671875, + "nll": 0.39414187389874555 + }, + "gate_corrected_equal_errors": 2, + "gate_introduced_equal_errors": 10, + "mean_expert0_coefficient": 0.530255913734436, + "std_expert0_coefficient": 0.06830063462257385, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 13.603739500045776 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "basis": "X", + "rounds": 11, + "shots": 5120, + "expert0": { + "failure": 0.2271484375, + "nll": 0.4446032066295591 + }, + "expert1": { + "failure": 0.22421875, + "nll": 0.44320368906751373 + }, + "equal_trained_experts": { + "failure": 0.223046875, + "nll": 0.4428183122598364 + }, + "dynamic_gate": { + "failure": 0.2244140625, + "nll": 0.44302532941774403 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2232421875, + "nll": 0.4428700584373978 + }, + "gate_corrected_equal_errors": 4, + "gate_introduced_equal_errors": 11, + "mean_expert0_coefficient": 0.5345233678817749, + "std_expert0_coefficient": 0.062176112085580826, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 15.346349000930786 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "basis": "X", + "rounds": 13, + "shots": 5120, + "expert0": { + "failure": 0.24765625, + "nll": 0.47590735060196954 + }, + "expert1": { + "failure": 0.2470703125, + "nll": 0.47459121241944696 + }, + "equal_trained_experts": { + "failure": 0.24296875, + "nll": 0.47413432992213667 + }, + "dynamic_gate": { + "failure": 0.242578125, + "nll": 0.4741026016844188 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2427734375, + "nll": 0.4741881184705699 + }, + "gate_corrected_equal_errors": 6, + "gate_introduced_equal_errors": 4, + "mean_expert0_coefficient": 0.5384196043014526, + "std_expert0_coefficient": 0.05908098444342613, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 17.11844229698181 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "basis": "X", + "rounds": 15, + "shots": 5120, + "expert0": { + "failure": 0.2755859375, + "nll": 0.5175774109551222 + }, + "expert1": { + "failure": 0.280078125, + "nll": 0.516026191772235 + }, + "equal_trained_experts": { + "failure": 0.27890625, + "nll": 0.5157280185432036 + }, + "dynamic_gate": { + "failure": 0.2783203125, + "nll": 0.5159312632677555 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2779296875, + "nll": 0.515793995224958 + }, + "gate_corrected_equal_errors": 7, + "gate_introduced_equal_errors": 4, + "mean_expert0_coefficient": 0.539627194404602, + "std_expert0_coefficient": 0.05580662190914154, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 22.691049575805664 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "basis": "X", + "rounds": 17, + "shots": 5120, + "expert0": { + "failure": 0.31640625, + "nll": 0.5577424633735462 + }, + "expert1": { + "failure": 0.315625, + "nll": 0.5576663663992221 + }, + "equal_trained_experts": { + "failure": 0.3162109375, + "nll": 0.5565376323407308 + }, + "dynamic_gate": { + "failure": 0.3169921875, + "nll": 0.5564828092907865 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3150390625, + "nll": 0.5565462292161597 + }, + "gate_corrected_equal_errors": 7, + "gate_introduced_equal_errors": 11, + "mean_expert0_coefficient": 0.5424057245254517, + "std_expert0_coefficient": 0.05438447371125221, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 25.300830841064453 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "basis": "X", + "rounds": 19, + "shots": 5120, + "expert0": { + "failure": 0.3388671875, + "nll": 0.5837997456513507 + }, + "expert1": { + "failure": 0.3384765625, + "nll": 0.5847411594476529 + }, + "equal_trained_experts": { + "failure": 0.3390625, + "nll": 0.5833099920012861 + }, + "dynamic_gate": { + "failure": 0.3390625, + "nll": 0.5832371055263733 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3384765625, + "nll": 0.5832784014147767 + }, + "gate_corrected_equal_errors": 11, + "gate_introduced_equal_errors": 11, + "mean_expert0_coefficient": 0.5359338521957397, + "std_expert0_coefficient": 0.051874786615371704, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 27.91725444793701 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "basis": "X", + "rounds": 21, + "shots": 5120, + "expert0": { + "failure": 0.3662109375, + "nll": 0.6076133920116034 + }, + "expert1": { + "failure": 0.369140625, + "nll": 0.6071917215590312 + }, + "equal_trained_experts": { + "failure": 0.3701171875, + "nll": 0.6063657480540328 + }, + "dynamic_gate": { + "failure": 0.36953125, + "nll": 0.6063881390940098 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3705078125, + "nll": 0.6063905748613219 + }, + "gate_corrected_equal_errors": 14, + "gate_introduced_equal_errors": 11, + "mean_expert0_coefficient": 0.5456953644752502, + "std_expert0_coefficient": 0.050440263003110886, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 30.560015439987183 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "basis": "X", + "rounds": 23, + "shots": 5120, + "expert0": { + "failure": 0.368359375, + "nll": 0.61631975459775 + }, + "expert1": { + "failure": 0.3705078125, + "nll": 0.614173209450278 + }, + "equal_trained_experts": { + "failure": 0.3708984375, + "nll": 0.6143662470475627 + }, + "dynamic_gate": { + "failure": 0.373046875, + "nll": 0.6145727383267309 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.37109375, + "nll": 0.6144560758575842 + }, + "gate_corrected_equal_errors": 5, + "gate_introduced_equal_errors": 16, + "mean_expert0_coefficient": 0.540281355381012, + "std_expert0_coefficient": 0.047126900404691696, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 37.255695819854736 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "basis": "X", + "rounds": 25, + "shots": 5120, + "expert0": { + "failure": 0.37421875, + "nll": 0.6242979080519364 + }, + "expert1": { + "failure": 0.3740234375, + "nll": 0.623306169701449 + }, + "equal_trained_experts": { + "failure": 0.3736328125, + "nll": 0.6230182617588539 + }, + "dynamic_gate": { + "failure": 0.3716796875, + "nll": 0.6229818068739688 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3720703125, + "nll": 0.6230596297797891 + }, + "gate_corrected_equal_errors": 19, + "gate_introduced_equal_errors": 9, + "mean_expert0_coefficient": 0.5391442179679871, + "std_expert0_coefficient": 0.04634866863489151, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 40.73431181907654 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "basis": "Z", + "rounds": 1, + "shots": 5120, + "expert0": { + "failure": 0.0076171875, + "nll": 0.021198583307549555 + }, + "expert1": { + "failure": 0.0076171875, + "nll": 0.021275985565688833 + }, + "equal_trained_experts": { + "failure": 0.007421875, + "nll": 0.02119811608723381 + }, + "dynamic_gate": { + "failure": 0.007421875, + "nll": 0.021146653522693768 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.007421875, + "nll": 0.0211981784807526 + }, + "gate_corrected_equal_errors": 0, + "gate_introduced_equal_errors": 0, + "mean_expert0_coefficient": 0.49917072057724, + "std_expert0_coefficient": 0.059397242963314056, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 41.578567028045654 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "basis": "Z", + "rounds": 3, + "shots": 5120, + "expert0": { + "failure": 0.0482421875, + "nll": 0.12516342925052798 + }, + "expert1": { + "failure": 0.0494140625, + "nll": 0.12353469532484392 + }, + "equal_trained_experts": { + "failure": 0.0478515625, + "nll": 0.1239613699243884 + }, + "dynamic_gate": { + "failure": 0.0482421875, + "nll": 0.12388002844146044 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.0484375, + "nll": 0.12381060184525561 + }, + "gate_corrected_equal_errors": 3, + "gate_introduced_equal_errors": 5, + "mean_expert0_coefficient": 0.39460644125938416, + "std_expert0_coefficient": 0.10839922726154327, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 42.42226243019104 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "basis": "Z", + "rounds": 5, + "shots": 5120, + "expert0": { + "failure": 0.1013671875, + "nll": 0.23236749620691627 + }, + "expert1": { + "failure": 0.1044921875, + "nll": 0.23383704202157105 + }, + "equal_trained_experts": { + "failure": 0.1017578125, + "nll": 0.23231925743517867 + }, + "dynamic_gate": { + "failure": 0.1021484375, + "nll": 0.23245813757103004 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.101953125, + "nll": 0.23250355270736298 + }, + "gate_corrected_equal_errors": 2, + "gate_introduced_equal_errors": 4, + "mean_expert0_coefficient": 0.3959144651889801, + "std_expert0_coefficient": 0.08889319747686386, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 43.27338671684265 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "basis": "Z", + "rounds": 7, + "shots": 5120, + "expert0": { + "failure": 0.14609375, + "nll": 0.3216520844556492 + }, + "expert1": { + "failure": 0.1466796875, + "nll": 0.3226608080885554 + }, + "equal_trained_experts": { + "failure": 0.1466796875, + "nll": 0.3210766142105096 + }, + "dynamic_gate": { + "failure": 0.1466796875, + "nll": 0.3211672824401675 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1466796875, + "nll": 0.32121920975739837 + }, + "gate_corrected_equal_errors": 7, + "gate_introduced_equal_errors": 7, + "mean_expert0_coefficient": 0.39942383766174316, + "std_expert0_coefficient": 0.07547392696142197, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 44.14881372451782 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "basis": "Z", + "rounds": 9, + "shots": 5120, + "expert0": { + "failure": 0.1716796875, + "nll": 0.35731982943857526 + }, + "expert1": { + "failure": 0.1744140625, + "nll": 0.3584290271796774 + }, + "equal_trained_experts": { + "failure": 0.172265625, + "nll": 0.35674203416980405 + }, + "dynamic_gate": { + "failure": 0.1712890625, + "nll": 0.3567630494088907 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.1716796875, + "nll": 0.35687457845513 + }, + "gate_corrected_equal_errors": 9, + "gate_introduced_equal_errors": 4, + "mean_expert0_coefficient": 0.4117465913295746, + "std_expert0_coefficient": 0.06932516396045685, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 45.88748526573181 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "basis": "Z", + "rounds": 11, + "shots": 5120, + "expert0": { + "failure": 0.210546875, + "nll": 0.4295501766866147 + }, + "expert1": { + "failure": 0.212109375, + "nll": 0.4323599548406068 + }, + "equal_trained_experts": { + "failure": 0.209375, + "nll": 0.4298129923158453 + }, + "dynamic_gate": { + "failure": 0.209375, + "nll": 0.4300743890146242 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2091796875, + "nll": 0.4300544827645377 + }, + "gate_corrected_equal_errors": 7, + "gate_introduced_equal_errors": 7, + "mean_expert0_coefficient": 0.42359980940818787, + "std_expert0_coefficient": 0.0634247288107872, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 47.63466954231262 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "basis": "Z", + "rounds": 13, + "shots": 5120, + "expert0": { + "failure": 0.2322265625, + "nll": 0.4581964113280307 + }, + "expert1": { + "failure": 0.2361328125, + "nll": 0.4590084550126168 + }, + "equal_trained_experts": { + "failure": 0.2345703125, + "nll": 0.45741017303938136 + }, + "dynamic_gate": { + "failure": 0.2330078125, + "nll": 0.4575275303079394 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2333984375, + "nll": 0.45749135441411726 + }, + "gate_corrected_equal_errors": 17, + "gate_introduced_equal_errors": 9, + "mean_expert0_coefficient": 0.4303242564201355, + "std_expert0_coefficient": 0.05787336826324463, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 49.39001536369324 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "basis": "Z", + "rounds": 15, + "shots": 5120, + "expert0": { + "failure": 0.2595703125, + "nll": 0.4985333691392662 + }, + "expert1": { + "failure": 0.2638671875, + "nll": 0.498479431501444 + }, + "equal_trained_experts": { + "failure": 0.25859375, + "nll": 0.49730048588225173 + }, + "dynamic_gate": { + "failure": 0.2591796875, + "nll": 0.4974556856186039 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.2603515625, + "nll": 0.49732945501154247 + }, + "gate_corrected_equal_errors": 7, + "gate_introduced_equal_errors": 10, + "mean_expert0_coefficient": 0.4275582432746887, + "std_expert0_coefficient": 0.05489642545580864, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 51.99720120429993 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "basis": "Z", + "rounds": 17, + "shots": 5120, + "expert0": { + "failure": 0.3025390625, + "nll": 0.5421902699997512 + }, + "expert1": { + "failure": 0.2966796875, + "nll": 0.5412640907440226 + }, + "equal_trained_experts": { + "failure": 0.301171875, + "nll": 0.5405238421331762 + }, + "dynamic_gate": { + "failure": 0.2994140625, + "nll": 0.5405083149629246 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3009765625, + "nll": 0.5404856022980973 + }, + "gate_corrected_equal_errors": 17, + "gate_introduced_equal_errors": 8, + "mean_expert0_coefficient": 0.431435763835907, + "std_expert0_coefficient": 0.05232278257608414, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 54.61855983734131 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "basis": "Z", + "rounds": 19, + "shots": 5120, + "expert0": { + "failure": 0.32421875, + "nll": 0.5718471979038606 + }, + "expert1": { + "failure": 0.3333984375, + "nll": 0.5728657570296636 + }, + "equal_trained_experts": { + "failure": 0.324609375, + "nll": 0.5711804509388563 + }, + "dynamic_gate": { + "failure": 0.32578125, + "nll": 0.5714357311691097 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3259765625, + "nll": 0.5712894544931431 + }, + "gate_corrected_equal_errors": 9, + "gate_introduced_equal_errors": 15, + "mean_expert0_coefficient": 0.4252522885799408, + "std_expert0_coefficient": 0.050149668008089066, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 57.23480463027954 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "basis": "Z", + "rounds": 21, + "shots": 5120, + "expert0": { + "failure": 0.3392578125, + "nll": 0.5844876732950487 + }, + "expert1": { + "failure": 0.3400390625, + "nll": 0.5842818571092032 + }, + "equal_trained_experts": { + "failure": 0.3369140625, + "nll": 0.5833404479132334 + }, + "dynamic_gate": { + "failure": 0.3357421875, + "nll": 0.583352821965087 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3357421875, + "nll": 0.5833504524520623 + }, + "gate_corrected_equal_errors": 19, + "gate_introduced_equal_errors": 13, + "mean_expert0_coefficient": 0.43242019414901733, + "std_expert0_coefficient": 0.047953102737665176, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 59.855043172836304 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "basis": "Z", + "rounds": 23, + "shots": 5120, + "expert0": { + "failure": 0.3515625, + "nll": 0.5990825432528515 + }, + "expert1": { + "failure": 0.3556640625, + "nll": 0.5989442902172882 + }, + "equal_trained_experts": { + "failure": 0.3529296875, + "nll": 0.598072503622755 + }, + "dynamic_gate": { + "failure": 0.353515625, + "nll": 0.5981155884918229 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.354296875, + "nll": 0.5980860524780912 + }, + "gate_corrected_equal_errors": 14, + "gate_introduced_equal_errors": 17, + "mean_expert0_coefficient": 0.4296036660671234, + "std_expert0_coefficient": 0.046422749757766724, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 63.31757092475891 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "basis": "Z", + "rounds": 25, + "shots": 5120, + "expert0": { + "failure": 0.373828125, + "nll": 0.6270165313839197 + }, + "expert1": { + "failure": 0.3755859375, + "nll": 0.6247001052834686 + }, + "equal_trained_experts": { + "failure": 0.3724609375, + "nll": 0.6249072789556098 + }, + "dynamic_gate": { + "failure": 0.3728515625, + "nll": 0.6248442052611475 + }, + "condition_mean_gate_diagnostic": { + "failure": 0.3734375, + "nll": 0.6247616863727404 + }, + "gate_corrected_equal_errors": 14, + "gate_introduced_equal_errors": 16, + "mean_expert0_coefficient": 0.4255400598049164, + "std_expert0_coefficient": 0.04466654360294342, + "original_joint_inference_comparison": { + "max_probability_difference": 0.0, + "decision_differences": 0 + }, + "elapsed_seconds": 66.79905652999878 + } + ], + "seconds": 66.8079903125763, + "test_data_used": false, + "source_sha256": { + "joint_gate_ablation.py": "ea765d87c0c7495f3871bec5abe05200c866c6dcd52493f6068c99ac9ebfa818", + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb" + } + } + }, + "new_optimizer_updates": 0, + "new_trainable_parameters": 0, + "test_data_used": false, + "initialization": "All extracted parameters descend from the joint study session-trained random-initialization parents; exact tensors are serialized without further fitting", + "selection_scope": "Adaptive follow-up proposed after observing validation branch diagnostics. All13 durations perbasis are included. Transductive condition-mean gates are excluded. This is not an independent confirmation dataset." + }, + "confidence_joint1": { + "declared_plan": { + "hypothesis": "Adding fully differentiated expert confidence may let the jointly trained gate use complementary expert certainty beyond syndrome density and history alone", + "parents": [ + "fresh2_full/weights-1536.npz", + "reserved1_full/weights-1536.npz" + ], + "initialization": "Same session-trained parents and exact Adam states as joint_mixture1; same gate seed20261310 preserves its41input hidden weights; append4zero input rows; zero output gives same initial equal mixture", + "features": "Existing41syndrome/basis/duration features plus clipped logits/8 for each expert and sqrt(z^2+1e-4) for each;clip probabilities to[1e-6,1-1e-6] and logit to[-8,8];45inputs,32SiLU hidden;shot-local,label-free,ID-free,fixedscales;full derivative through predictions", + "loss": "Stable mixture BCE; total multiplier on expert BCE gradient is responsibility+(1-2*y)*exp(-expert_BCE)*(gate-only derivative dL/dq); all prediction-to-gate paths differentiated; labels used only in loss", + "training": "Matched joint_mixture1:2048updates B1024;seed20261311 yields same uniform draws over516880rows/26conditions;expertLR.0001,gateLR.001;separate restored expert Adam clocks,fresh gate Adam;globalnorm1,decay1e-4", + "selection_steps": [ + 0, + 512, + 1024, + 2048 + ], + "validation": "Full133120 supplied validation shots per listed checkpoint; perbasis choose incumbent or rawjoint/equalphysical,all13durations; tiesretainincumbent. Step0 is fixedmean of trainedparents.1536has screening only and is not a full-selection checkpoint.", + "audit_scope": "All training labels are eligible; no independent reserved-training-label audit claim. Parent initialization provenance retained.", + "controls": "CPU scalar finite differences/exact autodiff with nonzero confidence couplings passed;two1update CPU restoration/sampling audit passed;four-case portable CPU runtime passed (order/subsets/delegation exact,independent mixture max5.96e-8,CPU priors vs GPUcache max3.58e-7);actual GPUcontrol still required before training; composed joint->robust->confidence CPU runtime passed after using distinct confidence cache attributes; actual joint/robust sources unchanged; constructed joint->logicalresidual->confidence CPU runtime also passed retained paths/order/distinct caches", + "runtime": "Two exact neural passes share one physical-prior computation; preserve all retained incumbent dispatches;fullreplay/scoring/readonlyrelocation/projection before any publication", + "interpretation": "Matched recipe extension; no physical-regime identification or independent reserved-label audit claim", + "gpu": "One H100; serialized after completed branch verification", + "test_data_used": false, + "parameter_counts": { + "expert0": 29505, + "expert1": 29505, + "gate": 1505, + "total": 60515 + }, + "physical_blend_clarification_before_training": "Equal physical blends use the existing calibrated/ensemble physical pass3 decoder output from turbo1/predictions, checked against runtime config and DEM/plans/weights. Raw feedback5_cache pass3 is only the neural conditioning prior/diagnostic. Corrected before any GPU training or selection in this study.", + "status": "Launched after fixed branch extraction verification", + "queued_utc": "2026-10-21T16:04:11.785757+00:00", + "launch_rationale": "Fixed branch diagnostics show modest, basis-dependent gate gains and a stronger individual Zexpert. The previously prepared matched confidence-input extension tests whether the gate can better use expert certainty. Recipe and selection checkpoints remain unchanged.", + "launch_utc": "2026-10-21T16:11:35.399436+00:00" + }, + "physical_blend_reference": { + "package": "/run-state/workspace/research/context_upgrades/turbo1/package", + "predictions": "/run-state/workspace/research/context_upgrades/turbo1/predictions", + "component": "Existing physical pass3 decoder output, including its training-fitted calibration/ensemble; exactly the hybrid3.py blend_turbo path", + "verified_config": "turbo settings equal; physical DEM/plans and calibration/ensemble weights have identical SHA256", + "verified_files": [ + "dems/surface_code_bX_d5_r01_center_5_5.dem", + "dems/surface_code_bX_d5_r03_center_5_5.dem", + "dems/surface_code_bX_d5_r05_center_5_5.dem", + "dems/surface_code_bX_d5_r07_center_5_5.dem", + "dems/surface_code_bX_d5_r09_center_5_5.dem", + "dems/surface_code_bX_d5_r11_center_5_5.dem", + "dems/surface_code_bX_d5_r13_center_5_5.dem", + "dems/surface_code_bX_d5_r15_center_5_5.dem", + "dems/surface_code_bX_d5_r17_center_5_5.dem", + "dems/surface_code_bX_d5_r19_center_5_5.dem", + "dems/surface_code_bX_d5_r21_center_5_5.dem", + "dems/surface_code_bX_d5_r23_center_5_5.dem", + "dems/surface_code_bX_d5_r25_center_5_5.dem", + "dems/surface_code_bZ_d5_r01_center_5_5.dem", + "dems/surface_code_bZ_d5_r03_center_5_5.dem", + "dems/surface_code_bZ_d5_r05_center_5_5.dem", + "dems/surface_code_bZ_d5_r07_center_5_5.dem", + "dems/surface_code_bZ_d5_r09_center_5_5.dem", + "dems/surface_code_bZ_d5_r11_center_5_5.dem", + "dems/surface_code_bZ_d5_r13_center_5_5.dem", + "dems/surface_code_bZ_d5_r15_center_5_5.dem", + "dems/surface_code_bZ_d5_r17_center_5_5.dem", + "dems/surface_code_bZ_d5_r19_center_5_5.dem", + "dems/surface_code_bZ_d5_r21_center_5_5.dem", + "dems/surface_code_bZ_d5_r23_center_5_5.dem", + "dems/surface_code_bZ_d5_r25_center_5_5.dem", + "plans/surface_code_bX_d5_r01_center_5_5.npz", + "plans/surface_code_bZ_d5_r01_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r03_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r05_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r07_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r09_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r11_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r13_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r15_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r17_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r19_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r21_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r23_center_5_5.npz", + "turbo_plans/surface_code_bX_d5_r25_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r05_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r07_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r09_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r11_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r13_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r15_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r17_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r19_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r21_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r23_center_5_5.npz", + "turbo_plans/surface_code_bZ_d5_r25_center_5_5.npz", + "weights/turbo1-d5_bX_center_5_5.npz", + "weights/turbo1-d5_bZ_center_5_5.npz" + ], + "clarification": "Use these ID-aligned probabilities, not the raw pass3 column in feedback5_cache. Physical priors supplied to neural networks remain unchanged." + }, + "selection_history": [ + { + "basis": "X", + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23168569711538464, + "0-physical0": 0.23249699519230768, + "0-physical0.5": 0.2334435096153846, + "512-physical0": 0.2323016826923077, + "512-physical0.5": 0.23267728365384616, + "1024-physical0": 0.23158052884615385, + "1024-physical0.5": 0.23243689903846157, + "2048-physical0": 0.2327524038461538, + "2048-physical0.5": 0.23300781250000002 + }, + "selected": "1024-physical0" + }, + { + "basis": "Z", + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21918569711538466, + "0-physical0": 0.2207481971153846, + "0-physical0.5": 0.2204176682692308, + "512-physical0": 0.22052283653846155, + "512-physical0.5": 0.22055288461538464, + "1024-physical0": 0.22104867788461538, + "1024-physical0.5": 0.22001201923076924, + "2048-physical0": 0.22032752403846154, + "2048-physical0.5": 0.22038762019230768 + }, + "selected": "incumbent" + } + ], + "selected_checkpoints": { + "1024": { + "step": 1024, + "training_draws": 1048576, + "adam_counts": { + "expert0": 3072, + "expert1": 3072, + "gate": 1024 + }, + "distinct_phase_rows": 446971, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 17445, + "surface_code_bX_d5_r03_center_5_5": 17875, + "surface_code_bX_d5_r05_center_5_5": 16246, + "surface_code_bX_d5_r07_center_5_5": 16070, + "surface_code_bX_d5_r09_center_5_5": 16429, + "surface_code_bX_d5_r11_center_5_5": 17791, + "surface_code_bX_d5_r13_center_5_5": 17193, + "surface_code_bX_d5_r15_center_5_5": 17571, + "surface_code_bX_d5_r17_center_5_5": 17502, + "surface_code_bX_d5_r19_center_5_5": 17754, + "surface_code_bX_d5_r21_center_5_5": 17567, + "surface_code_bX_d5_r23_center_5_5": 16091, + "surface_code_bX_d5_r25_center_5_5": 17260, + "surface_code_bZ_d5_r01_center_5_5": 16790, + "surface_code_bZ_d5_r03_center_5_5": 17857, + "surface_code_bZ_d5_r05_center_5_5": 17484, + "surface_code_bZ_d5_r07_center_5_5": 17491, + "surface_code_bZ_d5_r09_center_5_5": 16204, + "surface_code_bZ_d5_r11_center_5_5": 17217, + "surface_code_bZ_d5_r13_center_5_5": 18278, + "surface_code_bZ_d5_r15_center_5_5": 17617, + "surface_code_bZ_d5_r17_center_5_5": 16049, + "surface_code_bZ_d5_r19_center_5_5": 17173, + "surface_code_bZ_d5_r21_center_5_5": 17037, + "surface_code_bZ_d5_r23_center_5_5": 17805, + "surface_code_bZ_d5_r25_center_5_5": 17175 + }, + "weights_sha256": "bf3eecca4cabbe147d19aca5c2539e527baf0683b8de673b360630d4517d3e9a", + "complete": true + } + }, + "training": { + "run_config": { + "parents": [ + "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz" + ], + "output": "/run-state/workspace/research/learned_d5/confidence_joint1", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "resume": null, + "steps": 2048, + "batch": 1024, + "expert_lr": 0.0001, + "gate_lr": 0.001, + "gate_seed": 20261310, + "seed": 20261311, + "eval_every": 512, + "validation_shots": 1024, + "validation_batch": 512, + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__confidence_joint.py": "c597e7b57876691b10f66f267a5d2f33bf1329982b68090473ddaf680fecf39b", + "learned_d5__confidence_joint_gradient.py": "6a4e537d18316f58f5e9aa12add65543bb71fea8f46cdded26d3dbe1fb021836", + "learned_d5__confidence_joint_state.py": "13306f1821b73b02b3ba6e2d61800f7c593e7201ac0121c61e3126504d573be9", + "learned_d5__confidence_joint_train.py": "e8183406d073286498f14d3c0c9904a08b69b781d650e8bcd9a2666d3099c1f0", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "initialization": "Both experts copied with exact Adam state from declared session-trained parents; new gate retains the original seeded 41-input hidden weights, appends four zero confidence-input rows, and has zero output, giving the same initial equal mixture", + "sampling": "Same seed and draws as syndrome-only joint_mixture1; resumed phases restore only their own saved sampling state", + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3" + } + }, + "parent_provenance": [ + { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 491030, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18670, + "surface_code_bX_d5_r03_center_5_5": 18940, + "surface_code_bX_d5_r05_center_5_5": 19128, + "surface_code_bX_d5_r07_center_5_5": 18988, + "surface_code_bX_d5_r09_center_5_5": 18523, + "surface_code_bX_d5_r11_center_5_5": 19227, + "surface_code_bX_d5_r13_center_5_5": 18816, + "surface_code_bX_d5_r15_center_5_5": 18107, + "surface_code_bX_d5_r17_center_5_5": 18728, + "surface_code_bX_d5_r19_center_5_5": 18983, + "surface_code_bX_d5_r21_center_5_5": 18959, + "surface_code_bX_d5_r23_center_5_5": 19079, + "surface_code_bX_d5_r25_center_5_5": 19193, + "surface_code_bZ_d5_r01_center_5_5": 18828, + "surface_code_bZ_d5_r03_center_5_5": 18896, + "surface_code_bZ_d5_r05_center_5_5": 19011, + "surface_code_bZ_d5_r07_center_5_5": 18806, + "surface_code_bZ_d5_r09_center_5_5": 18268, + "surface_code_bZ_d5_r11_center_5_5": 18927, + "surface_code_bZ_d5_r13_center_5_5": 19399, + "surface_code_bZ_d5_r15_center_5_5": 19358, + "surface_code_bZ_d5_r17_center_5_5": 18634, + "surface_code_bZ_d5_r19_center_5_5": 19126, + "surface_code_bZ_d5_r21_center_5_5": 18603, + "surface_code_bZ_d5_r23_center_5_5": 18626, + "surface_code_bZ_d5_r25_center_5_5": 19207 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/fresh2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_warm/weights-512.npz", + "starting_checkpoint_sha256": "d3e3abba07693bd7fd3d17be2dd981d5b803a496e76ba230ed94afeb51f26f4f", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 325678, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 11962, + "surface_code_bX_d5_r03_center_5_5": 10232, + "surface_code_bX_d5_r05_center_5_5": 14014, + "surface_code_bX_d5_r07_center_5_5": 11594, + "surface_code_bX_d5_r09_center_5_5": 12805, + "surface_code_bX_d5_r11_center_5_5": 11644, + "surface_code_bX_d5_r13_center_5_5": 13845, + "surface_code_bX_d5_r15_center_5_5": 10703, + "surface_code_bX_d5_r17_center_5_5": 15460, + "surface_code_bX_d5_r19_center_5_5": 14156, + "surface_code_bX_d5_r21_center_5_5": 11568, + "surface_code_bX_d5_r23_center_5_5": 14156, + "surface_code_bX_d5_r25_center_5_5": 12021, + "surface_code_bZ_d5_r01_center_5_5": 10601, + "surface_code_bZ_d5_r03_center_5_5": 14135, + "surface_code_bZ_d5_r05_center_5_5": 11975, + "surface_code_bZ_d5_r07_center_5_5": 13841, + "surface_code_bZ_d5_r09_center_5_5": 12024, + "surface_code_bZ_d5_r11_center_5_5": 11151, + "surface_code_bZ_d5_r13_center_5_5": 10640, + "surface_code_bZ_d5_r15_center_5_5": 11089, + "surface_code_bZ_d5_r17_center_5_5": 13788, + "surface_code_bZ_d5_r19_center_5_5": 12350, + "surface_code_bZ_d5_r21_center_5_5": 12797, + "surface_code_bZ_d5_r23_center_5_5": 12809, + "surface_code_bZ_d5_r25_center_5_5": 14318 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261135", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6522030830383301, + "objective": 0.6522030830383301, + "error": 0.375, + "gradient_norm": 0.11649785190820694, + "elapsed": 30.089841604232788 + }, + { + "step": 16, + "loss": 0.5927819609642029, + "objective": 0.5927819609642029, + "error": 0.3466796875, + "gradient_norm": 0.07945127785205841, + "elapsed": 48.85365080833435 + }, + { + "step": 32, + "loss": 0.3115929663181305, + "objective": 0.3115929663181305, + "error": 0.13671875, + "gradient_norm": 0.039320655167102814, + "elapsed": 63.60312819480896 + }, + { + "step": 48, + "loss": 0.2456369698047638, + "objective": 0.2456369698047638, + "error": 0.1015625, + "gradient_norm": 0.029398636892437935, + "elapsed": 73.71074151992798 + }, + { + "step": 64, + "loss": 0.6231744885444641, + "objective": 0.6231744885444641, + "error": 0.3759765625, + "gradient_norm": 0.06867238879203796, + "elapsed": 83.75580954551697 + }, + { + "step": 80, + "loss": 0.3674217164516449, + "objective": 0.3674217164516449, + "error": 0.1572265625, + "gradient_norm": 0.0557992123067379, + "elapsed": 94.6383364200592 + }, + { + "step": 96, + "loss": 0.5152362585067749, + "objective": 0.5152362585067749, + "error": 0.2568359375, + "gradient_norm": 0.08284599334001541, + "elapsed": 106.90000939369202 + }, + { + "step": 112, + "loss": 0.020773420110344887, + "objective": 0.020773420110344887, + "error": 0.0048828125, + "gradient_norm": 0.008813572116196156, + "elapsed": 117.77558088302612 + }, + { + "step": 128, + "loss": 0.02593131735920906, + "objective": 0.02593131735920906, + "error": 0.0087890625, + "gradient_norm": 0.00872033555060625, + "elapsed": 128.93439435958862 + }, + { + "step": 144, + "loss": 0.5852900743484497, + "objective": 0.5852900743484497, + "error": 0.3291015625, + "gradient_norm": 0.04771002382040024, + "elapsed": 139.5588686466217 + }, + { + "step": 160, + "loss": 0.46074625849723816, + "objective": 0.46074625849723816, + "error": 0.232421875, + "gradient_norm": 0.08834747970104218, + "elapsed": 151.5595977306366 + }, + { + "step": 176, + "loss": 0.6310865879058838, + "objective": 0.6310865879058838, + "error": 0.376953125, + "gradient_norm": 0.14084596931934357, + "elapsed": 163.7892107963562 + }, + { + "step": 192, + "loss": 0.246865376830101, + "objective": 0.246865376830101, + "error": 0.1103515625, + "gradient_norm": 0.041402049362659454, + "elapsed": 174.28971648216248 + }, + { + "step": 208, + "loss": 0.3103577196598053, + "objective": 0.3103577196598053, + "error": 0.15625, + "gradient_norm": 0.04525696486234665, + "elapsed": 187.03909611701965 + }, + { + "step": 224, + "loss": 0.4523138999938965, + "objective": 0.4523138999938965, + "error": 0.208984375, + "gradient_norm": 0.09180521965026855, + "elapsed": 199.56195068359375 + }, + { + "step": 240, + "loss": 0.02241751179099083, + "objective": 0.02241751179099083, + "error": 0.009765625, + "gradient_norm": 0.009998111054301262, + "elapsed": 212.35500597953796 + }, + { + "step": 256, + "loss": 0.5487150549888611, + "objective": 0.5487150549888611, + "error": 0.294921875, + "gradient_norm": 0.12748055160045624, + "elapsed": 223.03854608535767 + }, + { + "step": 272, + "loss": 0.023057367652654648, + "objective": 0.023057367652654648, + "error": 0.0078125, + "gradient_norm": 0.006953821517527103, + "elapsed": 244.6508972644806 + }, + { + "step": 288, + "loss": 0.5845386981964111, + "objective": 0.5845386981964111, + "error": 0.330078125, + "gradient_norm": 0.06542652100324631, + "elapsed": 256.78167748451233 + }, + { + "step": 304, + "loss": 0.442532479763031, + "objective": 0.442532479763031, + "error": 0.232421875, + "gradient_norm": 0.10874580591917038, + "elapsed": 269.1364529132843 + }, + { + "step": 320, + "loss": 0.3264174163341522, + "objective": 0.3264174163341522, + "error": 0.15625, + "gradient_norm": 0.06276191771030426, + "elapsed": 282.38969564437866 + }, + { + "step": 336, + "loss": 0.386960506439209, + "objective": 0.386960506439209, + "error": 0.177734375, + "gradient_norm": 0.06561421602964401, + "elapsed": 292.9079031944275 + }, + { + "step": 352, + "loss": 0.23919886350631714, + "objective": 0.23919886350631714, + "error": 0.107421875, + "gradient_norm": 0.02755703590810299, + "elapsed": 304.16068935394287 + }, + { + "step": 368, + "loss": 0.5029175281524658, + "objective": 0.5029175281524658, + "error": 0.259765625, + "gradient_norm": 0.0378776490688324, + "elapsed": 315.11088514328003 + }, + { + "step": 384, + "loss": 0.565666675567627, + "objective": 0.565666675567627, + "error": 0.322265625, + "gradient_norm": 0.11368246376514435, + "elapsed": 324.3651068210602 + }, + { + "step": 400, + "loss": 0.5846428275108337, + "objective": 0.5846428275108337, + "error": 0.3408203125, + "gradient_norm": 0.08116643130779266, + "elapsed": 334.70786476135254 + }, + { + "step": 416, + "loss": 0.025111017748713493, + "objective": 0.025111017748713493, + "error": 0.0078125, + "gradient_norm": 0.008838560432195663, + "elapsed": 345.56963562965393 + }, + { + "step": 432, + "loss": 0.628488302230835, + "objective": 0.628488302230835, + "error": 0.3818359375, + "gradient_norm": 0.04001976177096367, + "elapsed": 355.3310384750366 + }, + { + "step": 448, + "loss": 0.4569575786590576, + "objective": 0.4569575786590576, + "error": 0.2578125, + "gradient_norm": 0.06344135850667953, + "elapsed": 367.05255675315857 + }, + { + "step": 464, + "loss": 0.49193111062049866, + "objective": 0.49193111062049866, + "error": 0.24609375, + "gradient_norm": 0.06022385507822037, + "elapsed": 377.38399291038513 + }, + { + "step": 480, + "loss": 0.5920064449310303, + "objective": 0.5920064449310303, + "error": 0.3466796875, + "gradient_norm": 0.036063045263290405, + "elapsed": 387.7266733646393 + }, + { + "step": 496, + "loss": 0.22157302498817444, + "objective": 0.22157302498817444, + "error": 0.09375, + "gradient_norm": 0.04071022942662239, + "elapsed": 397.78643012046814 + }, + { + "step": 512, + "loss": 0.39216887950897217, + "objective": 0.39216887950897217, + "error": 0.1728515625, + "gradient_norm": 0.09079446643590927, + "elapsed": 407.0137679576874 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6092928647994995, + "objective": 0.6092928647994995, + "error": 0.3583984375, + "gradient_norm": 0.08161187171936035, + "elapsed": 27.421262741088867 + }, + { + "step": 16, + "loss": 0.4709879755973816, + "objective": 0.4709879755973816, + "error": 0.2529296875, + "gradient_norm": 0.0541619211435318, + "elapsed": 48.74575757980347 + }, + { + "step": 32, + "loss": 0.5842419862747192, + "objective": 0.5842419862747192, + "error": 0.34375, + "gradient_norm": 0.09450904279947281, + "elapsed": 60.68022179603577 + }, + { + "step": 48, + "loss": 0.5840846300125122, + "objective": 0.5840846300125122, + "error": 0.32421875, + "gradient_norm": 0.04569687321782112, + "elapsed": 74.63272476196289 + }, + { + "step": 64, + "loss": 0.5139708518981934, + "objective": 0.5139708518981934, + "error": 0.2646484375, + "gradient_norm": 0.16111725568771362, + "elapsed": 91.88426613807678 + }, + { + "step": 80, + "loss": 0.49099838733673096, + "objective": 0.49099838733673096, + "error": 0.251953125, + "gradient_norm": 0.04431874305009842, + "elapsed": 105.08457684516907 + }, + { + "step": 96, + "loss": 0.30287861824035645, + "objective": 0.30287861824035645, + "error": 0.14453125, + "gradient_norm": 0.03792181238532066, + "elapsed": 118.16054177284241 + }, + { + "step": 112, + "loss": 0.6026535630226135, + "objective": 0.6026535630226135, + "error": 0.359375, + "gradient_norm": 0.043088704347610474, + "elapsed": 134.6414511203766 + }, + { + "step": 128, + "loss": 0.5983598828315735, + "objective": 0.5983598828315735, + "error": 0.328125, + "gradient_norm": 0.06492504477500916, + "elapsed": 148.38875198364258 + }, + { + "step": 144, + "loss": 0.616276204586029, + "objective": 0.616276204586029, + "error": 0.3857421875, + "gradient_norm": 0.05420554056763649, + "elapsed": 164.11315298080444 + }, + { + "step": 160, + "loss": 0.017882924526929855, + "objective": 0.017882924526929855, + "error": 0.0048828125, + "gradient_norm": 0.004682278726249933, + "elapsed": 178.31525373458862 + }, + { + "step": 176, + "loss": 0.5279660820960999, + "objective": 0.5279660820960999, + "error": 0.271484375, + "gradient_norm": 0.03895021602511406, + "elapsed": 192.20261907577515 + }, + { + "step": 192, + "loss": 0.5794406533241272, + "objective": 0.5794406533241272, + "error": 0.34375, + "gradient_norm": 0.041880734264850616, + "elapsed": 200.32051873207092 + }, + { + "step": 208, + "loss": 0.3353561758995056, + "objective": 0.3353561758995056, + "error": 0.1513671875, + "gradient_norm": 0.07022152841091156, + "elapsed": 212.5193521976471 + }, + { + "step": 224, + "loss": 0.47239983081817627, + "objective": 0.47239983081817627, + "error": 0.23828125, + "gradient_norm": 0.044771477580070496, + "elapsed": 223.36571788787842 + }, + { + "step": 240, + "loss": 0.6235381364822388, + "objective": 0.6235381364822388, + "error": 0.3779296875, + "gradient_norm": 0.047636937350034714, + "elapsed": 233.90032649040222 + }, + { + "step": 256, + "loss": 0.516319751739502, + "objective": 0.516319751739502, + "error": 0.271484375, + "gradient_norm": 0.087476447224617, + "elapsed": 245.52193427085876 + }, + { + "step": 272, + "loss": 0.23385891318321228, + "objective": 0.23385891318321228, + "error": 0.091796875, + "gradient_norm": 0.05921977758407593, + "elapsed": 254.38622951507568 + }, + { + "step": 288, + "loss": 0.31280556321144104, + "objective": 0.31280556321144104, + "error": 0.1318359375, + "gradient_norm": 0.03548427298665047, + "elapsed": 263.25871300697327 + }, + { + "step": 304, + "loss": 0.6208417415618896, + "objective": 0.6208417415618896, + "error": 0.361328125, + "gradient_norm": 0.10255666077136993, + "elapsed": 273.5115919113159 + }, + { + "step": 320, + "loss": 0.5985375642776489, + "objective": 0.5985375642776489, + "error": 0.3603515625, + "gradient_norm": 0.04024764895439148, + "elapsed": 285.4135670661926 + }, + { + "step": 336, + "loss": 0.028151696547865868, + "objective": 0.028151696547865868, + "error": 0.009765625, + "gradient_norm": 0.008847440592944622, + "elapsed": 295.0800693035126 + }, + { + "step": 352, + "loss": 0.6147637963294983, + "objective": 0.6147637963294983, + "error": 0.3603515625, + "gradient_norm": 0.05709920823574066, + "elapsed": 305.32019686698914 + }, + { + "step": 368, + "loss": 0.5955979824066162, + "objective": 0.5955979824066162, + "error": 0.3486328125, + "gradient_norm": 0.04276399686932564, + "elapsed": 316.3869025707245 + }, + { + "step": 384, + "loss": 0.23504304885864258, + "objective": 0.23504304885864258, + "error": 0.1025390625, + "gradient_norm": 0.03205326199531555, + "elapsed": 325.7849349975586 + }, + { + "step": 400, + "loss": 0.13460804522037506, + "objective": 0.13460804522037506, + "error": 0.0546875, + "gradient_norm": 0.03109711967408657, + "elapsed": 335.72691917419434 + }, + { + "step": 416, + "loss": 0.5798783302307129, + "objective": 0.5798783302307129, + "error": 0.322265625, + "gradient_norm": 0.053542010486125946, + "elapsed": 345.7052640914917 + }, + { + "step": 432, + "loss": 0.3892784118652344, + "objective": 0.3892784118652344, + "error": 0.19140625, + "gradient_norm": 0.052194178104400635, + "elapsed": 357.38475036621094 + }, + { + "step": 448, + "loss": 0.23582103848457336, + "objective": 0.23582103848457336, + "error": 0.1181640625, + "gradient_norm": 0.032037943601608276, + "elapsed": 369.5841510295868 + }, + { + "step": 464, + "loss": 0.5408849716186523, + "objective": 0.5408849716186523, + "error": 0.2900390625, + "gradient_norm": 0.07508285343647003, + "elapsed": 379.84099793434143 + }, + { + "step": 480, + "loss": 0.3894873559474945, + "objective": 0.3894873559474945, + "error": 0.19140625, + "gradient_norm": 0.03977999836206436, + "elapsed": 390.9687530994415 + }, + { + "step": 496, + "loss": 0.6059300899505615, + "objective": 0.6059300899505615, + "error": 0.361328125, + "gradient_norm": 0.06041429564356804, + "elapsed": 403.2380111217499 + }, + { + "step": 512, + "loss": 0.2117740511894226, + "objective": 0.2117740511894226, + "error": 0.0908203125, + "gradient_norm": 0.05693414434790611, + "elapsed": 414.4854781627655 + }, + { + "step": 528, + "loss": 0.4666211009025574, + "objective": 0.4666211009025574, + "error": 0.2470703125, + "gradient_norm": 0.0764947235584259, + "elapsed": 433.42368054389954 + }, + { + "step": 544, + "loss": 0.22636458277702332, + "objective": 0.22636458277702332, + "error": 0.1083984375, + "gradient_norm": 0.03683016076683998, + "elapsed": 442.92575907707214 + }, + { + "step": 560, + "loss": 0.23172692954540253, + "objective": 0.23172692954540253, + "error": 0.1083984375, + "gradient_norm": 0.034071482717990875, + "elapsed": 453.3129711151123 + }, + { + "step": 576, + "loss": 0.4768703579902649, + "objective": 0.4768703579902649, + "error": 0.2529296875, + "gradient_norm": 0.06308378279209137, + "elapsed": 462.4127457141876 + }, + { + "step": 592, + "loss": 0.5165150165557861, + "objective": 0.5165150165557861, + "error": 0.291015625, + "gradient_norm": 0.07674732059240341, + "elapsed": 473.8309862613678 + }, + { + "step": 608, + "loss": 0.5919064283370972, + "objective": 0.5919064283370972, + "error": 0.3359375, + "gradient_norm": 0.06379934400320053, + "elapsed": 484.3733870983124 + }, + { + "step": 624, + "loss": 0.01804366335272789, + "objective": 0.01804366335272789, + "error": 0.0068359375, + "gradient_norm": 0.005318541545420885, + "elapsed": 495.94076347351074 + }, + { + "step": 640, + "loss": 0.41747498512268066, + "objective": 0.41747498512268066, + "error": 0.1962890625, + "gradient_norm": 0.052116431295871735, + "elapsed": 506.73559165000916 + }, + { + "step": 656, + "loss": 0.6140056848526001, + "objective": 0.6140056848526001, + "error": 0.3896484375, + "gradient_norm": 0.05376415699720383, + "elapsed": 517.2397899627686 + }, + { + "step": 672, + "loss": 0.4098930358886719, + "objective": 0.4098930358886719, + "error": 0.197265625, + "gradient_norm": 0.04737741872668266, + "elapsed": 525.7957897186279 + }, + { + "step": 688, + "loss": 0.3499884009361267, + "objective": 0.3499884009361267, + "error": 0.1650390625, + "gradient_norm": 0.0714973583817482, + "elapsed": 534.9302124977112 + }, + { + "step": 704, + "loss": 0.552291989326477, + "objective": 0.552291989326477, + "error": 0.3095703125, + "gradient_norm": 0.10188189148902893, + "elapsed": 545.4470670223236 + }, + { + "step": 720, + "loss": 0.4040689468383789, + "objective": 0.4040689468383789, + "error": 0.1943359375, + "gradient_norm": 0.06630362570285797, + "elapsed": 554.2920794487 + }, + { + "step": 736, + "loss": 0.3191133439540863, + "objective": 0.3191133439540863, + "error": 0.15625, + "gradient_norm": 0.060587506741285324, + "elapsed": 562.335791349411 + }, + { + "step": 752, + "loss": 0.5949387550354004, + "objective": 0.5949387550354004, + "error": 0.330078125, + "gradient_norm": 0.051291145384311676, + "elapsed": 570.9363489151001 + }, + { + "step": 768, + "loss": 0.4783790409564972, + "objective": 0.4783790409564972, + "error": 0.244140625, + "gradient_norm": 0.08808670938014984, + "elapsed": 581.1555306911469 + }, + { + "step": 784, + "loss": 0.4414710998535156, + "objective": 0.4414710998535156, + "error": 0.20703125, + "gradient_norm": 0.06632383912801743, + "elapsed": 590.4109175205231 + }, + { + "step": 800, + "loss": 0.2536136507987976, + "objective": 0.2536136507987976, + "error": 0.1142578125, + "gradient_norm": 0.03191893920302391, + "elapsed": 601.43274974823 + }, + { + "step": 816, + "loss": 0.22448071837425232, + "objective": 0.22448071837425232, + "error": 0.1015625, + "gradient_norm": 0.04966023191809654, + "elapsed": 612.7252013683319 + }, + { + "step": 832, + "loss": 0.5342355966567993, + "objective": 0.5342355966567993, + "error": 0.2783203125, + "gradient_norm": 0.05757307633757591, + "elapsed": 623.6647284030914 + }, + { + "step": 848, + "loss": 0.2506354749202728, + "objective": 0.2506354749202728, + "error": 0.109375, + "gradient_norm": 0.03991081938147545, + "elapsed": 635.1636409759521 + }, + { + "step": 864, + "loss": 0.40698009729385376, + "objective": 0.40698009729385376, + "error": 0.1953125, + "gradient_norm": 0.09155476838350296, + "elapsed": 645.2128469944 + }, + { + "step": 880, + "loss": 0.563283383846283, + "objective": 0.563283383846283, + "error": 0.3134765625, + "gradient_norm": 0.11409252882003784, + "elapsed": 659.2946681976318 + }, + { + "step": 896, + "loss": 0.13591040670871735, + "objective": 0.13591040670871735, + "error": 0.064453125, + "gradient_norm": 0.02692740224301815, + "elapsed": 668.6167254447937 + }, + { + "step": 912, + "loss": 0.5798318982124329, + "objective": 0.5798318982124329, + "error": 0.3310546875, + "gradient_norm": 0.06674209237098694, + "elapsed": 680.6492185592651 + }, + { + "step": 928, + "loss": 0.6140691041946411, + "objective": 0.6140691041946411, + "error": 0.3857421875, + "gradient_norm": 0.06117575615644455, + "elapsed": 693.1704411506653 + }, + { + "step": 944, + "loss": 0.3964633643627167, + "objective": 0.3964633643627167, + "error": 0.1865234375, + "gradient_norm": 0.08617512136697769, + "elapsed": 708.2128443717957 + }, + { + "step": 960, + "loss": 0.5512299537658691, + "objective": 0.5512299537658691, + "error": 0.2861328125, + "gradient_norm": 0.05705108866095543, + "elapsed": 720.2417063713074 + }, + { + "step": 976, + "loss": 0.454137921333313, + "objective": 0.454137921333313, + "error": 0.216796875, + "gradient_norm": 0.07962293922901154, + "elapsed": 730.2567391395569 + }, + { + "step": 992, + "loss": 0.5681213140487671, + "objective": 0.5681213140487671, + "error": 0.3017578125, + "gradient_norm": 0.09802286326885223, + "elapsed": 742.7380962371826 + }, + { + "step": 1008, + "loss": 0.13060352206230164, + "objective": 0.13060352206230164, + "error": 0.0537109375, + "gradient_norm": 0.04271279275417328, + "elapsed": 750.8077793121338 + }, + { + "step": 1024, + "loss": 0.6129879355430603, + "objective": 0.6129879355430603, + "error": 0.3603515625, + "gradient_norm": 0.04127912223339081, + "elapsed": 761.0585849285126 + }, + { + "step": 1040, + "loss": 0.31361687183380127, + "objective": 0.31361687183380127, + "error": 0.1455078125, + "gradient_norm": 0.04341907799243927, + "elapsed": 776.3491418361664 + }, + { + "step": 1056, + "loss": 0.6326502561569214, + "objective": 0.6326502561569214, + "error": 0.365234375, + "gradient_norm": 0.07518075406551361, + "elapsed": 786.0424168109894 + }, + { + "step": 1072, + "loss": 0.537599503993988, + "objective": 0.537599503993988, + "error": 0.2958984375, + "gradient_norm": 0.08455493301153183, + "elapsed": 795.1607735157013 + }, + { + "step": 1088, + "loss": 0.5953108072280884, + "objective": 0.5953108072280884, + "error": 0.337890625, + "gradient_norm": 0.06973882764577866, + "elapsed": 804.0053510665894 + }, + { + "step": 1104, + "loss": 0.36860400438308716, + "objective": 0.36860400438308716, + "error": 0.1923828125, + "gradient_norm": 0.04828036576509476, + "elapsed": 813.4029138088226 + }, + { + "step": 1120, + "loss": 0.5423247218132019, + "objective": 0.5423247218132019, + "error": 0.28125, + "gradient_norm": 0.04841453209519386, + "elapsed": 823.626978635788 + }, + { + "step": 1136, + "loss": 0.4766136407852173, + "objective": 0.4766136407852173, + "error": 0.236328125, + "gradient_norm": 0.07564551383256912, + "elapsed": 832.4641265869141 + }, + { + "step": 1152, + "loss": 0.5473434925079346, + "objective": 0.5473434925079346, + "error": 0.2958984375, + "gradient_norm": 0.13677075505256653, + "elapsed": 844.9307618141174 + }, + { + "step": 1168, + "loss": 0.3040686249732971, + "objective": 0.3040686249732971, + "error": 0.150390625, + "gradient_norm": 0.045926257967948914, + "elapsed": 854.336992263794 + }, + { + "step": 1184, + "loss": 0.6298375129699707, + "objective": 0.6298375129699707, + "error": 0.3798828125, + "gradient_norm": 0.06807851791381836, + "elapsed": 864.5731596946716 + }, + { + "step": 1200, + "loss": 0.6272540092468262, + "objective": 0.6272540092468262, + "error": 0.37890625, + "gradient_norm": 0.139838308095932, + "elapsed": 877.8357374668121 + }, + { + "step": 1216, + "loss": 0.5224937200546265, + "objective": 0.5224937200546265, + "error": 0.287109375, + "gradient_norm": 0.0647057592868805, + "elapsed": 887.8107197284698 + }, + { + "step": 1232, + "loss": 0.02408422902226448, + "objective": 0.02408422902226448, + "error": 0.0107421875, + "gradient_norm": 0.007562167476862669, + "elapsed": 902.201171875 + }, + { + "step": 1248, + "loss": 0.01936865597963333, + "objective": 0.01936865597963333, + "error": 0.0048828125, + "gradient_norm": 0.006423021201044321, + "elapsed": 914.0247437953949 + }, + { + "step": 1264, + "loss": 0.47522181272506714, + "objective": 0.47522181272506714, + "error": 0.2490234375, + "gradient_norm": 0.04962826892733574, + "elapsed": 927.0462884902954 + }, + { + "step": 1280, + "loss": 0.019577551633119583, + "objective": 0.019577551633119583, + "error": 0.0068359375, + "gradient_norm": 0.008308992721140385, + "elapsed": 939.3647270202637 + }, + { + "step": 1296, + "loss": 0.5085430145263672, + "objective": 0.5085430145263672, + "error": 0.2734375, + "gradient_norm": 0.06214233115315437, + "elapsed": 949.4259700775146 + }, + { + "step": 1312, + "loss": 0.23232896625995636, + "objective": 0.23232896625995636, + "error": 0.1015625, + "gradient_norm": 0.05894213914871216, + "elapsed": 961.3636543750763 + }, + { + "step": 1328, + "loss": 0.5330536365509033, + "objective": 0.5330536365509033, + "error": 0.2861328125, + "gradient_norm": 0.11579663306474686, + "elapsed": 972.1607241630554 + }, + { + "step": 1344, + "loss": 0.019525721669197083, + "objective": 0.019525721669197083, + "error": 0.0087890625, + "gradient_norm": 0.008134250529110432, + "elapsed": 983.0828921794891 + }, + { + "step": 1360, + "loss": 0.22790294885635376, + "objective": 0.22790294885635376, + "error": 0.103515625, + "gradient_norm": 0.04187086224555969, + "elapsed": 991.3167304992676 + }, + { + "step": 1376, + "loss": 0.48713046312332153, + "objective": 0.48713046312332153, + "error": 0.2666015625, + "gradient_norm": 0.06267429888248444, + "elapsed": 1003.5033710002899 + }, + { + "step": 1392, + "loss": 0.6043434143066406, + "objective": 0.6043434143066406, + "error": 0.369140625, + "gradient_norm": 0.037880122661590576, + "elapsed": 1017.8567223548889 + }, + { + "step": 1408, + "loss": 0.034499723464250565, + "objective": 0.034499723464250565, + "error": 0.0068359375, + "gradient_norm": 0.013505477458238602, + "elapsed": 1027.3547134399414 + }, + { + "step": 1424, + "loss": 0.5320160388946533, + "objective": 0.5320160388946533, + "error": 0.306640625, + "gradient_norm": 0.07510018348693848, + "elapsed": 1036.9454221725464 + }, + { + "step": 1440, + "loss": 0.3451523780822754, + "objective": 0.3451523780822754, + "error": 0.171875, + "gradient_norm": 0.06453985720872879, + "elapsed": 1046.1805095672607 + }, + { + "step": 1456, + "loss": 0.21541815996170044, + "objective": 0.21541815996170044, + "error": 0.08984375, + "gradient_norm": 0.043503839522600174, + "elapsed": 1055.850379705429 + }, + { + "step": 1472, + "loss": 0.43667086958885193, + "objective": 0.43667086958885193, + "error": 0.22265625, + "gradient_norm": 0.07311506569385529, + "elapsed": 1066.6324400901794 + }, + { + "step": 1488, + "loss": 0.6163139939308167, + "objective": 0.6163139939308167, + "error": 0.3779296875, + "gradient_norm": 0.06406569480895996, + "elapsed": 1075.7883398532867 + }, + { + "step": 1504, + "loss": 0.23901250958442688, + "objective": 0.23901250958442688, + "error": 0.10546875, + "gradient_norm": 0.04792191833257675, + "elapsed": 1085.4756922721863 + }, + { + "step": 1520, + "loss": 0.3817014694213867, + "objective": 0.3817014694213867, + "error": 0.18359375, + "gradient_norm": 0.046061187982559204, + "elapsed": 1095.974383354187 + }, + { + "step": 1536, + "loss": 0.5593156814575195, + "objective": 0.5593156814575195, + "error": 0.3017578125, + "gradient_norm": 0.0735388696193695, + "elapsed": 1105.913155078888 + } + ] + }, + { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 466919, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/reserved1_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/reserved1_warm/weights-512.npz", + "starting_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261271", + "prior_pass": 3, + "initial_seed": 20261271, + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "Only the18856 declared fit rows per each of26 d5 conditions; both512-row gate and512-row audit partitions excluded from every optimizer update. Uniform condition/within-condition sampling.", + "reserved_training_partition": { + "manifest": "/run-state/workspace/research/learned_d5/reserved_split1/manifest.json", + "manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "selected_part": "fit", + "details": { + "schema": "qecbench-training-reserved-split/v1", + "seed": 20261270, + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "source_sha256": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "conditions": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "file": "surface_code_bX_d5_r01_center_5_5.npz", + "sha256": "c72d5c5ee3daf1b128e0c226f2815009daf6127e8b028004e86cebd6047ac474", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "file": "surface_code_bX_d5_r03_center_5_5.npz", + "sha256": "3a59636161c80fbbf326cf1919817ce5f60ec9e6d3e4b6223579cb6a36e12e31", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "file": "surface_code_bX_d5_r05_center_5_5.npz", + "sha256": "e808936ef0cb32869e0944ab70a3026ef96d0f31fe0fe9967c6d87a15b85abb5", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "file": "surface_code_bX_d5_r07_center_5_5.npz", + "sha256": "cd0f71459448a41af10e4399637d02e8d8193dea16ab300f839cb56ad8b08203", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "file": "surface_code_bX_d5_r09_center_5_5.npz", + "sha256": "56648e2b93499736d40f6aa5e9e8a568f150cbc8589929578f57c1e839c92d76", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "file": "surface_code_bX_d5_r11_center_5_5.npz", + "sha256": "ce2dcc2bfcb57bbfcb2291105a9a011a2a3113ad92348dfa7c76076f1fb3cacf", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "file": "surface_code_bX_d5_r13_center_5_5.npz", + "sha256": "968b14d4d948474afd0e182d9c60cd577297d4b7bb331e916058e41692d7c9d2", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "file": "surface_code_bX_d5_r15_center_5_5.npz", + "sha256": "8d73808a777d81c2acc2f6aab924cc11690a94136bc666fbf11f78292a47615d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "file": "surface_code_bX_d5_r17_center_5_5.npz", + "sha256": "0ab49c9dc61605d43f0c03427352af0ee230ecf7360927f75de60519d707c7ee", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "file": "surface_code_bX_d5_r19_center_5_5.npz", + "sha256": "27594cc6e0943860d828ebde2c76fdde64ccf2a357f896d551f3d4606e74fec4", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "file": "surface_code_bX_d5_r21_center_5_5.npz", + "sha256": "1b1fdcf280ca7c8ba94476f9c54b6ab70eee59b63b3be406a534014132295b7e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "file": "surface_code_bX_d5_r23_center_5_5.npz", + "sha256": "d31e0ca2ce6a6d04ed7bbd80113aec8cca40526b643752d8f429ece168736759", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "file": "surface_code_bX_d5_r25_center_5_5.npz", + "sha256": "f45a5978d77b1ef450f2ffd9fa19413c9d647448a3d61dfafd7590671dcace19", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "file": "surface_code_bZ_d5_r01_center_5_5.npz", + "sha256": "647e82ac0721a7245b3deb831a5a73eb555a3cb3e58b460774ffb96dc99c3b64", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "file": "surface_code_bZ_d5_r03_center_5_5.npz", + "sha256": "b64be8c7883b921bd57d5eefcc53656c2dad484833e5533e499b19b45be90158", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "file": "surface_code_bZ_d5_r05_center_5_5.npz", + "sha256": "63361e091640a4d506fc372bd0764ad248f6551d77cdf57550405b2624ca97b1", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "file": "surface_code_bZ_d5_r07_center_5_5.npz", + "sha256": "c50d26a58c1fb6b5a20f5737b94c3bac9182fe703bafa221532b8b012064f655", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "file": "surface_code_bZ_d5_r09_center_5_5.npz", + "sha256": "d62ecb975d63f13664bc6b02d30499a3fb10f0c22f1068b28bbbc31d1ec91fcc", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "file": "surface_code_bZ_d5_r11_center_5_5.npz", + "sha256": "724c7dc2c4cf2b551abf4f75e230f5aa04a74eebba79c25c845f14d15863de5e", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "file": "surface_code_bZ_d5_r13_center_5_5.npz", + "sha256": "0e618a998fb591a85dd365eead741a91b6560ed1a3987046286a67a2c754fa83", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "file": "surface_code_bZ_d5_r15_center_5_5.npz", + "sha256": "e1f8c6f812dc98c48402b69a08b09b520d1374e9f2e51b3e681b67bf306e17be", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "file": "surface_code_bZ_d5_r17_center_5_5.npz", + "sha256": "aa23a51a79677a8ac43cc31b72fe07e73c827f935c632c29b09924fc88242d0d", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "file": "surface_code_bZ_d5_r19_center_5_5.npz", + "sha256": "8420b79a8d7324f41dfd1cccacfd1fae9b27b370f40c60059e9de187864dba2b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "file": "surface_code_bZ_d5_r21_center_5_5.npz", + "sha256": "088b92610c90dc1a180b2eca8b16e8f225d191ec7fc11355c85e6959f35e7073", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "file": "surface_code_bZ_d5_r23_center_5_5.npz", + "sha256": "b1484c581cbd5439c74befabbd7c1c12e7cb38db099c793dfb3cf748df20fc3b", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "file": "surface_code_bZ_d5_r25_center_5_5.npz", + "sha256": "92f552059b6c197b53ff1030d9ba0fe03cf22ea1f116e5280be944ad60f04be3", + "counts": { + "fit": 18856, + "gate": 512, + "audit": 512 + } + } + ], + "counts": { + "fit": 490256, + "gate": 13312, + "audit": 13312 + }, + "split_features": "Only array lengths and seeded random permutations; IDs verify alignment and are never model features", + "gate_use": "Fit a small combiner on gate labels only after experts exclude both reserved parts", + "audit_use": "Diagnostic only; no parameter fitting, checkpoint selection, or hyperparameter selection", + "validation_use": "Supplied validation selects checkpoints and candidates; no validation labels fit parameters", + "test_data_used": false + } + }, + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 490256, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 317613, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261272, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261272", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.1412775069475174, + "objective": 0.1412775069475174, + "error": 0.0595703125, + "gradient_norm": 0.030735325068235397, + "elapsed": 28.457472801208496 + }, + { + "step": 16, + "loss": 0.6315727233886719, + "objective": 0.6315727233886719, + "error": 0.384765625, + "gradient_norm": 0.06563512235879898, + "elapsed": 47.886730670928955 + }, + { + "step": 32, + "loss": 0.5130410194396973, + "objective": 0.5130410194396973, + "error": 0.263671875, + "gradient_norm": 0.10626910626888275, + "elapsed": 60.16136598587036 + }, + { + "step": 48, + "loss": 0.6413166522979736, + "objective": 0.6413166522979736, + "error": 0.408203125, + "gradient_norm": 0.03790846839547157, + "elapsed": 70.9611382484436 + }, + { + "step": 64, + "loss": 0.5491592884063721, + "objective": 0.5491592884063721, + "error": 0.2939453125, + "gradient_norm": 0.093081034719944, + "elapsed": 81.46673464775085 + }, + { + "step": 80, + "loss": 0.6315242648124695, + "objective": 0.6315242648124695, + "error": 0.359375, + "gradient_norm": 0.0384257510304451, + "elapsed": 91.71172666549683 + }, + { + "step": 96, + "loss": 0.6311566829681396, + "objective": 0.6311566829681396, + "error": 0.3798828125, + "gradient_norm": 0.03731638938188553, + "elapsed": 100.83252763748169 + }, + { + "step": 112, + "loss": 0.5327925682067871, + "objective": 0.5327925682067871, + "error": 0.29296875, + "gradient_norm": 0.11202990263700485, + "elapsed": 111.35073852539062 + }, + { + "step": 128, + "loss": 0.6284654140472412, + "objective": 0.6284654140472412, + "error": 0.3740234375, + "gradient_norm": 0.03215613588690758, + "elapsed": 121.32994651794434 + }, + { + "step": 144, + "loss": 0.33964547514915466, + "objective": 0.33964547514915466, + "error": 0.1259765625, + "gradient_norm": 0.05133189633488655, + "elapsed": 131.2744882106781 + }, + { + "step": 160, + "loss": 0.14193454384803772, + "objective": 0.14193454384803772, + "error": 0.0478515625, + "gradient_norm": 0.03264402225613594, + "elapsed": 139.58473920822144 + }, + { + "step": 176, + "loss": 0.14203950762748718, + "objective": 0.14203950762748718, + "error": 0.0654296875, + "gradient_norm": 0.022548990324139595, + "elapsed": 148.9861602783203 + }, + { + "step": 192, + "loss": 0.6307225227355957, + "objective": 0.6307225227355957, + "error": 0.3955078125, + "gradient_norm": 0.08607082068920135, + "elapsed": 162.27514505386353 + }, + { + "step": 208, + "loss": 0.16193106770515442, + "objective": 0.16193106770515442, + "error": 0.064453125, + "gradient_norm": 0.023293493315577507, + "elapsed": 173.59824013710022 + }, + { + "step": 224, + "loss": 0.5426318049430847, + "objective": 0.5426318049430847, + "error": 0.3037109375, + "gradient_norm": 0.03944721072912216, + "elapsed": 182.70232272148132 + }, + { + "step": 240, + "loss": 0.6270365715026855, + "objective": 0.6270365715026855, + "error": 0.3896484375, + "gradient_norm": 0.14661568403244019, + "elapsed": 193.759183883667 + }, + { + "step": 256, + "loss": 0.4933152198791504, + "objective": 0.4933152198791504, + "error": 0.2724609375, + "gradient_norm": 0.1065438985824585, + "elapsed": 205.62959718704224 + }, + { + "step": 272, + "loss": 0.3671969473361969, + "objective": 0.3671969473361969, + "error": 0.177734375, + "gradient_norm": 0.05156548321247101, + "elapsed": 222.249596118927 + }, + { + "step": 288, + "loss": 0.5478869676589966, + "objective": 0.5478869676589966, + "error": 0.3203125, + "gradient_norm": 0.08357688039541245, + "elapsed": 232.2198715209961 + }, + { + "step": 304, + "loss": 0.21171918511390686, + "objective": 0.21171918511390686, + "error": 0.0849609375, + "gradient_norm": 0.06231697276234627, + "elapsed": 241.07631373405457 + }, + { + "step": 320, + "loss": 0.5333335995674133, + "objective": 0.5333335995674133, + "error": 0.2861328125, + "gradient_norm": 0.08931853622198105, + "elapsed": 251.28962755203247 + }, + { + "step": 336, + "loss": 0.12485946714878082, + "objective": 0.12485946714878082, + "error": 0.046875, + "gradient_norm": 0.018839582800865173, + "elapsed": 262.3605041503906 + }, + { + "step": 352, + "loss": 0.2334863245487213, + "objective": 0.2334863245487213, + "error": 0.09765625, + "gradient_norm": 0.03669576346874237, + "elapsed": 273.16373229026794 + }, + { + "step": 368, + "loss": 0.5818328857421875, + "objective": 0.5818328857421875, + "error": 0.3232421875, + "gradient_norm": 0.09833699464797974, + "elapsed": 282.8677294254303 + }, + { + "step": 384, + "loss": 0.6228232383728027, + "objective": 0.6228232383728027, + "error": 0.3671875, + "gradient_norm": 0.033418990671634674, + "elapsed": 295.04902839660645 + }, + { + "step": 400, + "loss": 0.5749450922012329, + "objective": 0.5749450922012329, + "error": 0.333984375, + "gradient_norm": 0.04644288495182991, + "elapsed": 306.67032837867737 + }, + { + "step": 416, + "loss": 0.46251457929611206, + "objective": 0.46251457929611206, + "error": 0.2216796875, + "gradient_norm": 0.06633804738521576, + "elapsed": 317.759464263916 + }, + { + "step": 432, + "loss": 0.5577508211135864, + "objective": 0.5577508211135864, + "error": 0.30859375, + "gradient_norm": 0.0970199704170227, + "elapsed": 327.4626543521881 + }, + { + "step": 448, + "loss": 0.11625733226537704, + "objective": 0.11625733226537704, + "error": 0.0419921875, + "gradient_norm": 0.020417485386133194, + "elapsed": 336.3522970676422 + }, + { + "step": 464, + "loss": 0.23657961189746857, + "objective": 0.23657961189746857, + "error": 0.1025390625, + "gradient_norm": 0.03908605873584747, + "elapsed": 344.3832321166992 + }, + { + "step": 480, + "loss": 0.011504358612000942, + "objective": 0.011504358612000942, + "error": 0.00390625, + "gradient_norm": 0.006708688102662563, + "elapsed": 355.18855381011963 + }, + { + "step": 496, + "loss": 0.3410624563694, + "objective": 0.3410624563694, + "error": 0.1533203125, + "gradient_norm": 0.05804387852549553, + "elapsed": 366.2978138923645 + }, + { + "step": 512, + "loss": 0.034005306661129, + "objective": 0.034005306661129, + "error": 0.0107421875, + "gradient_norm": 0.01019973959773779, + "elapsed": 375.73491764068604 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_warm", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "b31e8f5ee2b5ea1b661e6bf8b5649bec45b7ab5da74fe9de46e4d06846356b87", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 256, + 512 + ], + "training_draws": 524288, + "distinct_phase_training_rows": 317613, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 14297, + "surface_code_bX_d5_r03_center_5_5": 11305, + "surface_code_bX_d5_r05_center_5_5": 12479, + "surface_code_bX_d5_r07_center_5_5": 10433, + "surface_code_bX_d5_r09_center_5_5": 10919, + "surface_code_bX_d5_r11_center_5_5": 12516, + "surface_code_bX_d5_r13_center_5_5": 12043, + "surface_code_bX_d5_r15_center_5_5": 12143, + "surface_code_bX_d5_r17_center_5_5": 11354, + "surface_code_bX_d5_r19_center_5_5": 13660, + "surface_code_bX_d5_r21_center_5_5": 13753, + "surface_code_bX_d5_r23_center_5_5": 12161, + "surface_code_bX_d5_r25_center_5_5": 12531, + "surface_code_bZ_d5_r01_center_5_5": 11397, + "surface_code_bZ_d5_r03_center_5_5": 9053, + "surface_code_bZ_d5_r05_center_5_5": 13723, + "surface_code_bZ_d5_r07_center_5_5": 14763, + "surface_code_bZ_d5_r09_center_5_5": 10969, + "surface_code_bZ_d5_r11_center_5_5": 12129, + "surface_code_bZ_d5_r13_center_5_5": 10020, + "surface_code_bZ_d5_r15_center_5_5": 13170, + "surface_code_bZ_d5_r17_center_5_5": 14946, + "surface_code_bZ_d5_r19_center_5_5": 10579, + "surface_code_bZ_d5_r21_center_5_5": 11745, + "surface_code_bZ_d5_r23_center_5_5": 12426, + "surface_code_bZ_d5_r25_center_5_5": 13099 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 512, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5523660182952881, + "objective": 0.5523660182952881, + "error": 0.30859375, + "gradient_norm": 0.05200070142745972, + "elapsed": 30.08410096168518 + }, + { + "step": 16, + "loss": 0.5380295515060425, + "objective": 0.5380295515060425, + "error": 0.306640625, + "gradient_norm": 0.0804876759648323, + "elapsed": 50.77648210525513 + }, + { + "step": 32, + "loss": 0.6359301805496216, + "objective": 0.6359301805496216, + "error": 0.3837890625, + "gradient_norm": 0.059380218386650085, + "elapsed": 59.453776836395264 + }, + { + "step": 48, + "loss": 0.2540435492992401, + "objective": 0.2540435492992401, + "error": 0.1083984375, + "gradient_norm": 0.04367281496524811, + "elapsed": 67.29314041137695 + }, + { + "step": 64, + "loss": 0.5867692232131958, + "objective": 0.5867692232131958, + "error": 0.3447265625, + "gradient_norm": 0.053885214030742645, + "elapsed": 78.74847197532654 + }, + { + "step": 80, + "loss": 0.6015321016311646, + "objective": 0.6015321016311646, + "error": 0.365234375, + "gradient_norm": 0.04807985574007034, + "elapsed": 90.48145818710327 + }, + { + "step": 96, + "loss": 0.49287766218185425, + "objective": 0.49287766218185425, + "error": 0.271484375, + "gradient_norm": 0.07899080961942673, + "elapsed": 101.65468978881836 + }, + { + "step": 112, + "loss": 0.3271353542804718, + "objective": 0.3271353542804718, + "error": 0.15234375, + "gradient_norm": 0.049542222172021866, + "elapsed": 111.14713263511658 + }, + { + "step": 128, + "loss": 0.50013667345047, + "objective": 0.50013667345047, + "error": 0.271484375, + "gradient_norm": 0.06454745680093765, + "elapsed": 121.21207547187805 + }, + { + "step": 144, + "loss": 0.028576843440532684, + "objective": 0.028576843440532684, + "error": 0.0087890625, + "gradient_norm": 0.010781333781778812, + "elapsed": 130.69302248954773 + }, + { + "step": 160, + "loss": 0.5668779015541077, + "objective": 0.5668779015541077, + "error": 0.330078125, + "gradient_norm": 0.06098390743136406, + "elapsed": 142.14290237426758 + }, + { + "step": 176, + "loss": 0.3986494839191437, + "objective": 0.3986494839191437, + "error": 0.1884765625, + "gradient_norm": 0.042795032262802124, + "elapsed": 152.75753688812256 + }, + { + "step": 192, + "loss": 0.31897079944610596, + "objective": 0.31897079944610596, + "error": 0.142578125, + "gradient_norm": 0.040675707161426544, + "elapsed": 160.04981398582458 + }, + { + "step": 208, + "loss": 0.5092275142669678, + "objective": 0.5092275142669678, + "error": 0.255859375, + "gradient_norm": 0.07929783314466476, + "elapsed": 169.85345673561096 + }, + { + "step": 224, + "loss": 0.35782667994499207, + "objective": 0.35782667994499207, + "error": 0.1748046875, + "gradient_norm": 0.05785144120454788, + "elapsed": 179.90323066711426 + }, + { + "step": 240, + "loss": 0.5660895109176636, + "objective": 0.5660895109176636, + "error": 0.3349609375, + "gradient_norm": 0.10684454441070557, + "elapsed": 191.3668942451477 + }, + { + "step": 256, + "loss": 0.6265910863876343, + "objective": 0.6265910863876343, + "error": 0.3779296875, + "gradient_norm": 0.034383758902549744, + "elapsed": 200.3055775165558 + }, + { + "step": 272, + "loss": 0.6210677623748779, + "objective": 0.6210677623748779, + "error": 0.369140625, + "gradient_norm": 0.04434216767549515, + "elapsed": 210.09376430511475 + }, + { + "step": 288, + "loss": 0.4892377257347107, + "objective": 0.4892377257347107, + "error": 0.2490234375, + "gradient_norm": 0.1040654331445694, + "elapsed": 220.45881819725037 + }, + { + "step": 304, + "loss": 0.6407739520072937, + "objective": 0.6407739520072937, + "error": 0.3916015625, + "gradient_norm": 0.07782924920320511, + "elapsed": 233.3719048500061 + }, + { + "step": 320, + "loss": 0.4752756953239441, + "objective": 0.4752756953239441, + "error": 0.263671875, + "gradient_norm": 0.051829319447278976, + "elapsed": 244.25844407081604 + }, + { + "step": 336, + "loss": 0.6482080221176147, + "objective": 0.6482080221176147, + "error": 0.41015625, + "gradient_norm": 0.04979892820119858, + "elapsed": 253.1897099018097 + }, + { + "step": 352, + "loss": 0.34022292494773865, + "objective": 0.34022292494773865, + "error": 0.1708984375, + "gradient_norm": 0.09951864182949066, + "elapsed": 264.0781395435333 + }, + { + "step": 368, + "loss": 0.3494992256164551, + "objective": 0.3494992256164551, + "error": 0.15625, + "gradient_norm": 0.10392706841230392, + "elapsed": 275.8111581802368 + }, + { + "step": 384, + "loss": 0.47191378474235535, + "objective": 0.47191378474235535, + "error": 0.25, + "gradient_norm": 0.07366786152124405, + "elapsed": 283.9459602832794 + }, + { + "step": 400, + "loss": 0.583655595779419, + "objective": 0.583655595779419, + "error": 0.3623046875, + "gradient_norm": 0.10394527018070221, + "elapsed": 294.3349726200104 + }, + { + "step": 416, + "loss": 0.6212975978851318, + "objective": 0.6212975978851318, + "error": 0.37109375, + "gradient_norm": 0.054796766489744186, + "elapsed": 304.7477548122406 + }, + { + "step": 432, + "loss": 0.4719577431678772, + "objective": 0.4719577431678772, + "error": 0.2431640625, + "gradient_norm": 0.05418012663722038, + "elapsed": 315.91914200782776 + }, + { + "step": 448, + "loss": 0.5696494579315186, + "objective": 0.5696494579315186, + "error": 0.3330078125, + "gradient_norm": 0.047046076506376266, + "elapsed": 324.96326184272766 + }, + { + "step": 464, + "loss": 0.613875687122345, + "objective": 0.613875687122345, + "error": 0.34765625, + "gradient_norm": 0.05237002298235893, + "elapsed": 334.7670781612396 + }, + { + "step": 480, + "loss": 0.28741705417633057, + "objective": 0.28741705417633057, + "error": 0.1240234375, + "gradient_norm": 0.05365394428372383, + "elapsed": 344.03080439567566 + }, + { + "step": 496, + "loss": 0.3729455769062042, + "objective": 0.3729455769062042, + "error": 0.1875, + "gradient_norm": 0.05905403569340706, + "elapsed": 356.01581716537476 + }, + { + "step": 512, + "loss": 0.38685142993927, + "objective": 0.38685142993927, + "error": 0.17578125, + "gradient_norm": 0.048455506563186646, + "elapsed": 367.7296392917633 + }, + { + "step": 528, + "loss": 0.6062720417976379, + "objective": 0.6062720417976379, + "error": 0.369140625, + "gradient_norm": 0.07544548809528351, + "elapsed": 385.4480962753296 + }, + { + "step": 544, + "loss": 0.520085871219635, + "objective": 0.520085871219635, + "error": 0.279296875, + "gradient_norm": 0.08394371718168259, + "elapsed": 397.71993708610535 + }, + { + "step": 560, + "loss": 0.5944540500640869, + "objective": 0.5944540500640869, + "error": 0.3544921875, + "gradient_norm": 0.05468091368675232, + "elapsed": 406.9417428970337 + }, + { + "step": 576, + "loss": 0.34102559089660645, + "objective": 0.34102559089660645, + "error": 0.1611328125, + "gradient_norm": 0.07333917915821075, + "elapsed": 417.0068130493164 + }, + { + "step": 592, + "loss": 0.47373664379119873, + "objective": 0.47373664379119873, + "error": 0.2412109375, + "gradient_norm": 0.05662858858704567, + "elapsed": 425.1176447868347 + }, + { + "step": 608, + "loss": 0.48517894744873047, + "objective": 0.48517894744873047, + "error": 0.25, + "gradient_norm": 0.08127480745315552, + "elapsed": 434.92080903053284 + }, + { + "step": 624, + "loss": 0.39865612983703613, + "objective": 0.39865612983703613, + "error": 0.1904296875, + "gradient_norm": 0.07332058995962143, + "elapsed": 446.6602101325989 + }, + { + "step": 640, + "loss": 0.41867297887802124, + "objective": 0.41867297887802124, + "error": 0.2177734375, + "gradient_norm": 0.07386308163404465, + "elapsed": 457.0243580341339 + }, + { + "step": 656, + "loss": 0.5108687877655029, + "objective": 0.5108687877655029, + "error": 0.2822265625, + "gradient_norm": 0.052080318331718445, + "elapsed": 469.5842761993408 + }, + { + "step": 672, + "loss": 0.5043742656707764, + "objective": 0.5043742656707764, + "error": 0.2734375, + "gradient_norm": 0.047204963862895966, + "elapsed": 479.356397151947 + }, + { + "step": 688, + "loss": 0.5550935864448547, + "objective": 0.5550935864448547, + "error": 0.30078125, + "gradient_norm": 0.04080262407660484, + "elapsed": 489.9912152290344 + }, + { + "step": 704, + "loss": 0.5698974132537842, + "objective": 0.5698974132537842, + "error": 0.322265625, + "gradient_norm": 0.10692963004112244, + "elapsed": 500.3283371925354 + }, + { + "step": 720, + "loss": 0.45870622992515564, + "objective": 0.45870622992515564, + "error": 0.2255859375, + "gradient_norm": 0.06705734878778458, + "elapsed": 509.82279753685 + }, + { + "step": 736, + "loss": 0.555386483669281, + "objective": 0.555386483669281, + "error": 0.31640625, + "gradient_norm": 0.05112688988447189, + "elapsed": 518.507036447525 + }, + { + "step": 752, + "loss": 0.14282986521720886, + "objective": 0.14282986521720886, + "error": 0.056640625, + "gradient_norm": 0.03209136053919792, + "elapsed": 529.1373023986816 + }, + { + "step": 768, + "loss": 0.5362129807472229, + "objective": 0.5362129807472229, + "error": 0.2841796875, + "gradient_norm": 0.049996186047792435, + "elapsed": 538.9186007976532 + }, + { + "step": 784, + "loss": 0.5071826577186584, + "objective": 0.5071826577186584, + "error": 0.2744140625, + "gradient_norm": 0.04826078191399574, + "elapsed": 549.5225830078125 + }, + { + "step": 800, + "loss": 0.24775367975234985, + "objective": 0.24775367975234985, + "error": 0.107421875, + "gradient_norm": 0.06889795511960983, + "elapsed": 560.7170543670654 + }, + { + "step": 816, + "loss": 0.17432856559753418, + "objective": 0.17432856559753418, + "error": 0.06640625, + "gradient_norm": 0.05147368833422661, + "elapsed": 570.7887880802155 + }, + { + "step": 832, + "loss": 0.5410823822021484, + "objective": 0.5410823822021484, + "error": 0.3115234375, + "gradient_norm": 0.11862928420305252, + "elapsed": 581.9721121788025 + }, + { + "step": 848, + "loss": 0.5555508732795715, + "objective": 0.5555508732795715, + "error": 0.296875, + "gradient_norm": 0.060369592159986496, + "elapsed": 592.2823219299316 + }, + { + "step": 864, + "loss": 0.31839215755462646, + "objective": 0.31839215755462646, + "error": 0.1552734375, + "gradient_norm": 0.063877172768116, + "elapsed": 603.1910541057587 + }, + { + "step": 880, + "loss": 0.481766939163208, + "objective": 0.481766939163208, + "error": 0.2470703125, + "gradient_norm": 0.1623816341161728, + "elapsed": 614.4277107715607 + }, + { + "step": 896, + "loss": 0.5780366659164429, + "objective": 0.5780366659164429, + "error": 0.3037109375, + "gradient_norm": 0.06694691628217697, + "elapsed": 623.9365792274475 + }, + { + "step": 912, + "loss": 0.4794909358024597, + "objective": 0.4794909358024597, + "error": 0.2314453125, + "gradient_norm": 0.07813122123479843, + "elapsed": 633.9845306873322 + }, + { + "step": 928, + "loss": 0.6279138922691345, + "objective": 0.6279138922691345, + "error": 0.380859375, + "gradient_norm": 0.047679927200078964, + "elapsed": 643.7766675949097 + }, + { + "step": 944, + "loss": 0.6401606798171997, + "objective": 0.6401606798171997, + "error": 0.3994140625, + "gradient_norm": 0.07329051941633224, + "elapsed": 655.2369928359985 + }, + { + "step": 960, + "loss": 0.4340277910232544, + "objective": 0.4340277910232544, + "error": 0.2158203125, + "gradient_norm": 0.11762503534555435, + "elapsed": 666.9884371757507 + }, + { + "step": 976, + "loss": 0.44496864080429077, + "objective": 0.44496864080429077, + "error": 0.2236328125, + "gradient_norm": 0.05260347202420235, + "elapsed": 677.3464586734772 + }, + { + "step": 992, + "loss": 0.13230293989181519, + "objective": 0.13230293989181519, + "error": 0.05078125, + "gradient_norm": 0.030240925028920174, + "elapsed": 685.7275724411011 + }, + { + "step": 1008, + "loss": 0.2971688508987427, + "objective": 0.2971688508987427, + "error": 0.1171875, + "gradient_norm": 0.05503479763865471, + "elapsed": 694.1270356178284 + }, + { + "step": 1024, + "loss": 0.5688735246658325, + "objective": 0.5688735246658325, + "error": 0.314453125, + "gradient_norm": 0.06526188552379608, + "elapsed": 703.9192817211151 + }, + { + "step": 1040, + "loss": 0.42805811762809753, + "objective": 0.42805811762809753, + "error": 0.2080078125, + "gradient_norm": 0.13000032305717468, + "elapsed": 720.145961523056 + }, + { + "step": 1056, + "loss": 0.5543602705001831, + "objective": 0.5543602705001831, + "error": 0.298828125, + "gradient_norm": 0.15922385454177856, + "elapsed": 733.5112845897675 + }, + { + "step": 1072, + "loss": 0.031130114570260048, + "objective": 0.031130114570260048, + "error": 0.013671875, + "gradient_norm": 0.008926023729145527, + "elapsed": 742.4467866420746 + }, + { + "step": 1088, + "loss": 0.14947748184204102, + "objective": 0.14947748184204102, + "error": 0.056640625, + "gradient_norm": 0.03975249081850052, + "elapsed": 751.8575854301453 + }, + { + "step": 1104, + "loss": 0.6275734901428223, + "objective": 0.6275734901428223, + "error": 0.3671875, + "gradient_norm": 0.08096148073673248, + "elapsed": 761.5625903606415 + }, + { + "step": 1120, + "loss": 0.23923414945602417, + "objective": 0.23923414945602417, + "error": 0.0966796875, + "gradient_norm": 0.03325376287102699, + "elapsed": 773.9633615016937 + }, + { + "step": 1136, + "loss": 0.570243239402771, + "objective": 0.570243239402771, + "error": 0.31640625, + "gradient_norm": 0.07534287869930267, + "elapsed": 783.1533136367798 + }, + { + "step": 1152, + "loss": 0.4264270067214966, + "objective": 0.4264270067214966, + "error": 0.2119140625, + "gradient_norm": 0.08900073170661926, + "elapsed": 792.1710996627808 + }, + { + "step": 1168, + "loss": 0.5958121418952942, + "objective": 0.5958121418952942, + "error": 0.3583984375, + "gradient_norm": 0.08239343762397766, + "elapsed": 803.1175289154053 + }, + { + "step": 1184, + "loss": 0.2909137010574341, + "objective": 0.2909137010574341, + "error": 0.1416015625, + "gradient_norm": 0.05281354859471321, + "elapsed": 812.6055159568787 + }, + { + "step": 1200, + "loss": 0.6119058728218079, + "objective": 0.6119058728218079, + "error": 0.36328125, + "gradient_norm": 0.056254416704177856, + "elapsed": 823.2276427745819 + }, + { + "step": 1216, + "loss": 0.13595536351203918, + "objective": 0.13595536351203918, + "error": 0.0556640625, + "gradient_norm": 0.04057573154568672, + "elapsed": 834.1696293354034 + }, + { + "step": 1232, + "loss": 0.5840731263160706, + "objective": 0.5840731263160706, + "error": 0.328125, + "gradient_norm": 0.054566267877817154, + "elapsed": 845.3501887321472 + }, + { + "step": 1248, + "loss": 0.3053072690963745, + "objective": 0.3053072690963745, + "error": 0.1337890625, + "gradient_norm": 0.04617297649383545, + "elapsed": 854.9564871788025 + }, + { + "step": 1264, + "loss": 0.6288673281669617, + "objective": 0.6288673281669617, + "error": 0.3994140625, + "gradient_norm": 0.08229745179414749, + "elapsed": 864.8914043903351 + }, + { + "step": 1280, + "loss": 0.5586361289024353, + "objective": 0.5586361289024353, + "error": 0.2958984375, + "gradient_norm": 0.05713959410786629, + "elapsed": 877.0349607467651 + }, + { + "step": 1296, + "loss": 0.3648858666419983, + "objective": 0.3648858666419983, + "error": 0.16796875, + "gradient_norm": 0.08502963185310364, + "elapsed": 888.5764675140381 + }, + { + "step": 1312, + "loss": 0.4747084081172943, + "objective": 0.4747084081172943, + "error": 0.244140625, + "gradient_norm": 0.08609883487224579, + "elapsed": 899.7598609924316 + }, + { + "step": 1328, + "loss": 0.15583917498588562, + "objective": 0.15583917498588562, + "error": 0.05859375, + "gradient_norm": 0.027793049812316895, + "elapsed": 909.47514295578 + }, + { + "step": 1344, + "loss": 0.47515708208084106, + "objective": 0.47515708208084106, + "error": 0.263671875, + "gradient_norm": 0.07668807357549667, + "elapsed": 919.7640328407288 + }, + { + "step": 1360, + "loss": 0.5173689126968384, + "objective": 0.5173689126968384, + "error": 0.2744140625, + "gradient_norm": 0.05054212734103203, + "elapsed": 930.6309463977814 + }, + { + "step": 1376, + "loss": 0.46629998087882996, + "objective": 0.46629998087882996, + "error": 0.24609375, + "gradient_norm": 0.051172077655792236, + "elapsed": 939.0202586650848 + }, + { + "step": 1392, + "loss": 0.11312969774007797, + "objective": 0.11312969774007797, + "error": 0.044921875, + "gradient_norm": 0.05863805115222931, + "elapsed": 949.1451416015625 + }, + { + "step": 1408, + "loss": 0.5750841498374939, + "objective": 0.5750841498374939, + "error": 0.322265625, + "gradient_norm": 0.051106806844472885, + "elapsed": 959.94162940979 + }, + { + "step": 1424, + "loss": 0.5937192440032959, + "objective": 0.5937192440032959, + "error": 0.3408203125, + "gradient_norm": 0.05014815554022789, + "elapsed": 969.5868306159973 + }, + { + "step": 1440, + "loss": 0.5292985439300537, + "objective": 0.5292985439300537, + "error": 0.2958984375, + "gradient_norm": 0.057068243622779846, + "elapsed": 982.6692054271698 + }, + { + "step": 1456, + "loss": 0.5959951877593994, + "objective": 0.5959951877593994, + "error": 0.3408203125, + "gradient_norm": 0.0703694075345993, + "elapsed": 995.0066986083984 + }, + { + "step": 1472, + "loss": 0.018453411757946014, + "objective": 0.018453411757946014, + "error": 0.00390625, + "gradient_norm": 0.012016087770462036, + "elapsed": 1004.0057821273804 + }, + { + "step": 1488, + "loss": 0.5711684823036194, + "objective": 0.5711684823036194, + "error": 0.3095703125, + "gradient_norm": 0.07746906578540802, + "elapsed": 1016.1701967716217 + }, + { + "step": 1504, + "loss": 0.3114882707595825, + "objective": 0.3114882707595825, + "error": 0.1455078125, + "gradient_norm": 0.05321609228849411, + "elapsed": 1026.6053586006165 + }, + { + "step": 1520, + "loss": 0.6433392763137817, + "objective": 0.6433392763137817, + "error": 0.4072265625, + "gradient_norm": 0.05683734640479088, + "elapsed": 1036.1535296440125 + }, + { + "step": 1536, + "loss": 0.38409170508384705, + "objective": 0.38409170508384705, + "error": 0.19140625, + "gradient_norm": 0.07577994465827942, + "elapsed": 1046.9508447647095 + } + ], + "reserved_sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved1_full", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "7b45252d6bb77a39c003c8f34f040d0d672e9dd1a1338a14126e1fe07a02c8c9", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 512, + 1024, + 1536 + ], + "training_draws": 1572864, + "distinct_phase_training_rows": 466919, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18000, + "surface_code_bX_d5_r03_center_5_5": 18251, + "surface_code_bX_d5_r05_center_5_5": 18224, + "surface_code_bX_d5_r07_center_5_5": 17881, + "surface_code_bX_d5_r09_center_5_5": 18247, + "surface_code_bX_d5_r11_center_5_5": 17452, + "surface_code_bX_d5_r13_center_5_5": 17982, + "surface_code_bX_d5_r15_center_5_5": 17498, + "surface_code_bX_d5_r17_center_5_5": 18487, + "surface_code_bX_d5_r19_center_5_5": 18100, + "surface_code_bX_d5_r21_center_5_5": 17622, + "surface_code_bX_d5_r23_center_5_5": 17449, + "surface_code_bX_d5_r25_center_5_5": 17739, + "surface_code_bZ_d5_r01_center_5_5": 16689, + "surface_code_bZ_d5_r03_center_5_5": 18119, + "surface_code_bZ_d5_r05_center_5_5": 18146, + "surface_code_bZ_d5_r07_center_5_5": 18185, + "surface_code_bZ_d5_r09_center_5_5": 18473, + "surface_code_bZ_d5_r11_center_5_5": 18636, + "surface_code_bZ_d5_r13_center_5_5": 18474, + "surface_code_bZ_d5_r15_center_5_5": 17779, + "surface_code_bZ_d5_r17_center_5_5": 18474, + "surface_code_bZ_d5_r19_center_5_5": 17306, + "surface_code_bZ_d5_r21_center_5_5": 17165, + "surface_code_bZ_d5_r23_center_5_5": 18616, + "surface_code_bZ_d5_r25_center_5_5": 17925 + }, + "initial_optimizer_count": 512, + "last_optimizer_count": 2048, + "parent_checkpoint_sha256": "1adc47acc35148d4260df25e25384124609d2b1e098ffcf30a1eccea55ef8712", + "test_data_used": false + }, + "declared_study_plan": { + "hypothesis": "Fresh independent experts with an excluded training partition permit an honest combiner fit and an independent training-period diagnostic", + "experts": [ + { + "name": "reserved1", + "initial_seed": 20261271, + "sampling_seed": 20261272 + }, + { + "name": "reserved2", + "initial_seed": 20261273, + "sampling_seed": 20261274 + } + ], + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "partition": "Per26 d5 conditions:18856 fit,512 combiner,512 diagnostic rows; uniformly random partition seed20261270; sample IDs only check alignment", + "architecture": "Unchanged394-input64-unit neural correction, bound2, fixed physical pass3 priors, exact relevant-CSS contraction", + "training": "Each new expert:512 updates B1024 LR.001 from random initialization;1536 updates LR.0005 restoring own Adam/RNG state. Uniform eligible condition and row sampling, BCE, clip1,AdamW decay1e-4", + "validation_selection": "All26conditions/13durations: main-phase0/512/1024/1536, raw and equal-physical options versus incumbent, then fixed original/new ensembles with physical fractions0/.25/.5. Full replay/contract verification required before publication", + "combiner_expert_selection": "For each new expert and basis, minimum raw full-validation mean failure across0/512/1024/1536; earlier listed checkpoint wins ties. Freeze before using reserved labels", + "combiner_plan": "Fit small regularized syndrome-dependent mixtures using only the512 gate rows/condition. Diagnostic512 rows/condition must not fit or select weights/checkpoints/hyperparameters", + "holdout_prediction_generation": "Both reserved parts predicted without accessing label NPZ members; diagnostics only after final combiner selection is frozen", + "test_data_used": false + }, + "pipeline_control": { + "status": "passed", + "backend": "CPU", + "training_source_sha256": { + "learned_d5__reserved_train.py": "f1789039eb1500b30f716864237b9c564887ccb615f117fb9fb1a0ff15f54ff0", + "learned_d5__reserved_split.py": "69f3d3741a9625b1d70490f45202f101b6cd61b6bf332977559ec14307597456", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_sha256": "0302573e82d5113dfe1f63080b21b6976cc05b2ddb3677a640b005fc6050aa66", + "audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke1", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ad3b3170d682b103f82456476e4a4f7c3096707269b72c242ec43d820dc06856", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 2, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 0, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 0, + "last_optimizer_count": 1, + "parent_checkpoint_sha256": null, + "test_data_used": false + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/reserved_smoke2", + "partition_manifest_sha256": "241221ce16d1d4fc634bdfef691aa2a40d888f6cb75e981485c570905056257b", + "source_sha256": "0b474c57cd4d84ef86c631af7473eac8a956f03b7e4c9859efc1fbf2dbd0bca6", + "training_config_sha256": "ea2e649b4880641cb0c7e7b7a349d4174ce4dd276c4cdbac376e9c087f00ea1f", + "fit_pool": 490256, + "gate_rows_excluded": 13312, + "audit_rows_excluded": 13312, + "sampling_replayed_checkpoints": [ + 1 + ], + "training_draws": 2, + "distinct_phase_training_rows": 2, + "distinct_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 0, + "surface_code_bX_d5_r03_center_5_5": 0, + "surface_code_bX_d5_r05_center_5_5": 0, + "surface_code_bX_d5_r07_center_5_5": 0, + "surface_code_bX_d5_r09_center_5_5": 0, + "surface_code_bX_d5_r11_center_5_5": 0, + "surface_code_bX_d5_r13_center_5_5": 0, + "surface_code_bX_d5_r15_center_5_5": 0, + "surface_code_bX_d5_r17_center_5_5": 0, + "surface_code_bX_d5_r19_center_5_5": 0, + "surface_code_bX_d5_r21_center_5_5": 0, + "surface_code_bX_d5_r23_center_5_5": 0, + "surface_code_bX_d5_r25_center_5_5": 0, + "surface_code_bZ_d5_r01_center_5_5": 0, + "surface_code_bZ_d5_r03_center_5_5": 0, + "surface_code_bZ_d5_r05_center_5_5": 0, + "surface_code_bZ_d5_r07_center_5_5": 0, + "surface_code_bZ_d5_r09_center_5_5": 0, + "surface_code_bZ_d5_r11_center_5_5": 0, + "surface_code_bZ_d5_r13_center_5_5": 0, + "surface_code_bZ_d5_r15_center_5_5": 0, + "surface_code_bZ_d5_r17_center_5_5": 0, + "surface_code_bZ_d5_r19_center_5_5": 0, + "surface_code_bZ_d5_r21_center_5_5": 2, + "surface_code_bZ_d5_r23_center_5_5": 0, + "surface_code_bZ_d5_r25_center_5_5": 0 + }, + "initial_optimizer_count": 1, + "last_optimizer_count": 2, + "parent_checkpoint_sha256": "faf01476f397259640c31a761f9774af9c0592e9118c38ffdce9502acdfcfb31", + "test_data_used": false + } + ], + "initialization_exact": true, + "parameters_updated": true, + "smoke_runs_excluded_from_selection_and_submission": true, + "test_data_used": false + } + } + ], + "training": "All516880 supplied d5 training rows eligible; uniform condition and row sampling with replacement", + "training_shots": 516880, + "distinct_phase_rows": 507134, + "loss": "Conditional logical BCE of two trainable exact-decoder probabilities; responsibilities and the complete expert-confidence gate chain rule scale expert BCE gradients; free gate-logit adjoint is coefficient minus responsibility", + "optimizer": "Separate restored expert AdamW states and fresh gate AdamW; one global norm1 clipping over the full joint gradient, weight_decay1e-4; rates in run_config", + "gate": "41 fixed-scale syndrome/basis/duration features plus two expert clipped logits/8 and their smooth absolute values;45 inputs,32-unit SiLU hidden layer,one free logit,other logit zero;no label/ID/position features;confidence features are fully differentiated", + "validation": "Uniform1024-shot per-condition screens by default, seed20261102; full validation required for checkpoint selection", + "independence": "This joint model uses all training rows; it does not retain the reserved-parent training-label holdout claim", + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.4036223292350769, + "error": 0.2216796875, + "gradient_norm": 0.05712996795773506, + "mean_coefficients": [ + 0.5, + 0.5 + ], + "elapsed": 49.76326084136963 + }, + { + "step": 16, + "loss": 0.33412688970565796, + "error": 0.1513671875, + "gradient_norm": 0.04193934425711632, + "mean_coefficients": [ + 0.48445138335227966, + 0.515548586845398 + ], + "elapsed": 87.89749240875244 + }, + { + "step": 32, + "loss": 0.5103147029876709, + "error": 0.2578125, + "gradient_norm": 0.04149926081299782, + "mean_coefficients": [ + 0.48745596408843994, + 0.5125440359115601 + ], + "elapsed": 109.54462122917175 + }, + { + "step": 48, + "loss": 0.47251832485198975, + "error": 0.2587890625, + "gradient_norm": 0.06802857667207718, + "mean_coefficients": [ + 0.4789726436138153, + 0.5210273265838623 + ], + "elapsed": 130.6331160068512 + }, + { + "step": 64, + "loss": 0.6120781898498535, + "error": 0.3671875, + "gradient_norm": 0.0358138270676136, + "mean_coefficients": [ + 0.4769706130027771, + 0.5230294466018677 + ], + "elapsed": 150.05813884735107 + }, + { + "step": 80, + "loss": 0.554662823677063, + "error": 0.3037109375, + "gradient_norm": 0.056489016860723495, + "mean_coefficients": [ + 0.4823434352874756, + 0.5176565647125244 + ], + "elapsed": 168.34923815727234 + }, + { + "step": 96, + "loss": 0.6412055492401123, + "error": 0.3740234375, + "gradient_norm": 0.039852436631917953, + "mean_coefficients": [ + 0.4712947607040405, + 0.5287052392959595 + ], + "elapsed": 190.58055973052979 + }, + { + "step": 112, + "loss": 0.3109495937824249, + "error": 0.142578125, + "gradient_norm": 0.03886308893561363, + "mean_coefficients": [ + 0.45006707310676575, + 0.5499329566955566 + ], + "elapsed": 213.9315640926361 + }, + { + "step": 128, + "loss": 0.23736454546451569, + "error": 0.0927734375, + "gradient_norm": 0.03215952590107918, + "mean_coefficients": [ + 0.4261288642883301, + 0.5738711357116699 + ], + "elapsed": 231.67947053909302 + }, + { + "step": 144, + "loss": 0.4813973903656006, + "error": 0.2578125, + "gradient_norm": 0.05488501489162445, + "mean_coefficients": [ + 0.3918776512145996, + 0.6081223487854004 + ], + "elapsed": 252.2230739593506 + }, + { + "step": 160, + "loss": 0.3278241753578186, + "error": 0.1474609375, + "gradient_norm": 0.04151356965303421, + "mean_coefficients": [ + 0.39742979407310486, + 0.6025702357292175 + ], + "elapsed": 274.9597041606903 + }, + { + "step": 176, + "loss": 0.5885686874389648, + "error": 0.333984375, + "gradient_norm": 0.03575228154659271, + "mean_coefficients": [ + 0.40967798233032227, + 0.5903220176696777 + ], + "elapsed": 294.3734323978424 + }, + { + "step": 192, + "loss": 0.42112070322036743, + "error": 0.2099609375, + "gradient_norm": 0.04569379612803459, + "mean_coefficients": [ + 0.43145084381103516, + 0.5685491561889648 + ], + "elapsed": 313.2173867225647 + }, + { + "step": 208, + "loss": 0.5783687829971313, + "error": 0.3193359375, + "gradient_norm": 0.042599551379680634, + "mean_coefficients": [ + 0.4513463079929352, + 0.5486536622047424 + ], + "elapsed": 333.7401764392853 + }, + { + "step": 224, + "loss": 0.5515865087509155, + "error": 0.3203125, + "gradient_norm": 0.03869892284274101, + "mean_coefficients": [ + 0.4341263473033905, + 0.5658736228942871 + ], + "elapsed": 351.47052550315857 + }, + { + "step": 240, + "loss": 0.3223426342010498, + "error": 0.146484375, + "gradient_norm": 0.04186154156923294, + "mean_coefficients": [ + 0.43603426218032837, + 0.5639657378196716 + ], + "elapsed": 374.7843656539917 + }, + { + "step": 256, + "loss": 0.14871227741241455, + "error": 0.064453125, + "gradient_norm": 0.023555459454655647, + "mean_coefficients": [ + 0.4506397247314453, + 0.5493602752685547 + ], + "elapsed": 395.3091163635254 + }, + { + "step": 272, + "loss": 0.016909323632717133, + "error": 0.005859375, + "gradient_norm": 0.007026465609669685, + "mean_coefficients": [ + 0.4752832055091858, + 0.524716854095459 + ], + "elapsed": 415.26047015190125 + }, + { + "step": 288, + "loss": 0.03126589581370354, + "error": 0.0107421875, + "gradient_norm": 0.006781043950468302, + "mean_coefficients": [ + 0.48893266916275024, + 0.511067271232605 + ], + "elapsed": 436.30883622169495 + }, + { + "step": 304, + "loss": 0.015056362375617027, + "error": 0.00390625, + "gradient_norm": 0.004392748232930899, + "mean_coefficients": [ + 0.4831840395927429, + 0.5168160200119019 + ], + "elapsed": 455.13061451911926 + }, + { + "step": 320, + "loss": 0.6543328762054443, + "error": 0.3984375, + "gradient_norm": 0.04365016147494316, + "mean_coefficients": [ + 0.4614368677139282, + 0.5385631322860718 + ], + "elapsed": 476.7051467895508 + }, + { + "step": 336, + "loss": 0.43367019295692444, + "error": 0.22265625, + "gradient_norm": 0.05245780572295189, + "mean_coefficients": [ + 0.4564368724822998, + 0.5435631275177002 + ], + "elapsed": 492.2610676288605 + }, + { + "step": 352, + "loss": 0.47127318382263184, + "error": 0.2578125, + "gradient_norm": 0.08501528948545456, + "mean_coefficients": [ + 0.473591685295105, + 0.526408314704895 + ], + "elapsed": 513.9218988418579 + }, + { + "step": 368, + "loss": 0.580036997795105, + "error": 0.333984375, + "gradient_norm": 0.049262672662734985, + "mean_coefficients": [ + 0.47182202339172363, + 0.5281779766082764 + ], + "elapsed": 533.3198461532593 + }, + { + "step": 384, + "loss": 0.22403216361999512, + "error": 0.09375, + "gradient_norm": 0.028693370521068573, + "mean_coefficients": [ + 0.5073230266571045, + 0.4926769733428955 + ], + "elapsed": 550.4840412139893 + }, + { + "step": 400, + "loss": 0.5979220271110535, + "error": 0.3642578125, + "gradient_norm": 0.041639503091573715, + "mean_coefficients": [ + 0.4975281357765198, + 0.502471923828125 + ], + "elapsed": 570.4193587303162 + }, + { + "step": 416, + "loss": 0.543749988079071, + "error": 0.2783203125, + "gradient_norm": 0.04076413810253143, + "mean_coefficients": [ + 0.531822144985199, + 0.468177855014801 + ], + "elapsed": 586.4983899593353 + }, + { + "step": 432, + "loss": 0.4745346009731293, + "error": 0.2529296875, + "gradient_norm": 0.046946220099925995, + "mean_coefficients": [ + 0.5304737091064453, + 0.4695262908935547 + ], + "elapsed": 605.9193391799927 + }, + { + "step": 448, + "loss": 0.6348696947097778, + "error": 0.384765625, + "gradient_norm": 0.03517582267522812, + "mean_coefficients": [ + 0.517922580242157, + 0.482077419757843 + ], + "elapsed": 624.8159971237183 + }, + { + "step": 464, + "loss": 0.020332692191004753, + "error": 0.009765625, + "gradient_norm": 0.006904551759362221, + "mean_coefficients": [ + 0.5102247595787048, + 0.489775151014328 + ], + "elapsed": 645.2841138839722 + }, + { + "step": 480, + "loss": 0.12150688469409943, + "error": 0.0400390625, + "gradient_norm": 0.020669475197792053, + "mean_coefficients": [ + 0.48335233330726624, + 0.5166476964950562 + ], + "elapsed": 665.8179624080658 + }, + { + "step": 496, + "loss": 0.5669726133346558, + "error": 0.3212890625, + "gradient_norm": 0.05334789305925369, + "mean_coefficients": [ + 0.5116512775421143, + 0.48834872245788574 + ], + "elapsed": 686.3218657970428 + }, + { + "step": 512, + "loss": 0.4890466630458832, + "error": 0.2431640625, + "gradient_norm": 0.06109321117401123, + "mean_coefficients": [ + 0.474801242351532, + 0.525198757648468 + ], + "elapsed": 705.7049040794373 + }, + { + "step": 528, + "loss": 0.5006762146949768, + "error": 0.267578125, + "gradient_norm": 0.06276444345712662, + "mean_coefficients": [ + 0.46492671966552734, + 0.5350732803344727 + ], + "elapsed": 739.5815801620483 + }, + { + "step": 544, + "loss": 0.4780537188053131, + "error": 0.2421875, + "gradient_norm": 0.05104239657521248, + "mean_coefficients": [ + 0.4472466707229614, + 0.5527533292770386 + ], + "elapsed": 760.1313257217407 + }, + { + "step": 560, + "loss": 0.5480388402938843, + "error": 0.3125, + "gradient_norm": 0.049343351274728775, + "mean_coefficients": [ + 0.4505765736103058, + 0.5494234561920166 + ], + "elapsed": 779.594918012619 + }, + { + "step": 576, + "loss": 0.16030390560626984, + "error": 0.0615234375, + "gradient_norm": 0.025567732751369476, + "mean_coefficients": [ + 0.4429452121257782, + 0.5570548176765442 + ], + "elapsed": 798.4556517601013 + }, + { + "step": 592, + "loss": 0.31866347789764404, + "error": 0.150390625, + "gradient_norm": 0.049026813358068466, + "mean_coefficients": [ + 0.4401828646659851, + 0.5598171353340149 + ], + "elapsed": 819.5528373718262 + }, + { + "step": 608, + "loss": 0.5188072919845581, + "error": 0.2919921875, + "gradient_norm": 0.04269728437066078, + "mean_coefficients": [ + 0.46529898047447205, + 0.5347009897232056 + ], + "elapsed": 841.7381131649017 + }, + { + "step": 624, + "loss": 0.5420897603034973, + "error": 0.3017578125, + "gradient_norm": 0.07121618837118149, + "mean_coefficients": [ + 0.47779664397239685, + 0.5222033262252808 + ], + "elapsed": 861.1627905368805 + }, + { + "step": 640, + "loss": 0.5146007537841797, + "error": 0.2724609375, + "gradient_norm": 0.04219149798154831, + "mean_coefficients": [ + 0.5096858739852905, + 0.4903140962123871 + ], + "elapsed": 883.9286649227142 + }, + { + "step": 656, + "loss": 0.5478307008743286, + "error": 0.2998046875, + "gradient_norm": 0.04328296333551407, + "mean_coefficients": [ + 0.5128682851791382, + 0.4871317148208618 + ], + "elapsed": 904.9922392368317 + }, + { + "step": 672, + "loss": 0.5807644128799438, + "error": 0.31640625, + "gradient_norm": 0.054511796683073044, + "mean_coefficients": [ + 0.5073788166046143, + 0.49262115359306335 + ], + "elapsed": 928.8545944690704 + }, + { + "step": 688, + "loss": 0.5923843383789062, + "error": 0.33984375, + "gradient_norm": 0.05367732048034668, + "mean_coefficients": [ + 0.5055835247039795, + 0.4944165050983429 + ], + "elapsed": 953.8574857711792 + }, + { + "step": 704, + "loss": 0.6142840385437012, + "error": 0.3232421875, + "gradient_norm": 0.05233320593833923, + "mean_coefficients": [ + 0.5155944228172302, + 0.4844055771827698 + ], + "elapsed": 974.3944721221924 + }, + { + "step": 720, + "loss": 0.027358366176486015, + "error": 0.0087890625, + "gradient_norm": 0.005057512782514095, + "mean_coefficients": [ + 0.5103153586387634, + 0.4896846413612366 + ], + "elapsed": 991.0279428958893 + }, + { + "step": 736, + "loss": 0.01929454132914543, + "error": 0.0048828125, + "gradient_norm": 0.012140742503106594, + "mean_coefficients": [ + 0.48161613941192627, + 0.5183838605880737 + ], + "elapsed": 1014.8423478603363 + }, + { + "step": 752, + "loss": 0.28369730710983276, + "error": 0.1162109375, + "gradient_norm": 0.04357714578509331, + "mean_coefficients": [ + 0.455532044172287, + 0.5444679260253906 + ], + "elapsed": 1035.8887724876404 + }, + { + "step": 768, + "loss": 0.4945949614048004, + "error": 0.2880859375, + "gradient_norm": 0.04213714972138405, + "mean_coefficients": [ + 0.4854201078414917, + 0.5145798921585083 + ], + "elapsed": 1057.482372045517 + }, + { + "step": 784, + "loss": 0.4845636785030365, + "error": 0.2646484375, + "gradient_norm": 0.05959535762667656, + "mean_coefficients": [ + 0.4692148268222809, + 0.5307851433753967 + ], + "elapsed": 1077.914472103119 + }, + { + "step": 800, + "loss": 0.14743395149707794, + "error": 0.0537109375, + "gradient_norm": 0.024860840290784836, + "mean_coefficients": [ + 0.5159314274787903, + 0.4840685725212097 + ], + "elapsed": 1096.1542534828186 + }, + { + "step": 816, + "loss": 0.5364655256271362, + "error": 0.2900390625, + "gradient_norm": 0.04806547239422798, + "mean_coefficients": [ + 0.4568425416946411, + 0.5431574583053589 + ], + "elapsed": 1112.3347380161285 + }, + { + "step": 832, + "loss": 0.6114795207977295, + "error": 0.3603515625, + "gradient_norm": 0.0635693371295929, + "mean_coefficients": [ + 0.4484628736972809, + 0.5515371561050415 + ], + "elapsed": 1132.2765245437622 + }, + { + "step": 848, + "loss": 0.13529735803604126, + "error": 0.05078125, + "gradient_norm": 0.034189604222774506, + "mean_coefficients": [ + 0.5056543350219727, + 0.4943457543849945 + ], + "elapsed": 1155.0370814800262 + }, + { + "step": 864, + "loss": 0.6020858287811279, + "error": 0.37109375, + "gradient_norm": 0.037933457642793655, + "mean_coefficients": [ + 0.5042256712913513, + 0.4957742989063263 + ], + "elapsed": 1173.8644449710846 + }, + { + "step": 880, + "loss": 0.4664004445075989, + "error": 0.244140625, + "gradient_norm": 0.05184689164161682, + "mean_coefficients": [ + 0.4940606355667114, + 0.5059393644332886 + ], + "elapsed": 1196.058119058609 + }, + { + "step": 896, + "loss": 0.3505539298057556, + "error": 0.1796875, + "gradient_norm": 0.04592430219054222, + "mean_coefficients": [ + 0.47500336170196533, + 0.5249966382980347 + ], + "elapsed": 1214.8971903324127 + }, + { + "step": 912, + "loss": 0.5886581540107727, + "error": 0.3447265625, + "gradient_norm": 0.045282669365406036, + "mean_coefficients": [ + 0.41471076011657715, + 0.5852892398834229 + ], + "elapsed": 1233.19801902771 + }, + { + "step": 928, + "loss": 0.6051422357559204, + "error": 0.3408203125, + "gradient_norm": 0.05030329152941704, + "mean_coefficients": [ + 0.4460579752922058, + 0.553942084312439 + ], + "elapsed": 1258.6773264408112 + }, + { + "step": 944, + "loss": 0.3430785536766052, + "error": 0.1611328125, + "gradient_norm": 0.04459737613797188, + "mean_coefficients": [ + 0.5021646618843079, + 0.49783530831336975 + ], + "elapsed": 1280.7998759746552 + }, + { + "step": 960, + "loss": 0.6355323791503906, + "error": 0.3779296875, + "gradient_norm": 0.04846363887190819, + "mean_coefficients": [ + 0.4798702299594879, + 0.5201297402381897 + ], + "elapsed": 1300.8965022563934 + }, + { + "step": 976, + "loss": 0.5717917680740356, + "error": 0.3349609375, + "gradient_norm": 0.036213431507349014, + "mean_coefficients": [ + 0.46208077669143677, + 0.537919282913208 + ], + "elapsed": 1324.139143705368 + }, + { + "step": 992, + "loss": 0.3269951343536377, + "error": 0.1494140625, + "gradient_norm": 0.053097859025001526, + "mean_coefficients": [ + 0.42578503489494324, + 0.5742149353027344 + ], + "elapsed": 1347.369577407837 + }, + { + "step": 1008, + "loss": 0.6329390406608582, + "error": 0.375, + "gradient_norm": 0.03612024337053299, + "mean_coefficients": [ + 0.4536976218223572, + 0.5463024377822876 + ], + "elapsed": 1368.3757274150848 + }, + { + "step": 1024, + "loss": 0.622788667678833, + "error": 0.3798828125, + "gradient_norm": 0.048653967678546906, + "mean_coefficients": [ + 0.4117824137210846, + 0.5882176160812378 + ], + "elapsed": 1388.8368351459503 + }, + { + "step": 1040, + "loss": 0.4211883544921875, + "error": 0.1875, + "gradient_norm": 0.06087575480341911, + "mean_coefficients": [ + 0.4550839960575104, + 0.544916033744812 + ], + "elapsed": 1417.957153558731 + }, + { + "step": 1056, + "loss": 0.5631680488586426, + "error": 0.322265625, + "gradient_norm": 0.055916208773851395, + "mean_coefficients": [ + 0.5335804224014282, + 0.4664195775985718 + ], + "elapsed": 1439.500872850418 + }, + { + "step": 1072, + "loss": 0.108216792345047, + "error": 0.033203125, + "gradient_norm": 0.03527612239122391, + "mean_coefficients": [ + 0.5173947811126709, + 0.4826052188873291 + ], + "elapsed": 1458.3008992671967 + }, + { + "step": 1088, + "loss": 0.5264992117881775, + "error": 0.265625, + "gradient_norm": 0.04225881025195122, + "mean_coefficients": [ + 0.5083321928977966, + 0.49166783690452576 + ], + "elapsed": 1483.1362960338593 + }, + { + "step": 1104, + "loss": 0.4087854027748108, + "error": 0.2109375, + "gradient_norm": 0.03571213036775589, + "mean_coefficients": [ + 0.5122845768928528, + 0.4877154529094696 + ], + "elapsed": 1502.0312390327454 + }, + { + "step": 1120, + "loss": 0.13440972566604614, + "error": 0.0556640625, + "gradient_norm": 0.02237301506102085, + "mean_coefficients": [ + 0.4512101411819458, + 0.5487897992134094 + ], + "elapsed": 1526.364354133606 + }, + { + "step": 1136, + "loss": 0.5450243353843689, + "error": 0.3115234375, + "gradient_norm": 0.06525330990552902, + "mean_coefficients": [ + 0.4614710211753845, + 0.5385289788246155 + ], + "elapsed": 1550.664964914322 + }, + { + "step": 1152, + "loss": 0.305819571018219, + "error": 0.1376953125, + "gradient_norm": 0.045920733362436295, + "mean_coefficients": [ + 0.41365426778793335, + 0.5863457918167114 + ], + "elapsed": 1572.7423918247223 + }, + { + "step": 1168, + "loss": 0.5833675265312195, + "error": 0.33203125, + "gradient_norm": 0.04592693969607353, + "mean_coefficients": [ + 0.4553712010383606, + 0.5446288585662842 + ], + "elapsed": 1596.0391218662262 + }, + { + "step": 1184, + "loss": 0.528708815574646, + "error": 0.275390625, + "gradient_norm": 0.048785146325826645, + "mean_coefficients": [ + 0.5489151477813721, + 0.45108485221862793 + ], + "elapsed": 1616.0237476825714 + }, + { + "step": 1200, + "loss": 0.5420647859573364, + "error": 0.296875, + "gradient_norm": 0.04217496141791344, + "mean_coefficients": [ + 0.45916807651519775, + 0.5408319234848022 + ], + "elapsed": 1633.7869067192078 + }, + { + "step": 1216, + "loss": 0.5781849026679993, + "error": 0.322265625, + "gradient_norm": 0.039233315736055374, + "mean_coefficients": [ + 0.44143176078796387, + 0.5585682392120361 + ], + "elapsed": 1655.9928333759308 + }, + { + "step": 1232, + "loss": 0.026123421266674995, + "error": 0.0107421875, + "gradient_norm": 0.0070108105428516865, + "mean_coefficients": [ + 0.488278329372406, + 0.5117216110229492 + ], + "elapsed": 1675.984426498413 + }, + { + "step": 1248, + "loss": 0.02904634363949299, + "error": 0.0078125, + "gradient_norm": 0.009644721634685993, + "mean_coefficients": [ + 0.49334973096847534, + 0.5066503286361694 + ], + "elapsed": 1694.2655746936798 + }, + { + "step": 1264, + "loss": 0.5827265381813049, + "error": 0.3291015625, + "gradient_norm": 0.06638327240943909, + "mean_coefficients": [ + 0.5088695287704468, + 0.49113044142723083 + ], + "elapsed": 1715.3726058006287 + }, + { + "step": 1280, + "loss": 0.3117225468158722, + "error": 0.14453125, + "gradient_norm": 0.039189379662275314, + "mean_coefficients": [ + 0.424649715423584, + 0.575350284576416 + ], + "elapsed": 1736.4227755069733 + }, + { + "step": 1296, + "loss": 0.5949872732162476, + "error": 0.357421875, + "gradient_norm": 0.03425392135977745, + "mean_coefficients": [ + 0.44115158915519714, + 0.5588484406471252 + ], + "elapsed": 1756.3223190307617 + }, + { + "step": 1312, + "loss": 0.36037731170654297, + "error": 0.16796875, + "gradient_norm": 0.05413590371608734, + "mean_coefficients": [ + 0.41624122858047485, + 0.5837587714195251 + ], + "elapsed": 1781.1879160404205 + }, + { + "step": 1328, + "loss": 0.13597947359085083, + "error": 0.0478515625, + "gradient_norm": 0.024408109486103058, + "mean_coefficients": [ + 0.39792561531066895, + 0.602074384689331 + ], + "elapsed": 1803.326646566391 + }, + { + "step": 1344, + "loss": 0.5115143060684204, + "error": 0.2822265625, + "gradient_norm": 0.05343877524137497, + "mean_coefficients": [ + 0.4039475619792938, + 0.5960524678230286 + ], + "elapsed": 1820.527043581009 + }, + { + "step": 1360, + "loss": 0.6190681457519531, + "error": 0.3779296875, + "gradient_norm": 0.04025372490286827, + "mean_coefficients": [ + 0.3999170660972595, + 0.6000829935073853 + ], + "elapsed": 1837.7727808952332 + }, + { + "step": 1376, + "loss": 0.2115240842103958, + "error": 0.08984375, + "gradient_norm": 0.04224822670221329, + "mean_coefficients": [ + 0.4782406687736511, + 0.5217593312263489 + ], + "elapsed": 1856.6197447776794 + }, + { + "step": 1392, + "loss": 0.01897607557475567, + "error": 0.0087890625, + "gradient_norm": 0.005255325231701136, + "mean_coefficients": [ + 0.49148452281951904, + 0.508515477180481 + ], + "elapsed": 1878.7961161136627 + }, + { + "step": 1408, + "loss": 0.6291846036911011, + "error": 0.373046875, + "gradient_norm": 0.036440156400203705, + "mean_coefficients": [ + 0.513500452041626, + 0.486499547958374 + ], + "elapsed": 1899.898497581482 + }, + { + "step": 1424, + "loss": 0.5362213253974915, + "error": 0.294921875, + "gradient_norm": 0.0612572506070137, + "mean_coefficients": [ + 0.4535876214504242, + 0.5464123487472534 + ], + "elapsed": 1920.4266550540924 + }, + { + "step": 1440, + "loss": 0.13184919953346252, + "error": 0.0537109375, + "gradient_norm": 0.03664940968155861, + "mean_coefficients": [ + 0.4659469425678253, + 0.5340530872344971 + ], + "elapsed": 1943.2025790214539 + }, + { + "step": 1456, + "loss": 0.1234961748123169, + "error": 0.044921875, + "gradient_norm": 0.02656761184334755, + "mean_coefficients": [ + 0.3433038592338562, + 0.6566961407661438 + ], + "elapsed": 1960.9652829170227 + }, + { + "step": 1472, + "loss": 0.13811054825782776, + "error": 0.0615234375, + "gradient_norm": 0.026958489790558815, + "mean_coefficients": [ + 0.5041490793228149, + 0.49585089087486267 + ], + "elapsed": 1982.5899024009705 + }, + { + "step": 1488, + "loss": 0.1384657323360443, + "error": 0.0537109375, + "gradient_norm": 0.03001009114086628, + "mean_coefficients": [ + 0.4110681414604187, + 0.5889318585395813 + ], + "elapsed": 2001.9230613708496 + }, + { + "step": 1504, + "loss": 0.5583388805389404, + "error": 0.310546875, + "gradient_norm": 0.049438849091529846, + "mean_coefficients": [ + 0.5016011595726013, + 0.4983988404273987 + ], + "elapsed": 2024.014773607254 + }, + { + "step": 1520, + "loss": 0.4180654287338257, + "error": 0.193359375, + "gradient_norm": 0.04933231323957443, + "mean_coefficients": [ + 0.38047677278518677, + 0.619523286819458 + ], + "elapsed": 2045.5694217681885 + }, + { + "step": 1536, + "loss": 0.5738208293914795, + "error": 0.3359375, + "gradient_norm": 0.040103811770677567, + "mean_coefficients": [ + 0.38509148359298706, + 0.6149084568023682 + ], + "elapsed": 2068.2303218841553 + }, + { + "step": 1552, + "loss": 0.1515752375125885, + "error": 0.0625, + "gradient_norm": 0.025591658428311348, + "mean_coefficients": [ + 0.467977374792099, + 0.5320225954055786 + ], + "elapsed": 2096.348117351532 + }, + { + "step": 1568, + "loss": 0.36540937423706055, + "error": 0.1796875, + "gradient_norm": 0.047427255660295486, + "mean_coefficients": [ + 0.3580866754055023, + 0.6419132947921753 + ], + "elapsed": 2115.137165784836 + }, + { + "step": 1584, + "loss": 0.6101622581481934, + "error": 0.36328125, + "gradient_norm": 0.06318912655115128, + "mean_coefficients": [ + 0.37807729840278625, + 0.6219227313995361 + ], + "elapsed": 2135.0769436359406 + }, + { + "step": 1600, + "loss": 0.5122940540313721, + "error": 0.271484375, + "gradient_norm": 0.048690538853406906, + "mean_coefficients": [ + 0.45286378264427185, + 0.5471362471580505 + ], + "elapsed": 2158.3224182128906 + }, + { + "step": 1616, + "loss": 0.4213346242904663, + "error": 0.2177734375, + "gradient_norm": 0.04104650765657425, + "mean_coefficients": [ + 0.4934980869293213, + 0.5065019130706787 + ], + "elapsed": 2177.1882932186127 + }, + { + "step": 1632, + "loss": 0.5365848541259766, + "error": 0.3017578125, + "gradient_norm": 0.03759608417749405, + "mean_coefficients": [ + 0.5423836708068848, + 0.4576163589954376 + ], + "elapsed": 2197.6926758289337 + }, + { + "step": 1648, + "loss": 0.5968635082244873, + "error": 0.353515625, + "gradient_norm": 0.04261911287903786, + "mean_coefficients": [ + 0.5572072863578796, + 0.44279271364212036 + ], + "elapsed": 2216.004762172699 + }, + { + "step": 1664, + "loss": 0.0162962693721056, + "error": 0.0048828125, + "gradient_norm": 0.009088750928640366, + "mean_coefficients": [ + 0.508819580078125, + 0.491180419921875 + ], + "elapsed": 2239.915328025818 + }, + { + "step": 1680, + "loss": 0.475721150636673, + "error": 0.248046875, + "gradient_norm": 0.046967294067144394, + "mean_coefficients": [ + 0.5249752998352051, + 0.4750247001647949 + ], + "elapsed": 2259.9213016033173 + }, + { + "step": 1696, + "loss": 0.6343687772750854, + "error": 0.390625, + "gradient_norm": 0.038217853754758835, + "mean_coefficients": [ + 0.5429720878601074, + 0.45702797174453735 + ], + "elapsed": 2281.536628007889 + }, + { + "step": 1712, + "loss": 0.1417185217142105, + "error": 0.0537109375, + "gradient_norm": 0.03146106377243996, + "mean_coefficients": [ + 0.4240075349807739, + 0.5759924650192261 + ], + "elapsed": 2302.0118980407715 + }, + { + "step": 1728, + "loss": 0.43767619132995605, + "error": 0.2236328125, + "gradient_norm": 0.04500988498330116, + "mean_coefficients": [ + 0.5534324645996094, + 0.4465675354003906 + ], + "elapsed": 2320.4027025699615 + }, + { + "step": 1744, + "loss": 0.385886549949646, + "error": 0.189453125, + "gradient_norm": 0.047172464430332184, + "mean_coefficients": [ + 0.5362986922264099, + 0.4637013077735901 + ], + "elapsed": 2340.944346189499 + }, + { + "step": 1760, + "loss": 0.026525381952524185, + "error": 0.0078125, + "gradient_norm": 0.007969392463564873, + "mean_coefficients": [ + 0.5239819884300232, + 0.4760180115699768 + ], + "elapsed": 2364.2342314720154 + }, + { + "step": 1776, + "loss": 0.02684444561600685, + "error": 0.0087890625, + "gradient_norm": 0.008620208129286766, + "mean_coefficients": [ + 0.505234956741333, + 0.49476510286331177 + ], + "elapsed": 2382.5404546260834 + }, + { + "step": 1792, + "loss": 0.43624019622802734, + "error": 0.2236328125, + "gradient_norm": 0.05820999667048454, + "mean_coefficients": [ + 0.47588345408439636, + 0.5241165161132812 + ], + "elapsed": 2400.247804880142 + }, + { + "step": 1808, + "loss": 0.5943660736083984, + "error": 0.361328125, + "gradient_norm": 0.06795281171798706, + "mean_coefficients": [ + 0.470124751329422, + 0.5298752784729004 + ], + "elapsed": 2420.775459051132 + }, + { + "step": 1824, + "loss": 0.4362870454788208, + "error": 0.216796875, + "gradient_norm": 0.07399562746286392, + "mean_coefficients": [ + 0.37969398498535156, + 0.6203060150146484 + ], + "elapsed": 2440.1737010478973 + }, + { + "step": 1840, + "loss": 0.3196547031402588, + "error": 0.1494140625, + "gradient_norm": 0.0555063858628273, + "mean_coefficients": [ + 0.34116512537002563, + 0.6588348746299744 + ], + "elapsed": 2459.6450209617615 + }, + { + "step": 1856, + "loss": 0.3750680088996887, + "error": 0.1826171875, + "gradient_norm": 0.07091590762138367, + "mean_coefficients": [ + 0.3328593373298645, + 0.6671406626701355 + ], + "elapsed": 2481.8535311222076 + }, + { + "step": 1872, + "loss": 0.1499752402305603, + "error": 0.0615234375, + "gradient_norm": 0.03735237568616867, + "mean_coefficients": [ + 0.45258277654647827, + 0.547417163848877 + ], + "elapsed": 2499.1260933876038 + }, + { + "step": 1888, + "loss": 0.4416336417198181, + "error": 0.2265625, + "gradient_norm": 0.07852961122989655, + "mean_coefficients": [ + 0.3772684335708618, + 0.6227315664291382 + ], + "elapsed": 2520.7669806480408 + }, + { + "step": 1904, + "loss": 0.44372808933258057, + "error": 0.2158203125, + "gradient_norm": 0.0635901540517807, + "mean_coefficients": [ + 0.4829699993133545, + 0.5170300006866455 + ], + "elapsed": 2541.8811144828796 + }, + { + "step": 1920, + "loss": 0.49325892329216003, + "error": 0.25, + "gradient_norm": 0.05905412510037422, + "mean_coefficients": [ + 0.4928499460220337, + 0.5071500539779663 + ], + "elapsed": 2560.2098133563995 + }, + { + "step": 1936, + "loss": 0.6059773564338684, + "error": 0.37109375, + "gradient_norm": 0.04938071221113205, + "mean_coefficients": [ + 0.500090479850769, + 0.49990957975387573 + ], + "elapsed": 2584.084639310837 + }, + { + "step": 1952, + "loss": 0.4812850058078766, + "error": 0.248046875, + "gradient_norm": 0.057975947856903076, + "mean_coefficients": [ + 0.5330917835235596, + 0.4669082760810852 + ], + "elapsed": 2601.8387653827667 + }, + { + "step": 1968, + "loss": 0.09479217231273651, + "error": 0.033203125, + "gradient_norm": 0.026396002620458603, + "mean_coefficients": [ + 0.40904074907302856, + 0.5909592509269714 + ], + "elapsed": 2624.566103696823 + }, + { + "step": 1984, + "loss": 0.4216373562812805, + "error": 0.1982421875, + "gradient_norm": 0.051009174436330795, + "mean_coefficients": [ + 0.41901540756225586, + 0.5809845924377441 + ], + "elapsed": 2648.4207508563995 + }, + { + "step": 2000, + "loss": 0.14940249919891357, + "error": 0.0673828125, + "gradient_norm": 0.026154836639761925, + "mean_coefficients": [ + 0.5412362813949585, + 0.4587636888027191 + ], + "elapsed": 2665.051350593567 + }, + { + "step": 2016, + "loss": 0.02241397276520729, + "error": 0.0068359375, + "gradient_norm": 0.009612033143639565, + "mean_coefficients": [ + 0.5494938492774963, + 0.45050618052482605 + ], + "elapsed": 2687.8019590377808 + }, + { + "step": 2032, + "loss": 0.5801632404327393, + "error": 0.32421875, + "gradient_norm": 0.06857500970363617, + "mean_coefficients": [ + 0.5887697339057922, + 0.41123026609420776 + ], + "elapsed": 2710.038647174835 + }, + { + "step": 2048, + "loss": 0.3091006278991699, + "error": 0.1357421875, + "gradient_norm": 0.04302384331822395, + "mean_coefficients": [ + 0.40432390570640564, + 0.595676064491272 + ], + "elapsed": 2729.4878153800964 + } + ], + "seconds": 2740.104104042053, + "declared_plan": { + "hypothesis": "Adding fully differentiated expert confidence may let the jointly trained gate use complementary expert certainty beyond syndrome density and history alone", + "parents": [ + "fresh2_full/weights-1536.npz", + "reserved1_full/weights-1536.npz" + ], + "initialization": "Same session-trained parents and exact Adam states as joint_mixture1; same gate seed20261310 preserves its41input hidden weights; append4zero input rows; zero output gives same initial equal mixture", + "features": "Existing41syndrome/basis/duration features plus clipped logits/8 for each expert and sqrt(z^2+1e-4) for each;clip probabilities to[1e-6,1-1e-6] and logit to[-8,8];45inputs,32SiLU hidden;shot-local,label-free,ID-free,fixedscales;full derivative through predictions", + "loss": "Stable mixture BCE; total multiplier on expert BCE gradient is responsibility+(1-2*y)*exp(-expert_BCE)*(gate-only derivative dL/dq); all prediction-to-gate paths differentiated; labels used only in loss", + "training": "Matched joint_mixture1:2048updates B1024;seed20261311 yields same uniform draws over516880rows/26conditions;expertLR.0001,gateLR.001;separate restored expert Adam clocks,fresh gate Adam;globalnorm1,decay1e-4", + "selection_steps": [ + 0, + 512, + 1024, + 2048 + ], + "validation": "Full133120 supplied validation shots per listed checkpoint; perbasis choose incumbent or rawjoint/equalphysical,all13durations; tiesretainincumbent. Step0 is fixedmean of trainedparents.1536has screening only and is not a full-selection checkpoint.", + "audit_scope": "All training labels are eligible; no independent reserved-training-label audit claim. Parent initialization provenance retained.", + "controls": "CPU scalar finite differences/exact autodiff with nonzero confidence couplings passed;two1update CPU restoration/sampling audit passed;four-case portable CPU runtime passed (order/subsets/delegation exact,independent mixture max5.96e-8,CPU priors vs GPUcache max3.58e-7);actual GPUcontrol still required before training; composed joint->robust->confidence CPU runtime passed after using distinct confidence cache attributes; actual joint/robust sources unchanged; constructed joint->logicalresidual->confidence CPU runtime also passed retained paths/order/distinct caches", + "runtime": "Two exact neural passes share one physical-prior computation; preserve all retained incumbent dispatches;fullreplay/scoring/readonlyrelocation/projection before any publication", + "interpretation": "Matched recipe extension; no physical-regime identification or independent reserved-label audit claim", + "gpu": "One H100; serialized after completed branch verification", + "test_data_used": false, + "parameter_counts": { + "expert0": 29505, + "expert1": 29505, + "gate": 1505, + "total": 60515 + }, + "physical_blend_clarification_before_training": "Equal physical blends use the existing calibrated/ensemble physical pass3 decoder output from turbo1/predictions, checked against runtime config and DEM/plans/weights. Raw feedback5_cache pass3 is only the neural conditioning prior/diagnostic. Corrected before any GPU training or selection in this study.", + "status": "Launched after fixed branch extraction verification", + "queued_utc": "2026-10-21T16:04:11.785757+00:00", + "launch_rationale": "Fixed branch diagnostics show modest, basis-dependent gate gains and a stronger individual Zexpert. The previously prepared matched confidence-input extension tests whether the gate can better use expert certainty. Recipe and selection checkpoints remain unchanged.", + "launch_utc": "2026-10-21T16:11:35.399436+00:00" + }, + "sampling_audit": { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/confidence_joint1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 512, + 1024, + 1536, + 2048 + ], + "training_draws": 2097152, + "distinct_phase_rows": 507134, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 4096, + "expert1": 4096, + "gate": 2048 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + "pipeline_control": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 runs; no selection or submission", + "expert_parent_state_exact": true, + "new_gate_initialization_exact": true, + "new_gate_zero_adam": true, + "all_three_parts_updated": true, + "resume_weights_optimizer_rng_exact": true, + "sampling_audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/confidence_joint_smoke1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/confidence_joint_smoke2", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "final_adam_counts": { + "expert0": 2050, + "expert1": 2050, + "gate": 2 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + } + ], + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__confidence_joint.py": "c597e7b57876691b10f66f267a5d2f33bf1329982b68090473ddaf680fecf39b", + "learned_d5__confidence_joint_gradient.py": "6a4e537d18316f58f5e9aa12add65543bb71fea8f46cdded26d3dbe1fb021836", + "learned_d5__confidence_joint_state.py": "13306f1821b73b02b3ba6e2d61800f7c593e7201ac0121c61e3126504d573be9", + "learned_d5__confidence_joint_train.py": "e8183406d073286498f14d3c0c9904a08b69b781d650e8bcd9a2666d3099c1f0", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "source_sha256": "770b196571071f6c91f341fb576689db0e18351b38318a7b7ac663bccfdaa1a6" + }, + "matched_joint_comparison": { + "status": "passed", + "reference": "joint_mixture1", + "sampling_states": { + "0": true, + "512": true, + "1024": true, + "1536": true, + "2048": true + }, + "scope": "Same parent weights and Adam states, expert/gate learning rates,41-row hidden initialization, seeds and draw sequence;45-input gate and complete confidence derivative are the intended changes" + } + }, + "controls": { + "confidence_joint_control_cpu.json": { + "status": "passed", + "device": "CPU", + "optimizer_updates": 0, + "purpose": "Discarded synthetic controls for an untrained, unqueued prototype; no fitting or checkpoint selection.", + "initialization": "Original 41 feature rows and all other parameters exact; four added rows zero; initial equal mixture.", + "scalar_finite_difference_max_abs_error": 6.239920212480765e-11, + "scalar_autodiff_max_abs_error": 2.7755575615628914e-17, + "scalar_gate_autodiff_max_abs_error": 2.220446049250313e-16, + "scalar_gate_prediction_adjoint_l2": 32.33065557711948, + "confidence_subset_and_order_exact": true, + "exact_chain_relative_l2_error": 2.5672075025795493e-06, + "exact_loss_abs_error": 0.0, + "omitted_confidence_path_relative_l2_error": 0.0026213880628347397, + "source_sha256": { + "confidence_joint.py": "c597e7b57876691b10f66f267a5d2f33bf1329982b68090473ddaf680fecf39b", + "confidence_joint_gradient.py": "6a4e537d18316f58f5e9aa12add65543bb71fea8f46cdded26d3dbe1fb021836", + "confidence_joint_control.py": "8919a60518c3cd57798d467c447a28656e47db3de8062f30c20f6160eabac7c7" + } + }, + "confidence_joint_control_gpu.json": { + "status": "passed", + "device": "cuda:0", + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 2, + "gradient_relative_l2_error": 1.108649121306371e-05, + "loss_abs_error": 6.51925802230835e-08, + "neutral_mixture_max_abs_error": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 2, + "gradient_relative_l2_error": 1.009340394375613e-05, + "loss_abs_error": 1.7881393432617188e-07, + "neutral_mixture_max_abs_error": 1.1920928955078125e-07 + } + ], + "control_parameters": "Session-trained parents with synthetic nonzero confidence/output gate couplings; discarded, never used for training or selection", + "optimizer_updates": 0, + "test_data_used": false, + "source_sha256": { + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "confidence_joint.py": "c597e7b57876691b10f66f267a5d2f33bf1329982b68090473ddaf680fecf39b", + "confidence_joint_gradient.py": "6a4e537d18316f58f5e9aa12add65543bb71fea8f46cdded26d3dbe1fb021836", + "confidence_joint_state.py": "13306f1821b73b02b3ba6e2d61800f7c593e7201ac0121c61e3126504d573be9", + "model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "confidence_joint_gpu_control.py": "c98e8fd43b52d72ae14b013c8cb6bb761da1a39942c23fa7f9a9288c57710e54" + } + }, + "confidence_joint_pipeline_control_cpu.json": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 runs; no selection or submission", + "expert_parent_state_exact": true, + "new_gate_initialization_exact": true, + "new_gate_zero_adam": true, + "all_three_parts_updated": true, + "resume_weights_optimizer_rng_exact": true, + "sampling_audits": [ + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/confidence_joint_smoke1", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2048, + "expert1": 2048, + "gate": 0 + }, + "final_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + }, + { + "status": "passed", + "run": "/run-state/workspace/research/learned_d5/confidence_joint_smoke2", + "eligible_training_rows": 516880, + "sampling_replayed_checkpoints": [ + 0, + 1 + ], + "training_draws": 2, + "distinct_phase_rows": 2, + "initial_adam_counts": { + "expert0": 2049, + "expert1": 2049, + "gate": 1 + }, + "final_adam_counts": { + "expert0": 2050, + "expert1": 2050, + "gate": 2 + }, + "source_sha256": "8ecd75bc07d69f5077c96efcec519c33faf4245bb331860120c8c0550165c625" + } + ], + "parent_records": [ + { + "part": "expert0", + "weights": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "optimizer": "/run-state/workspace/research/learned_d5/fresh2_full/optimizer-1536.npz", + "optimizer_sha256": "ebd3d11cf11c9cd7e262e15695c3ec0ac227c1b9688d781f3d13e3ae6f98d00b", + "initial_adam_count": 2048, + "moments_restored": true + }, + { + "part": "expert1", + "weights": "/run-state/workspace/research/learned_d5/reserved1_full/weights-1536.npz", + "weights_sha256": "65a762bc0623024c3fbc416ff5df00d8ea275f6c7d691a54c6e0492f459a362f", + "optimizer": "/run-state/workspace/research/learned_d5/reserved1_full/optimizer-1536.npz", + "optimizer_sha256": "b8c13e9f941a0b89696d5eb79c8396a8870bcb80cf4f11b69854f52de0c3a22a", + "initial_adam_count": 2048, + "moments_restored": true + } + ], + "training_source_sha256": { + "learned_d5__joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "learned_d5__confidence_joint.py": "c597e7b57876691b10f66f267a5d2f33bf1329982b68090473ddaf680fecf39b", + "learned_d5__confidence_joint_gradient.py": "6a4e537d18316f58f5e9aa12add65543bb71fea8f46cdded26d3dbe1fb021836", + "learned_d5__confidence_joint_state.py": "13306f1821b73b02b3ba6e2d61800f7c593e7201ac0121c61e3126504d573be9", + "learned_d5__confidence_joint_train.py": "e8183406d073286498f14d3c0c9904a08b69b781d650e8bcd9a2666d3099c1f0", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "source_sha256": "770b196571071f6c91f341fb576689db0e18351b38318a7b7ac663bccfdaa1a6" + }, + "confidence_joint_runtime_control_cpu.json": { + "status": "passed", + "device": "CPU", + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 1, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 0.0, + "cpu_recompute_vs_gpu_cached_max_abs_error": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 3, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 2.9103830456733704e-11, + "cpu_recompute_vs_gpu_cached_max_abs_error": 0.0 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 0.0, + "cpu_recompute_vs_gpu_cached_max_abs_error": 4.307366907596588e-09 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "old_path_exact": true, + "subset_order_exact": true, + "independent_mixture_max_abs_error": 5.960464477539063e-08, + "cpu_recompute_vs_gpu_cached_max_abs_error": 3.5762786865234375e-07 + } + ], + "weights": "Discarded two-update pipeline control, excluded from selection/submission", + "source_sha256": { + "confidence_joint.py": "c597e7b57876691b10f66f267a5d2f33bf1329982b68090473ddaf680fecf39b", + "confidence_joint_gradient.py": "6a4e537d18316f58f5e9aa12add65543bb71fea8f46cdded26d3dbe1fb021836", + "confidence_joint_contextual.py": "3d2c62eda6cc837b5c6b381d6d769f3bc5a6e7d35450bcf0152b3a7ee2c57471" + }, + "previous_runtime_sha256": "8e3274896738f9dca23812b59676dcf3f96d15167a83702ee88a335af71ce2d1" + }, + "confidence_joint_composed_control_cpu.json": { + "status": "passed", + "device": "CPU", + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "retained_joint_and_robust_paths_exact": true, + "confidence_order_exact": true, + "distinct_runtime_caches": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "retained_joint_and_robust_paths_exact": true, + "confidence_order_exact": true, + "distinct_runtime_caches": true + } + ], + "scope": "Discarded smoke weights; constructed wrapper chain exercises retained joint and robust configurations even if neither publishes. No training/selection.", + "fix": "Use confidence_infer/confidence_weights, leaving inherited joint_infer/joint_weights intact.", + "source_sha256": { + "joint_mixture_contextual.py": "76c4f2ad404018ab18e3919fc46c4983110cd336133f09551dce4e94ad7021ca", + "robust_loss_contextual.py": "a66ab4137bd1489d8adfb98f8a9f5e42bde4d808308f5d58111b1214c3cabac2", + "confidence_joint_contextual.py": "3d2c62eda6cc837b5c6b381d6d769f3bc5a6e7d35450bcf0152b3a7ee2c57471", + "confidence_joint_composed_control.py": "a3d0fea6d4e09f1dbe510effc0a34f586845e783225fc0b06f2ab41615b60ca4" + } + }, + "confidence_logical_composed_control_cpu.json": { + "status": "passed", + "device": "CPU", + "cases": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 3, + "retained_residual_reference_and_neural_paths_exact": true, + "residual_order_exact": true, + "distinct_caches": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 3, + "retained_residual_reference_and_neural_paths_exact": true, + "residual_order_exact": true, + "distinct_caches": true + } + ], + "scope": "Discarded smoke weights in a constructed runtime chain; no candidate training or selection.", + "previous_package": "/run-state/workspace/research/context_upgrades/fresh_temporal1_swa_ensemble/package", + "source_sha256": { + "confidence_joint_contextual.py": "3d2c62eda6cc837b5c6b381d6d769f3bc5a6e7d35450bcf0152b3a7ee2c57471", + "confidence_logical_composed_control.py": "14dd60d8203a29f017456fce628df20c6b06c18f308a1177ad6ad67af1c1d156" + }, + "residual_source_sha256": { + "model.py": "f8f2e5ea8babf36152e2144e661e6272115908dff1abb1690ad103d1880b7d60", + "contextual.py": "04f554eb056da34bd780b465449b2c56d0d820cb8b3aa122e467c948b232d77d" + } + } + }, + "test_data_used": false + }, + "prior_pass1": { + "declared_plan": { + "name": "prior_pass1", + "status": "Launched after posterior-context study; actual current-runtime GPU control passed", + "hypothesis": "The edge correction learned with three physical feedback passes may benefit from adaptation to five-pass priors. A matched three-pass continuation distinguishes prior quality from additional optimization on the smaller cached training pool.", + "parent": "learned_d5/fresh2_full/weights-1536.npz", + "initialization": "Both arms start from the same session-trained parent, originally random seed20261134. Restore all parameters and Adam moments/count2048. No new parameters. Explicitly reset sampling RNG to20261400 in each arm.", + "training_rows": "The same existing4096 training rows per each of all26d5conditions,106496eligible rows. Cached indices were sampled without replacement using seed20261023. They are previously used training rows, not held-out labels.", + "arms": [ + 3, + 5 + ], + "steps": 512, + "batch": 1024, + "learning_rate": 0.0001, + "sampling_seed": 20261400, + "optimizer": "AdamW decay1e-4, global gradient norm clipping1, restored parent state", + "loss": "Uniform conditional logical BCE through exact relevant-CSS contraction; cached physical priors fixed", + "selection": "Raw pass3 checkpoints256/512 and raw pass5 checkpoints0/256/512 versus current incumbent, separately perbasis over all13durations. Ties retain incumbent. Parent pass3 full predictions already exist and are reused for the scientific comparison; no confirmation retraining or new pass3-zero selection.", + "selection_steps": { + "3": [ + 256, + 512 + ], + "5": [ + 0, + 256, + 512 + ] + }, + "screen": "1024 validation rows percondition with existing seed20261102; screen does not add selection candidates", + "runtime": "Existing raw neural runtime already supports prior_pass5. No new wrapper is needed. Actual replay must include all five physical passes and satisfy projected3600s limit.", + "controls": "Training-only cache alignment and hash audit; short discarded CPU pipeline runs for both arms; restored-state and complete sampling replay; current-runtime CPU check and actual assembled-runtime GPU check after predecessor finishes", + "selection_declared_before_new_pass5_neural_evaluation": true, + "test_data_used": false, + "prepared_utc": "2026-10-21T16:40:08.094485+00:00", + "frozen_source_sha256": { + "prior_pass_study/after_posterior.py": "1cadb20b1fe4ead41f00baebb62541167ab6e8b916b5bb02fe6cacadbc4502d7", + "prior_pass_study/package.py": "f9915505bac8c81a402f23a7dcf06b5278dfb06b418a0cc25c48797a141cfc73", + "prior_pass_study/cpu_smoke.py": "9f7ee28f797ca46ff403f6af1836596664988e8414de60b0f792c86c2b2ca3b1", + "prior_pass_study/runtime_control.py": "06e725750085d90d1bba1e4ebfd49557f2c19787946614325064e648a011de20", + "prior_pass_study/audit_run.py": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da", + "prior_pass_study/cache_audit.py": "6a6f34061e048af6e5e7bedcdbe124aeee64c324bf69e482c45b10c2e92f2b5e", + "learned_d5/evaluate.py": "647c7e3964d8def7948c105f49c31a7237f99e32272ab45388a3ed6069b0cf9b" + }, + "launch_utc": "2026-10-21T17:40:38.975372+00:00" + }, + "selection_history": [ + { + "basis": "X", + "group": "d5_bX_center_5_5", + "candidates": { + "incumbent": 0.23158052884615385, + "pass3-256": 0.23311298076923076, + "pass3-512": 0.23330829326923075, + "pass5-0": 0.2325721153846154, + "pass5-256": 0.23294771634615385, + "pass5-512": 0.23315805288461539 + }, + "selected": "incumbent" + }, + { + "basis": "Z", + "group": "d5_bZ_center_5_5", + "candidates": { + "incumbent": 0.21918569711538466, + "pass3-256": 0.22046274038461539, + "pass3-512": 0.220537860576923, + "pass5-0": 0.21915564903846152, + "pass5-256": 0.21935096153846154, + "pass5-512": 0.21989182692307693 + }, + "selected": "pass5-0" + } + ], + "selected_checkpoints": { + "pass5-0": { + "step": 0, + "training_samples": 0, + "unique_training_rows_seen_in_this_phase": 0, + "weights_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "complete": true + } + }, + "training": { + "3": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "training_cache": null, + "training_cache_provenance": null, + "training_shots": 106496, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 105004, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 3939, + "surface_code_bX_d5_r03_center_5_5": 4010, + "surface_code_bX_d5_r05_center_5_5": 4060, + "surface_code_bX_d5_r07_center_5_5": 3935, + "surface_code_bX_d5_r09_center_5_5": 4092, + "surface_code_bX_d5_r11_center_5_5": 4073, + "surface_code_bX_d5_r13_center_5_5": 4033, + "surface_code_bX_d5_r15_center_5_5": 4095, + "surface_code_bX_d5_r17_center_5_5": 4073, + "surface_code_bX_d5_r19_center_5_5": 4089, + "surface_code_bX_d5_r21_center_5_5": 4080, + "surface_code_bX_d5_r23_center_5_5": 4075, + "surface_code_bX_d5_r25_center_5_5": 4086, + "surface_code_bZ_d5_r01_center_5_5": 4086, + "surface_code_bZ_d5_r03_center_5_5": 3973, + "surface_code_bZ_d5_r05_center_5_5": 4051, + "surface_code_bZ_d5_r07_center_5_5": 3978, + "surface_code_bZ_d5_r09_center_5_5": 3994, + "surface_code_bZ_d5_r11_center_5_5": 4082, + "surface_code_bZ_d5_r13_center_5_5": 4088, + "surface_code_bZ_d5_r15_center_5_5": 3829, + "surface_code_bZ_d5_r17_center_5_5": 4008, + "surface_code_bZ_d5_r19_center_5_5": 4046, + "surface_code_bZ_d5_r21_center_5_5": 4086, + "surface_code_bZ_d5_r23_center_5_5": 4057, + "surface_code_bZ_d5_r25_center_5_5": 4086 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.0001, + "sampling_seed": 20261400, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": true, + "sampling_state_source": "Fresh NumPy default_rng seed 20261400", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "starting_checkpoint_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "starting_training_provenance": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 491030, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18670, + "surface_code_bX_d5_r03_center_5_5": 18940, + "surface_code_bX_d5_r05_center_5_5": 19128, + "surface_code_bX_d5_r07_center_5_5": 18988, + "surface_code_bX_d5_r09_center_5_5": 18523, + "surface_code_bX_d5_r11_center_5_5": 19227, + "surface_code_bX_d5_r13_center_5_5": 18816, + "surface_code_bX_d5_r15_center_5_5": 18107, + "surface_code_bX_d5_r17_center_5_5": 18728, + "surface_code_bX_d5_r19_center_5_5": 18983, + "surface_code_bX_d5_r21_center_5_5": 18959, + "surface_code_bX_d5_r23_center_5_5": 19079, + "surface_code_bX_d5_r25_center_5_5": 19193, + "surface_code_bZ_d5_r01_center_5_5": 18828, + "surface_code_bZ_d5_r03_center_5_5": 18896, + "surface_code_bZ_d5_r05_center_5_5": 19011, + "surface_code_bZ_d5_r07_center_5_5": 18806, + "surface_code_bZ_d5_r09_center_5_5": 18268, + "surface_code_bZ_d5_r11_center_5_5": 18927, + "surface_code_bZ_d5_r13_center_5_5": 19399, + "surface_code_bZ_d5_r15_center_5_5": 19358, + "surface_code_bZ_d5_r17_center_5_5": 18634, + "surface_code_bZ_d5_r19_center_5_5": 19126, + "surface_code_bZ_d5_r21_center_5_5": 18603, + "surface_code_bZ_d5_r23_center_5_5": 18626, + "surface_code_bZ_d5_r25_center_5_5": 19207 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/fresh2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_warm/weights-512.npz", + "starting_checkpoint_sha256": "d3e3abba07693bd7fd3d17be2dd981d5b803a496e76ba230ed94afeb51f26f4f", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 325678, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 11962, + "surface_code_bX_d5_r03_center_5_5": 10232, + "surface_code_bX_d5_r05_center_5_5": 14014, + "surface_code_bX_d5_r07_center_5_5": 11594, + "surface_code_bX_d5_r09_center_5_5": 12805, + "surface_code_bX_d5_r11_center_5_5": 11644, + "surface_code_bX_d5_r13_center_5_5": 13845, + "surface_code_bX_d5_r15_center_5_5": 10703, + "surface_code_bX_d5_r17_center_5_5": 15460, + "surface_code_bX_d5_r19_center_5_5": 14156, + "surface_code_bX_d5_r21_center_5_5": 11568, + "surface_code_bX_d5_r23_center_5_5": 14156, + "surface_code_bX_d5_r25_center_5_5": 12021, + "surface_code_bZ_d5_r01_center_5_5": 10601, + "surface_code_bZ_d5_r03_center_5_5": 14135, + "surface_code_bZ_d5_r05_center_5_5": 11975, + "surface_code_bZ_d5_r07_center_5_5": 13841, + "surface_code_bZ_d5_r09_center_5_5": 12024, + "surface_code_bZ_d5_r11_center_5_5": 11151, + "surface_code_bZ_d5_r13_center_5_5": 10640, + "surface_code_bZ_d5_r15_center_5_5": 11089, + "surface_code_bZ_d5_r17_center_5_5": 13788, + "surface_code_bZ_d5_r19_center_5_5": 12350, + "surface_code_bZ_d5_r21_center_5_5": 12797, + "surface_code_bZ_d5_r23_center_5_5": 12809, + "surface_code_bZ_d5_r25_center_5_5": 14318 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261135", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6522030830383301, + "objective": 0.6522030830383301, + "error": 0.375, + "gradient_norm": 0.11649785190820694, + "elapsed": 30.089841604232788 + }, + { + "step": 16, + "loss": 0.5927819609642029, + "objective": 0.5927819609642029, + "error": 0.3466796875, + "gradient_norm": 0.07945127785205841, + "elapsed": 48.85365080833435 + }, + { + "step": 32, + "loss": 0.3115929663181305, + "objective": 0.3115929663181305, + "error": 0.13671875, + "gradient_norm": 0.039320655167102814, + "elapsed": 63.60312819480896 + }, + { + "step": 48, + "loss": 0.2456369698047638, + "objective": 0.2456369698047638, + "error": 0.1015625, + "gradient_norm": 0.029398636892437935, + "elapsed": 73.71074151992798 + }, + { + "step": 64, + "loss": 0.6231744885444641, + "objective": 0.6231744885444641, + "error": 0.3759765625, + "gradient_norm": 0.06867238879203796, + "elapsed": 83.75580954551697 + }, + { + "step": 80, + "loss": 0.3674217164516449, + "objective": 0.3674217164516449, + "error": 0.1572265625, + "gradient_norm": 0.0557992123067379, + "elapsed": 94.6383364200592 + }, + { + "step": 96, + "loss": 0.5152362585067749, + "objective": 0.5152362585067749, + "error": 0.2568359375, + "gradient_norm": 0.08284599334001541, + "elapsed": 106.90000939369202 + }, + { + "step": 112, + "loss": 0.020773420110344887, + "objective": 0.020773420110344887, + "error": 0.0048828125, + "gradient_norm": 0.008813572116196156, + "elapsed": 117.77558088302612 + }, + { + "step": 128, + "loss": 0.02593131735920906, + "objective": 0.02593131735920906, + "error": 0.0087890625, + "gradient_norm": 0.00872033555060625, + "elapsed": 128.93439435958862 + }, + { + "step": 144, + "loss": 0.5852900743484497, + "objective": 0.5852900743484497, + "error": 0.3291015625, + "gradient_norm": 0.04771002382040024, + "elapsed": 139.5588686466217 + }, + { + "step": 160, + "loss": 0.46074625849723816, + "objective": 0.46074625849723816, + "error": 0.232421875, + "gradient_norm": 0.08834747970104218, + "elapsed": 151.5595977306366 + }, + { + "step": 176, + "loss": 0.6310865879058838, + "objective": 0.6310865879058838, + "error": 0.376953125, + "gradient_norm": 0.14084596931934357, + "elapsed": 163.7892107963562 + }, + { + "step": 192, + "loss": 0.246865376830101, + "objective": 0.246865376830101, + "error": 0.1103515625, + "gradient_norm": 0.041402049362659454, + "elapsed": 174.28971648216248 + }, + { + "step": 208, + "loss": 0.3103577196598053, + "objective": 0.3103577196598053, + "error": 0.15625, + "gradient_norm": 0.04525696486234665, + "elapsed": 187.03909611701965 + }, + { + "step": 224, + "loss": 0.4523138999938965, + "objective": 0.4523138999938965, + "error": 0.208984375, + "gradient_norm": 0.09180521965026855, + "elapsed": 199.56195068359375 + }, + { + "step": 240, + "loss": 0.02241751179099083, + "objective": 0.02241751179099083, + "error": 0.009765625, + "gradient_norm": 0.009998111054301262, + "elapsed": 212.35500597953796 + }, + { + "step": 256, + "loss": 0.5487150549888611, + "objective": 0.5487150549888611, + "error": 0.294921875, + "gradient_norm": 0.12748055160045624, + "elapsed": 223.03854608535767 + }, + { + "step": 272, + "loss": 0.023057367652654648, + "objective": 0.023057367652654648, + "error": 0.0078125, + "gradient_norm": 0.006953821517527103, + "elapsed": 244.6508972644806 + }, + { + "step": 288, + "loss": 0.5845386981964111, + "objective": 0.5845386981964111, + "error": 0.330078125, + "gradient_norm": 0.06542652100324631, + "elapsed": 256.78167748451233 + }, + { + "step": 304, + "loss": 0.442532479763031, + "objective": 0.442532479763031, + "error": 0.232421875, + "gradient_norm": 0.10874580591917038, + "elapsed": 269.1364529132843 + }, + { + "step": 320, + "loss": 0.3264174163341522, + "objective": 0.3264174163341522, + "error": 0.15625, + "gradient_norm": 0.06276191771030426, + "elapsed": 282.38969564437866 + }, + { + "step": 336, + "loss": 0.386960506439209, + "objective": 0.386960506439209, + "error": 0.177734375, + "gradient_norm": 0.06561421602964401, + "elapsed": 292.9079031944275 + }, + { + "step": 352, + "loss": 0.23919886350631714, + "objective": 0.23919886350631714, + "error": 0.107421875, + "gradient_norm": 0.02755703590810299, + "elapsed": 304.16068935394287 + }, + { + "step": 368, + "loss": 0.5029175281524658, + "objective": 0.5029175281524658, + "error": 0.259765625, + "gradient_norm": 0.0378776490688324, + "elapsed": 315.11088514328003 + }, + { + "step": 384, + "loss": 0.565666675567627, + "objective": 0.565666675567627, + "error": 0.322265625, + "gradient_norm": 0.11368246376514435, + "elapsed": 324.3651068210602 + }, + { + "step": 400, + "loss": 0.5846428275108337, + "objective": 0.5846428275108337, + "error": 0.3408203125, + "gradient_norm": 0.08116643130779266, + "elapsed": 334.70786476135254 + }, + { + "step": 416, + "loss": 0.025111017748713493, + "objective": 0.025111017748713493, + "error": 0.0078125, + "gradient_norm": 0.008838560432195663, + "elapsed": 345.56963562965393 + }, + { + "step": 432, + "loss": 0.628488302230835, + "objective": 0.628488302230835, + "error": 0.3818359375, + "gradient_norm": 0.04001976177096367, + "elapsed": 355.3310384750366 + }, + { + "step": 448, + "loss": 0.4569575786590576, + "objective": 0.4569575786590576, + "error": 0.2578125, + "gradient_norm": 0.06344135850667953, + "elapsed": 367.05255675315857 + }, + { + "step": 464, + "loss": 0.49193111062049866, + "objective": 0.49193111062049866, + "error": 0.24609375, + "gradient_norm": 0.06022385507822037, + "elapsed": 377.38399291038513 + }, + { + "step": 480, + "loss": 0.5920064449310303, + "objective": 0.5920064449310303, + "error": 0.3466796875, + "gradient_norm": 0.036063045263290405, + "elapsed": 387.7266733646393 + }, + { + "step": 496, + "loss": 0.22157302498817444, + "objective": 0.22157302498817444, + "error": 0.09375, + "gradient_norm": 0.04071022942662239, + "elapsed": 397.78643012046814 + }, + { + "step": 512, + "loss": 0.39216887950897217, + "objective": 0.39216887950897217, + "error": 0.1728515625, + "gradient_norm": 0.09079446643590927, + "elapsed": 407.0137679576874 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6092928647994995, + "objective": 0.6092928647994995, + "error": 0.3583984375, + "gradient_norm": 0.08161187171936035, + "elapsed": 27.421262741088867 + }, + { + "step": 16, + "loss": 0.4709879755973816, + "objective": 0.4709879755973816, + "error": 0.2529296875, + "gradient_norm": 0.0541619211435318, + "elapsed": 48.74575757980347 + }, + { + "step": 32, + "loss": 0.5842419862747192, + "objective": 0.5842419862747192, + "error": 0.34375, + "gradient_norm": 0.09450904279947281, + "elapsed": 60.68022179603577 + }, + { + "step": 48, + "loss": 0.5840846300125122, + "objective": 0.5840846300125122, + "error": 0.32421875, + "gradient_norm": 0.04569687321782112, + "elapsed": 74.63272476196289 + }, + { + "step": 64, + "loss": 0.5139708518981934, + "objective": 0.5139708518981934, + "error": 0.2646484375, + "gradient_norm": 0.16111725568771362, + "elapsed": 91.88426613807678 + }, + { + "step": 80, + "loss": 0.49099838733673096, + "objective": 0.49099838733673096, + "error": 0.251953125, + "gradient_norm": 0.04431874305009842, + "elapsed": 105.08457684516907 + }, + { + "step": 96, + "loss": 0.30287861824035645, + "objective": 0.30287861824035645, + "error": 0.14453125, + "gradient_norm": 0.03792181238532066, + "elapsed": 118.16054177284241 + }, + { + "step": 112, + "loss": 0.6026535630226135, + "objective": 0.6026535630226135, + "error": 0.359375, + "gradient_norm": 0.043088704347610474, + "elapsed": 134.6414511203766 + }, + { + "step": 128, + "loss": 0.5983598828315735, + "objective": 0.5983598828315735, + "error": 0.328125, + "gradient_norm": 0.06492504477500916, + "elapsed": 148.38875198364258 + }, + { + "step": 144, + "loss": 0.616276204586029, + "objective": 0.616276204586029, + "error": 0.3857421875, + "gradient_norm": 0.05420554056763649, + "elapsed": 164.11315298080444 + }, + { + "step": 160, + "loss": 0.017882924526929855, + "objective": 0.017882924526929855, + "error": 0.0048828125, + "gradient_norm": 0.004682278726249933, + "elapsed": 178.31525373458862 + }, + { + "step": 176, + "loss": 0.5279660820960999, + "objective": 0.5279660820960999, + "error": 0.271484375, + "gradient_norm": 0.03895021602511406, + "elapsed": 192.20261907577515 + }, + { + "step": 192, + "loss": 0.5794406533241272, + "objective": 0.5794406533241272, + "error": 0.34375, + "gradient_norm": 0.041880734264850616, + "elapsed": 200.32051873207092 + }, + { + "step": 208, + "loss": 0.3353561758995056, + "objective": 0.3353561758995056, + "error": 0.1513671875, + "gradient_norm": 0.07022152841091156, + "elapsed": 212.5193521976471 + }, + { + "step": 224, + "loss": 0.47239983081817627, + "objective": 0.47239983081817627, + "error": 0.23828125, + "gradient_norm": 0.044771477580070496, + "elapsed": 223.36571788787842 + }, + { + "step": 240, + "loss": 0.6235381364822388, + "objective": 0.6235381364822388, + "error": 0.3779296875, + "gradient_norm": 0.047636937350034714, + "elapsed": 233.90032649040222 + }, + { + "step": 256, + "loss": 0.516319751739502, + "objective": 0.516319751739502, + "error": 0.271484375, + "gradient_norm": 0.087476447224617, + "elapsed": 245.52193427085876 + }, + { + "step": 272, + "loss": 0.23385891318321228, + "objective": 0.23385891318321228, + "error": 0.091796875, + "gradient_norm": 0.05921977758407593, + "elapsed": 254.38622951507568 + }, + { + "step": 288, + "loss": 0.31280556321144104, + "objective": 0.31280556321144104, + "error": 0.1318359375, + "gradient_norm": 0.03548427298665047, + "elapsed": 263.25871300697327 + }, + { + "step": 304, + "loss": 0.6208417415618896, + "objective": 0.6208417415618896, + "error": 0.361328125, + "gradient_norm": 0.10255666077136993, + "elapsed": 273.5115919113159 + }, + { + "step": 320, + "loss": 0.5985375642776489, + "objective": 0.5985375642776489, + "error": 0.3603515625, + "gradient_norm": 0.04024764895439148, + "elapsed": 285.4135670661926 + }, + { + "step": 336, + "loss": 0.028151696547865868, + "objective": 0.028151696547865868, + "error": 0.009765625, + "gradient_norm": 0.008847440592944622, + "elapsed": 295.0800693035126 + }, + { + "step": 352, + "loss": 0.6147637963294983, + "objective": 0.6147637963294983, + "error": 0.3603515625, + "gradient_norm": 0.05709920823574066, + "elapsed": 305.32019686698914 + }, + { + "step": 368, + "loss": 0.5955979824066162, + "objective": 0.5955979824066162, + "error": 0.3486328125, + "gradient_norm": 0.04276399686932564, + "elapsed": 316.3869025707245 + }, + { + "step": 384, + "loss": 0.23504304885864258, + "objective": 0.23504304885864258, + "error": 0.1025390625, + "gradient_norm": 0.03205326199531555, + "elapsed": 325.7849349975586 + }, + { + "step": 400, + "loss": 0.13460804522037506, + "objective": 0.13460804522037506, + "error": 0.0546875, + "gradient_norm": 0.03109711967408657, + "elapsed": 335.72691917419434 + }, + { + "step": 416, + "loss": 0.5798783302307129, + "objective": 0.5798783302307129, + "error": 0.322265625, + "gradient_norm": 0.053542010486125946, + "elapsed": 345.7052640914917 + }, + { + "step": 432, + "loss": 0.3892784118652344, + "objective": 0.3892784118652344, + "error": 0.19140625, + "gradient_norm": 0.052194178104400635, + "elapsed": 357.38475036621094 + }, + { + "step": 448, + "loss": 0.23582103848457336, + "objective": 0.23582103848457336, + "error": 0.1181640625, + "gradient_norm": 0.032037943601608276, + "elapsed": 369.5841510295868 + }, + { + "step": 464, + "loss": 0.5408849716186523, + "objective": 0.5408849716186523, + "error": 0.2900390625, + "gradient_norm": 0.07508285343647003, + "elapsed": 379.84099793434143 + }, + { + "step": 480, + "loss": 0.3894873559474945, + "objective": 0.3894873559474945, + "error": 0.19140625, + "gradient_norm": 0.03977999836206436, + "elapsed": 390.9687530994415 + }, + { + "step": 496, + "loss": 0.6059300899505615, + "objective": 0.6059300899505615, + "error": 0.361328125, + "gradient_norm": 0.06041429564356804, + "elapsed": 403.2380111217499 + }, + { + "step": 512, + "loss": 0.2117740511894226, + "objective": 0.2117740511894226, + "error": 0.0908203125, + "gradient_norm": 0.05693414434790611, + "elapsed": 414.4854781627655 + }, + { + "step": 528, + "loss": 0.4666211009025574, + "objective": 0.4666211009025574, + "error": 0.2470703125, + "gradient_norm": 0.0764947235584259, + "elapsed": 433.42368054389954 + }, + { + "step": 544, + "loss": 0.22636458277702332, + "objective": 0.22636458277702332, + "error": 0.1083984375, + "gradient_norm": 0.03683016076683998, + "elapsed": 442.92575907707214 + }, + { + "step": 560, + "loss": 0.23172692954540253, + "objective": 0.23172692954540253, + "error": 0.1083984375, + "gradient_norm": 0.034071482717990875, + "elapsed": 453.3129711151123 + }, + { + "step": 576, + "loss": 0.4768703579902649, + "objective": 0.4768703579902649, + "error": 0.2529296875, + "gradient_norm": 0.06308378279209137, + "elapsed": 462.4127457141876 + }, + { + "step": 592, + "loss": 0.5165150165557861, + "objective": 0.5165150165557861, + "error": 0.291015625, + "gradient_norm": 0.07674732059240341, + "elapsed": 473.8309862613678 + }, + { + "step": 608, + "loss": 0.5919064283370972, + "objective": 0.5919064283370972, + "error": 0.3359375, + "gradient_norm": 0.06379934400320053, + "elapsed": 484.3733870983124 + }, + { + "step": 624, + "loss": 0.01804366335272789, + "objective": 0.01804366335272789, + "error": 0.0068359375, + "gradient_norm": 0.005318541545420885, + "elapsed": 495.94076347351074 + }, + { + "step": 640, + "loss": 0.41747498512268066, + "objective": 0.41747498512268066, + "error": 0.1962890625, + "gradient_norm": 0.052116431295871735, + "elapsed": 506.73559165000916 + }, + { + "step": 656, + "loss": 0.6140056848526001, + "objective": 0.6140056848526001, + "error": 0.3896484375, + "gradient_norm": 0.05376415699720383, + "elapsed": 517.2397899627686 + }, + { + "step": 672, + "loss": 0.4098930358886719, + "objective": 0.4098930358886719, + "error": 0.197265625, + "gradient_norm": 0.04737741872668266, + "elapsed": 525.7957897186279 + }, + { + "step": 688, + "loss": 0.3499884009361267, + "objective": 0.3499884009361267, + "error": 0.1650390625, + "gradient_norm": 0.0714973583817482, + "elapsed": 534.9302124977112 + }, + { + "step": 704, + "loss": 0.552291989326477, + "objective": 0.552291989326477, + "error": 0.3095703125, + "gradient_norm": 0.10188189148902893, + "elapsed": 545.4470670223236 + }, + { + "step": 720, + "loss": 0.4040689468383789, + "objective": 0.4040689468383789, + "error": 0.1943359375, + "gradient_norm": 0.06630362570285797, + "elapsed": 554.2920794487 + }, + { + "step": 736, + "loss": 0.3191133439540863, + "objective": 0.3191133439540863, + "error": 0.15625, + "gradient_norm": 0.060587506741285324, + "elapsed": 562.335791349411 + }, + { + "step": 752, + "loss": 0.5949387550354004, + "objective": 0.5949387550354004, + "error": 0.330078125, + "gradient_norm": 0.051291145384311676, + "elapsed": 570.9363489151001 + }, + { + "step": 768, + "loss": 0.4783790409564972, + "objective": 0.4783790409564972, + "error": 0.244140625, + "gradient_norm": 0.08808670938014984, + "elapsed": 581.1555306911469 + }, + { + "step": 784, + "loss": 0.4414710998535156, + "objective": 0.4414710998535156, + "error": 0.20703125, + "gradient_norm": 0.06632383912801743, + "elapsed": 590.4109175205231 + }, + { + "step": 800, + "loss": 0.2536136507987976, + "objective": 0.2536136507987976, + "error": 0.1142578125, + "gradient_norm": 0.03191893920302391, + "elapsed": 601.43274974823 + }, + { + "step": 816, + "loss": 0.22448071837425232, + "objective": 0.22448071837425232, + "error": 0.1015625, + "gradient_norm": 0.04966023191809654, + "elapsed": 612.7252013683319 + }, + { + "step": 832, + "loss": 0.5342355966567993, + "objective": 0.5342355966567993, + "error": 0.2783203125, + "gradient_norm": 0.05757307633757591, + "elapsed": 623.6647284030914 + }, + { + "step": 848, + "loss": 0.2506354749202728, + "objective": 0.2506354749202728, + "error": 0.109375, + "gradient_norm": 0.03991081938147545, + "elapsed": 635.1636409759521 + }, + { + "step": 864, + "loss": 0.40698009729385376, + "objective": 0.40698009729385376, + "error": 0.1953125, + "gradient_norm": 0.09155476838350296, + "elapsed": 645.2128469944 + }, + { + "step": 880, + "loss": 0.563283383846283, + "objective": 0.563283383846283, + "error": 0.3134765625, + "gradient_norm": 0.11409252882003784, + "elapsed": 659.2946681976318 + }, + { + "step": 896, + "loss": 0.13591040670871735, + "objective": 0.13591040670871735, + "error": 0.064453125, + "gradient_norm": 0.02692740224301815, + "elapsed": 668.6167254447937 + }, + { + "step": 912, + "loss": 0.5798318982124329, + "objective": 0.5798318982124329, + "error": 0.3310546875, + "gradient_norm": 0.06674209237098694, + "elapsed": 680.6492185592651 + }, + { + "step": 928, + "loss": 0.6140691041946411, + "objective": 0.6140691041946411, + "error": 0.3857421875, + "gradient_norm": 0.06117575615644455, + "elapsed": 693.1704411506653 + }, + { + "step": 944, + "loss": 0.3964633643627167, + "objective": 0.3964633643627167, + "error": 0.1865234375, + "gradient_norm": 0.08617512136697769, + "elapsed": 708.2128443717957 + }, + { + "step": 960, + "loss": 0.5512299537658691, + "objective": 0.5512299537658691, + "error": 0.2861328125, + "gradient_norm": 0.05705108866095543, + "elapsed": 720.2417063713074 + }, + { + "step": 976, + "loss": 0.454137921333313, + "objective": 0.454137921333313, + "error": 0.216796875, + "gradient_norm": 0.07962293922901154, + "elapsed": 730.2567391395569 + }, + { + "step": 992, + "loss": 0.5681213140487671, + "objective": 0.5681213140487671, + "error": 0.3017578125, + "gradient_norm": 0.09802286326885223, + "elapsed": 742.7380962371826 + }, + { + "step": 1008, + "loss": 0.13060352206230164, + "objective": 0.13060352206230164, + "error": 0.0537109375, + "gradient_norm": 0.04271279275417328, + "elapsed": 750.8077793121338 + }, + { + "step": 1024, + "loss": 0.6129879355430603, + "objective": 0.6129879355430603, + "error": 0.3603515625, + "gradient_norm": 0.04127912223339081, + "elapsed": 761.0585849285126 + }, + { + "step": 1040, + "loss": 0.31361687183380127, + "objective": 0.31361687183380127, + "error": 0.1455078125, + "gradient_norm": 0.04341907799243927, + "elapsed": 776.3491418361664 + }, + { + "step": 1056, + "loss": 0.6326502561569214, + "objective": 0.6326502561569214, + "error": 0.365234375, + "gradient_norm": 0.07518075406551361, + "elapsed": 786.0424168109894 + }, + { + "step": 1072, + "loss": 0.537599503993988, + "objective": 0.537599503993988, + "error": 0.2958984375, + "gradient_norm": 0.08455493301153183, + "elapsed": 795.1607735157013 + }, + { + "step": 1088, + "loss": 0.5953108072280884, + "objective": 0.5953108072280884, + "error": 0.337890625, + "gradient_norm": 0.06973882764577866, + "elapsed": 804.0053510665894 + }, + { + "step": 1104, + "loss": 0.36860400438308716, + "objective": 0.36860400438308716, + "error": 0.1923828125, + "gradient_norm": 0.04828036576509476, + "elapsed": 813.4029138088226 + }, + { + "step": 1120, + "loss": 0.5423247218132019, + "objective": 0.5423247218132019, + "error": 0.28125, + "gradient_norm": 0.04841453209519386, + "elapsed": 823.626978635788 + }, + { + "step": 1136, + "loss": 0.4766136407852173, + "objective": 0.4766136407852173, + "error": 0.236328125, + "gradient_norm": 0.07564551383256912, + "elapsed": 832.4641265869141 + }, + { + "step": 1152, + "loss": 0.5473434925079346, + "objective": 0.5473434925079346, + "error": 0.2958984375, + "gradient_norm": 0.13677075505256653, + "elapsed": 844.9307618141174 + }, + { + "step": 1168, + "loss": 0.3040686249732971, + "objective": 0.3040686249732971, + "error": 0.150390625, + "gradient_norm": 0.045926257967948914, + "elapsed": 854.336992263794 + }, + { + "step": 1184, + "loss": 0.6298375129699707, + "objective": 0.6298375129699707, + "error": 0.3798828125, + "gradient_norm": 0.06807851791381836, + "elapsed": 864.5731596946716 + }, + { + "step": 1200, + "loss": 0.6272540092468262, + "objective": 0.6272540092468262, + "error": 0.37890625, + "gradient_norm": 0.139838308095932, + "elapsed": 877.8357374668121 + }, + { + "step": 1216, + "loss": 0.5224937200546265, + "objective": 0.5224937200546265, + "error": 0.287109375, + "gradient_norm": 0.0647057592868805, + "elapsed": 887.8107197284698 + }, + { + "step": 1232, + "loss": 0.02408422902226448, + "objective": 0.02408422902226448, + "error": 0.0107421875, + "gradient_norm": 0.007562167476862669, + "elapsed": 902.201171875 + }, + { + "step": 1248, + "loss": 0.01936865597963333, + "objective": 0.01936865597963333, + "error": 0.0048828125, + "gradient_norm": 0.006423021201044321, + "elapsed": 914.0247437953949 + }, + { + "step": 1264, + "loss": 0.47522181272506714, + "objective": 0.47522181272506714, + "error": 0.2490234375, + "gradient_norm": 0.04962826892733574, + "elapsed": 927.0462884902954 + }, + { + "step": 1280, + "loss": 0.019577551633119583, + "objective": 0.019577551633119583, + "error": 0.0068359375, + "gradient_norm": 0.008308992721140385, + "elapsed": 939.3647270202637 + }, + { + "step": 1296, + "loss": 0.5085430145263672, + "objective": 0.5085430145263672, + "error": 0.2734375, + "gradient_norm": 0.06214233115315437, + "elapsed": 949.4259700775146 + }, + { + "step": 1312, + "loss": 0.23232896625995636, + "objective": 0.23232896625995636, + "error": 0.1015625, + "gradient_norm": 0.05894213914871216, + "elapsed": 961.3636543750763 + }, + { + "step": 1328, + "loss": 0.5330536365509033, + "objective": 0.5330536365509033, + "error": 0.2861328125, + "gradient_norm": 0.11579663306474686, + "elapsed": 972.1607241630554 + }, + { + "step": 1344, + "loss": 0.019525721669197083, + "objective": 0.019525721669197083, + "error": 0.0087890625, + "gradient_norm": 0.008134250529110432, + "elapsed": 983.0828921794891 + }, + { + "step": 1360, + "loss": 0.22790294885635376, + "objective": 0.22790294885635376, + "error": 0.103515625, + "gradient_norm": 0.04187086224555969, + "elapsed": 991.3167304992676 + }, + { + "step": 1376, + "loss": 0.48713046312332153, + "objective": 0.48713046312332153, + "error": 0.2666015625, + "gradient_norm": 0.06267429888248444, + "elapsed": 1003.5033710002899 + }, + { + "step": 1392, + "loss": 0.6043434143066406, + "objective": 0.6043434143066406, + "error": 0.369140625, + "gradient_norm": 0.037880122661590576, + "elapsed": 1017.8567223548889 + }, + { + "step": 1408, + "loss": 0.034499723464250565, + "objective": 0.034499723464250565, + "error": 0.0068359375, + "gradient_norm": 0.013505477458238602, + "elapsed": 1027.3547134399414 + }, + { + "step": 1424, + "loss": 0.5320160388946533, + "objective": 0.5320160388946533, + "error": 0.306640625, + "gradient_norm": 0.07510018348693848, + "elapsed": 1036.9454221725464 + }, + { + "step": 1440, + "loss": 0.3451523780822754, + "objective": 0.3451523780822754, + "error": 0.171875, + "gradient_norm": 0.06453985720872879, + "elapsed": 1046.1805095672607 + }, + { + "step": 1456, + "loss": 0.21541815996170044, + "objective": 0.21541815996170044, + "error": 0.08984375, + "gradient_norm": 0.043503839522600174, + "elapsed": 1055.850379705429 + }, + { + "step": 1472, + "loss": 0.43667086958885193, + "objective": 0.43667086958885193, + "error": 0.22265625, + "gradient_norm": 0.07311506569385529, + "elapsed": 1066.6324400901794 + }, + { + "step": 1488, + "loss": 0.6163139939308167, + "objective": 0.6163139939308167, + "error": 0.3779296875, + "gradient_norm": 0.06406569480895996, + "elapsed": 1075.7883398532867 + }, + { + "step": 1504, + "loss": 0.23901250958442688, + "objective": 0.23901250958442688, + "error": 0.10546875, + "gradient_norm": 0.04792191833257675, + "elapsed": 1085.4756922721863 + }, + { + "step": 1520, + "loss": 0.3817014694213867, + "objective": 0.3817014694213867, + "error": 0.18359375, + "gradient_norm": 0.046061187982559204, + "elapsed": 1095.974383354187 + }, + { + "step": 1536, + "loss": 0.5593156814575195, + "objective": 0.5593156814575195, + "error": 0.3017578125, + "gradient_norm": 0.0735388696193695, + "elapsed": 1105.913155078888 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5875545144081116, + "objective": 0.5875545144081116, + "error": 0.341796875, + "gradient_norm": 0.07232116162776947, + "elapsed": 24.623218297958374 + }, + { + "step": 16, + "loss": 0.5004383325576782, + "objective": 0.5004383325576782, + "error": 0.2685546875, + "gradient_norm": 0.07209929823875427, + "elapsed": 46.83251929283142 + }, + { + "step": 32, + "loss": 0.5355455875396729, + "objective": 0.5355455875396729, + "error": 0.2978515625, + "gradient_norm": 0.06145563721656799, + "elapsed": 58.210827350616455 + }, + { + "step": 48, + "loss": 0.02583758719265461, + "objective": 0.02583758719265461, + "error": 0.0087890625, + "gradient_norm": 0.0189728494733572, + "elapsed": 68.48884010314941 + }, + { + "step": 64, + "loss": 0.4804553985595703, + "objective": 0.4804553985595703, + "error": 0.2578125, + "gradient_norm": 0.10756462067365646, + "elapsed": 81.58980226516724 + }, + { + "step": 80, + "loss": 0.014867682009935379, + "objective": 0.014867682009935379, + "error": 0.0048828125, + "gradient_norm": 0.0035971610341221094, + "elapsed": 92.75763940811157 + }, + { + "step": 96, + "loss": 0.4588717818260193, + "objective": 0.4588717818260193, + "error": 0.2529296875, + "gradient_norm": 0.06125853210687637, + "elapsed": 103.91085052490234 + }, + { + "step": 112, + "loss": 0.02983422391116619, + "objective": 0.02983422391116619, + "error": 0.0087890625, + "gradient_norm": 0.010100561194121838, + "elapsed": 112.73191356658936 + }, + { + "step": 128, + "loss": 0.563227653503418, + "objective": 0.563227653503418, + "error": 0.3134765625, + "gradient_norm": 0.050932250916957855, + "elapsed": 123.29799246788025 + }, + { + "step": 144, + "loss": 0.4543372392654419, + "objective": 0.4543372392654419, + "error": 0.255859375, + "gradient_norm": 0.07798800617456436, + "elapsed": 133.57565450668335 + }, + { + "step": 160, + "loss": 0.6137585043907166, + "objective": 0.6137585043907166, + "error": 0.36328125, + "gradient_norm": 0.055799346417188644, + "elapsed": 144.94875645637512 + }, + { + "step": 176, + "loss": 0.6298239231109619, + "objective": 0.6298239231109619, + "error": 0.3681640625, + "gradient_norm": 0.05265408754348755, + "elapsed": 156.92637729644775 + }, + { + "step": 192, + "loss": 0.5863606929779053, + "objective": 0.5863606929779053, + "error": 0.3388671875, + "gradient_norm": 0.055871717631816864, + "elapsed": 167.19068932533264 + }, + { + "step": 208, + "loss": 0.41824066638946533, + "objective": 0.41824066638946533, + "error": 0.208984375, + "gradient_norm": 0.05700479820370674, + "elapsed": 179.71222853660583 + }, + { + "step": 224, + "loss": 0.19714157283306122, + "objective": 0.19714157283306122, + "error": 0.08203125, + "gradient_norm": 0.08069340139627457, + "elapsed": 189.93716096878052 + }, + { + "step": 240, + "loss": 0.6208732724189758, + "objective": 0.6208732724189758, + "error": 0.3720703125, + "gradient_norm": 0.05663277953863144, + "elapsed": 201.90824031829834 + }, + { + "step": 256, + "loss": 0.1692095249891281, + "objective": 0.1692095249891281, + "error": 0.0615234375, + "gradient_norm": 0.037714891135692596, + "elapsed": 212.0968942642212 + }, + { + "step": 272, + "loss": 0.4060826897621155, + "objective": 0.4060826897621155, + "error": 0.19921875, + "gradient_norm": 0.09783580899238586, + "elapsed": 228.83709192276 + }, + { + "step": 288, + "loss": 0.5767850875854492, + "objective": 0.5767850875854492, + "error": 0.3466796875, + "gradient_norm": 0.05610447749495506, + "elapsed": 238.7966763973236 + }, + { + "step": 304, + "loss": 0.6033234000205994, + "objective": 0.6033234000205994, + "error": 0.349609375, + "gradient_norm": 0.11035548895597458, + "elapsed": 250.43343496322632 + }, + { + "step": 320, + "loss": 0.15587139129638672, + "objective": 0.15587139129638672, + "error": 0.064453125, + "gradient_norm": 0.03521726280450821, + "elapsed": 263.2277765274048 + }, + { + "step": 336, + "loss": 0.24655082821846008, + "objective": 0.24655082821846008, + "error": 0.111328125, + "gradient_norm": 0.039142120629549026, + "elapsed": 274.87964034080505 + }, + { + "step": 352, + "loss": 0.021554915234446526, + "objective": 0.021554915234446526, + "error": 0.0087890625, + "gradient_norm": 0.008269127458333969, + "elapsed": 287.3679096698761 + }, + { + "step": 368, + "loss": 0.017723169177770615, + "objective": 0.017723169177770615, + "error": 0.005859375, + "gradient_norm": 0.007770172320306301, + "elapsed": 296.40210723876953 + }, + { + "step": 384, + "loss": 0.13239723443984985, + "objective": 0.13239723443984985, + "error": 0.0537109375, + "gradient_norm": 0.035724934190511703, + "elapsed": 307.52680230140686 + }, + { + "step": 400, + "loss": 0.614764928817749, + "objective": 0.614764928817749, + "error": 0.3486328125, + "gradient_norm": 0.08224000036716461, + "elapsed": 318.62148237228394 + }, + { + "step": 416, + "loss": 0.6283708810806274, + "objective": 0.6283708810806274, + "error": 0.376953125, + "gradient_norm": 0.06731405109167099, + "elapsed": 327.9952435493469 + }, + { + "step": 432, + "loss": 0.489668607711792, + "objective": 0.489668607711792, + "error": 0.2705078125, + "gradient_norm": 0.09828612953424454, + "elapsed": 336.55896639823914 + }, + { + "step": 448, + "loss": 0.6081756353378296, + "objective": 0.6081756353378296, + "error": 0.365234375, + "gradient_norm": 0.05721558630466461, + "elapsed": 347.0610954761505 + }, + { + "step": 464, + "loss": 0.6268260478973389, + "objective": 0.6268260478973389, + "error": 0.380859375, + "gradient_norm": 0.07860013097524643, + "elapsed": 357.03172731399536 + }, + { + "step": 480, + "loss": 0.037026144564151764, + "objective": 0.037026144564151764, + "error": 0.009765625, + "gradient_norm": 0.017784126102924347, + "elapsed": 367.5407898426056 + }, + { + "step": 496, + "loss": 0.6177941560745239, + "objective": 0.6177941560745239, + "error": 0.3525390625, + "gradient_norm": 0.06657450646162033, + "elapsed": 380.9171233177185 + }, + { + "step": 512, + "loss": 0.589913010597229, + "objective": 0.589913010597229, + "error": 0.3408203125, + "gradient_norm": 0.10982488840818405, + "elapsed": 391.4458239078522 + } + ], + "declared_plan": { + "name": "prior_pass1", + "status": "Launched after posterior-context study; actual current-runtime GPU control passed", + "hypothesis": "The edge correction learned with three physical feedback passes may benefit from adaptation to five-pass priors. A matched three-pass continuation distinguishes prior quality from additional optimization on the smaller cached training pool.", + "parent": "learned_d5/fresh2_full/weights-1536.npz", + "initialization": "Both arms start from the same session-trained parent, originally random seed20261134. Restore all parameters and Adam moments/count2048. No new parameters. Explicitly reset sampling RNG to20261400 in each arm.", + "training_rows": "The same existing4096 training rows per each of all26d5conditions,106496eligible rows. Cached indices were sampled without replacement using seed20261023. They are previously used training rows, not held-out labels.", + "arms": [ + 3, + 5 + ], + "steps": 512, + "batch": 1024, + "learning_rate": 0.0001, + "sampling_seed": 20261400, + "optimizer": "AdamW decay1e-4, global gradient norm clipping1, restored parent state", + "loss": "Uniform conditional logical BCE through exact relevant-CSS contraction; cached physical priors fixed", + "selection": "Raw pass3 checkpoints256/512 and raw pass5 checkpoints0/256/512 versus current incumbent, separately perbasis over all13durations. Ties retain incumbent. Parent pass3 full predictions already exist and are reused for the scientific comparison; no confirmation retraining or new pass3-zero selection.", + "selection_steps": { + "3": [ + 256, + 512 + ], + "5": [ + 0, + 256, + 512 + ] + }, + "screen": "1024 validation rows percondition with existing seed20261102; screen does not add selection candidates", + "runtime": "Existing raw neural runtime already supports prior_pass5. No new wrapper is needed. Actual replay must include all five physical passes and satisfy projected3600s limit.", + "controls": "Training-only cache alignment and hash audit; short discarded CPU pipeline runs for both arms; restored-state and complete sampling replay; current-runtime CPU check and actual assembled-runtime GPU check after predecessor finishes", + "selection_declared_before_new_pass5_neural_evaluation": true, + "test_data_used": false, + "prepared_utc": "2026-10-21T16:40:08.094485+00:00", + "frozen_source_sha256": { + "prior_pass_study/after_posterior.py": "1cadb20b1fe4ead41f00baebb62541167ab6e8b916b5bb02fe6cacadbc4502d7", + "prior_pass_study/package.py": "f9915505bac8c81a402f23a7dcf06b5278dfb06b418a0cc25c48797a141cfc73", + "prior_pass_study/cpu_smoke.py": "9f7ee28f797ca46ff403f6af1836596664988e8414de60b0f792c86c2b2ca3b1", + "prior_pass_study/runtime_control.py": "06e725750085d90d1bba1e4ebfd49557f2c19787946614325064e648a011de20", + "prior_pass_study/audit_run.py": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da", + "prior_pass_study/cache_audit.py": "6a6f34061e048af6e5e7bedcdbe124aeee64c324bf69e482c45b10c2e92f2b5e", + "learned_d5/evaluate.py": "647c7e3964d8def7948c105f49c31a7237f99e32272ab45388a3ed6069b0cf9b" + }, + "launch_utc": "2026-10-21T17:40:38.975372+00:00" + }, + "sampling_audit": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 524288, + "distinct_rows_seen": 105004, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 256, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2304 + }, + { + "step": 512, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2560 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + }, + "pipeline_control": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 controls, not eligible for selection or submission", + "arms": { + "3": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 2, + "distinct_rows_seen": 2, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 1, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2049 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + }, + "5": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 2, + "distinct_rows_seen": 2, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 1, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2049 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + } + }, + "matched_sampling_states_exact": true, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_source_sha256": "9f7ee28f797ca46ff403f6af1836596664988e8414de60b0f792c86c2b2ca3b1", + "test_data_used": false + }, + "cache_audit": { + "status": "passed", + "scope": "Training-only row/label/feature comparison; validation cache shapes checked, validation labels not read", + "training_rows": 106496, + "training_subset_seed": 20261023, + "records": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 0.0, + "input_sha256": "0de3fe461bfa141fc49f1cd2cf4c7d4a9cf1e835d9619dd55d81f92ec9011a2a", + "turbo_cache_sha256": "441736f9bdba176272888dba8787dce1c2fbacd7250169962707a5eea27f6a37", + "feedback_cache_sha256": "a8f3d5cf4ccd279ba3060a8db2737203bb172416b82b0eb913469e14790e0817" + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.68849515914917, + "input_sha256": "512c32ea26171d1d0f13ad197c5134a24ea2e2814168abc31c1d261b5ec45a80", + "turbo_cache_sha256": "9847461cc42fee9c90414f78fd0e78305f8f6ed118d930b29426d27f5a4cf548", + "feedback_cache_sha256": "d8e4e5fe2eb3c2c75cd32613c9e4513ca042bf53d82f6fdf97298a41206ddc6f" + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9068970680236816, + "input_sha256": "422273891bb97dca7f4913ca15cc3433e108a4ea795dcbfd871ff1ee185cb3c1", + "turbo_cache_sha256": "ab1e3b7376f7883031983d385950ba67747e828735396ac1b63170b7141f8ed4", + "feedback_cache_sha256": "33c8b8c5d617eafdb32f790958139199b21126176a03a9792429e78dff88af19" + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.2904839515686035, + "input_sha256": "45c5f49d60d35858e7c829bcfa8a1c5c37e1c9c17aba60c6610f2d20b4b34967", + "turbo_cache_sha256": "c6abca56049ea6b82d247c8bf79c0a9a6f19e9cf60a4e4a2723c2a17a6a88448", + "feedback_cache_sha256": "4f31e1be93fd66b3d227de72416e3de1c8ba294b5cf55bb9c0d59e0a295da6e8" + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.7693614959716797, + "input_sha256": "d0b3ff6031a2c2e6bd1d4a058b45725345a67c3403e0bd21f679f6f0d329c787", + "turbo_cache_sha256": "18a81a4ca70c5c5c08deda38d43955c5a42ffd961a212e2ee6c783dd4837d49f", + "feedback_cache_sha256": "b420124bbebdf7e99ffe57ab3624569cc93379290c43594f5f2ccfea4684b51e" + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.163759469985962, + "input_sha256": "18fab0c6789333021da1ac6115028694717c9009da0fd2b1face03e8efc28884", + "turbo_cache_sha256": "92b7fd80f827e20349b7cec2b87e5e5cd4f4046a8fcb17201db33cb3e178a82e", + "feedback_cache_sha256": "41939274bd8b08684de8f6d201f9527302613400497545cb001ee59129648f87" + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9551092386245728, + "input_sha256": "0efb3e7203badf4a61c2cb5fe27a2ff3ad8928ed80b27c53488a453492948d7d", + "turbo_cache_sha256": "526567a159461dabf2f3aa67ce4848b336b11eb0a8cb9ecde604d094173d6deb", + "feedback_cache_sha256": "12d6f49dca817de1de639081b4fca7c9b74f53daf057165945a5c9ee4f72d86f" + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 3.5012946128845215, + "input_sha256": "957bb2f3b59b726696917ad60ce0775e9ecc1b40f4d610acb7e1f8f66e3c9512", + "turbo_cache_sha256": "44310eacdb54599d2370a86be3161e6c6d3752c41e59a76822ad90a8a39023b1", + "feedback_cache_sha256": "1172de602cca7bd6d039cde49596535ad8f656f3c2e5d644adab4cd1c06bae4f" + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 3.163731575012207, + "input_sha256": "d7044a2673b4d2f927c5082bd8f76c1e8feb2b2d64851c691de1d818ca7aba36", + "turbo_cache_sha256": "ad18d21a2e824bab2f16163774eb8356d96f2f4163800c1fc55ca0b2a6f68c55", + "feedback_cache_sha256": "4acef03709505af3a50f8fb82a7b839ad8a48f4de4e965f3dad35adb37ca756e" + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9745681285858154, + "input_sha256": "be6a20ba225022b8cd8b6529988c614d1edfca2dee7b966ef918fd91a1551528", + "turbo_cache_sha256": "f8d8046214fef19c419e5bc550c112fb056d0bc48e5b7b83f3d47f96b188426c", + "feedback_cache_sha256": "ae79c9c1b75cc4c46ca9b7e78ade17683023663607b615945c73d02367d0f063" + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.541386604309082, + "input_sha256": "a65c605895dc6d4d879b1edce2442e65c795e31cbb4775f260d6303a1864b9b6", + "turbo_cache_sha256": "dcd8bff02e2f1ff95e6dbfb5a8589f2037eaa3f50d7352361fd7bd8bcaa9528e", + "feedback_cache_sha256": "cc2c8098c741208092efc3d40f38d4ccf366b2d95c89396155620411622c7eb0" + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.212656021118164, + "input_sha256": "b89334defc3d8367e03a46501634b7d80638d60710784650cfa56f372dd1e832", + "turbo_cache_sha256": "eb68a945e1da883c2573bba4fba0a297d07df8382cea297b31501d1d870538a9", + "feedback_cache_sha256": "a79d3a7db0de0531aae43afef3fd194ee4b799a63e499f7939cab8b35e9de3dd" + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9682941436767578, + "input_sha256": "2a5563cb5a31543543ae852afd671bb1c2617be93c03a03b961b6999891bea78", + "turbo_cache_sha256": "fb70e5f556ae6385d0cd791955ba6a9113b17a3c59c2793e9922a1a35d50fb2c", + "feedback_cache_sha256": "57d40a801480351332c4638d9171ae09b571d8fcc4d4446b3bddb081087d4fa7" + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 0.0, + "input_sha256": "4ab27356cd0fc3ed97d379fc92427cb87ce91f602fca3daf602bd60c811d0fac", + "turbo_cache_sha256": "aceaba5ee49df7cd626a9f59013829333fb13c868ad028cac6aee3b1595bbacd", + "feedback_cache_sha256": "301ba8a545e793a42a528df964404f401098bbe152a5c5aa0f40a4291646b6c5" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.8697710037231445, + "input_sha256": "faad8d29ffbd8a1d2db08dc8297486f622e875a71eea94474fca14158bfae013", + "turbo_cache_sha256": "f0b1eae6bf871eb3cb084894d490fd8366953b42bb862d133e7af91f49e8469a", + "feedback_cache_sha256": "86e438fb4e29575375184eff94b0ee6592a2c2d9de55737896f1d0d1cb1e515d" + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.7381677627563477, + "input_sha256": "bf91b7e8c7111e612cd870869742892e063bce3dfa1d29985b0be4bfe86e9b2f", + "turbo_cache_sha256": "531e127bab68c231981a1328abb0665221f6fc37e684580dd11ab88222c7a4c9", + "feedback_cache_sha256": "8078dfb13d6ee9c2fbb62cb04fe4ffe64dbe71dbc0242cf2d9ad849d571a9e9f" + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.778193473815918, + "input_sha256": "2dc53db4be79136e0b9e61c91c48cbd71199d0f52c0bf927582eba9ef7af0586", + "turbo_cache_sha256": "e84097accab9567c02997fa77a9711741ede3d8ac67b41a875177ef767f8a270", + "feedback_cache_sha256": "61572fd0745d75b05af7b08883886174740c4b22c0ae8ae1fe952f700212cf16" + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.392045497894287, + "input_sha256": "1e68d0415ad28c43c21562225793fdc043df1c240e923ef6fe4d7b73de6f8cf9", + "turbo_cache_sha256": "be967eb6ba11cbdd493a9746bac80d38b52dd38b1c9c2d7eead820538c33c5d3", + "feedback_cache_sha256": "57ac7366e184ed3e54e99693872ad483e715fb29f52d6351f5472cce6442e369" + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.842482328414917, + "input_sha256": "3976eebf5a2fc1733c0ebf1c6cb6aae3827c423a06394a761cb364d7b40e857b", + "turbo_cache_sha256": "4c8d80236d177fae8e713e2aaf4a3e43f0d4c0e64891fca02f0b4da5b9ba26d7", + "feedback_cache_sha256": "a22984a13547731fac87f16349ebfac9b9a8e45a4ca1d744f3e2dfeab5c0bbe0" + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.5524821281433105, + "input_sha256": "32b3943314083c605ba29e900f20c2755df2d4b85988b443cc428e13f5720992", + "turbo_cache_sha256": "8b192e2f4e0e3f5aea18043667073db2ed9ef50854c6e99727afb28d2a7a2bd9", + "feedback_cache_sha256": "5efb2696166d010b05700078e9760bb12112fbd4e7f2e8b80e90a7cf3f240867" + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.2862725257873535, + "input_sha256": "ab29a38afb0fab42916b446f15ad9da61cb4778798fde70cd77fdce2e6999418", + "turbo_cache_sha256": "bf35c69ec38eb42a391142ea09346877b79c29463e2ea10c88cadc388c3c226c", + "feedback_cache_sha256": "109b5b979952d5a70276e5330e678fc7be36da7e6171831135b570545643fd6b" + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.3719873428344727, + "input_sha256": "61210ad6292b9829ebcdb61ca92766a33d1ff0d43a8ace70c959d4622a796831", + "turbo_cache_sha256": "f639df2f3a89dd6b3382f5431171a77c03f838658d71e7e422b7e21e4b134d90", + "feedback_cache_sha256": "c2944ec6d1f5e481de74dec8f517a6d67df3c6fb267ff6ee5c863afde93628f2" + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.293153762817383, + "input_sha256": "c96c01753928ba64ab33ff06e9a162b3e848f7cd37805943fcc9f426f1d565d7", + "turbo_cache_sha256": "23b665988b82f979ec208b4a5363cd62aed8721ea4fcae166646e5bc6ac5011d", + "feedback_cache_sha256": "5c56f8f0ac37cf5f35aa62e25c9e7cb8824fa4e8f79a9e8b5cbbce9d25d5b56f" + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.232598304748535, + "input_sha256": "1d94ffdc063b36e8f5708849c1ec87bcefb471655e188c52b05c6d2efab85ffe", + "turbo_cache_sha256": "c77c6499f021cf8caaa5358ac52e59238d0b34261f5e18907d55cc2b2f3e30ec", + "feedback_cache_sha256": "f75edb10b0e9578371d2a0589c9bda70ea8d9197b95c1db7bb2b073d3e94a40e" + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.383565664291382, + "input_sha256": "d5e2b560a8976679fc8fc29086f72b03816609fddc03774ae96a19f9e9b4004c", + "turbo_cache_sha256": "af0508df2707c3335086a147896088be33f7b44d4b6eef0a6f43ce5b835bb7b2", + "feedback_cache_sha256": "150d303d0f442cb03732e553087c6016aea153d4d70a3ff50b25bbd2c3fea357" + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.25010085105896, + "input_sha256": "a2aad8582952d22d67664862a53dae079385f42fd341d6b9eb82a308a4c5faff", + "turbo_cache_sha256": "f8fe087e5d1b3b33ca58bb02921ccc8df8e7962e2daddf9c55adc988aca84b64", + "feedback_cache_sha256": "1af169e7dbf4626d236c6cbd64312a810bd2faebcb3f55ec5e09d24b5c4e7719" + } + ], + "test_data_used": false, + "source_sha256": { + "learned_d5/data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "prior_pass_study/cache_audit.py": "6a6f34061e048af6e5e7bedcdbe124aeee64c324bf69e482c45b10c2e92f2b5e" + } + } + }, + "5": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 5, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.", + "training_cache": null, + "training_cache_provenance": null, + "training_shots": 106496, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 105004, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 3939, + "surface_code_bX_d5_r03_center_5_5": 4010, + "surface_code_bX_d5_r05_center_5_5": 4060, + "surface_code_bX_d5_r07_center_5_5": 3935, + "surface_code_bX_d5_r09_center_5_5": 4092, + "surface_code_bX_d5_r11_center_5_5": 4073, + "surface_code_bX_d5_r13_center_5_5": 4033, + "surface_code_bX_d5_r15_center_5_5": 4095, + "surface_code_bX_d5_r17_center_5_5": 4073, + "surface_code_bX_d5_r19_center_5_5": 4089, + "surface_code_bX_d5_r21_center_5_5": 4080, + "surface_code_bX_d5_r23_center_5_5": 4075, + "surface_code_bX_d5_r25_center_5_5": 4086, + "surface_code_bZ_d5_r01_center_5_5": 4086, + "surface_code_bZ_d5_r03_center_5_5": 3973, + "surface_code_bZ_d5_r05_center_5_5": 4051, + "surface_code_bZ_d5_r07_center_5_5": 3978, + "surface_code_bZ_d5_r09_center_5_5": 3994, + "surface_code_bZ_d5_r11_center_5_5": 4082, + "surface_code_bZ_d5_r13_center_5_5": 4088, + "surface_code_bZ_d5_r15_center_5_5": 3829, + "surface_code_bZ_d5_r17_center_5_5": 4008, + "surface_code_bZ_d5_r19_center_5_5": 4046, + "surface_code_bZ_d5_r21_center_5_5": 4086, + "surface_code_bZ_d5_r23_center_5_5": 4057, + "surface_code_bZ_d5_r25_center_5_5": 4086 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.0001, + "sampling_seed": 20261400, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": true, + "sampling_state_source": "Fresh NumPy default_rng seed 20261400", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_full/weights-1536.npz", + "starting_checkpoint_sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea", + "starting_training_provenance": { + "initialization": "Continue from the recorded session-trained checkpoint; original random initialization seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 491030, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 18670, + "surface_code_bX_d5_r03_center_5_5": 18940, + "surface_code_bX_d5_r05_center_5_5": 19128, + "surface_code_bX_d5_r07_center_5_5": 18988, + "surface_code_bX_d5_r09_center_5_5": 18523, + "surface_code_bX_d5_r11_center_5_5": 19227, + "surface_code_bX_d5_r13_center_5_5": 18816, + "surface_code_bX_d5_r15_center_5_5": 18107, + "surface_code_bX_d5_r17_center_5_5": 18728, + "surface_code_bX_d5_r19_center_5_5": 18983, + "surface_code_bX_d5_r21_center_5_5": 18959, + "surface_code_bX_d5_r23_center_5_5": 19079, + "surface_code_bX_d5_r25_center_5_5": 19193, + "surface_code_bZ_d5_r01_center_5_5": 18828, + "surface_code_bZ_d5_r03_center_5_5": 18896, + "surface_code_bZ_d5_r05_center_5_5": 19011, + "surface_code_bZ_d5_r07_center_5_5": 18806, + "surface_code_bZ_d5_r09_center_5_5": 18268, + "surface_code_bZ_d5_r11_center_5_5": 18927, + "surface_code_bZ_d5_r13_center_5_5": 19399, + "surface_code_bZ_d5_r15_center_5_5": 19358, + "surface_code_bZ_d5_r17_center_5_5": 18634, + "surface_code_bZ_d5_r19_center_5_5": 19126, + "surface_code_bZ_d5_r21_center_5_5": 18603, + "surface_code_bZ_d5_r23_center_5_5": 18626, + "surface_code_bZ_d5_r25_center_5_5": 19207 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 1536, + "batch": 1024, + "learning_rate": 0.0005, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": true, + "rng_restored": true, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "/run-state/workspace/research/learned_d5/fresh2_warm/rng-512.json", + "starting_checkpoint": "/run-state/workspace/research/learned_d5/fresh2_warm/weights-512.npz", + "starting_checkpoint_sha256": "d3e3abba07693bd7fd3d17be2dd981d5b803a496e76ba230ed94afeb51f26f4f", + "starting_training_provenance": { + "initialization": "All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed 20261134", + "prior_pass": 3, + "initial_seed": 20261134, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "runtime_versions": { + "jax": "0.7.2", + "numpy": "2.3.3", + "optax": "0.2.6" + }, + "hidden_width": 64, + "input_features": 394, + "feature_mode": "local events, reconstructed measurements, shot densities, physical edge support and conditioned prior", + "architecture": "Two 64-unit SiLU layers; 394 features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.", + "training": "All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.", + "training_cache": "/run-state/workspace/research/learned_d5/full_training_priors3", + "training_cache_provenance": { + "method": "Three undamped physical CSS extrinsic-message passes, clipping8, pass1/pass3 priors captured before logical readout", + "scope": "All supplied training rows in all26 d5 conditions; no validation or test labels used in cache generation", + "reused_rows": "4096 rows per condition from feedback5_cache, sampled with seed20261023; same first three passes", + "remaining_rows": "Computed now with last-only logical tracking; previously controlled against full logical tracking", + "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8", + "records": [ + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 44.93641114234924, + "elapsed": 45.15474009513855, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.11551070213318, + "elapsed": 88.52458453178406, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 39.70699763298035, + "elapsed": 128.4802794456482, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.178571701049805, + "elapsed": 169.95510387420654, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 41.53053879737854, + "elapsed": 211.7576286792755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 43.43117809295654, + "elapsed": 255.62733364105225, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 33.84876799583435, + "elapsed": 289.70106053352356, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 32.88018870353699, + "elapsed": 322.7981607913971, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.585307836532593, + "elapsed": 352.58776783943176, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.854028463363647, + "elapsed": 382.6393291950226, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 26.721288919448853, + "elapsed": 409.54919600486755, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.810269832611084, + "elapsed": 439.6440734863281, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 29.79407238960266, + "elapsed": 469.7887041568756, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 28.757604837417603, + "elapsed": 498.71140813827515, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.38013219833374, + "elapsed": 524.2447266578674, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 25.378958225250244, + "elapsed": 549.8600506782532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 21.241567850112915, + "elapsed": 571.2600774765015, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 18.780335664749146, + "elapsed": 590.304051399231, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.346807956695557, + "elapsed": 604.8041462898254, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 14.03441047668457, + "elapsed": 618.9537570476532, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.811666488647461, + "elapsed": 629.8610434532166, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 10.982703924179077, + "elapsed": 640.9919559955597, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.846271991729736, + "elapsed": 648.9624857902527, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 7.83586859703064, + "elapsed": 656.9065537452698, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.7685718536376953, + "elapsed": 657.7747800350189, + "peak_gpu_bytes": 58661028096 + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 19880, + "reused_training_rows": 4096, + "new_rows": 15784, + "seconds": 0.748960018157959, + "elapsed": 658.5666444301605, + "peak_gpu_bytes": 58661028096 + } + ], + "test_data_used": false + }, + "training_shots": 516880, + "training_pool_interpretation": "Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.", + "unique_training_rows_seen_in_this_phase": 325678, + "unique_rows_by_condition": { + "surface_code_bX_d5_r01_center_5_5": 11962, + "surface_code_bX_d5_r03_center_5_5": 10232, + "surface_code_bX_d5_r05_center_5_5": 14014, + "surface_code_bX_d5_r07_center_5_5": 11594, + "surface_code_bX_d5_r09_center_5_5": 12805, + "surface_code_bX_d5_r11_center_5_5": 11644, + "surface_code_bX_d5_r13_center_5_5": 13845, + "surface_code_bX_d5_r15_center_5_5": 10703, + "surface_code_bX_d5_r17_center_5_5": 15460, + "surface_code_bX_d5_r19_center_5_5": 14156, + "surface_code_bX_d5_r21_center_5_5": 11568, + "surface_code_bX_d5_r23_center_5_5": 14156, + "surface_code_bX_d5_r25_center_5_5": 12021, + "surface_code_bZ_d5_r01_center_5_5": 10601, + "surface_code_bZ_d5_r03_center_5_5": 14135, + "surface_code_bZ_d5_r05_center_5_5": 11975, + "surface_code_bZ_d5_r07_center_5_5": 13841, + "surface_code_bZ_d5_r09_center_5_5": 12024, + "surface_code_bZ_d5_r11_center_5_5": 11151, + "surface_code_bZ_d5_r13_center_5_5": 10640, + "surface_code_bZ_d5_r15_center_5_5": 11089, + "surface_code_bZ_d5_r17_center_5_5": 13788, + "surface_code_bZ_d5_r19_center_5_5": 12350, + "surface_code_bZ_d5_r21_center_5_5": 12797, + "surface_code_bZ_d5_r23_center_5_5": 12809, + "surface_code_bZ_d5_r25_center_5_5": 14318 + }, + "gradient_block_size": 32, + "bucket_operations": true, + "accumulate_conditions": 1, + "effective_batch_size": 1024, + "uncertainty_weight_floor": 1.0, + "example_weighting": "Uniform BCE", + "loss": "Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed", + "steps": 512, + "batch": 1024, + "learning_rate": 0.001, + "sampling_seed": 20261135, + "optimizer": "AdamW, weight decay 1e-4, global gradient norm clip 1", + "optimizer_restored": false, + "rng_restored": false, + "explicit_optimizer_reset": false, + "explicit_rng_reset": false, + "sampling_state_source": "Fresh NumPy default_rng seed 20261135", + "starting_checkpoint": null, + "starting_checkpoint_sha256": null, + "starting_training_provenance": null, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6522030830383301, + "objective": 0.6522030830383301, + "error": 0.375, + "gradient_norm": 0.11649785190820694, + "elapsed": 30.089841604232788 + }, + { + "step": 16, + "loss": 0.5927819609642029, + "objective": 0.5927819609642029, + "error": 0.3466796875, + "gradient_norm": 0.07945127785205841, + "elapsed": 48.85365080833435 + }, + { + "step": 32, + "loss": 0.3115929663181305, + "objective": 0.3115929663181305, + "error": 0.13671875, + "gradient_norm": 0.039320655167102814, + "elapsed": 63.60312819480896 + }, + { + "step": 48, + "loss": 0.2456369698047638, + "objective": 0.2456369698047638, + "error": 0.1015625, + "gradient_norm": 0.029398636892437935, + "elapsed": 73.71074151992798 + }, + { + "step": 64, + "loss": 0.6231744885444641, + "objective": 0.6231744885444641, + "error": 0.3759765625, + "gradient_norm": 0.06867238879203796, + "elapsed": 83.75580954551697 + }, + { + "step": 80, + "loss": 0.3674217164516449, + "objective": 0.3674217164516449, + "error": 0.1572265625, + "gradient_norm": 0.0557992123067379, + "elapsed": 94.6383364200592 + }, + { + "step": 96, + "loss": 0.5152362585067749, + "objective": 0.5152362585067749, + "error": 0.2568359375, + "gradient_norm": 0.08284599334001541, + "elapsed": 106.90000939369202 + }, + { + "step": 112, + "loss": 0.020773420110344887, + "objective": 0.020773420110344887, + "error": 0.0048828125, + "gradient_norm": 0.008813572116196156, + "elapsed": 117.77558088302612 + }, + { + "step": 128, + "loss": 0.02593131735920906, + "objective": 0.02593131735920906, + "error": 0.0087890625, + "gradient_norm": 0.00872033555060625, + "elapsed": 128.93439435958862 + }, + { + "step": 144, + "loss": 0.5852900743484497, + "objective": 0.5852900743484497, + "error": 0.3291015625, + "gradient_norm": 0.04771002382040024, + "elapsed": 139.5588686466217 + }, + { + "step": 160, + "loss": 0.46074625849723816, + "objective": 0.46074625849723816, + "error": 0.232421875, + "gradient_norm": 0.08834747970104218, + "elapsed": 151.5595977306366 + }, + { + "step": 176, + "loss": 0.6310865879058838, + "objective": 0.6310865879058838, + "error": 0.376953125, + "gradient_norm": 0.14084596931934357, + "elapsed": 163.7892107963562 + }, + { + "step": 192, + "loss": 0.246865376830101, + "objective": 0.246865376830101, + "error": 0.1103515625, + "gradient_norm": 0.041402049362659454, + "elapsed": 174.28971648216248 + }, + { + "step": 208, + "loss": 0.3103577196598053, + "objective": 0.3103577196598053, + "error": 0.15625, + "gradient_norm": 0.04525696486234665, + "elapsed": 187.03909611701965 + }, + { + "step": 224, + "loss": 0.4523138999938965, + "objective": 0.4523138999938965, + "error": 0.208984375, + "gradient_norm": 0.09180521965026855, + "elapsed": 199.56195068359375 + }, + { + "step": 240, + "loss": 0.02241751179099083, + "objective": 0.02241751179099083, + "error": 0.009765625, + "gradient_norm": 0.009998111054301262, + "elapsed": 212.35500597953796 + }, + { + "step": 256, + "loss": 0.5487150549888611, + "objective": 0.5487150549888611, + "error": 0.294921875, + "gradient_norm": 0.12748055160045624, + "elapsed": 223.03854608535767 + }, + { + "step": 272, + "loss": 0.023057367652654648, + "objective": 0.023057367652654648, + "error": 0.0078125, + "gradient_norm": 0.006953821517527103, + "elapsed": 244.6508972644806 + }, + { + "step": 288, + "loss": 0.5845386981964111, + "objective": 0.5845386981964111, + "error": 0.330078125, + "gradient_norm": 0.06542652100324631, + "elapsed": 256.78167748451233 + }, + { + "step": 304, + "loss": 0.442532479763031, + "objective": 0.442532479763031, + "error": 0.232421875, + "gradient_norm": 0.10874580591917038, + "elapsed": 269.1364529132843 + }, + { + "step": 320, + "loss": 0.3264174163341522, + "objective": 0.3264174163341522, + "error": 0.15625, + "gradient_norm": 0.06276191771030426, + "elapsed": 282.38969564437866 + }, + { + "step": 336, + "loss": 0.386960506439209, + "objective": 0.386960506439209, + "error": 0.177734375, + "gradient_norm": 0.06561421602964401, + "elapsed": 292.9079031944275 + }, + { + "step": 352, + "loss": 0.23919886350631714, + "objective": 0.23919886350631714, + "error": 0.107421875, + "gradient_norm": 0.02755703590810299, + "elapsed": 304.16068935394287 + }, + { + "step": 368, + "loss": 0.5029175281524658, + "objective": 0.5029175281524658, + "error": 0.259765625, + "gradient_norm": 0.0378776490688324, + "elapsed": 315.11088514328003 + }, + { + "step": 384, + "loss": 0.565666675567627, + "objective": 0.565666675567627, + "error": 0.322265625, + "gradient_norm": 0.11368246376514435, + "elapsed": 324.3651068210602 + }, + { + "step": 400, + "loss": 0.5846428275108337, + "objective": 0.5846428275108337, + "error": 0.3408203125, + "gradient_norm": 0.08116643130779266, + "elapsed": 334.70786476135254 + }, + { + "step": 416, + "loss": 0.025111017748713493, + "objective": 0.025111017748713493, + "error": 0.0078125, + "gradient_norm": 0.008838560432195663, + "elapsed": 345.56963562965393 + }, + { + "step": 432, + "loss": 0.628488302230835, + "objective": 0.628488302230835, + "error": 0.3818359375, + "gradient_norm": 0.04001976177096367, + "elapsed": 355.3310384750366 + }, + { + "step": 448, + "loss": 0.4569575786590576, + "objective": 0.4569575786590576, + "error": 0.2578125, + "gradient_norm": 0.06344135850667953, + "elapsed": 367.05255675315857 + }, + { + "step": 464, + "loss": 0.49193111062049866, + "objective": 0.49193111062049866, + "error": 0.24609375, + "gradient_norm": 0.06022385507822037, + "elapsed": 377.38399291038513 + }, + { + "step": 480, + "loss": 0.5920064449310303, + "objective": 0.5920064449310303, + "error": 0.3466796875, + "gradient_norm": 0.036063045263290405, + "elapsed": 387.7266733646393 + }, + { + "step": 496, + "loss": 0.22157302498817444, + "objective": 0.22157302498817444, + "error": 0.09375, + "gradient_norm": 0.04071022942662239, + "elapsed": 397.78643012046814 + }, + { + "step": 512, + "loss": 0.39216887950897217, + "objective": 0.39216887950897217, + "error": 0.1728515625, + "gradient_norm": 0.09079446643590927, + "elapsed": 407.0137679576874 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.6092928647994995, + "objective": 0.6092928647994995, + "error": 0.3583984375, + "gradient_norm": 0.08161187171936035, + "elapsed": 27.421262741088867 + }, + { + "step": 16, + "loss": 0.4709879755973816, + "objective": 0.4709879755973816, + "error": 0.2529296875, + "gradient_norm": 0.0541619211435318, + "elapsed": 48.74575757980347 + }, + { + "step": 32, + "loss": 0.5842419862747192, + "objective": 0.5842419862747192, + "error": 0.34375, + "gradient_norm": 0.09450904279947281, + "elapsed": 60.68022179603577 + }, + { + "step": 48, + "loss": 0.5840846300125122, + "objective": 0.5840846300125122, + "error": 0.32421875, + "gradient_norm": 0.04569687321782112, + "elapsed": 74.63272476196289 + }, + { + "step": 64, + "loss": 0.5139708518981934, + "objective": 0.5139708518981934, + "error": 0.2646484375, + "gradient_norm": 0.16111725568771362, + "elapsed": 91.88426613807678 + }, + { + "step": 80, + "loss": 0.49099838733673096, + "objective": 0.49099838733673096, + "error": 0.251953125, + "gradient_norm": 0.04431874305009842, + "elapsed": 105.08457684516907 + }, + { + "step": 96, + "loss": 0.30287861824035645, + "objective": 0.30287861824035645, + "error": 0.14453125, + "gradient_norm": 0.03792181238532066, + "elapsed": 118.16054177284241 + }, + { + "step": 112, + "loss": 0.6026535630226135, + "objective": 0.6026535630226135, + "error": 0.359375, + "gradient_norm": 0.043088704347610474, + "elapsed": 134.6414511203766 + }, + { + "step": 128, + "loss": 0.5983598828315735, + "objective": 0.5983598828315735, + "error": 0.328125, + "gradient_norm": 0.06492504477500916, + "elapsed": 148.38875198364258 + }, + { + "step": 144, + "loss": 0.616276204586029, + "objective": 0.616276204586029, + "error": 0.3857421875, + "gradient_norm": 0.05420554056763649, + "elapsed": 164.11315298080444 + }, + { + "step": 160, + "loss": 0.017882924526929855, + "objective": 0.017882924526929855, + "error": 0.0048828125, + "gradient_norm": 0.004682278726249933, + "elapsed": 178.31525373458862 + }, + { + "step": 176, + "loss": 0.5279660820960999, + "objective": 0.5279660820960999, + "error": 0.271484375, + "gradient_norm": 0.03895021602511406, + "elapsed": 192.20261907577515 + }, + { + "step": 192, + "loss": 0.5794406533241272, + "objective": 0.5794406533241272, + "error": 0.34375, + "gradient_norm": 0.041880734264850616, + "elapsed": 200.32051873207092 + }, + { + "step": 208, + "loss": 0.3353561758995056, + "objective": 0.3353561758995056, + "error": 0.1513671875, + "gradient_norm": 0.07022152841091156, + "elapsed": 212.5193521976471 + }, + { + "step": 224, + "loss": 0.47239983081817627, + "objective": 0.47239983081817627, + "error": 0.23828125, + "gradient_norm": 0.044771477580070496, + "elapsed": 223.36571788787842 + }, + { + "step": 240, + "loss": 0.6235381364822388, + "objective": 0.6235381364822388, + "error": 0.3779296875, + "gradient_norm": 0.047636937350034714, + "elapsed": 233.90032649040222 + }, + { + "step": 256, + "loss": 0.516319751739502, + "objective": 0.516319751739502, + "error": 0.271484375, + "gradient_norm": 0.087476447224617, + "elapsed": 245.52193427085876 + }, + { + "step": 272, + "loss": 0.23385891318321228, + "objective": 0.23385891318321228, + "error": 0.091796875, + "gradient_norm": 0.05921977758407593, + "elapsed": 254.38622951507568 + }, + { + "step": 288, + "loss": 0.31280556321144104, + "objective": 0.31280556321144104, + "error": 0.1318359375, + "gradient_norm": 0.03548427298665047, + "elapsed": 263.25871300697327 + }, + { + "step": 304, + "loss": 0.6208417415618896, + "objective": 0.6208417415618896, + "error": 0.361328125, + "gradient_norm": 0.10255666077136993, + "elapsed": 273.5115919113159 + }, + { + "step": 320, + "loss": 0.5985375642776489, + "objective": 0.5985375642776489, + "error": 0.3603515625, + "gradient_norm": 0.04024764895439148, + "elapsed": 285.4135670661926 + }, + { + "step": 336, + "loss": 0.028151696547865868, + "objective": 0.028151696547865868, + "error": 0.009765625, + "gradient_norm": 0.008847440592944622, + "elapsed": 295.0800693035126 + }, + { + "step": 352, + "loss": 0.6147637963294983, + "objective": 0.6147637963294983, + "error": 0.3603515625, + "gradient_norm": 0.05709920823574066, + "elapsed": 305.32019686698914 + }, + { + "step": 368, + "loss": 0.5955979824066162, + "objective": 0.5955979824066162, + "error": 0.3486328125, + "gradient_norm": 0.04276399686932564, + "elapsed": 316.3869025707245 + }, + { + "step": 384, + "loss": 0.23504304885864258, + "objective": 0.23504304885864258, + "error": 0.1025390625, + "gradient_norm": 0.03205326199531555, + "elapsed": 325.7849349975586 + }, + { + "step": 400, + "loss": 0.13460804522037506, + "objective": 0.13460804522037506, + "error": 0.0546875, + "gradient_norm": 0.03109711967408657, + "elapsed": 335.72691917419434 + }, + { + "step": 416, + "loss": 0.5798783302307129, + "objective": 0.5798783302307129, + "error": 0.322265625, + "gradient_norm": 0.053542010486125946, + "elapsed": 345.7052640914917 + }, + { + "step": 432, + "loss": 0.3892784118652344, + "objective": 0.3892784118652344, + "error": 0.19140625, + "gradient_norm": 0.052194178104400635, + "elapsed": 357.38475036621094 + }, + { + "step": 448, + "loss": 0.23582103848457336, + "objective": 0.23582103848457336, + "error": 0.1181640625, + "gradient_norm": 0.032037943601608276, + "elapsed": 369.5841510295868 + }, + { + "step": 464, + "loss": 0.5408849716186523, + "objective": 0.5408849716186523, + "error": 0.2900390625, + "gradient_norm": 0.07508285343647003, + "elapsed": 379.84099793434143 + }, + { + "step": 480, + "loss": 0.3894873559474945, + "objective": 0.3894873559474945, + "error": 0.19140625, + "gradient_norm": 0.03977999836206436, + "elapsed": 390.9687530994415 + }, + { + "step": 496, + "loss": 0.6059300899505615, + "objective": 0.6059300899505615, + "error": 0.361328125, + "gradient_norm": 0.06041429564356804, + "elapsed": 403.2380111217499 + }, + { + "step": 512, + "loss": 0.2117740511894226, + "objective": 0.2117740511894226, + "error": 0.0908203125, + "gradient_norm": 0.05693414434790611, + "elapsed": 414.4854781627655 + }, + { + "step": 528, + "loss": 0.4666211009025574, + "objective": 0.4666211009025574, + "error": 0.2470703125, + "gradient_norm": 0.0764947235584259, + "elapsed": 433.42368054389954 + }, + { + "step": 544, + "loss": 0.22636458277702332, + "objective": 0.22636458277702332, + "error": 0.1083984375, + "gradient_norm": 0.03683016076683998, + "elapsed": 442.92575907707214 + }, + { + "step": 560, + "loss": 0.23172692954540253, + "objective": 0.23172692954540253, + "error": 0.1083984375, + "gradient_norm": 0.034071482717990875, + "elapsed": 453.3129711151123 + }, + { + "step": 576, + "loss": 0.4768703579902649, + "objective": 0.4768703579902649, + "error": 0.2529296875, + "gradient_norm": 0.06308378279209137, + "elapsed": 462.4127457141876 + }, + { + "step": 592, + "loss": 0.5165150165557861, + "objective": 0.5165150165557861, + "error": 0.291015625, + "gradient_norm": 0.07674732059240341, + "elapsed": 473.8309862613678 + }, + { + "step": 608, + "loss": 0.5919064283370972, + "objective": 0.5919064283370972, + "error": 0.3359375, + "gradient_norm": 0.06379934400320053, + "elapsed": 484.3733870983124 + }, + { + "step": 624, + "loss": 0.01804366335272789, + "objective": 0.01804366335272789, + "error": 0.0068359375, + "gradient_norm": 0.005318541545420885, + "elapsed": 495.94076347351074 + }, + { + "step": 640, + "loss": 0.41747498512268066, + "objective": 0.41747498512268066, + "error": 0.1962890625, + "gradient_norm": 0.052116431295871735, + "elapsed": 506.73559165000916 + }, + { + "step": 656, + "loss": 0.6140056848526001, + "objective": 0.6140056848526001, + "error": 0.3896484375, + "gradient_norm": 0.05376415699720383, + "elapsed": 517.2397899627686 + }, + { + "step": 672, + "loss": 0.4098930358886719, + "objective": 0.4098930358886719, + "error": 0.197265625, + "gradient_norm": 0.04737741872668266, + "elapsed": 525.7957897186279 + }, + { + "step": 688, + "loss": 0.3499884009361267, + "objective": 0.3499884009361267, + "error": 0.1650390625, + "gradient_norm": 0.0714973583817482, + "elapsed": 534.9302124977112 + }, + { + "step": 704, + "loss": 0.552291989326477, + "objective": 0.552291989326477, + "error": 0.3095703125, + "gradient_norm": 0.10188189148902893, + "elapsed": 545.4470670223236 + }, + { + "step": 720, + "loss": 0.4040689468383789, + "objective": 0.4040689468383789, + "error": 0.1943359375, + "gradient_norm": 0.06630362570285797, + "elapsed": 554.2920794487 + }, + { + "step": 736, + "loss": 0.3191133439540863, + "objective": 0.3191133439540863, + "error": 0.15625, + "gradient_norm": 0.060587506741285324, + "elapsed": 562.335791349411 + }, + { + "step": 752, + "loss": 0.5949387550354004, + "objective": 0.5949387550354004, + "error": 0.330078125, + "gradient_norm": 0.051291145384311676, + "elapsed": 570.9363489151001 + }, + { + "step": 768, + "loss": 0.4783790409564972, + "objective": 0.4783790409564972, + "error": 0.244140625, + "gradient_norm": 0.08808670938014984, + "elapsed": 581.1555306911469 + }, + { + "step": 784, + "loss": 0.4414710998535156, + "objective": 0.4414710998535156, + "error": 0.20703125, + "gradient_norm": 0.06632383912801743, + "elapsed": 590.4109175205231 + }, + { + "step": 800, + "loss": 0.2536136507987976, + "objective": 0.2536136507987976, + "error": 0.1142578125, + "gradient_norm": 0.03191893920302391, + "elapsed": 601.43274974823 + }, + { + "step": 816, + "loss": 0.22448071837425232, + "objective": 0.22448071837425232, + "error": 0.1015625, + "gradient_norm": 0.04966023191809654, + "elapsed": 612.7252013683319 + }, + { + "step": 832, + "loss": 0.5342355966567993, + "objective": 0.5342355966567993, + "error": 0.2783203125, + "gradient_norm": 0.05757307633757591, + "elapsed": 623.6647284030914 + }, + { + "step": 848, + "loss": 0.2506354749202728, + "objective": 0.2506354749202728, + "error": 0.109375, + "gradient_norm": 0.03991081938147545, + "elapsed": 635.1636409759521 + }, + { + "step": 864, + "loss": 0.40698009729385376, + "objective": 0.40698009729385376, + "error": 0.1953125, + "gradient_norm": 0.09155476838350296, + "elapsed": 645.2128469944 + }, + { + "step": 880, + "loss": 0.563283383846283, + "objective": 0.563283383846283, + "error": 0.3134765625, + "gradient_norm": 0.11409252882003784, + "elapsed": 659.2946681976318 + }, + { + "step": 896, + "loss": 0.13591040670871735, + "objective": 0.13591040670871735, + "error": 0.064453125, + "gradient_norm": 0.02692740224301815, + "elapsed": 668.6167254447937 + }, + { + "step": 912, + "loss": 0.5798318982124329, + "objective": 0.5798318982124329, + "error": 0.3310546875, + "gradient_norm": 0.06674209237098694, + "elapsed": 680.6492185592651 + }, + { + "step": 928, + "loss": 0.6140691041946411, + "objective": 0.6140691041946411, + "error": 0.3857421875, + "gradient_norm": 0.06117575615644455, + "elapsed": 693.1704411506653 + }, + { + "step": 944, + "loss": 0.3964633643627167, + "objective": 0.3964633643627167, + "error": 0.1865234375, + "gradient_norm": 0.08617512136697769, + "elapsed": 708.2128443717957 + }, + { + "step": 960, + "loss": 0.5512299537658691, + "objective": 0.5512299537658691, + "error": 0.2861328125, + "gradient_norm": 0.05705108866095543, + "elapsed": 720.2417063713074 + }, + { + "step": 976, + "loss": 0.454137921333313, + "objective": 0.454137921333313, + "error": 0.216796875, + "gradient_norm": 0.07962293922901154, + "elapsed": 730.2567391395569 + }, + { + "step": 992, + "loss": 0.5681213140487671, + "objective": 0.5681213140487671, + "error": 0.3017578125, + "gradient_norm": 0.09802286326885223, + "elapsed": 742.7380962371826 + }, + { + "step": 1008, + "loss": 0.13060352206230164, + "objective": 0.13060352206230164, + "error": 0.0537109375, + "gradient_norm": 0.04271279275417328, + "elapsed": 750.8077793121338 + }, + { + "step": 1024, + "loss": 0.6129879355430603, + "objective": 0.6129879355430603, + "error": 0.3603515625, + "gradient_norm": 0.04127912223339081, + "elapsed": 761.0585849285126 + }, + { + "step": 1040, + "loss": 0.31361687183380127, + "objective": 0.31361687183380127, + "error": 0.1455078125, + "gradient_norm": 0.04341907799243927, + "elapsed": 776.3491418361664 + }, + { + "step": 1056, + "loss": 0.6326502561569214, + "objective": 0.6326502561569214, + "error": 0.365234375, + "gradient_norm": 0.07518075406551361, + "elapsed": 786.0424168109894 + }, + { + "step": 1072, + "loss": 0.537599503993988, + "objective": 0.537599503993988, + "error": 0.2958984375, + "gradient_norm": 0.08455493301153183, + "elapsed": 795.1607735157013 + }, + { + "step": 1088, + "loss": 0.5953108072280884, + "objective": 0.5953108072280884, + "error": 0.337890625, + "gradient_norm": 0.06973882764577866, + "elapsed": 804.0053510665894 + }, + { + "step": 1104, + "loss": 0.36860400438308716, + "objective": 0.36860400438308716, + "error": 0.1923828125, + "gradient_norm": 0.04828036576509476, + "elapsed": 813.4029138088226 + }, + { + "step": 1120, + "loss": 0.5423247218132019, + "objective": 0.5423247218132019, + "error": 0.28125, + "gradient_norm": 0.04841453209519386, + "elapsed": 823.626978635788 + }, + { + "step": 1136, + "loss": 0.4766136407852173, + "objective": 0.4766136407852173, + "error": 0.236328125, + "gradient_norm": 0.07564551383256912, + "elapsed": 832.4641265869141 + }, + { + "step": 1152, + "loss": 0.5473434925079346, + "objective": 0.5473434925079346, + "error": 0.2958984375, + "gradient_norm": 0.13677075505256653, + "elapsed": 844.9307618141174 + }, + { + "step": 1168, + "loss": 0.3040686249732971, + "objective": 0.3040686249732971, + "error": 0.150390625, + "gradient_norm": 0.045926257967948914, + "elapsed": 854.336992263794 + }, + { + "step": 1184, + "loss": 0.6298375129699707, + "objective": 0.6298375129699707, + "error": 0.3798828125, + "gradient_norm": 0.06807851791381836, + "elapsed": 864.5731596946716 + }, + { + "step": 1200, + "loss": 0.6272540092468262, + "objective": 0.6272540092468262, + "error": 0.37890625, + "gradient_norm": 0.139838308095932, + "elapsed": 877.8357374668121 + }, + { + "step": 1216, + "loss": 0.5224937200546265, + "objective": 0.5224937200546265, + "error": 0.287109375, + "gradient_norm": 0.0647057592868805, + "elapsed": 887.8107197284698 + }, + { + "step": 1232, + "loss": 0.02408422902226448, + "objective": 0.02408422902226448, + "error": 0.0107421875, + "gradient_norm": 0.007562167476862669, + "elapsed": 902.201171875 + }, + { + "step": 1248, + "loss": 0.01936865597963333, + "objective": 0.01936865597963333, + "error": 0.0048828125, + "gradient_norm": 0.006423021201044321, + "elapsed": 914.0247437953949 + }, + { + "step": 1264, + "loss": 0.47522181272506714, + "objective": 0.47522181272506714, + "error": 0.2490234375, + "gradient_norm": 0.04962826892733574, + "elapsed": 927.0462884902954 + }, + { + "step": 1280, + "loss": 0.019577551633119583, + "objective": 0.019577551633119583, + "error": 0.0068359375, + "gradient_norm": 0.008308992721140385, + "elapsed": 939.3647270202637 + }, + { + "step": 1296, + "loss": 0.5085430145263672, + "objective": 0.5085430145263672, + "error": 0.2734375, + "gradient_norm": 0.06214233115315437, + "elapsed": 949.4259700775146 + }, + { + "step": 1312, + "loss": 0.23232896625995636, + "objective": 0.23232896625995636, + "error": 0.1015625, + "gradient_norm": 0.05894213914871216, + "elapsed": 961.3636543750763 + }, + { + "step": 1328, + "loss": 0.5330536365509033, + "objective": 0.5330536365509033, + "error": 0.2861328125, + "gradient_norm": 0.11579663306474686, + "elapsed": 972.1607241630554 + }, + { + "step": 1344, + "loss": 0.019525721669197083, + "objective": 0.019525721669197083, + "error": 0.0087890625, + "gradient_norm": 0.008134250529110432, + "elapsed": 983.0828921794891 + }, + { + "step": 1360, + "loss": 0.22790294885635376, + "objective": 0.22790294885635376, + "error": 0.103515625, + "gradient_norm": 0.04187086224555969, + "elapsed": 991.3167304992676 + }, + { + "step": 1376, + "loss": 0.48713046312332153, + "objective": 0.48713046312332153, + "error": 0.2666015625, + "gradient_norm": 0.06267429888248444, + "elapsed": 1003.5033710002899 + }, + { + "step": 1392, + "loss": 0.6043434143066406, + "objective": 0.6043434143066406, + "error": 0.369140625, + "gradient_norm": 0.037880122661590576, + "elapsed": 1017.8567223548889 + }, + { + "step": 1408, + "loss": 0.034499723464250565, + "objective": 0.034499723464250565, + "error": 0.0068359375, + "gradient_norm": 0.013505477458238602, + "elapsed": 1027.3547134399414 + }, + { + "step": 1424, + "loss": 0.5320160388946533, + "objective": 0.5320160388946533, + "error": 0.306640625, + "gradient_norm": 0.07510018348693848, + "elapsed": 1036.9454221725464 + }, + { + "step": 1440, + "loss": 0.3451523780822754, + "objective": 0.3451523780822754, + "error": 0.171875, + "gradient_norm": 0.06453985720872879, + "elapsed": 1046.1805095672607 + }, + { + "step": 1456, + "loss": 0.21541815996170044, + "objective": 0.21541815996170044, + "error": 0.08984375, + "gradient_norm": 0.043503839522600174, + "elapsed": 1055.850379705429 + }, + { + "step": 1472, + "loss": 0.43667086958885193, + "objective": 0.43667086958885193, + "error": 0.22265625, + "gradient_norm": 0.07311506569385529, + "elapsed": 1066.6324400901794 + }, + { + "step": 1488, + "loss": 0.6163139939308167, + "objective": 0.6163139939308167, + "error": 0.3779296875, + "gradient_norm": 0.06406569480895996, + "elapsed": 1075.7883398532867 + }, + { + "step": 1504, + "loss": 0.23901250958442688, + "objective": 0.23901250958442688, + "error": 0.10546875, + "gradient_norm": 0.04792191833257675, + "elapsed": 1085.4756922721863 + }, + { + "step": 1520, + "loss": 0.3817014694213867, + "objective": 0.3817014694213867, + "error": 0.18359375, + "gradient_norm": 0.046061187982559204, + "elapsed": 1095.974383354187 + }, + { + "step": 1536, + "loss": 0.5593156814575195, + "objective": 0.5593156814575195, + "error": 0.3017578125, + "gradient_norm": 0.0735388696193695, + "elapsed": 1105.913155078888 + } + ] + }, + "validation": "Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication", + "validation_shots_per_condition": 1024, + "test_data_used": false, + "records": [ + { + "step": 1, + "loss": 0.5881413221359253, + "objective": 0.5881413221359253, + "error": 0.3369140625, + "gradient_norm": 0.08291956782341003, + "elapsed": 23.48729920387268 + }, + { + "step": 16, + "loss": 0.502086341381073, + "objective": 0.502086341381073, + "error": 0.26171875, + "gradient_norm": 0.07637006789445877, + "elapsed": 44.39913535118103 + }, + { + "step": 32, + "loss": 0.5353690981864929, + "objective": 0.5353690981864929, + "error": 0.2958984375, + "gradient_norm": 0.06264567375183105, + "elapsed": 55.7660174369812 + }, + { + "step": 48, + "loss": 0.02578452043235302, + "objective": 0.02578452043235302, + "error": 0.0087890625, + "gradient_norm": 0.018823392689228058, + "elapsed": 66.00806975364685 + }, + { + "step": 64, + "loss": 0.48237740993499756, + "objective": 0.48237740993499756, + "error": 0.2587890625, + "gradient_norm": 0.11103151738643646, + "elapsed": 79.09161877632141 + }, + { + "step": 80, + "loss": 0.014869043603539467, + "objective": 0.014869043603539467, + "error": 0.0048828125, + "gradient_norm": 0.0035882671363651752, + "elapsed": 90.1970727443695 + }, + { + "step": 96, + "loss": 0.46030884981155396, + "objective": 0.46030884981155396, + "error": 0.2509765625, + "gradient_norm": 0.061675507575273514, + "elapsed": 101.26038980484009 + }, + { + "step": 112, + "loss": 0.029823757708072662, + "objective": 0.029823757708072662, + "error": 0.0087890625, + "gradient_norm": 0.010024171322584152, + "elapsed": 110.03156900405884 + }, + { + "step": 128, + "loss": 0.5630518198013306, + "objective": 0.5630518198013306, + "error": 0.3173828125, + "gradient_norm": 0.05113575980067253, + "elapsed": 120.53027200698853 + }, + { + "step": 144, + "loss": 0.4569598436355591, + "objective": 0.4569598436355591, + "error": 0.2548828125, + "gradient_norm": 0.07764673978090286, + "elapsed": 130.75372648239136 + }, + { + "step": 160, + "loss": 0.6147853136062622, + "objective": 0.6147853136062622, + "error": 0.359375, + "gradient_norm": 0.05682089179754257, + "elapsed": 142.11531591415405 + }, + { + "step": 176, + "loss": 0.6308855414390564, + "objective": 0.6308855414390564, + "error": 0.3681640625, + "gradient_norm": 0.05234925076365471, + "elapsed": 154.08127236366272 + }, + { + "step": 192, + "loss": 0.5855196714401245, + "objective": 0.5855196714401245, + "error": 0.33984375, + "gradient_norm": 0.05840183421969414, + "elapsed": 164.33522963523865 + }, + { + "step": 208, + "loss": 0.41838279366493225, + "objective": 0.41838279366493225, + "error": 0.208984375, + "gradient_norm": 0.06075137481093407, + "elapsed": 176.81598925590515 + }, + { + "step": 224, + "loss": 0.1997503936290741, + "objective": 0.1997503936290741, + "error": 0.0830078125, + "gradient_norm": 0.08286777883768082, + "elapsed": 187.0221254825592 + }, + { + "step": 240, + "loss": 0.6210553050041199, + "objective": 0.6210553050041199, + "error": 0.375, + "gradient_norm": 0.05884546786546707, + "elapsed": 198.94637846946716 + }, + { + "step": 256, + "loss": 0.17126862704753876, + "objective": 0.17126862704753876, + "error": 0.0625, + "gradient_norm": 0.037614110857248306, + "elapsed": 209.13299751281738 + }, + { + "step": 272, + "loss": 0.40841472148895264, + "objective": 0.40841472148895264, + "error": 0.2021484375, + "gradient_norm": 0.09548575431108475, + "elapsed": 225.90833830833435 + }, + { + "step": 288, + "loss": 0.5768122673034668, + "objective": 0.5768122673034668, + "error": 0.341796875, + "gradient_norm": 0.05774112790822983, + "elapsed": 235.85267281532288 + }, + { + "step": 304, + "loss": 0.6053926944732666, + "objective": 0.6053926944732666, + "error": 0.353515625, + "gradient_norm": 0.1182902604341507, + "elapsed": 247.4910695552826 + }, + { + "step": 320, + "loss": 0.1564791351556778, + "objective": 0.1564791351556778, + "error": 0.0654296875, + "gradient_norm": 0.03618538752198219, + "elapsed": 260.2975630760193 + }, + { + "step": 336, + "loss": 0.2477060854434967, + "objective": 0.2477060854434967, + "error": 0.1123046875, + "gradient_norm": 0.0420403927564621, + "elapsed": 271.92711758613586 + }, + { + "step": 352, + "loss": 0.021552149206399918, + "objective": 0.021552149206399918, + "error": 0.0087890625, + "gradient_norm": 0.008260722272098064, + "elapsed": 284.4344198703766 + }, + { + "step": 368, + "loss": 0.017769455909729004, + "objective": 0.017769455909729004, + "error": 0.005859375, + "gradient_norm": 0.007968166843056679, + "elapsed": 293.4922397136688 + }, + { + "step": 384, + "loss": 0.13265271484851837, + "objective": 0.13265271484851837, + "error": 0.052734375, + "gradient_norm": 0.03565056249499321, + "elapsed": 304.59369254112244 + }, + { + "step": 400, + "loss": 0.6161723136901855, + "objective": 0.6161723136901855, + "error": 0.3603515625, + "gradient_norm": 0.08742408454418182, + "elapsed": 315.67102909088135 + }, + { + "step": 416, + "loss": 0.6278735399246216, + "objective": 0.6278735399246216, + "error": 0.3779296875, + "gradient_norm": 0.06798138469457626, + "elapsed": 325.0327904224396 + }, + { + "step": 432, + "loss": 0.4908595085144043, + "objective": 0.4908595085144043, + "error": 0.271484375, + "gradient_norm": 0.1032123789191246, + "elapsed": 333.5508737564087 + }, + { + "step": 448, + "loss": 0.6096877455711365, + "objective": 0.6096877455711365, + "error": 0.359375, + "gradient_norm": 0.05942204222083092, + "elapsed": 344.0580425262451 + }, + { + "step": 464, + "loss": 0.6265090703964233, + "objective": 0.6265090703964233, + "error": 0.3798828125, + "gradient_norm": 0.0800209492444992, + "elapsed": 354.0210793018341 + }, + { + "step": 480, + "loss": 0.03691313415765762, + "objective": 0.03691313415765762, + "error": 0.009765625, + "gradient_norm": 0.017540218308568, + "elapsed": 364.5313858985901 + }, + { + "step": 496, + "loss": 0.617385745048523, + "objective": 0.617385745048523, + "error": 0.349609375, + "gradient_norm": 0.06501252949237823, + "elapsed": 377.97098994255066 + }, + { + "step": 512, + "loss": 0.5908491015434265, + "objective": 0.5908491015434265, + "error": 0.3447265625, + "gradient_norm": 0.11100064218044281, + "elapsed": 388.5160744190216 + } + ], + "declared_plan": { + "name": "prior_pass1", + "status": "Launched after posterior-context study; actual current-runtime GPU control passed", + "hypothesis": "The edge correction learned with three physical feedback passes may benefit from adaptation to five-pass priors. A matched three-pass continuation distinguishes prior quality from additional optimization on the smaller cached training pool.", + "parent": "learned_d5/fresh2_full/weights-1536.npz", + "initialization": "Both arms start from the same session-trained parent, originally random seed20261134. Restore all parameters and Adam moments/count2048. No new parameters. Explicitly reset sampling RNG to20261400 in each arm.", + "training_rows": "The same existing4096 training rows per each of all26d5conditions,106496eligible rows. Cached indices were sampled without replacement using seed20261023. They are previously used training rows, not held-out labels.", + "arms": [ + 3, + 5 + ], + "steps": 512, + "batch": 1024, + "learning_rate": 0.0001, + "sampling_seed": 20261400, + "optimizer": "AdamW decay1e-4, global gradient norm clipping1, restored parent state", + "loss": "Uniform conditional logical BCE through exact relevant-CSS contraction; cached physical priors fixed", + "selection": "Raw pass3 checkpoints256/512 and raw pass5 checkpoints0/256/512 versus current incumbent, separately perbasis over all13durations. Ties retain incumbent. Parent pass3 full predictions already exist and are reused for the scientific comparison; no confirmation retraining or new pass3-zero selection.", + "selection_steps": { + "3": [ + 256, + 512 + ], + "5": [ + 0, + 256, + 512 + ] + }, + "screen": "1024 validation rows percondition with existing seed20261102; screen does not add selection candidates", + "runtime": "Existing raw neural runtime already supports prior_pass5. No new wrapper is needed. Actual replay must include all five physical passes and satisfy projected3600s limit.", + "controls": "Training-only cache alignment and hash audit; short discarded CPU pipeline runs for both arms; restored-state and complete sampling replay; current-runtime CPU check and actual assembled-runtime GPU check after predecessor finishes", + "selection_declared_before_new_pass5_neural_evaluation": true, + "test_data_used": false, + "prepared_utc": "2026-10-21T16:40:08.094485+00:00", + "frozen_source_sha256": { + "prior_pass_study/after_posterior.py": "1cadb20b1fe4ead41f00baebb62541167ab6e8b916b5bb02fe6cacadbc4502d7", + "prior_pass_study/package.py": "f9915505bac8c81a402f23a7dcf06b5278dfb06b418a0cc25c48797a141cfc73", + "prior_pass_study/cpu_smoke.py": "9f7ee28f797ca46ff403f6af1836596664988e8414de60b0f792c86c2b2ca3b1", + "prior_pass_study/runtime_control.py": "06e725750085d90d1bba1e4ebfd49557f2c19787946614325064e648a011de20", + "prior_pass_study/audit_run.py": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da", + "prior_pass_study/cache_audit.py": "6a6f34061e048af6e5e7bedcdbe124aeee64c324bf69e482c45b10c2e92f2b5e", + "learned_d5/evaluate.py": "647c7e3964d8def7948c105f49c31a7237f99e32272ab45388a3ed6069b0cf9b" + }, + "launch_utc": "2026-10-21T17:40:38.975372+00:00" + }, + "sampling_audit": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 524288, + "distinct_rows_seen": 105004, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 256, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2304 + }, + { + "step": 512, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2560 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + }, + "pipeline_control": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 controls, not eligible for selection or submission", + "arms": { + "3": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 2, + "distinct_rows_seen": 2, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 1, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2049 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + }, + "5": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 2, + "distinct_rows_seen": 2, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 1, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2049 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + } + }, + "matched_sampling_states_exact": true, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_source_sha256": "9f7ee28f797ca46ff403f6af1836596664988e8414de60b0f792c86c2b2ca3b1", + "test_data_used": false + }, + "cache_audit": { + "status": "passed", + "scope": "Training-only row/label/feature comparison; validation cache shapes checked, validation labels not read", + "training_rows": 106496, + "training_subset_seed": 20261023, + "records": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 0.0, + "input_sha256": "0de3fe461bfa141fc49f1cd2cf4c7d4a9cf1e835d9619dd55d81f92ec9011a2a", + "turbo_cache_sha256": "441736f9bdba176272888dba8787dce1c2fbacd7250169962707a5eea27f6a37", + "feedback_cache_sha256": "a8f3d5cf4ccd279ba3060a8db2737203bb172416b82b0eb913469e14790e0817" + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.68849515914917, + "input_sha256": "512c32ea26171d1d0f13ad197c5134a24ea2e2814168abc31c1d261b5ec45a80", + "turbo_cache_sha256": "9847461cc42fee9c90414f78fd0e78305f8f6ed118d930b29426d27f5a4cf548", + "feedback_cache_sha256": "d8e4e5fe2eb3c2c75cd32613c9e4513ca042bf53d82f6fdf97298a41206ddc6f" + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9068970680236816, + "input_sha256": "422273891bb97dca7f4913ca15cc3433e108a4ea795dcbfd871ff1ee185cb3c1", + "turbo_cache_sha256": "ab1e3b7376f7883031983d385950ba67747e828735396ac1b63170b7141f8ed4", + "feedback_cache_sha256": "33c8b8c5d617eafdb32f790958139199b21126176a03a9792429e78dff88af19" + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.2904839515686035, + "input_sha256": "45c5f49d60d35858e7c829bcfa8a1c5c37e1c9c17aba60c6610f2d20b4b34967", + "turbo_cache_sha256": "c6abca56049ea6b82d247c8bf79c0a9a6f19e9cf60a4e4a2723c2a17a6a88448", + "feedback_cache_sha256": "4f31e1be93fd66b3d227de72416e3de1c8ba294b5cf55bb9c0d59e0a295da6e8" + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.7693614959716797, + "input_sha256": "d0b3ff6031a2c2e6bd1d4a058b45725345a67c3403e0bd21f679f6f0d329c787", + "turbo_cache_sha256": "18a81a4ca70c5c5c08deda38d43955c5a42ffd961a212e2ee6c783dd4837d49f", + "feedback_cache_sha256": "b420124bbebdf7e99ffe57ab3624569cc93379290c43594f5f2ccfea4684b51e" + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.163759469985962, + "input_sha256": "18fab0c6789333021da1ac6115028694717c9009da0fd2b1face03e8efc28884", + "turbo_cache_sha256": "92b7fd80f827e20349b7cec2b87e5e5cd4f4046a8fcb17201db33cb3e178a82e", + "feedback_cache_sha256": "41939274bd8b08684de8f6d201f9527302613400497545cb001ee59129648f87" + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9551092386245728, + "input_sha256": "0efb3e7203badf4a61c2cb5fe27a2ff3ad8928ed80b27c53488a453492948d7d", + "turbo_cache_sha256": "526567a159461dabf2f3aa67ce4848b336b11eb0a8cb9ecde604d094173d6deb", + "feedback_cache_sha256": "12d6f49dca817de1de639081b4fca7c9b74f53daf057165945a5c9ee4f72d86f" + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 3.5012946128845215, + "input_sha256": "957bb2f3b59b726696917ad60ce0775e9ecc1b40f4d610acb7e1f8f66e3c9512", + "turbo_cache_sha256": "44310eacdb54599d2370a86be3161e6c6d3752c41e59a76822ad90a8a39023b1", + "feedback_cache_sha256": "1172de602cca7bd6d039cde49596535ad8f656f3c2e5d644adab4cd1c06bae4f" + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 3.163731575012207, + "input_sha256": "d7044a2673b4d2f927c5082bd8f76c1e8feb2b2d64851c691de1d818ca7aba36", + "turbo_cache_sha256": "ad18d21a2e824bab2f16163774eb8356d96f2f4163800c1fc55ca0b2a6f68c55", + "feedback_cache_sha256": "4acef03709505af3a50f8fb82a7b839ad8a48f4de4e965f3dad35adb37ca756e" + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9745681285858154, + "input_sha256": "be6a20ba225022b8cd8b6529988c614d1edfca2dee7b966ef918fd91a1551528", + "turbo_cache_sha256": "f8d8046214fef19c419e5bc550c112fb056d0bc48e5b7b83f3d47f96b188426c", + "feedback_cache_sha256": "ae79c9c1b75cc4c46ca9b7e78ade17683023663607b615945c73d02367d0f063" + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.541386604309082, + "input_sha256": "a65c605895dc6d4d879b1edce2442e65c795e31cbb4775f260d6303a1864b9b6", + "turbo_cache_sha256": "dcd8bff02e2f1ff95e6dbfb5a8589f2037eaa3f50d7352361fd7bd8bcaa9528e", + "feedback_cache_sha256": "cc2c8098c741208092efc3d40f38d4ccf366b2d95c89396155620411622c7eb0" + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.212656021118164, + "input_sha256": "b89334defc3d8367e03a46501634b7d80638d60710784650cfa56f372dd1e832", + "turbo_cache_sha256": "eb68a945e1da883c2573bba4fba0a297d07df8382cea297b31501d1d870538a9", + "feedback_cache_sha256": "a79d3a7db0de0531aae43afef3fd194ee4b799a63e499f7939cab8b35e9de3dd" + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9682941436767578, + "input_sha256": "2a5563cb5a31543543ae852afd671bb1c2617be93c03a03b961b6999891bea78", + "turbo_cache_sha256": "fb70e5f556ae6385d0cd791955ba6a9113b17a3c59c2793e9922a1a35d50fb2c", + "feedback_cache_sha256": "57d40a801480351332c4638d9171ae09b571d8fcc4d4446b3bddb081087d4fa7" + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 0.0, + "input_sha256": "4ab27356cd0fc3ed97d379fc92427cb87ce91f602fca3daf602bd60c811d0fac", + "turbo_cache_sha256": "aceaba5ee49df7cd626a9f59013829333fb13c868ad028cac6aee3b1595bbacd", + "feedback_cache_sha256": "301ba8a545e793a42a528df964404f401098bbe152a5c5aa0f40a4291646b6c5" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.8697710037231445, + "input_sha256": "faad8d29ffbd8a1d2db08dc8297486f622e875a71eea94474fca14158bfae013", + "turbo_cache_sha256": "f0b1eae6bf871eb3cb084894d490fd8366953b42bb862d133e7af91f49e8469a", + "feedback_cache_sha256": "86e438fb4e29575375184eff94b0ee6592a2c2d9de55737896f1d0d1cb1e515d" + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.7381677627563477, + "input_sha256": "bf91b7e8c7111e612cd870869742892e063bce3dfa1d29985b0be4bfe86e9b2f", + "turbo_cache_sha256": "531e127bab68c231981a1328abb0665221f6fc37e684580dd11ab88222c7a4c9", + "feedback_cache_sha256": "8078dfb13d6ee9c2fbb62cb04fe4ffe64dbe71dbc0242cf2d9ad849d571a9e9f" + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.778193473815918, + "input_sha256": "2dc53db4be79136e0b9e61c91c48cbd71199d0f52c0bf927582eba9ef7af0586", + "turbo_cache_sha256": "e84097accab9567c02997fa77a9711741ede3d8ac67b41a875177ef767f8a270", + "feedback_cache_sha256": "61572fd0745d75b05af7b08883886174740c4b22c0ae8ae1fe952f700212cf16" + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.392045497894287, + "input_sha256": "1e68d0415ad28c43c21562225793fdc043df1c240e923ef6fe4d7b73de6f8cf9", + "turbo_cache_sha256": "be967eb6ba11cbdd493a9746bac80d38b52dd38b1c9c2d7eead820538c33c5d3", + "feedback_cache_sha256": "57ac7366e184ed3e54e99693872ad483e715fb29f52d6351f5472cce6442e369" + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.842482328414917, + "input_sha256": "3976eebf5a2fc1733c0ebf1c6cb6aae3827c423a06394a761cb364d7b40e857b", + "turbo_cache_sha256": "4c8d80236d177fae8e713e2aaf4a3e43f0d4c0e64891fca02f0b4da5b9ba26d7", + "feedback_cache_sha256": "a22984a13547731fac87f16349ebfac9b9a8e45a4ca1d744f3e2dfeab5c0bbe0" + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.5524821281433105, + "input_sha256": "32b3943314083c605ba29e900f20c2755df2d4b85988b443cc428e13f5720992", + "turbo_cache_sha256": "8b192e2f4e0e3f5aea18043667073db2ed9ef50854c6e99727afb28d2a7a2bd9", + "feedback_cache_sha256": "5efb2696166d010b05700078e9760bb12112fbd4e7f2e8b80e90a7cf3f240867" + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.2862725257873535, + "input_sha256": "ab29a38afb0fab42916b446f15ad9da61cb4778798fde70cd77fdce2e6999418", + "turbo_cache_sha256": "bf35c69ec38eb42a391142ea09346877b79c29463e2ea10c88cadc388c3c226c", + "feedback_cache_sha256": "109b5b979952d5a70276e5330e678fc7be36da7e6171831135b570545643fd6b" + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.3719873428344727, + "input_sha256": "61210ad6292b9829ebcdb61ca92766a33d1ff0d43a8ace70c959d4622a796831", + "turbo_cache_sha256": "f639df2f3a89dd6b3382f5431171a77c03f838658d71e7e422b7e21e4b134d90", + "feedback_cache_sha256": "c2944ec6d1f5e481de74dec8f517a6d67df3c6fb267ff6ee5c863afde93628f2" + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.293153762817383, + "input_sha256": "c96c01753928ba64ab33ff06e9a162b3e848f7cd37805943fcc9f426f1d565d7", + "turbo_cache_sha256": "23b665988b82f979ec208b4a5363cd62aed8721ea4fcae166646e5bc6ac5011d", + "feedback_cache_sha256": "5c56f8f0ac37cf5f35aa62e25c9e7cb8824fa4e8f79a9e8b5cbbce9d25d5b56f" + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.232598304748535, + "input_sha256": "1d94ffdc063b36e8f5708849c1ec87bcefb471655e188c52b05c6d2efab85ffe", + "turbo_cache_sha256": "c77c6499f021cf8caaa5358ac52e59238d0b34261f5e18907d55cc2b2f3e30ec", + "feedback_cache_sha256": "f75edb10b0e9578371d2a0589c9bda70ea8d9197b95c1db7bb2b073d3e94a40e" + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.383565664291382, + "input_sha256": "d5e2b560a8976679fc8fc29086f72b03816609fddc03774ae96a19f9e9b4004c", + "turbo_cache_sha256": "af0508df2707c3335086a147896088be33f7b44d4b6eef0a6f43ce5b835bb7b2", + "feedback_cache_sha256": "150d303d0f442cb03732e553087c6016aea153d4d70a3ff50b25bbd2c3fea357" + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.25010085105896, + "input_sha256": "a2aad8582952d22d67664862a53dae079385f42fd341d6b9eb82a308a4c5faff", + "turbo_cache_sha256": "f8fe087e5d1b3b33ca58bb02921ccc8df8e7962e2daddf9c55adc988aca84b64", + "feedback_cache_sha256": "1af169e7dbf4626d236c6cbd64312a810bd2faebcb3f55ec5e09d24b5c4e7719" + } + ], + "test_data_used": false, + "source_sha256": { + "learned_d5/data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "prior_pass_study/cache_audit.py": "6a6f34061e048af6e5e7bedcdbe124aeee64c324bf69e482c45b10c2e92f2b5e" + } + } + } + }, + "controls": { + "cache_audit.json": { + "status": "passed", + "scope": "Training-only row/label/feature comparison; validation cache shapes checked, validation labels not read", + "training_rows": 106496, + "training_subset_seed": 20261023, + "records": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 0.0, + "input_sha256": "0de3fe461bfa141fc49f1cd2cf4c7d4a9cf1e835d9619dd55d81f92ec9011a2a", + "turbo_cache_sha256": "441736f9bdba176272888dba8787dce1c2fbacd7250169962707a5eea27f6a37", + "feedback_cache_sha256": "a8f3d5cf4ccd279ba3060a8db2737203bb172416b82b0eb913469e14790e0817" + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.68849515914917, + "input_sha256": "512c32ea26171d1d0f13ad197c5134a24ea2e2814168abc31c1d261b5ec45a80", + "turbo_cache_sha256": "9847461cc42fee9c90414f78fd0e78305f8f6ed118d930b29426d27f5a4cf548", + "feedback_cache_sha256": "d8e4e5fe2eb3c2c75cd32613c9e4513ca042bf53d82f6fdf97298a41206ddc6f" + }, + { + "condition": "surface_code_bX_d5_r05_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9068970680236816, + "input_sha256": "422273891bb97dca7f4913ca15cc3433e108a4ea795dcbfd871ff1ee185cb3c1", + "turbo_cache_sha256": "ab1e3b7376f7883031983d385950ba67747e828735396ac1b63170b7141f8ed4", + "feedback_cache_sha256": "33c8b8c5d617eafdb32f790958139199b21126176a03a9792429e78dff88af19" + }, + { + "condition": "surface_code_bX_d5_r07_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.2904839515686035, + "input_sha256": "45c5f49d60d35858e7c829bcfa8a1c5c37e1c9c17aba60c6610f2d20b4b34967", + "turbo_cache_sha256": "c6abca56049ea6b82d247c8bf79c0a9a6f19e9cf60a4e4a2723c2a17a6a88448", + "feedback_cache_sha256": "4f31e1be93fd66b3d227de72416e3de1c8ba294b5cf55bb9c0d59e0a295da6e8" + }, + { + "condition": "surface_code_bX_d5_r09_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.7693614959716797, + "input_sha256": "d0b3ff6031a2c2e6bd1d4a058b45725345a67c3403e0bd21f679f6f0d329c787", + "turbo_cache_sha256": "18a81a4ca70c5c5c08deda38d43955c5a42ffd961a212e2ee6c783dd4837d49f", + "feedback_cache_sha256": "b420124bbebdf7e99ffe57ab3624569cc93379290c43594f5f2ccfea4684b51e" + }, + { + "condition": "surface_code_bX_d5_r11_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.163759469985962, + "input_sha256": "18fab0c6789333021da1ac6115028694717c9009da0fd2b1face03e8efc28884", + "turbo_cache_sha256": "92b7fd80f827e20349b7cec2b87e5e5cd4f4046a8fcb17201db33cb3e178a82e", + "feedback_cache_sha256": "41939274bd8b08684de8f6d201f9527302613400497545cb001ee59129648f87" + }, + { + "condition": "surface_code_bX_d5_r13_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9551092386245728, + "input_sha256": "0efb3e7203badf4a61c2cb5fe27a2ff3ad8928ed80b27c53488a453492948d7d", + "turbo_cache_sha256": "526567a159461dabf2f3aa67ce4848b336b11eb0a8cb9ecde604d094173d6deb", + "feedback_cache_sha256": "12d6f49dca817de1de639081b4fca7c9b74f53daf057165945a5c9ee4f72d86f" + }, + { + "condition": "surface_code_bX_d5_r15_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 3.5012946128845215, + "input_sha256": "957bb2f3b59b726696917ad60ce0775e9ecc1b40f4d610acb7e1f8f66e3c9512", + "turbo_cache_sha256": "44310eacdb54599d2370a86be3161e6c6d3752c41e59a76822ad90a8a39023b1", + "feedback_cache_sha256": "1172de602cca7bd6d039cde49596535ad8f656f3c2e5d644adab4cd1c06bae4f" + }, + { + "condition": "surface_code_bX_d5_r17_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 3.163731575012207, + "input_sha256": "d7044a2673b4d2f927c5082bd8f76c1e8feb2b2d64851c691de1d818ca7aba36", + "turbo_cache_sha256": "ad18d21a2e824bab2f16163774eb8356d96f2f4163800c1fc55ca0b2a6f68c55", + "feedback_cache_sha256": "4acef03709505af3a50f8fb82a7b839ad8a48f4de4e965f3dad35adb37ca756e" + }, + { + "condition": "surface_code_bX_d5_r19_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9745681285858154, + "input_sha256": "be6a20ba225022b8cd8b6529988c614d1edfca2dee7b966ef918fd91a1551528", + "turbo_cache_sha256": "f8d8046214fef19c419e5bc550c112fb056d0bc48e5b7b83f3d47f96b188426c", + "feedback_cache_sha256": "ae79c9c1b75cc4c46ca9b7e78ade17683023663607b615945c73d02367d0f063" + }, + { + "condition": "surface_code_bX_d5_r21_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.541386604309082, + "input_sha256": "a65c605895dc6d4d879b1edce2442e65c795e31cbb4775f260d6303a1864b9b6", + "turbo_cache_sha256": "dcd8bff02e2f1ff95e6dbfb5a8589f2037eaa3f50d7352361fd7bd8bcaa9528e", + "feedback_cache_sha256": "cc2c8098c741208092efc3d40f38d4ccf366b2d95c89396155620411622c7eb0" + }, + { + "condition": "surface_code_bX_d5_r23_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.212656021118164, + "input_sha256": "b89334defc3d8367e03a46501634b7d80638d60710784650cfa56f372dd1e832", + "turbo_cache_sha256": "eb68a945e1da883c2573bba4fba0a297d07df8382cea297b31501d1d870538a9", + "feedback_cache_sha256": "a79d3a7db0de0531aae43afef3fd194ee4b799a63e499f7939cab8b35e9de3dd" + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.9682941436767578, + "input_sha256": "2a5563cb5a31543543ae852afd671bb1c2617be93c03a03b961b6999891bea78", + "turbo_cache_sha256": "fb70e5f556ae6385d0cd791955ba6a9113b17a3c59c2793e9922a1a35d50fb2c", + "feedback_cache_sha256": "57d40a801480351332c4638d9171ae09b571d8fcc4d4446b3bddb081087d4fa7" + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 0.0, + "input_sha256": "4ab27356cd0fc3ed97d379fc92427cb87ce91f602fca3daf602bd60c811d0fac", + "turbo_cache_sha256": "aceaba5ee49df7cd626a9f59013829333fb13c868ad028cac6aee3b1595bbacd", + "feedback_cache_sha256": "301ba8a545e793a42a528df964404f401098bbe152a5c5aa0f40a4291646b6c5" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.8697710037231445, + "input_sha256": "faad8d29ffbd8a1d2db08dc8297486f622e875a71eea94474fca14158bfae013", + "turbo_cache_sha256": "f0b1eae6bf871eb3cb084894d490fd8366953b42bb862d133e7af91f49e8469a", + "feedback_cache_sha256": "86e438fb4e29575375184eff94b0ee6592a2c2d9de55737896f1d0d1cb1e515d" + }, + { + "condition": "surface_code_bZ_d5_r05_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.7381677627563477, + "input_sha256": "bf91b7e8c7111e612cd870869742892e063bce3dfa1d29985b0be4bfe86e9b2f", + "turbo_cache_sha256": "531e127bab68c231981a1328abb0665221f6fc37e684580dd11ab88222c7a4c9", + "feedback_cache_sha256": "8078dfb13d6ee9c2fbb62cb04fe4ffe64dbe71dbc0242cf2d9ad849d571a9e9f" + }, + { + "condition": "surface_code_bZ_d5_r07_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 1.778193473815918, + "input_sha256": "2dc53db4be79136e0b9e61c91c48cbd71199d0f52c0bf927582eba9ef7af0586", + "turbo_cache_sha256": "e84097accab9567c02997fa77a9711741ede3d8ac67b41a875177ef767f8a270", + "feedback_cache_sha256": "61572fd0745d75b05af7b08883886174740c4b22c0ae8ae1fe952f700212cf16" + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.392045497894287, + "input_sha256": "1e68d0415ad28c43c21562225793fdc043df1c240e923ef6fe4d7b73de6f8cf9", + "turbo_cache_sha256": "be967eb6ba11cbdd493a9746bac80d38b52dd38b1c9c2d7eead820538c33c5d3", + "feedback_cache_sha256": "57ac7366e184ed3e54e99693872ad483e715fb29f52d6351f5472cce6442e369" + }, + { + "condition": "surface_code_bZ_d5_r11_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.842482328414917, + "input_sha256": "3976eebf5a2fc1733c0ebf1c6cb6aae3827c423a06394a761cb364d7b40e857b", + "turbo_cache_sha256": "4c8d80236d177fae8e713e2aaf4a3e43f0d4c0e64891fca02f0b4da5b9ba26d7", + "feedback_cache_sha256": "a22984a13547731fac87f16349ebfac9b9a8e45a4ca1d744f3e2dfeab5c0bbe0" + }, + { + "condition": "surface_code_bZ_d5_r13_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.5524821281433105, + "input_sha256": "32b3943314083c605ba29e900f20c2755df2d4b85988b443cc428e13f5720992", + "turbo_cache_sha256": "8b192e2f4e0e3f5aea18043667073db2ed9ef50854c6e99727afb28d2a7a2bd9", + "feedback_cache_sha256": "5efb2696166d010b05700078e9760bb12112fbd4e7f2e8b80e90a7cf3f240867" + }, + { + "condition": "surface_code_bZ_d5_r15_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.2862725257873535, + "input_sha256": "ab29a38afb0fab42916b446f15ad9da61cb4778798fde70cd77fdce2e6999418", + "turbo_cache_sha256": "bf35c69ec38eb42a391142ea09346877b79c29463e2ea10c88cadc388c3c226c", + "feedback_cache_sha256": "109b5b979952d5a70276e5330e678fc7be36da7e6171831135b570545643fd6b" + }, + { + "condition": "surface_code_bZ_d5_r17_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.3719873428344727, + "input_sha256": "61210ad6292b9829ebcdb61ca92766a33d1ff0d43a8ace70c959d4622a796831", + "turbo_cache_sha256": "f639df2f3a89dd6b3382f5431171a77c03f838658d71e7e422b7e21e4b134d90", + "feedback_cache_sha256": "c2944ec6d1f5e481de74dec8f517a6d67df3c6fb267ff6ee5c863afde93628f2" + }, + { + "condition": "surface_code_bZ_d5_r19_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.293153762817383, + "input_sha256": "c96c01753928ba64ab33ff06e9a162b3e848f7cd37805943fcc9f426f1d565d7", + "turbo_cache_sha256": "23b665988b82f979ec208b4a5363cd62aed8721ea4fcae166646e5bc6ac5011d", + "feedback_cache_sha256": "5c56f8f0ac37cf5f35aa62e25c9e7cb8824fa4e8f79a9e8b5cbbce9d25d5b56f" + }, + { + "condition": "surface_code_bZ_d5_r21_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.232598304748535, + "input_sha256": "1d94ffdc063b36e8f5708849c1ec87bcefb471655e188c52b05c6d2efab85ffe", + "turbo_cache_sha256": "c77c6499f021cf8caaa5358ac52e59238d0b34261f5e18907d55cc2b2f3e30ec", + "feedback_cache_sha256": "f75edb10b0e9578371d2a0589c9bda70ea8d9197b95c1db7bb2b073d3e94a40e" + }, + { + "condition": "surface_code_bZ_d5_r23_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.383565664291382, + "input_sha256": "d5e2b560a8976679fc8fc29086f72b03816609fddc03774ae96a19f9e9b4004c", + "turbo_cache_sha256": "af0508df2707c3335086a147896088be33f7b44d4b6eef0a6f43ce5b835bb7b2", + "feedback_cache_sha256": "150d303d0f442cb03732e553087c6016aea153d4d70a3ff50b25bbd2c3fea357" + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "shots": 4096, + "sample_ids_and_labels_exact": true, + "other_model_inputs_exact": true, + "prior_logit_max_abs_difference": 2.25010085105896, + "input_sha256": "a2aad8582952d22d67664862a53dae079385f42fd341d6b9eb82a308a4c5faff", + "turbo_cache_sha256": "f8fe087e5d1b3b33ca58bb02921ccc8df8e7962e2daddf9c55adc988aca84b64", + "feedback_cache_sha256": "1af169e7dbf4626d236c6cbd64312a810bd2faebcb3f55ec5e09d24b5c4e7719" + } + ], + "test_data_used": false, + "source_sha256": { + "learned_d5/data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "prior_pass_study/cache_audit.py": "6a6f34061e048af6e5e7bedcdbe124aeee64c324bf69e482c45b10c2e92f2b5e" + } + }, + "pipeline_control_cpu.json": { + "status": "passed", + "device": "CPU", + "scope": "Two discarded one-update B2 controls, not eligible for selection or submission", + "arms": { + "3": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 2, + "distinct_rows_seen": 2, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 1, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2049 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + }, + "5": { + "status": "passed", + "parent_parameters_exact": true, + "parent_optimizer_state_exact": true, + "fresh_sampling_seed": 20261400, + "eligible_rows": 106496, + "training_draws": 2, + "distinct_rows_seen": 2, + "checkpoints": [ + { + "step": 0, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2048 + }, + { + "step": 1, + "sampling_state_exact": true, + "distinct_rows_exact": true, + "adam_count": 2049 + } + ], + "test_data_used": false, + "audit_source_sha256": "46dcc0c8e1716d8f66a247f8dbe7982349ff3ed943c04f6f36bcbca5089195da" + } + }, + "matched_sampling_states_exact": true, + "training_source_sha256": { + "learned_d5__train.py": "1f66b75e34e385a6d2654021f3fd124c9d8a359da1f677369e3e774728f83168", + "learned_d5__data.py": "9e3bcfe9d45f6af60b86a580cdc9374043758a1a6f10564aef9eb344f7a6b364", + "learned_d5__model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001", + "learned_exact__checkpoint_gradient.py": "7ece6b3f45e009727fd104a3d39e2816a8c3437f737c3d98131d3a5d7d60e9b8", + "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "control_source_sha256": "9f7ee28f797ca46ff403f6af1836596664988e8414de60b0f792c86c2b2ca3b1", + "test_data_used": false + }, + "runtime_control_cpu.json": { + "status": "passed", + "device": "cpu", + "package": "/run-state/workspace/research/context_upgrades/joint_branch_extract1/package", + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "prior_pass": 3, + "shots": 1, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "prior_pass": 5, + "shots": 1, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "prior_pass": 3, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "prior_pass": 5, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "prior_pass": 3, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 2.7939677238464355e-09, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "prior_pass": 5, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 1.1175870895385742e-08, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "prior_pass": 3, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 1.7881393432617188e-07, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "prior_pass": 5, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 1.341104507446289e-07, + "live_prior_order_and_subset_exact": true + } + ], + "scope": "Numerical runtime control using fixed session-trained parent; no accuracy evaluation or model selection", + "runtime_sha256": { + "package.py": "f61bf18c6659d2b862a0639f05d806f3ce784a3ba0c846f159b6b2c883d354c2", + "exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825", + "temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "package3.py": "d15c9dfd5a905c37d59e781f38961c2594b34e7a4ba8edb013f0240a11d2694e", + "temporal_base_contextual.py": "5cdd9c9bdaf0bb526cd7922ce1a990d1206a4bfba72dc76751cd3a09964ad95d", + "turbo_features.py": "a3e7e23092ee4655f05ce0ec7e4440a9de91a51badd5672b5076b8cf1f64df8c", + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "d5_prejoint_contextual.py": "8e3274896738f9dca23812b59676dcf3f96d15167a83702ee88a335af71ce2d1", + "hybrid3.py": "b61d22a6f6efcf6f0b866c4bb9053583d006efaeb14681a3342181f6a812b09f", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "rich_model.py": "70c2de03c127eca461bfb17d57ec9ee5645583caf2a44d35671fd6a52035ce27", + "training_code.py": "6412e060d3f581e8097a6cb03060f146f769cd348fba24ef7a093a8d501a7f40", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "rich_contextual.py": "6e06ff34651f5536176f19f48966e762901898caa1046d591bc805e767247732", + "d5_reserved_gate.py": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1", + "joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee", + "hybrid.py": "736c2f51f24db453dceee86ef54e0a346bbc4ec40046246d6dc4e906c12a3390", + "decoder.py": "6e69ad3ebe0c688e1e008e99ef2bf077fbf4dbbb94df36242cc24eca726c5680", + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "context_model.py": "bc36fa5fa0191abc8e67e4ede0d4ff87848d80e9e2fac5cd60c0ac4fcefc3088", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "d5_contextual.py": "76c4f2ad404018ab18e3919fc46c4983110cd336133f09551dce4e94ad7021ca", + "contextual.py": "fa6b2eed74315cd329afc4b413e64a68db6e3199f82bead07f5542a2d4819565", + "short_syndrome_model.py": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af", + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "conditional.py": "3c20842c9500053cc16114d739e9b651ea3c0a0532c8677b31afe0cee28033eb", + "temporal_contextual.py": "0ecb0608637d040b2d167953403a230f659886663df884348011959427edec98", + "d5_base_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550" + }, + "source_sha256": { + "learned_d5/model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "prior_pass_study/runtime_control.py": "06e725750085d90d1bba1e4ebfd49557f2c19787946614325064e648a011de20" + }, + "test_data_used": false + }, + "runtime_control_gpu.json": { + "status": "passed", + "device": "gpu", + "package": "/run-state/workspace/research/context_upgrades/confidence_joint1/package", + "cases": [ + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "prior_pass": 3, + "shots": 1, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "prior_pass": 5, + "shots": 1, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "prior_pass": 3, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r01_center_5_5", + "prior_pass": 5, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 0.0, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "prior_pass": 3, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 2.1420419216156006e-08, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "prior_pass": 5, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 5.960464477539063e-08, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "prior_pass": 3, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 1.7881393432617188e-07, + "live_prior_order_and_subset_exact": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "prior_pass": 5, + "shots": 3, + "independent_prediction_max_abs_difference": 0.0, + "cached_vs_recomputed_max_abs_difference": 1.7881393432617188e-07, + "live_prior_order_and_subset_exact": true + } + ], + "scope": "Numerical runtime control using fixed session-trained parent; no accuracy evaluation or model selection", + "runtime_sha256": { + "d5_preconfidence_contextual.py": "76c4f2ad404018ab18e3919fc46c4983110cd336133f09551dce4e94ad7021ca", + "temporal_contextual.py": "0ecb0608637d040b2d167953403a230f659886663df884348011959427edec98", + "d5_contextual.py": "3d2c62eda6cc837b5c6b381d6d769f3bc5a6e7d35450bcf0152b3a7ee2c57471", + "d5_base_contextual.py": "59d6c85dc4bd61e26cf7243baf0e2637c3de1d35327b2c763707badd19446550", + "decoder.py": "6e69ad3ebe0c688e1e008e99ef2bf077fbf4dbbb94df36242cc24eca726c5680", + "turbo.py": "c07dce8d7098142f5cd550d594b948290287a8cb2221f70acaeff3965c3dac0b", + "d5_history_context_model.py": "4cc383b4909ff740bccfd20b687f8ee46866e67f93f82fe6c4bace162149ffb4", + "d5_prejoint_contextual.py": "8e3274896738f9dca23812b59676dcf3f96d15167a83702ee88a335af71ce2d1", + "short_syndrome_model.py": "451ce740551f9e13348064f2e726e7e31a611b64bcf5d95def601deb78e854af", + "joint_mixture.py": "07b111c55b7a380d387ef0955cb4ce894f6c76f6f84a5488c6ac80ae09415137", + "hybrid3.py": "b61d22a6f6efcf6f0b866c4bb9053583d006efaeb14681a3342181f6a812b09f", + "d5_temporal_context_model.py": "d58bcfe01767228d18ce2078d555abf13037b5df63edf38273ba66f0966ee445", + "hybrid.py": "736c2f51f24db453dceee86ef54e0a346bbc4ec40046246d6dc4e906c12a3390", + "confidence_joint.py": "c597e7b57876691b10f66f267a5d2f33bf1329982b68090473ddaf680fecf39b", + "package.py": "f61bf18c6659d2b862a0639f05d806f3ce784a3ba0c846f159b6b2c883d354c2", + "turbo_features.py": "a3e7e23092ee4655f05ce0ec7e4440a9de91a51badd5672b5076b8cf1f64df8c", + "rich_model.py": "70c2de03c127eca461bfb17d57ec9ee5645583caf2a44d35671fd6a52035ce27", + "d5_base_context_model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "package3.py": "d15c9dfd5a905c37d59e781f38961c2594b34e7a4ba8edb013f0240a11d2694e", + "contextual.py": "fa6b2eed74315cd329afc4b413e64a68db6e3199f82bead07f5542a2d4819565", + "joint_mixture_gradient.py": "1d776ad02b1081e9f78e8c700ed10f038466a39211726d6ec98ce2c99796e9cd", + "confidence_joint_gradient.py": "6a4e537d18316f58f5e9aa12add65543bb71fea8f46cdded26d3dbe1fb021836", + "training_code.py": "6412e060d3f581e8097a6cb03060f146f769cd348fba24ef7a093a8d501a7f40", + "context_model.py": "bc36fa5fa0191abc8e67e4ede0d4ff87848d80e9e2fac5cd60c0ac4fcefc3088", + "d5_history_features.py": "d709cd54225aa1b14707afa436314c8392f59f748a0007d988c6d18dedd275ee", + "exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825", + "conditional.py": "3c20842c9500053cc16114d739e9b651ea3c0a0532c8677b31afe0cee28033eb", + "rich_contextual.py": "6e06ff34651f5536176f19f48966e762901898caa1046d591bc805e767247732", + "temporal_base_contextual.py": "5cdd9c9bdaf0bb526cd7922ce1a990d1206a4bfba72dc76751cd3a09964ad95d", + "d5_context_model.py": "53342e15dcbb8bc2dd0b288d75ea115fb504be99a33bc283a518b9d76232cd99", + "temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186", + "d5_reserved_gate.py": "b79fbd618cbaa804838159b126c8c877188c88a26cb763d68e1902c0dbe08cb1" + }, + "source_sha256": { + "learned_d5/model.py": "3b2d4b34a8945ddfe82d76e28b4aa917f11933ed885c0cdcd2bc389448a871fb", + "prior_pass_study/runtime_control.py": "06e725750085d90d1bba1e4ebfd49557f2c19787946614325064e648a011de20" + }, + "test_data_used": false + }, + "matched_control.json": { + "status": "passed", + "sampling_states": { + "0": true, + "256": true, + "512": true + }, + "scope": "Same parent weights, optimizer state, freshly reset sampling seed, condition/row draws, learning rate and updates. Physical conditioning pass is the intended change.", + "test_data_used": false + } + }, + "test_data_used": false + }, + "r3_pattern1": { + "training": { + "plan": { + "created_utc": "2026-10-21T17:38:29.497576+00:00", + "hypothesis": "Repeated three-round d3 syndromes may support useful small categorical corrections beyond a shared neural edge model; test all eight geometries/bases with a common regularization strength.", + "scope": "All eight d3 r3 conditions; all other122conditions remain in full benchmark scoring. Training-only frequency audit found74.42% repeated-shot coverage; no validation inspection used to define this experiment.", + "initialization": "One residual logit per training-observed24-bit detector pattern, Normal(0,.01), independent seeds20261500+10*lexicographic-condition-rank+alpha-index. All new fitted parameters initialize randomly in this session.", + "alphas": [ + 16, + 64, + 256, + 1024 + ], + "training": "All19880 training labels per condition,159040total. Exact binomial sufficient statistics;64clipped diagonalNewton updates, stepclip2.0, from random residual logits.", + "fixed_prior": "Exact full-DEM logical probability from current authorized d3 width10physical plan on each unique training pattern. Logical labels do not enter physical computation.", + "validation": "One globalalpha and mode(raw or equal-incumbent probability average) acrossall8r3conditions; unseenpatterns retainincumbent; ties retainincumbent. Full130condition expectedP forselection; no percondition choice.", + "reference": { + "package": "/run-state/workspace/research/context_upgrades/confidence_joint1/package", + "predictions": "/run-state/workspace/research/context_upgrades/confidence_joint1/predictions", + "score": "/run-state/workspace/research/context_upgrades/confidence_joint1/score.json", + "P": 0.7674297626201922 + }, + "reference_model_config_sha256": "342e2d633ece01ffea1d1c43f21b3e648739b1152d903d2b3e8ff3cf4dc9b8af", + "runtime": "Sparse sorteduint32syndrome keys only; no sample IDs or row-derived features. Portable runtime, assembledreplay, fullscorer and relocationrequired beforepublication.", + "resources": "CPU4cores,JAXCPU; no CUDA work duringqueuedstudies. Any improvedpackage replay serializedaftersector study.", + "conditions": [ + { + "name": "surface_code_bX_d3_r03_center_3_5", + "arrays": "conditions/surface_code_bX_d3_r03_center_3_5/arrays.npz", + "arrays_sha256": "374c0e7bc27d2d76fe51026c026a36a3a7769e184ffa2d95de292967e50342cf", + "num_detectors": 24, + "group": "d3_bX_center_3_5", + "physical_plan": "plans/surface_code_bX_d3_r03_center_3_5.npz", + "physical_plan_sha256": "131b7ceebfac49e32dc389e748a8409fcd991cdc57075c1a766e9242fcd86869" + }, + { + "name": "surface_code_bX_d3_r03_center_5_3", + "arrays": "conditions/surface_code_bX_d3_r03_center_5_3/arrays.npz", + "arrays_sha256": "d29afb998ee82ab3c9328754429c047f30f3d1593b7aeb4ba8aadf8f53003e3c", + "num_detectors": 24, + "group": "d3_bX_center_5_3", + "physical_plan": "plans/surface_code_bX_d3_r03_center_5_3.npz", + "physical_plan_sha256": "d36df1a7d41a418fd26882afdd2f190b8adc1a3d794dc4e73fa25878d532124a" + }, + { + "name": "surface_code_bX_d3_r03_center_5_7", + "arrays": "conditions/surface_code_bX_d3_r03_center_5_7/arrays.npz", + "arrays_sha256": "20ed991979dd17e4da34b61cc6a1659d531696d18663a75bfa9164c2e2871c23", + "num_detectors": 24, + "group": "d3_bX_center_5_7", + "physical_plan": "plans/surface_code_bX_d3_r03_center_5_7.npz", + "physical_plan_sha256": "18abef7984e600ce942b37ef84d5ea67b820acec15d615b348ee85867a8f0ad8" + }, + { + "name": "surface_code_bX_d3_r03_center_7_5", + "arrays": "conditions/surface_code_bX_d3_r03_center_7_5/arrays.npz", + "arrays_sha256": "ed037e8c6e4a3ca74d83cfa98f007b4e078a0e75a2f415b2c4084c71d4910723", + "num_detectors": 24, + "group": "d3_bX_center_7_5", + "physical_plan": "plans/surface_code_bX_d3_r03_center_7_5.npz", + "physical_plan_sha256": "072dd603cbc795cec0861a6fd8b4b3e9a1d6f006a8b00f8a12f976664d6029d8" + }, + { + "name": "surface_code_bZ_d3_r03_center_3_5", + "arrays": "conditions/surface_code_bZ_d3_r03_center_3_5/arrays.npz", + "arrays_sha256": "ff29c62710736353ed71e96ca600676497ac5022938ccf1895cf4e728e5c1c20", + "num_detectors": 24, + "group": "d3_bZ_center_3_5", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_3_5.npz", + "physical_plan_sha256": "1b9e4f6b715209449438cb4accca053a18752f204274cad3d42caea28e3969dd" + }, + { + "name": "surface_code_bZ_d3_r03_center_5_3", + "arrays": "conditions/surface_code_bZ_d3_r03_center_5_3/arrays.npz", + "arrays_sha256": "2f5dda83886e30ff4958580ddb6b03a726d7d8527da7f60ca44355aa292d6e91", + "num_detectors": 24, + "group": "d3_bZ_center_5_3", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_5_3.npz", + "physical_plan_sha256": "431039e07e889a8e707abbe85e82018894782a4ee065c634c7d1ab9ac38b2186" + }, + { + "name": "surface_code_bZ_d3_r03_center_5_7", + "arrays": "conditions/surface_code_bZ_d3_r03_center_5_7/arrays.npz", + "arrays_sha256": "674d28fdb6f7826b4bb86fc059dbbdfa6b2bc9127aa4096364782347719fc9a1", + "num_detectors": 24, + "group": "d3_bZ_center_5_7", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_5_7.npz", + "physical_plan_sha256": "d27d7ec19ae2025018024d054fb17ac48621457b4ef731c08702be0d51cf832b" + }, + { + "name": "surface_code_bZ_d3_r03_center_7_5", + "arrays": "conditions/surface_code_bZ_d3_r03_center_7_5/arrays.npz", + "arrays_sha256": "f1a11fa0978a48e355cc932f6140c37cb4f3de9e9750f991ae69ce619e5eb806", + "num_detectors": 24, + "group": "d3_bZ_center_7_5", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_7_5.npz", + "physical_plan_sha256": "7b17a9459a1226964077255666ab1ec1a296ddaeeec7956a44c32994bb566646" + } + ], + "test_data_used": false + }, + "models": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "alpha": 16, + "seed": 20261500, + "training_shots": 19880, + "distinct_patterns": 7197, + "initial_residual_sha256": "23994bf59d24e77d7511a107b36c2d62e9191bc412400a8c64cc5cd42f470933", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bX_d3_r03_center_3_5.npz", + "weights_sha256": "c6087710e3258ce145b18345403a74e4ee7408495eb54765c1d1247e465cd246" + }, + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "alpha": 64, + "seed": 20261501, + "training_shots": 19880, + "distinct_patterns": 7197, + "initial_residual_sha256": "b0c489a677240778687b9655468f7062099039addb4887a75b157934cde7b886", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bX_d3_r03_center_3_5.npz", + "weights_sha256": "8b108d4b623f0969b757f18ed8a39fb76a2a028ad77307da78081d5b6a4d2861" + }, + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "alpha": 256, + "seed": 20261502, + "training_shots": 19880, + "distinct_patterns": 7197, + "initial_residual_sha256": "6d408160daf8312599a9b15818ddc70603c70d6b87dd15cbb9315fd71edd66e3", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bX_d3_r03_center_3_5.npz", + "weights_sha256": "651269e905f8705f61a2beee9c282b011a07eb50f91db5932a24509bda84d53b" + }, + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "alpha": 1024, + "seed": 20261503, + "training_shots": 19880, + "distinct_patterns": 7197, + "initial_residual_sha256": "cda1f12013c627953d31400e944fe940cca93a715ae15e81650c7af665591fcd", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bX_d3_r03_center_3_5.npz", + "weights_sha256": "19ae1b5d1880646a9def81c3e0f1e01bf4d086e1d337ef985786d7ad3846017d" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "alpha": 16, + "seed": 20261510, + "training_shots": 19880, + "distinct_patterns": 6763, + "initial_residual_sha256": "8694cb7e172e666e5026154ed727ac2ab91d0a259eb5c8ffe9fa21d338875daa", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bX_d3_r03_center_5_3.npz", + "weights_sha256": "61b58e7d4a7cb24241ddfe3c7d646cd9596696bef70b002170045ae59b23c88f" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "alpha": 64, + "seed": 20261511, + "training_shots": 19880, + "distinct_patterns": 6763, + "initial_residual_sha256": "fdc3141e4acde98b27bd2adf3fb731dbee6a49c0582883b8b6ab7d12b8787f51", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bX_d3_r03_center_5_3.npz", + "weights_sha256": "29cd31f930b25064e70726b6ac66523cc71be18a7a86b7ba0dc22e488ce6e1c4" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "alpha": 256, + "seed": 20261512, + "training_shots": 19880, + "distinct_patterns": 6763, + "initial_residual_sha256": "aca11c7d64e4dd1096e9e799ff3c691bb0d5a89a5089e8a4ed82f328fcf0aa1b", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bX_d3_r03_center_5_3.npz", + "weights_sha256": "ba9d2f390dc43d0f459f18c8b0337bebb5e2f7a854ba6ce6eaa8ff8566ae828b" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "alpha": 1024, + "seed": 20261513, + "training_shots": 19880, + "distinct_patterns": 6763, + "initial_residual_sha256": "284340dbb78986bb16624e93366451a30531b73062be8b5d147fe64042daf64f", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bX_d3_r03_center_5_3.npz", + "weights_sha256": "15aee3f9f868c758af65d76818a2714c7ab5ecd5204ea789495196e14438b2d1" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "alpha": 16, + "seed": 20261520, + "training_shots": 19880, + "distinct_patterns": 6279, + "initial_residual_sha256": "0183346b2df3fbaa948e936dd6f97f27f3fa43fd4be63601638fcd78e5f0b941", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bX_d3_r03_center_5_7.npz", + "weights_sha256": "8b2ef7af0dad65d27734636350f41d39787710ee8b86775bd01c4c61b6865112" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "alpha": 64, + "seed": 20261521, + "training_shots": 19880, + "distinct_patterns": 6279, + "initial_residual_sha256": "b7164e1fdfeeb3c6859041da11e4727ec24dac6342af1fe18b2b204ad89b43c9", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bX_d3_r03_center_5_7.npz", + "weights_sha256": "ddce1a6d67da51f4453f06ff58c4c057ef7eb68bbf43d7f1d26953c7adc4bf87" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "alpha": 256, + "seed": 20261522, + "training_shots": 19880, + "distinct_patterns": 6279, + "initial_residual_sha256": "aa313ee9ac3be04b6df879c929a1f647c4c4d834e1a04cd56f4ef53daffecae7", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bX_d3_r03_center_5_7.npz", + "weights_sha256": "ba51b4386b4afada0d44e631a2639fcda19f9531574c59d5a6a95af05c55e8df" + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "alpha": 1024, + "seed": 20261523, + "training_shots": 19880, + "distinct_patterns": 6279, + "initial_residual_sha256": "616660a345515708fcc9b29469b8e9ed0996b525f10df73071564328bda2be30", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bX_d3_r03_center_5_7.npz", + "weights_sha256": "34048a84478aee7a9955cbe83bfff8581662b1119da716f1a3c9ddfca78eba6f" + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "alpha": 16, + "seed": 20261530, + "training_shots": 19880, + "distinct_patterns": 6162, + "initial_residual_sha256": "f65c04ee36f65e802d74d5e8c000da9fa878b90a6053d2083a78603aecaa23a4", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bX_d3_r03_center_7_5.npz", + "weights_sha256": "748cfc80c6979a15b4c77d939ed579272e7499cc02846fb9feb4ed6f897f19a0" + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "alpha": 64, + "seed": 20261531, + "training_shots": 19880, + "distinct_patterns": 6162, + "initial_residual_sha256": "e0f3767edb5f266a5406fc65eac525608f39c7b7446313c491c21c159f2c0aca", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bX_d3_r03_center_7_5.npz", + "weights_sha256": "2d77ca5c595f6269010a648402f1bf77ccacd3302d738283338b65e09367ee8c" + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "alpha": 256, + "seed": 20261532, + "training_shots": 19880, + "distinct_patterns": 6162, + "initial_residual_sha256": "1f77753540d72e93e51d6272eea5129168be29d1855de815d7b97bd6e49da8d3", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bX_d3_r03_center_7_5.npz", + "weights_sha256": "803176155400f914dda549df8ec48898e52ab49ebebaed19fcbce787d83b0ffc" + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "alpha": 1024, + "seed": 20261533, + "training_shots": 19880, + "distinct_patterns": 6162, + "initial_residual_sha256": "7afef58408058f7ba6425cbcc9f55e5076373bd5f93124a7afa1d3e55f5d8675", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bX_d3_r03_center_7_5.npz", + "weights_sha256": "7ad6709bd4713ec24e958368560e08f7ea6bb312967834a9d6f52641d7b4979b" + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "alpha": 16, + "seed": 20261540, + "training_shots": 19880, + "distinct_patterns": 6832, + "initial_residual_sha256": "fedc0c7eb93f4de7cc298ba4a926d028768a95f041eff61db32f531006c4f213", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bZ_d3_r03_center_3_5.npz", + "weights_sha256": "139bb1ec0ed243779a01c5e82d09062ad0228018a0ef0c56c122c224965e4307" + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "alpha": 64, + "seed": 20261541, + "training_shots": 19880, + "distinct_patterns": 6832, + "initial_residual_sha256": "b597ac8ed853eb233ebe9a25fef964d8713b01b0b1235327b4637396cb1acd85", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bZ_d3_r03_center_3_5.npz", + "weights_sha256": "70201331afff20fd7b2727f2b6a84a1d70036f74adb7ac0fec4f1c6004e9fefb" + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "alpha": 256, + "seed": 20261542, + "training_shots": 19880, + "distinct_patterns": 6832, + "initial_residual_sha256": "1790b67eb637920e5d09bcd86053b207ac137a20a5211c276c9607f3c664e543", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bZ_d3_r03_center_3_5.npz", + "weights_sha256": "3ae8ad6240e68313f16d8a826f238df131e02f37597783217804d4871a140d1d" + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "alpha": 1024, + "seed": 20261543, + "training_shots": 19880, + "distinct_patterns": 6832, + "initial_residual_sha256": "48748ffbea1af4305a78e0ca875598280f33c61dbfae1c804f4d899607dd39d7", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bZ_d3_r03_center_3_5.npz", + "weights_sha256": "9371249a8413b839dd53385a772d0d9643d5ce01e2fe1da67795e60246c1ed06" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "alpha": 16, + "seed": 20261550, + "training_shots": 19880, + "distinct_patterns": 6978, + "initial_residual_sha256": "97ae756cec1dccaadcad071f9ad85c50e9320415e51700e93dd47f6d067a4b81", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bZ_d3_r03_center_5_3.npz", + "weights_sha256": "80c863090ba6268752342feeb442031e3ba90d6558b19e03a45c2b5079b412dc" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "alpha": 64, + "seed": 20261551, + "training_shots": 19880, + "distinct_patterns": 6978, + "initial_residual_sha256": "91651f673ec7c74231b30d853ce1add40de2798d534b5fe5a4c952785153a2ad", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bZ_d3_r03_center_5_3.npz", + "weights_sha256": "011e7c530b9a904fbbd26cd75b5004e729420fc004b1b939d41e4fdbd278b9c5" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "alpha": 256, + "seed": 20261552, + "training_shots": 19880, + "distinct_patterns": 6978, + "initial_residual_sha256": "894d7afdb4cbeacc446a0158fa2fb57239efdb27a094efc1f743294280793e74", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bZ_d3_r03_center_5_3.npz", + "weights_sha256": "694c78e09b9fa89001557516bb352d94eb73cdc1be8e8256ec42d8a71033f038" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "alpha": 1024, + "seed": 20261553, + "training_shots": 19880, + "distinct_patterns": 6978, + "initial_residual_sha256": "e87f55ba430c492b9dcdaabda899ff577d1f198cdb26c023121583e07ee80371", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bZ_d3_r03_center_5_3.npz", + "weights_sha256": "c994e19e28cc3abea8599c560683a3c5eb18bb54845fd3b4b39f6fbf43713823" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "alpha": 16, + "seed": 20261560, + "training_shots": 19880, + "distinct_patterns": 6583, + "initial_residual_sha256": "c17b0bb46c23cbecc49e06210f81b0056d013e58ae7f66aafc75cb00520fd338", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bZ_d3_r03_center_5_7.npz", + "weights_sha256": "9b3021ea6492eda42035f9e46dbe4acc676e565e1a7a005239a3018164bfe5b5" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "alpha": 64, + "seed": 20261561, + "training_shots": 19880, + "distinct_patterns": 6583, + "initial_residual_sha256": "93a71bd65f7c3995dbec2e6801b618eeb494719771b4daf37fa6ec5e59ee141e", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bZ_d3_r03_center_5_7.npz", + "weights_sha256": "9c57b4bfd9645b44753075bfab89d462c4513166420619dc9fda79474f83ec46" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "alpha": 256, + "seed": 20261562, + "training_shots": 19880, + "distinct_patterns": 6583, + "initial_residual_sha256": "6590f1d72d42d3603ec49638af87fd2627a4ca508bccee81ffb774a20a4a1191", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bZ_d3_r03_center_5_7.npz", + "weights_sha256": "5daca19838c2f708681d32e77b0fbf7d3ce92bce593d29eca8e3df2b63ace6d5" + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "alpha": 1024, + "seed": 20261563, + "training_shots": 19880, + "distinct_patterns": 6583, + "initial_residual_sha256": "ff90ac01d45b0198b9c6dde99ca8191ad860f53c33d65f7953f1db0d404d26db", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bZ_d3_r03_center_5_7.npz", + "weights_sha256": "69fdbc3183b1036a31ac6e986b3cf607421d85cedd425755b68f5907d9fd283f" + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "alpha": 16, + "seed": 20261570, + "training_shots": 19880, + "distinct_patterns": 6324, + "initial_residual_sha256": "4c4e89e8cfb0094e31ba1b4b8652342e4c0a7e3047b918e31c249219fd0066d3", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha16-surface_code_bZ_d3_r03_center_7_5.npz", + "weights_sha256": "9b304e91b57afc0285fcb827cbabcae5049ceafe8f97c6ee079fb194b7ab8032" + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "alpha": 64, + "seed": 20261571, + "training_shots": 19880, + "distinct_patterns": 6324, + "initial_residual_sha256": "f62f4cfa879339bbf2a88c0fa698486042868b4a0825922ceff4975896259820", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha64-surface_code_bZ_d3_r03_center_7_5.npz", + "weights_sha256": "72de60b1d455d22a64dd1957af62f98747472cb465b6c4d56d81474a81f3d363" + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "alpha": 256, + "seed": 20261572, + "training_shots": 19880, + "distinct_patterns": 6324, + "initial_residual_sha256": "0aa4a6805cb0ca5dbec0a2f4c95a82075b7fad2bbfed1d23a93d19795175b4a8", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha256-surface_code_bZ_d3_r03_center_7_5.npz", + "weights_sha256": "d4ac408769ffbe5a586c293b6f8937b789367679fcfe924c24f6afb4e9c3393f" + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "alpha": 1024, + "seed": 20261573, + "training_shots": 19880, + "distinct_patterns": 6324, + "initial_residual_sha256": "4d81b4468166133f9b39f5f1a5d21e43e14708528f9eb8a0b614ad2aa8f97073", + "optimizer_updates": 64, + "closed_form_optimum_max_abs_difference": 2.220446049250313e-16, + "weights": "weights-alpha1024-surface_code_bZ_d3_r03_center_7_5.npz", + "weights_sha256": "c9bb6694ee7ec3c8f8bdb003bfc1c2f0cc162ce5a181b375c34751fb08218564" + } + ], + "source_sha256": { + "short_syndromes/r3_study/train.py": "5d3d654175a9e496788022c46d13c2155b099ca44b0db93c3cf970bc8906d337", + "short_syndromes/r3_study/model.py": "24fbc23be719b230fd7fab57416f33d47d7fe9912dda0a709db1eff1fe8a24a3", + "exact_d3/exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825" + }, + "training_seconds": 17.859074759995565, + "control": { + "status": "passed", + "cases": [ + { + "shots": 1, + "mode": "raw", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 1, + "mode": "equal", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 3, + "mode": "raw", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 3, + "mode": "equal", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 8, + "mode": "raw", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 8, + "mode": "equal", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 17, + "mode": "raw", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 17, + "mode": "equal", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 5120, + "mode": "raw", + "independent_lookup_order_subset_exact": true + }, + { + "shots": 5120, + "mode": "equal", + "independent_lookup_order_subset_exact": true + } + ], + "optimizer_closed_form_max_abs_difference": 1.1102230246251565e-16, + "source_sha256": { + "control.py": "2f988c3b82d437a66ed6b4b94fee6c4914fd7bf8618195d3a9013a048795c3b7", + "model.py": "24fbc23be719b230fd7fab57416f33d47d7fe9912dda0a709db1eff1fe8a24a3", + "train.py": "5d3d654175a9e496788022c46d13c2155b099ca44b0db93c3cf970bc8906d337" + }, + "synthetic_only": true, + "selection_eligible": false + }, + "test_data_used": false, + "post_selection_diagnostic": { + "scope": "Post-selection descriptive intervention: replace fitted residuals by zero while holding the training-pattern support and equal neural mixture fixed. All8r3conditions. No new fitting, no candidate selection or publication. Fitted-candidate paired P standard error assumes independent shots and omits model selection and shot dependence.", + "totals": { + "incumbent_errors": 2954, + "fitted_errors": 2947, + "zero_residual_errors": 2947, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0 + }, + "fitted_paired_P_standard_error": 7.570206373813412e-06, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "incumbent_errors": 315, + "fitted_errors": 319, + "zero_residual_errors": 319, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 2.2880731557677284e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.0001417144958395511 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "incumbent_errors": 406, + "fitted_errors": 403, + "zero_residual_errors": 403, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 4.959404526755409e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.0001302023883908987 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "incumbent_errors": 371, + "fitted_errors": 370, + "zero_residual_errors": 370, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 2.6707352081018636e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.00014499598182737827 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "incumbent_errors": 389, + "fitted_errors": 383, + "zero_residual_errors": 383, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 3.8127597362460923e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.00017737507005222142 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "incumbent_errors": 365, + "fitted_errors": 369, + "zero_residual_errors": 369, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 2.2880731557677284e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.00010354756523156539 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "incumbent_errors": 390, + "fitted_errors": 389, + "zero_residual_errors": 389, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 3.4338237019483183e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.00016137465718202293 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "incumbent_errors": 367, + "fitted_errors": 366, + "zero_residual_errors": 366, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 1.1445582204089546e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.00012770923785865307 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "incumbent_errors": 351, + "fitted_errors": 348, + "zero_residual_errors": 348, + "fitting_corrected_versus_zero_residual": 0, + "fitting_introduced_versus_zero_residual": 0, + "fitted_vs_incumbent_variance_of_condition_mean": 4.196316032908955e-07, + "mean_fitted_vs_zero_residual_probability_difference": 0.0001591240579728037 + } + ], + "selection_eligible": false, + "test_data_used": false, + "source_sha256": "b9f0139f1940b01553aa99a9b4be360d86b376beae652e2dc85e3190fb9ec82a" + } + }, + "selection": { + "plan": { + "created_utc": "2026-10-21T17:38:29.497576+00:00", + "hypothesis": "Repeated three-round d3 syndromes may support useful small categorical corrections beyond a shared neural edge model; test all eight geometries/bases with a common regularization strength.", + "scope": "All eight d3 r3 conditions; all other122conditions remain in full benchmark scoring. Training-only frequency audit found74.42% repeated-shot coverage; no validation inspection used to define this experiment.", + "initialization": "One residual logit per training-observed24-bit detector pattern, Normal(0,.01), independent seeds20261500+10*lexicographic-condition-rank+alpha-index. All new fitted parameters initialize randomly in this session.", + "alphas": [ + 16, + 64, + 256, + 1024 + ], + "training": "All19880 training labels per condition,159040total. Exact binomial sufficient statistics;64clipped diagonalNewton updates, stepclip2.0, from random residual logits.", + "fixed_prior": "Exact full-DEM logical probability from current authorized d3 width10physical plan on each unique training pattern. Logical labels do not enter physical computation.", + "validation": "One globalalpha and mode(raw or equal-incumbent probability average) acrossall8r3conditions; unseenpatterns retainincumbent; ties retainincumbent. Full130condition expectedP forselection; no percondition choice.", + "reference": { + "package": "/run-state/workspace/research/context_upgrades/confidence_joint1/package", + "predictions": "/run-state/workspace/research/context_upgrades/confidence_joint1/predictions", + "score": "/run-state/workspace/research/context_upgrades/confidence_joint1/score.json", + "P": 0.7674297626201922 + }, + "reference_model_config_sha256": "342e2d633ece01ffea1d1c43f21b3e648739b1152d903d2b3e8ff3cf4dc9b8af", + "runtime": "Sparse sorteduint32syndrome keys only; no sample IDs or row-derived features. Portable runtime, assembledreplay, fullscorer and relocationrequired beforepublication.", + "resources": "CPU4cores,JAXCPU; no CUDA work duringqueuedstudies. Any improvedpackage replay serializedaftersector study.", + "conditions": [ + { + "name": "surface_code_bX_d3_r03_center_3_5", + "arrays": "conditions/surface_code_bX_d3_r03_center_3_5/arrays.npz", + "arrays_sha256": "374c0e7bc27d2d76fe51026c026a36a3a7769e184ffa2d95de292967e50342cf", + "num_detectors": 24, + "group": "d3_bX_center_3_5", + "physical_plan": "plans/surface_code_bX_d3_r03_center_3_5.npz", + "physical_plan_sha256": "131b7ceebfac49e32dc389e748a8409fcd991cdc57075c1a766e9242fcd86869" + }, + { + "name": "surface_code_bX_d3_r03_center_5_3", + "arrays": "conditions/surface_code_bX_d3_r03_center_5_3/arrays.npz", + "arrays_sha256": "d29afb998ee82ab3c9328754429c047f30f3d1593b7aeb4ba8aadf8f53003e3c", + "num_detectors": 24, + "group": "d3_bX_center_5_3", + "physical_plan": "plans/surface_code_bX_d3_r03_center_5_3.npz", + "physical_plan_sha256": "d36df1a7d41a418fd26882afdd2f190b8adc1a3d794dc4e73fa25878d532124a" + }, + { + "name": "surface_code_bX_d3_r03_center_5_7", + "arrays": "conditions/surface_code_bX_d3_r03_center_5_7/arrays.npz", + "arrays_sha256": "20ed991979dd17e4da34b61cc6a1659d531696d18663a75bfa9164c2e2871c23", + "num_detectors": 24, + "group": "d3_bX_center_5_7", + "physical_plan": "plans/surface_code_bX_d3_r03_center_5_7.npz", + "physical_plan_sha256": "18abef7984e600ce942b37ef84d5ea67b820acec15d615b348ee85867a8f0ad8" + }, + { + "name": "surface_code_bX_d3_r03_center_7_5", + "arrays": "conditions/surface_code_bX_d3_r03_center_7_5/arrays.npz", + "arrays_sha256": "ed037e8c6e4a3ca74d83cfa98f007b4e078a0e75a2f415b2c4084c71d4910723", + "num_detectors": 24, + "group": "d3_bX_center_7_5", + "physical_plan": "plans/surface_code_bX_d3_r03_center_7_5.npz", + "physical_plan_sha256": "072dd603cbc795cec0861a6fd8b4b3e9a1d6f006a8b00f8a12f976664d6029d8" + }, + { + "name": "surface_code_bZ_d3_r03_center_3_5", + "arrays": "conditions/surface_code_bZ_d3_r03_center_3_5/arrays.npz", + "arrays_sha256": "ff29c62710736353ed71e96ca600676497ac5022938ccf1895cf4e728e5c1c20", + "num_detectors": 24, + "group": "d3_bZ_center_3_5", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_3_5.npz", + "physical_plan_sha256": "1b9e4f6b715209449438cb4accca053a18752f204274cad3d42caea28e3969dd" + }, + { + "name": "surface_code_bZ_d3_r03_center_5_3", + "arrays": "conditions/surface_code_bZ_d3_r03_center_5_3/arrays.npz", + "arrays_sha256": "2f5dda83886e30ff4958580ddb6b03a726d7d8527da7f60ca44355aa292d6e91", + "num_detectors": 24, + "group": "d3_bZ_center_5_3", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_5_3.npz", + "physical_plan_sha256": "431039e07e889a8e707abbe85e82018894782a4ee065c634c7d1ab9ac38b2186" + }, + { + "name": "surface_code_bZ_d3_r03_center_5_7", + "arrays": "conditions/surface_code_bZ_d3_r03_center_5_7/arrays.npz", + "arrays_sha256": "674d28fdb6f7826b4bb86fc059dbbdfa6b2bc9127aa4096364782347719fc9a1", + "num_detectors": 24, + "group": "d3_bZ_center_5_7", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_5_7.npz", + "physical_plan_sha256": "d27d7ec19ae2025018024d054fb17ac48621457b4ef731c08702be0d51cf832b" + }, + { + "name": "surface_code_bZ_d3_r03_center_7_5", + "arrays": "conditions/surface_code_bZ_d3_r03_center_7_5/arrays.npz", + "arrays_sha256": "f1a11fa0978a48e355cc932f6140c37cb4f3de9e9750f991ae69ce619e5eb806", + "num_detectors": 24, + "group": "d3_bZ_center_7_5", + "physical_plan": "plans/surface_code_bZ_d3_r03_center_7_5.npz", + "physical_plan_sha256": "7b17a9459a1226964077255666ab1ec1a296ddaeeec7956a44c32994bb566646" + } + ], + "test_data_used": false + }, + "candidates": [ + { + "alpha": 16, + "mode": "raw", + "gain_over_reference": -6.573016826923077e-06, + "expected_full_P": 0.7674231896033653, + "corrected": 70, + "introduced": 77, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 322, + "corrected": 6, + "introduced": 13, + "seen_shots": 3712, + "negative_log_likelihood": 0.1658704037547675 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 401, + "corrected": 11, + "introduced": 6, + "seen_shots": 3770, + "negative_log_likelihood": 0.1952572948181542 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 368, + "corrected": 9, + "introduced": 6, + "seen_shots": 3829, + "negative_log_likelihood": 0.1897993003149661 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 386, + "corrected": 12, + "introduced": 9, + "seen_shots": 3860, + "negative_log_likelihood": 0.1815292238073512 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 371, + "corrected": 4, + "introduced": 10, + "seen_shots": 3771, + "negative_log_likelihood": 0.17392630497551842 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 390, + "corrected": 8, + "introduced": 8, + "seen_shots": 3716, + "negative_log_likelihood": 0.19004543851592173 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 374, + "corrected": 4, + "introduced": 11, + "seen_shots": 3842, + "negative_log_likelihood": 0.1802202022054975 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 349, + "corrected": 16, + "introduced": 14, + "seen_shots": 3919, + "negative_log_likelihood": 0.17468629063146301 + } + ] + }, + { + "alpha": 16, + "mode": "equal", + "gain_over_reference": 5.2125104446418485e-22, + "expected_full_P": 0.7674297626201922, + "corrected": 34, + "introduced": 34, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 321, + "corrected": 0, + "introduced": 6, + "seen_shots": 3712, + "negative_log_likelihood": 0.16391031161416852 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 406, + "corrected": 2, + "introduced": 2, + "seen_shots": 3770, + "negative_log_likelihood": 0.1922796634261961 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 368, + "corrected": 7, + "introduced": 4, + "seen_shots": 3829, + "negative_log_likelihood": 0.18685193995160954 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 384, + "corrected": 9, + "introduced": 4, + "seen_shots": 3860, + "negative_log_likelihood": 0.18104523184329008 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 370, + "corrected": 1, + "introduced": 6, + "seen_shots": 3771, + "negative_log_likelihood": 0.17281541837325487 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 388, + "corrected": 5, + "introduced": 3, + "seen_shots": 3716, + "negative_log_likelihood": 0.18684169924920266 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 370, + "corrected": 2, + "introduced": 5, + "seen_shots": 3842, + "negative_log_likelihood": 0.1778622539090688 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 347, + "corrected": 8, + "introduced": 4, + "seen_shots": 3919, + "negative_log_likelihood": 0.17237959248344253 + } + ] + }, + { + "alpha": 64, + "mode": "raw", + "gain_over_reference": -1.7841045673076924e-05, + "expected_full_P": 0.7674119215745192, + "corrected": 54, + "introduced": 73, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 319, + "corrected": 6, + "introduced": 10, + "seen_shots": 3712, + "negative_log_likelihood": 0.16546134831630438 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 404, + "corrected": 11, + "introduced": 9, + "seen_shots": 3770, + "negative_log_likelihood": 0.1942750454414905 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 369, + "corrected": 6, + "introduced": 4, + "seen_shots": 3829, + "negative_log_likelihood": 0.1888898562249086 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 387, + "corrected": 9, + "introduced": 7, + "seen_shots": 3860, + "negative_log_likelihood": 0.1810635140657324 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 378, + "corrected": 2, + "introduced": 15, + "seen_shots": 3771, + "negative_log_likelihood": 0.1739092925760893 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 391, + "corrected": 6, + "introduced": 7, + "seen_shots": 3716, + "negative_log_likelihood": 0.1882771427447211 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 375, + "corrected": 3, + "introduced": 11, + "seen_shots": 3842, + "negative_log_likelihood": 0.17948530598894158 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 350, + "corrected": 11, + "introduced": 10, + "seen_shots": 3919, + "negative_log_likelihood": 0.17317225703497025 + } + ] + }, + { + "alpha": 64, + "mode": "equal", + "gain_over_reference": 2.8170072115384617e-06, + "expected_full_P": 0.7674325796274037, + "corrected": 29, + "introduced": 26, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 320, + "corrected": 1, + "introduced": 6, + "seen_shots": 3712, + "negative_log_likelihood": 0.16397544882982157 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 403, + "corrected": 4, + "introduced": 1, + "seen_shots": 3770, + "negative_log_likelihood": 0.1923331929504961 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 370, + "corrected": 4, + "introduced": 3, + "seen_shots": 3829, + "negative_log_likelihood": 0.1869587939110212 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 384, + "corrected": 7, + "introduced": 2, + "seen_shots": 3860, + "negative_log_likelihood": 0.18105203562831723 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 369, + "corrected": 1, + "introduced": 5, + "seen_shots": 3771, + "negative_log_likelihood": 0.1729924866021599 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 390, + "corrected": 4, + "introduced": 4, + "seen_shots": 3716, + "negative_log_likelihood": 0.18656948332566908 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 367, + "corrected": 1, + "introduced": 1, + "seen_shots": 3842, + "negative_log_likelihood": 0.17786130351036855 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 348, + "corrected": 7, + "introduced": 4, + "seen_shots": 3919, + "negative_log_likelihood": 0.17194995806365398 + } + ] + }, + { + "alpha": 256, + "mode": "raw", + "gain_over_reference": -1.3146033653846155e-05, + "expected_full_P": 0.7674166165865384, + "corrected": 57, + "introduced": 71, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 316, + "corrected": 8, + "introduced": 9, + "seen_shots": 3712, + "negative_log_likelihood": 0.1657779710188924 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 401, + "corrected": 12, + "introduced": 7, + "seen_shots": 3770, + "negative_log_likelihood": 0.1941828777212427 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 371, + "corrected": 5, + "introduced": 5, + "seen_shots": 3829, + "negative_log_likelihood": 0.188704881765863 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 385, + "corrected": 9, + "introduced": 5, + "seen_shots": 3860, + "negative_log_likelihood": 0.18119611478888992 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 376, + "corrected": 3, + "introduced": 14, + "seen_shots": 3771, + "negative_log_likelihood": 0.17447498026608818 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 392, + "corrected": 5, + "introduced": 7, + "seen_shots": 3716, + "negative_log_likelihood": 0.18789971956538998 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 374, + "corrected": 4, + "introduced": 11, + "seen_shots": 3842, + "negative_log_likelihood": 0.17943737455372838 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 353, + "corrected": 11, + "introduced": 13, + "seen_shots": 3919, + "negative_log_likelihood": 0.17265347364454034 + } + ] + }, + { + "alpha": 256, + "mode": "equal", + "gain_over_reference": 5.634014423076923e-06, + "expected_full_P": 0.7674353966346154, + "corrected": 35, + "introduced": 29, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 319, + "corrected": 1, + "introduced": 5, + "seen_shots": 3712, + "negative_log_likelihood": 0.16414682511964665 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 403, + "corrected": 8, + "introduced": 5, + "seen_shots": 3770, + "negative_log_likelihood": 0.1925170605666556 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 370, + "corrected": 4, + "introduced": 3, + "seen_shots": 3829, + "negative_log_likelihood": 0.18700325039039134 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 384, + "corrected": 7, + "introduced": 2, + "seen_shots": 3860, + "negative_log_likelihood": 0.18114891586770673 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 369, + "corrected": 1, + "introduced": 5, + "seen_shots": 3771, + "negative_log_likelihood": 0.17321873309583002 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 389, + "corrected": 5, + "introduced": 4, + "seen_shots": 3716, + "negative_log_likelihood": 0.1865637469477896 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 366, + "corrected": 2, + "introduced": 1, + "seen_shots": 3842, + "negative_log_likelihood": 0.1780072813576424 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 348, + "corrected": 7, + "introduced": 4, + "seen_shots": 3919, + "negative_log_likelihood": 0.17175236800482013 + } + ] + }, + { + "alpha": 1024, + "mode": "raw", + "gain_over_reference": -1.3146033653846155e-05, + "expected_full_P": 0.7674166165865384, + "corrected": 58, + "introduced": 72, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 316, + "corrected": 8, + "introduced": 9, + "seen_shots": 3712, + "negative_log_likelihood": 0.1660199383431144 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 401, + "corrected": 12, + "introduced": 7, + "seen_shots": 3770, + "negative_log_likelihood": 0.19424910024643272 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 372, + "corrected": 4, + "introduced": 5, + "seen_shots": 3829, + "negative_log_likelihood": 0.18869575015231485 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 384, + "corrected": 10, + "introduced": 5, + "seen_shots": 3860, + "negative_log_likelihood": 0.181319853916797 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 376, + "corrected": 3, + "introduced": 14, + "seen_shots": 3771, + "negative_log_likelihood": 0.17478305537075756 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 392, + "corrected": 5, + "introduced": 7, + "seen_shots": 3716, + "negative_log_likelihood": 0.18794271138491886 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 374, + "corrected": 5, + "introduced": 12, + "seen_shots": 3842, + "negative_log_likelihood": 0.179452867779811 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 353, + "corrected": 11, + "introduced": 13, + "seen_shots": 3919, + "negative_log_likelihood": 0.17247538215716168 + } + ] + }, + { + "alpha": 1024, + "mode": "equal", + "gain_over_reference": 6.573016826923077e-06, + "expected_full_P": 0.7674363356370192, + "corrected": 36, + "introduced": 29, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 319, + "corrected": 1, + "introduced": 5, + "seen_shots": 3712, + "negative_log_likelihood": 0.16422649864005784 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 403, + "corrected": 8, + "introduced": 5, + "seen_shots": 3770, + "negative_log_likelihood": 0.19268041613581482 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 370, + "corrected": 4, + "introduced": 3, + "seen_shots": 3829, + "negative_log_likelihood": 0.18700909051090328 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 383, + "corrected": 8, + "introduced": 2, + "seen_shots": 3860, + "negative_log_likelihood": 0.18120236440438334 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 369, + "corrected": 1, + "introduced": 5, + "seen_shots": 3771, + "negative_log_likelihood": 0.1733156354156408 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 389, + "corrected": 5, + "introduced": 4, + "seen_shots": 3716, + "negative_log_likelihood": 0.18661835099727148 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 366, + "corrected": 2, + "introduced": 1, + "seen_shots": 3842, + "negative_log_likelihood": 0.17809318693138096 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 348, + "corrected": 7, + "introduced": 4, + "seen_shots": 3919, + "negative_log_likelihood": 0.17166795339604946 + } + ] + } + ], + "selected": { + "alpha": 1024, + "mode": "equal", + "gain_over_reference": 6.573016826923077e-06, + "expected_full_P": 0.7674363356370192, + "corrected": 36, + "introduced": 29, + "conditions": [ + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 315, + "new_errors": 319, + "corrected": 1, + "introduced": 5, + "seen_shots": 3712, + "negative_log_likelihood": 0.16422649864005784 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 406, + "new_errors": 403, + "corrected": 8, + "introduced": 5, + "seen_shots": 3770, + "negative_log_likelihood": 0.19268041613581482 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 371, + "new_errors": 370, + "corrected": 4, + "introduced": 3, + "seen_shots": 3829, + "negative_log_likelihood": 0.18700909051090328 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 389, + "new_errors": 383, + "corrected": 8, + "introduced": 2, + "seen_shots": 3860, + "negative_log_likelihood": 0.18120236440438334 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 5120, + "old_errors": 365, + "new_errors": 369, + "corrected": 1, + "introduced": 5, + "seen_shots": 3771, + "negative_log_likelihood": 0.1733156354156408 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 5120, + "old_errors": 390, + "new_errors": 389, + "corrected": 5, + "introduced": 4, + "seen_shots": 3716, + "negative_log_likelihood": 0.18661835099727148 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 5120, + "old_errors": 367, + "new_errors": 366, + "corrected": 2, + "introduced": 1, + "seen_shots": 3842, + "negative_log_likelihood": 0.17809318693138096 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 5120, + "old_errors": 351, + "new_errors": 348, + "corrected": 7, + "introduced": 4, + "seen_shots": 3919, + "negative_log_likelihood": 0.17166795339604946 + } + ] + }, + "test_data_used": false, + "publication_status": "Unpublished; assembled runtime replay and relocation required if improved" + }, + "selected_weights": [ + "weights/r3-pattern1-weights-alpha1024-surface_code_bX_d3_r03_center_3_5.npz", + "weights/r3-pattern1-weights-alpha1024-surface_code_bX_d3_r03_center_5_3.npz", + "weights/r3-pattern1-weights-alpha1024-surface_code_bX_d3_r03_center_5_7.npz", + "weights/r3-pattern1-weights-alpha1024-surface_code_bX_d3_r03_center_7_5.npz", + "weights/r3-pattern1-weights-alpha1024-surface_code_bZ_d3_r03_center_3_5.npz", + "weights/r3-pattern1-weights-alpha1024-surface_code_bZ_d3_r03_center_5_3.npz", + "weights/r3-pattern1-weights-alpha1024-surface_code_bZ_d3_r03_center_5_7.npz", + "weights/r3-pattern1-weights-alpha1024-surface_code_bZ_d3_r03_center_7_5.npz" + ], + "runtime_sha256": { + "model.py": "24fbc23be719b230fd7fab57416f33d47d7fe9912dda0a709db1eff1fe8a24a3", + "runtime.py": "dcee0d278279eec5b9160054c136cc8cb05c2a32dc4cbbc2ff73ccb0f036f8aa", + "package.py": "b2d3aaba8ce1b6272edeb13851888bf0a2e90aba3fc03f663e4cb75dc3880032" + }, + "startup_recovery": { + "reason": "Source provenance relative_to used unresolved __file__ against resolvedresearchpath; /workspace resolves to /run-state/workspace. Failed before first trainingdata read or parameter initialization.", + "change": "Resolve __file__ before relative_to; training/model recipe unchanged", + "archive_failure": "Initial unresolved directoryrename returnedEXDEV, then shell command chain allowed secondlaunch againstexistingemptydirectory. ThatfailedFileExistsError. Resolvedpaths+shutil.move recovered. Initialrawlogwasoverwrittenbysecondlaunch; initialtraceisrecordedintooloutput.", + "archived": "initial_path_failure", + "optimizer_updates_before_failure": 0, + "validation_labels_accessed_before_failure": false + }, + "portable_runtime_control": { + "status": "passed", + "cases": [ + { + "condition": "surface_code_bZ_d3_r05_center_7_5", + "shots": 7, + "seen_patterns": 0, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_7_5", + "shots": 37, + "seen_patterns": 28, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_7", + "shots": 31, + "seen_patterns": 22, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_5_3", + "shots": 23, + "seen_patterns": 15, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r03_center_3_5", + "shots": 17, + "seen_patterns": 10, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_7_5", + "shots": 11, + "seen_patterns": 10, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_7", + "shots": 7, + "seen_patterns": 6, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_5_3", + "shots": 3, + "seen_patterns": 3, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r03_center_3_5", + "shots": 1, + "seen_patterns": 0, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "shots": 3, + "seen_patterns": 0, + "manual_composition_exact": true, + "maximum_probability_difference": 0.0 + } + ], + "seconds": 31.83873749198392, + "effective_uid": 1000, + "requested_verifier_uid_executed": false, + "scope": "Two read-only relocated package copies; fresh opaque IDs and shuffled input subsets; candidate compared to manual dictionary composition of actual CPU reference outputs. No validation labels, no accuracy selection, no Docker/network/mount isolation claim.", + "source_sha256": { + "runtime_control.py": "bfe8c14d78bd7b13d92f9325acfcd790ac3664f2491ded77e9f843d7defe5a07", + "model.py": "24fbc23be719b230fd7fab57416f33d47d7fe9912dda0a709db1eff1fe8a24a3", + "runtime.py": "dcee0d278279eec5b9160054c136cc8cb05c2a32dc4cbbc2ff73ccb0f036f8aa" + }, + "test_data_used": false + }, + "test_data_used": false + }, + "beam_calibration1": { + "declared_plan": { + "name": "beam_calibration1", + "status": "Declared before fitting; training evidence caches starting CPUonly", + "created_utc": "2026-10-21T20:21:49.646611+00:00", + "hypothesis": "The fullDEM beam supplies complementary probabilities but raw/equalr3globalchoices failed. Fit a small train-only correction; matchedparent-only arm identifies whether beam is needed. No accuracy improvement claimed.", + "reference": { + "current": { + "package": "/run-state/workspace/research/context_upgrades/r3_pattern1/package", + "predictions": "/run-state/workspace/research/context_upgrades/r3_pattern1/predictions", + "score": "/run-state/workspace/research/context_upgrades/r3_pattern1/score.json", + "P": 0.76744384765625 + }, + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "group": "d5_bX_center_5_5", + "record": { + "dem": "dems/surface_code_bX_d5_r03_center_5_5.dem", + "circuit_sha256": "1cbfca6766d1e142e35233b2cbeeb039f41aebf5179c46acbd45824d928a78a6", + "conditional_plan": "conditional_plans/surface_code_bX_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bX_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bX_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "confidence_joint": { + "weights": "weights/confidence-joint1-1024.npz" + }, + "prior_pass": 3, + "blend_turbo": false + }, + "plan_file": "plans/surface_code_bX_d5_r03_center_5_5.npz", + "plan_sha256": "cc763f0638add95aa03f2b76b5acf8dcceb470de00182d6804366e3bfa0e3f0d", + "source_schedule_sha256": "12e9b86c551a382dade82f1a1e3efe5aa26aa29edabd0e906607c2bde8b7dfc8", + "source_DEM_sha256": "b0f53a8924b9c471b5f574382d8162f5eef40e5003a85a15fcb62335a0af0e4c" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "group": "d5_bZ_center_5_5", + "record": { + "dem": "dems/surface_code_bZ_d5_r03_center_5_5.dem", + "circuit_sha256": "12b124311b84adfeeb4aa4e61b9b11707691692ee807a13cfd90ee73cf733f6c", + "conditional_plan": "conditional_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bZ_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "weights": "weights/prior-pass1-pass5-0.npz", + "prior_pass": 5, + "blend_turbo": false, + "training_checkpoint": "prior_pass1/pass5/0" + }, + "plan_file": "plans/surface_code_bZ_d5_r03_center_5_5.npz", + "plan_sha256": "3a6746481fe2953c4b5b7615b365fccfcee538ff1b8fadc910420fb0f9ba681d", + "source_schedule_sha256": "abebe153fc07da35e24b4f5e7aa7278896c2bb632a7d094ca95bcbaa58163ed7", + "source_DEM_sha256": "ed3409474d22d849cdc7b3deb9ded28d70aeff4a53cfb4a56a0d7411f5b57f88" + } + ], + "parent_manifest_sha256": "112a3c67e31cae326474ee93b1454382c8a14cc59900ff86344113d727fe4ce0", + "parent_config_sha256": "35badea7d1c73ab42edcb1193eff22613ad6f8aa0d8281596fe2c1fd78d73925", + "parent_provenance_sha256": "953d23dedc55520b654852a848cca45c0e555be23ff433f1368c5b5de1580df8", + "scope": "Nonlearned fullDEM schedules from authorized inputs, combined only with own session-trained parent. No syndrome/label/ID rows or predictions serialized as model state.", + "test_data_used": false + }, + "training_rows": 39760, + "conditions": [ + "surface_code_bX_d5_r03_center_5_5", + "surface_code_bZ_d5_r03_center_5_5" + ], + "beam_states_per_sector": 512, + "arms": [ + "parent_only", + "parent_plus_beam" + ], + "regularization": [ + 0.0001, + 0.001, + 0.01 + ], + "initial_seeds": { + "X": 20262100, + "Z": 20262101 + }, + "initialization": "Three coefficients perbasis drawnNormal(0,.001); parent_only uses firsttwo ofsameinitialvector, parent_plus_beam allthree. Eachlambda startsfromsamebasisinitialarray. No expert weights updated.", + "features": "Base offset logit(parent). Features parentlogit and beamlogit-minus-parentlogit, bothprobabilities clipped1e-7..1-1e-7 in float64. Center/scale fit onlyontraining, scalefloor.05; prependbias. Parent_only usesbiasandparentfeature.", + "loss": "Mean logicalBCE +.5lambda sum(weights^2*[.01,1,1]); independent perbasisfits, fullbatchL-BFGS-B max500,gtol1e-8,ftol1e-12.", + "selection": "Sixglobal(arm,lambda)choices across bothd5r3conditions againstfrozenownpublishedreference, full5120validationrows each; other128conditionsretained. No perbasisarm/lambdaselection. ActualGPU/portable/fullreplay/trustedscore/relocation/runtimebudgetrequired beforepublication; comparethen-currentstrongest.", + "fallback": "Emptybeam usesfrozenparent probability before featureconstruction. Parent_onlydoesnotexecute a beam ininference.", + "test_data_used": false, + "training_beam_source_sha256": "557ea3eef701c480b90896cda3e8f69e263bc852fcce805f054a90e43d7cffe5", + "reference_sha256": "9f0bbe90c63da1d9a13a27b9ecb61b07d689c64cc41055ba2c812e5b013c2701" + }, + "training": { + "status": "complete", + "declared_plan": { + "name": "beam_calibration1", + "status": "Declared before fitting; training evidence caches starting CPUonly", + "created_utc": "2026-10-21T20:21:49.646611+00:00", + "hypothesis": "The fullDEM beam supplies complementary probabilities but raw/equalr3globalchoices failed. Fit a small train-only correction; matchedparent-only arm identifies whether beam is needed. No accuracy improvement claimed.", + "reference": { + "current": { + "package": "/run-state/workspace/research/context_upgrades/r3_pattern1/package", + "predictions": "/run-state/workspace/research/context_upgrades/r3_pattern1/predictions", + "score": "/run-state/workspace/research/context_upgrades/r3_pattern1/score.json", + "P": 0.76744384765625 + }, + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "group": "d5_bX_center_5_5", + "record": { + "dem": "dems/surface_code_bX_d5_r03_center_5_5.dem", + "circuit_sha256": "1cbfca6766d1e142e35233b2cbeeb039f41aebf5179c46acbd45824d928a78a6", + "conditional_plan": "conditional_plans/surface_code_bX_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bX_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bX_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "confidence_joint": { + "weights": "weights/confidence-joint1-1024.npz" + }, + "prior_pass": 3, + "blend_turbo": false + }, + "plan_file": "plans/surface_code_bX_d5_r03_center_5_5.npz", + "plan_sha256": "cc763f0638add95aa03f2b76b5acf8dcceb470de00182d6804366e3bfa0e3f0d", + "source_schedule_sha256": "12e9b86c551a382dade82f1a1e3efe5aa26aa29edabd0e906607c2bde8b7dfc8", + "source_DEM_sha256": "b0f53a8924b9c471b5f574382d8162f5eef40e5003a85a15fcb62335a0af0e4c" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "group": "d5_bZ_center_5_5", + "record": { + "dem": "dems/surface_code_bZ_d5_r03_center_5_5.dem", + "circuit_sha256": "12b124311b84adfeeb4aa4e61b9b11707691692ee807a13cfd90ee73cf733f6c", + "conditional_plan": "conditional_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bZ_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "weights": "weights/prior-pass1-pass5-0.npz", + "prior_pass": 5, + "blend_turbo": false, + "training_checkpoint": "prior_pass1/pass5/0" + }, + "plan_file": "plans/surface_code_bZ_d5_r03_center_5_5.npz", + "plan_sha256": "3a6746481fe2953c4b5b7615b365fccfcee538ff1b8fadc910420fb0f9ba681d", + "source_schedule_sha256": "abebe153fc07da35e24b4f5e7aa7278896c2bb632a7d094ca95bcbaa58163ed7", + "source_DEM_sha256": "ed3409474d22d849cdc7b3deb9ded28d70aeff4a53cfb4a56a0d7411f5b57f88" + } + ], + "parent_manifest_sha256": "112a3c67e31cae326474ee93b1454382c8a14cc59900ff86344113d727fe4ce0", + "parent_config_sha256": "35badea7d1c73ab42edcb1193eff22613ad6f8aa0d8281596fe2c1fd78d73925", + "parent_provenance_sha256": "953d23dedc55520b654852a848cca45c0e555be23ff433f1368c5b5de1580df8", + "scope": "Nonlearned fullDEM schedules from authorized inputs, combined only with own session-trained parent. No syndrome/label/ID rows or predictions serialized as model state.", + "test_data_used": false + }, + "training_rows": 39760, + "conditions": [ + "surface_code_bX_d5_r03_center_5_5", + "surface_code_bZ_d5_r03_center_5_5" + ], + "beam_states_per_sector": 512, + "arms": [ + "parent_only", + "parent_plus_beam" + ], + "regularization": [ + 0.0001, + 0.001, + 0.01 + ], + "initial_seeds": { + "X": 20262100, + "Z": 20262101 + }, + "initialization": "Three coefficients perbasis drawnNormal(0,.001); parent_only uses firsttwo ofsameinitialvector, parent_plus_beam allthree. Eachlambda startsfromsamebasisinitialarray. No expert weights updated.", + "features": "Base offset logit(parent). Features parentlogit and beamlogit-minus-parentlogit, bothprobabilities clipped1e-7..1-1e-7 in float64. Center/scale fit onlyontraining, scalefloor.05; prependbias. Parent_only usesbiasandparentfeature.", + "loss": "Mean logicalBCE +.5lambda sum(weights^2*[.01,1,1]); independent perbasisfits, fullbatchL-BFGS-B max500,gtol1e-8,ftol1e-12.", + "selection": "Sixglobal(arm,lambda)choices across bothd5r3conditions againstfrozenownpublishedreference, full5120validationrows each; other128conditionsretained. No perbasisarm/lambdaselection. ActualGPU/portable/fullreplay/trustedscore/relocation/runtimebudgetrequired beforepublication; comparethen-currentstrongest.", + "fallback": "Emptybeam usesfrozenparent probability before featureconstruction. Parent_onlydoesnotexecute a beam ininference.", + "test_data_used": false, + "training_beam_source_sha256": "557ea3eef701c480b90896cda3e8f69e263bc852fcce805f054a90e43d7cffe5", + "reference_sha256": "9f0bbe90c63da1d9a13a27b9ecb61b07d689c64cc41055ba2c812e5b013c2701" + }, + "fits": [ + { + "name": "parent_only_lambda0.0001", + "arm": "parent_only", + "regularization": 0.0001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.0008904222146926071, + -0.00011428665525022358 + ], + "initial_objective": 0.14278155069445572, + "final_objective": 0.14274038983914675, + "optimizer_iterations": 6, + "function_evaluations": 8, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 8.452537136706609e-09, + "training_failure": 0.056790744466800804, + "training_nll": 0.14274038110596243, + "state": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "arm": "parent_only", + "regularization": 0.0001, + "center": [ + -2.702623737138793 + ], + "scale": [ + 5.7038010799253795 + ], + "weights": [ + -0.0501389466227126, + 0.012819330896991445 + ] + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.00039196482059606133, + 0.00045097930148191263 + ], + "initial_objective": 0.1319115622452317, + "final_objective": 0.1317708831391266, + "optimizer_iterations": 6, + "function_evaluations": 8, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 9.658190937414162e-12, + "training_failure": 0.05040241448692153, + "training_nll": 0.13176780338614147, + "state": { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "arm": "parent_only", + "regularization": 0.0001, + "center": [ + -3.27908665746099 + ], + "scale": [ + 5.995047332644429 + ], + "weights": [ + 0.13869162604739285, + -0.24768824004179757 + ] + } + } + ] + }, + { + "name": "parent_only_lambda0.001", + "arm": "parent_only", + "regularization": 0.001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.0008904222146926071, + -0.00011428665525022358 + ], + "initial_objective": 0.1427815507039012, + "final_objective": 0.14274046316460476, + "optimizer_iterations": 6, + "function_evaluations": 8, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 7.733995947348876e-10, + "training_failure": 0.056790744466800804, + "training_nll": 0.14274039364904217, + "state": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "arm": "parent_only", + "regularization": 0.001, + "center": [ + -2.702623737138793 + ], + "scale": [ + 5.7038010799253795 + ], + "weights": [ + -0.049257333922680696, + 0.010785950055188596 + ] + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.00039196482059606133, + 0.00045097930148191263 + ], + "initial_objective": 0.1319115623374451, + "final_objective": 0.13179398725373737, + "optimizer_iterations": 5, + "function_evaluations": 7, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 6.530917163845061e-09, + "training_failure": 0.05040241448692153, + "training_nll": 0.13177259808585817, + "state": { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "arm": "parent_only", + "regularization": 0.001, + "center": [ + -3.27908665746099 + ], + "scale": [ + 5.995047332644429 + ], + "weights": [ + 0.1185241572372795, + -0.20649880078807945 + ] + } + } + ] + }, + { + "name": "parent_only_lambda0.01", + "arm": "parent_only", + "regularization": 0.01, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.0008904222146926071, + -0.00011428665525022358 + ], + "initial_objective": 0.142781550798356, + "final_objective": 0.14274076465183108, + "optimizer_iterations": 4, + "function_evaluations": 6, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 4.931310645473006e-10, + "training_failure": 0.056790744466800804, + "training_nll": 0.14274057460705508, + "state": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "arm": "parent_only", + "regularization": 0.01, + "center": [ + -2.702623737138793 + ], + "scale": [ + 5.7038010799253795 + ], + "weights": [ + -0.046295712870130803, + 0.004098606934761435 + ] + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.00039196482059606133, + 0.00045097930148191263 + ], + "initial_objective": 0.13191156325957923, + "final_objective": 0.131865061011392, + "optimizer_iterations": 4, + "function_evaluations": 7, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 3.527443593297208e-11, + "training_failure": 0.0505533199195171, + "training_nll": 0.13183624273248945, + "state": { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "arm": "parent_only", + "regularization": 0.01, + "center": [ + -3.27908665746099 + ], + "scale": [ + 5.995047332644429 + ], + "weights": [ + 0.054390201442411204, + -0.07572406455728943 + ] + } + } + ] + }, + { + "name": "parent_plus_beam_lambda0.0001", + "arm": "parent_plus_beam", + "regularization": 0.0001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.0008904222146926071, + -0.00011428665525022358, + 0.000963904439557252 + ], + "initial_objective": 0.14277182680292996, + "final_objective": 0.14037881364720844, + "optimizer_iterations": 9, + "function_evaluations": 11, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 6.281800707876755e-09, + "training_failure": 0.056287726358148896, + "training_nll": 0.14036423838122727, + "state": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "arm": "parent_plus_beam", + "regularization": 0.0001, + "center": [ + -2.702623737138811, + -0.3232430237532058 + ], + "scale": [ + 5.70380107992538, + 0.9723746759532327 + ], + "weights": [ + -0.011975677524435652, + -0.2811597662497911, + 0.46096127193654723 + ] + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.00039196482059606133, + 0.00045097930148191263, + 0.000935714791758178 + ], + "initial_objective": 0.13190053156869616, + "final_objective": 0.12872425802924733, + "optimizer_iterations": 10, + "function_evaluations": 12, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 3.2864696367624984e-09, + "training_failure": 0.05070422535211268, + "training_nll": 0.12870538623400576, + "state": { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "arm": "parent_plus_beam", + "regularization": 0.0001, + "center": [ + -3.2790866574609825, + -0.21445213735898316 + ], + "scale": [ + 5.995047332644439, + 0.8414729101807127 + ], + "weights": [ + 0.13991201538185052, + -0.37012666327851007, + 0.4901249152934383 + ] + } + } + ] + }, + { + "name": "parent_plus_beam_lambda0.001", + "arm": "parent_plus_beam", + "regularization": 0.001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.0008904222146926071, + -0.00011428665525022358, + 0.000963904439557252 + ], + "initial_objective": 0.14277182723047574, + "final_objective": 0.14049916678097235, + "optimizer_iterations": 9, + "function_evaluations": 11, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 2.8489169940780663e-09, + "training_failure": 0.056388329979879276, + "training_nll": 0.14037608922878964, + "state": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "arm": "parent_plus_beam", + "regularization": 0.001, + "center": [ + -2.702623737138811, + -0.3232430237532058 + ], + "scale": [ + 5.70380107992538, + 0.9723746759532327 + ], + "weights": [ + -0.028984854314289165, + -0.23108254527136834, + 0.4390294827368008 + ] + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.00039196482059606133, + 0.00045097930148191263, + 0.000935714791758178 + ], + "initial_objective": 0.13190053205491256, + "final_objective": 0.12888094955148213, + "optimizer_iterations": 9, + "function_evaluations": 11, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 5.336398428777266e-09, + "training_failure": 0.05060362173038229, + "training_nll": 0.12871978197029882, + "state": { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "arm": "parent_plus_beam", + "regularization": 0.001, + "center": [ + -3.2790866574609825, + -0.21445213735898316 + ], + "scale": [ + 5.995047332644439, + 0.8414729101807127 + ], + "weights": [ + 0.11327237158871431, + -0.31150058932971436, + 0.47452802037587066 + ] + } + } + ] + }, + { + "name": "parent_plus_beam_lambda0.01", + "arm": "parent_plus_beam", + "regularization": 0.01, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.0008904222146926071, + -0.00011428665525022358, + 0.000963904439557252 + ], + "initial_objective": 0.1427718315059335, + "final_objective": 0.14117743947953007, + "optimizer_iterations": 7, + "function_evaluations": 9, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 6.297272858984265e-09, + "training_failure": 0.05618712273641851, + "training_nll": 0.14068549022803956, + "state": { + "condition": "surface_code_bX_d5_r03_center_5_5", + "arm": "parent_plus_beam", + "regularization": 0.01, + "center": [ + -2.702623737138811, + -0.3232430237532058 + ], + "scale": [ + 5.70380107992538, + 0.9723746759532327 + ], + "weights": [ + -0.07194087992131692, + -0.06897044963423382, + 0.30591059654356456 + ] + } + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "initial_weights": [ + -0.00039196482059606133, + 0.00045097930148191263, + 0.000935714791758178 + ], + "initial_objective": 0.13190053691707646, + "final_objective": 0.1297950128113894, + "optimizer_iterations": 8, + "function_evaluations": 10, + "optimizer_message": "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL", + "gradient_max_abs": 1.4760118214468543e-10, + "training_failure": 0.05070422535211268, + "training_nll": 0.1291184376629082, + "state": { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "arm": "parent_plus_beam", + "regularization": 0.01, + "center": [ + -3.2790866574609825, + -0.21445213735898316 + ], + "scale": [ + 5.995047332644439, + 0.8414729101807127 + ], + "weights": [ + 0.03282958672439998, + -0.11420657431588638, + 0.34965930624478575 + ] + } + } + ] + } + ], + "initial_weights_sha256": "8a8167e51f364216a4f34d30da609f8d817606e2b6538e6a8c7b12eaa3ed57d2", + "selection_data_opened": false, + "source_lock": { + "created_utc": "2026-10-21T20:25:33.650374+00:00", + "source_sha256": { + "beam_calibration/core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7", + "beam_calibration/fit.py": "bb494e78078963e81f287dcd0925ce4c071276e791b1902202a17d7a028a2f41", + "beam_calibration/control_cpu.py": "8e7dcb714f5e5ca8a1d86188fc24d569bd0456d65a42a86f8e7a1bd56a6a0f8f", + "beam_calibration/plan.json": "6a16f161a24d54c05afe10004f0d6f119aa3879394195d63f9d1ce65830b52c1", + "beam_calibration/generate_beam_training.py": "b7d8aabc20b10577500518002df566b789b65fa5da398584e8d35185892ce41f", + "beam_calibration/generate_parent_training.py": "c8c11132e5eb98cae6e71936cdeba4a90211fe1cdc03dd63e5b7982f49d87073", + "full_frontier/beam_lookahead.py": "557ea3eef701c480b90896cda3e8f69e263bc852fcce805f054a90e43d7cffe5", + "beam_r3/reference.json": "9f0bbe90c63da1d9a13a27b9ecb61b07d689c64cc41055ba2c812e5b013c2701" + }, + "scope": "Frozen before any beam_calibration hardware-label fitting. Evidence generation is in progress; fits await and audit both complete caches.", + "test_data_used": false + }, + "test_data_used": false + }, + "training_evidence_audit": { + "status": "passed", + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "all_ids_exact_by_value": true, + "arrays_sha256": "512c32ea26171d1d0f13ad197c5134a24ea2e2814168abc31c1d261b5ec45a80", + "cache_sha256": { + "beam_training": "cee146a284009f6acc42e8c5bbb5ec8b7b28de4702e1083e01ebf9c8826fbe54", + "parent_training": "f9305b93452ea7415c514291eddb564f4d7980d0c1625197f9b3277f22c13a78" + }, + "empty_fallbacks": 0 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "all_ids_exact_by_value": true, + "arrays_sha256": "faad8d29ffbd8a1d2db08dc8297486f622e875a71eea94474fca14158bfae013", + "cache_sha256": { + "beam_training": "67b74ffdc525f4d2a2a7d5d9aee952ce843b17573263669e7fc3b86af6e95c20", + "parent_training": "db8e3f0b4944b1e70852786ea8e291ede7295cd3058f94e5aa56d99a10f81c4b" + }, + "empty_fallbacks": 0 + } + ], + "training_rows": 39760, + "label_members_opened": false, + "test_data_used": false + }, + "evidence_generation": { + "beam_training": { + "status": "complete", + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "empty_count": 0, + "seconds": 617.974347114563, + "output_sha256": "cee146a284009f6acc42e8c5bbb5ec8b7b28de4702e1083e01ebf9c8826fbe54", + "arrays_sha256": "512c32ea26171d1d0f13ad197c5134a24ea2e2814168abc31c1d261b5ec45a80", + "schedule_sha256": "12e9b86c551a382dade82f1a1e3efe5aa26aa29edabd0e906607c2bde8b7dfc8" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "empty_count": 0, + "seconds": 611.0949277877808, + "output_sha256": "67b74ffdc525f4d2a2a7d5d9aee952ce843b17573263669e7fc3b86af6e95c20", + "arrays_sha256": "faad8d29ffbd8a1d2db08dc8297486f622e875a71eea94474fca14158bfae013", + "schedule_sha256": "abebe153fc07da35e24b4f5e7aa7278896c2bb632a7d094ca95bcbaa58163ed7" + } + ], + "seconds": 1229.1043140888214, + "scope": "All39760 supplied d5r3training syndromes, K512float64beam/float32savedprobabilities. No hardware logical-label member read. Empty flags saved for fallback to frozen parent in fitting/runtime. No model fitting or GPUwork.", + "test_data_used": false, + "source_sha256": { + "beam_calibration/generate_beam_training.py": "b7d8aabc20b10577500518002df566b789b65fa5da398584e8d35185892ce41f", + "full_frontier/beam_lookahead.py": "557ea3eef701c480b90896cda3e8f69e263bc852fcce805f054a90e43d7cffe5" + } + }, + "parent_training": { + "status": "complete", + "reference": { + "current": { + "package": "/run-state/workspace/research/context_upgrades/r3_pattern1/package", + "predictions": "/run-state/workspace/research/context_upgrades/r3_pattern1/predictions", + "score": "/run-state/workspace/research/context_upgrades/r3_pattern1/score.json", + "P": 0.76744384765625 + }, + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "group": "d5_bX_center_5_5", + "record": { + "dem": "dems/surface_code_bX_d5_r03_center_5_5.dem", + "circuit_sha256": "1cbfca6766d1e142e35233b2cbeeb039f41aebf5179c46acbd45824d928a78a6", + "conditional_plan": "conditional_plans/surface_code_bX_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bX_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bX_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "confidence_joint": { + "weights": "weights/confidence-joint1-1024.npz" + }, + "prior_pass": 3, + "blend_turbo": false + }, + "plan_file": "plans/surface_code_bX_d5_r03_center_5_5.npz", + "plan_sha256": "cc763f0638add95aa03f2b76b5acf8dcceb470de00182d6804366e3bfa0e3f0d", + "source_schedule_sha256": "12e9b86c551a382dade82f1a1e3efe5aa26aa29edabd0e906607c2bde8b7dfc8", + "source_DEM_sha256": "b0f53a8924b9c471b5f574382d8162f5eef40e5003a85a15fcb62335a0af0e4c" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "group": "d5_bZ_center_5_5", + "record": { + "dem": "dems/surface_code_bZ_d5_r03_center_5_5.dem", + "circuit_sha256": "12b124311b84adfeeb4aa4e61b9b11707691692ee807a13cfd90ee73cf733f6c", + "conditional_plan": "conditional_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bZ_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "weights": "weights/prior-pass1-pass5-0.npz", + "prior_pass": 5, + "blend_turbo": false, + "training_checkpoint": "prior_pass1/pass5/0" + }, + "plan_file": "plans/surface_code_bZ_d5_r03_center_5_5.npz", + "plan_sha256": "3a6746481fe2953c4b5b7615b365fccfcee538ff1b8fadc910420fb0f9ba681d", + "source_schedule_sha256": "abebe153fc07da35e24b4f5e7aa7278896c2bb632a7d094ca95bcbaa58163ed7", + "source_DEM_sha256": "ed3409474d22d849cdc7b3deb9ded28d70aeff4a53cfb4a56a0d7411f5b57f88" + } + ], + "parent_manifest_sha256": "112a3c67e31cae326474ee93b1454382c8a14cc59900ff86344113d727fe4ce0", + "parent_config_sha256": "35badea7d1c73ab42edcb1193eff22613ad6f8aa0d8281596fe2c1fd78d73925", + "parent_provenance_sha256": "953d23dedc55520b654852a848cca45c0e555be23ff433f1368c5b5de1580df8", + "scope": "Nonlearned fullDEM schedules from authorized inputs, combined only with own session-trained parent. No syndrome/label/ID rows or predictions serialized as model state.", + "test_data_used": false + }, + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "shots": 19880, + "prior_pass": 3, + "arrays_sha256": "512c32ea26171d1d0f13ad197c5134a24ea2e2814168abc31c1d261b5ec45a80", + "prior_cache_sha256": "d1914adb7f3dc4b13764913c9ae4302a7669e67d95809c4d793b8060680ff1ed", + "output_sha256": "f9305b93452ea7415c514291eddb564f4d7980d0c1625197f9b3277f22c13a78", + "seconds": 215.4025113582611 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "shots": 19880, + "prior_pass": 5, + "arrays_sha256": "faad8d29ffbd8a1d2db08dc8297486f622e875a71eea94474fca14158bfae013", + "prior_cache_sha256": "13529d5db9180913d201025fbe150b13ad0f873f4a9b68c3e5e390ed93d5ad6e", + "output_sha256": "db8e3f0b4944b1e70852786ea8e291ede7295cd3058f94e5aa56d99a10f81c4b", + "seconds": 110.62420415878296 + } + ], + "seconds": 326.0629012584686, + "scope": "All39760 supplied d5r3training syndromes with ownfrozenr3publication; cachedphysicalpriors allIDschecked, no labelmembers opened. CPUbatch128, no optimizerupdates.", + "test_data_used": false, + "source_sha256": "c8c11132e5eb98cae6e71936cdeba4a90211fe1cdc03dd63e5b7982f49d87073" + } + }, + "six_global_selection_results": { + "status": "complete", + "assessments": [ + { + "name": "parent_only_lambda0.0001", + "arm": "parent_only", + "regularization": 0.0001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "failure": 0.05078125, + "parent_failure": 0.0513671875, + "nll": 0.1384792912248836, + "corrected": 5, + "introduced": 2, + "P_gain": 1.1268028846153845e-05 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "failure": 0.0482421875, + "parent_failure": 0.0482421875, + "nll": 0.12470995566102375, + "corrected": 1, + "introduced": 1, + "P_gain": 0.0 + } + ], + "net_corrected": 3, + "P_gain": 1.1268028846153845e-05, + "expected_full_P": 0.7674551156850961, + "paired_naive_P_standard_error": 1.1268028846153847e-05 + }, + { + "name": "parent_only_lambda0.001", + "arm": "parent_only", + "regularization": 0.001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "failure": 0.05078125, + "parent_failure": 0.0513671875, + "nll": 0.13847906138552207, + "corrected": 5, + "introduced": 2, + "P_gain": 1.1268028846153845e-05 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "failure": 0.0484375, + "parent_failure": 0.0482421875, + "nll": 0.12466280070293534, + "corrected": 1, + "introduced": 2, + "P_gain": -3.7560096153846156e-06 + } + ], + "net_corrected": 2, + "P_gain": 7.5120192307692295e-06, + "expected_full_P": 0.7674513596754807, + "paired_naive_P_standard_error": 1.1877545298108396e-05 + }, + { + "name": "parent_only_lambda0.01", + "arm": "parent_only", + "regularization": 0.01, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "failure": 0.05078125, + "parent_failure": 0.0513671875, + "nll": 0.13847861219455943, + "corrected": 5, + "introduced": 2, + "P_gain": 1.1268028846153845e-05 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "failure": 0.0486328125, + "parent_failure": 0.0482421875, + "nll": 0.12456307079291615, + "corrected": 1, + "introduced": 3, + "P_gain": -7.512019230769231e-06 + } + ], + "net_corrected": 1, + "P_gain": 3.756009615384614e-06, + "expected_full_P": 0.7674476036658653, + "paired_naive_P_standard_error": 1.2457053370620118e-05 + }, + { + "name": "parent_plus_beam_lambda0.0001", + "arm": "parent_plus_beam", + "regularization": 0.0001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "failure": 0.0513671875, + "parent_failure": 0.0513671875, + "nll": 0.1346832704986473, + "corrected": 15, + "introduced": 15, + "P_gain": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "failure": 0.0486328125, + "parent_failure": 0.0482421875, + "nll": 0.12059465907504711, + "corrected": 20, + "introduced": 22, + "P_gain": -7.512019230769231e-06 + } + ], + "net_corrected": -2, + "P_gain": -7.512019230769231e-06, + "expected_full_P": 0.7674363356370192, + "paired_naive_P_standard_error": 3.18737383420279e-05 + }, + { + "name": "parent_plus_beam_lambda0.001", + "arm": "parent_plus_beam", + "regularization": 0.001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "failure": 0.0513671875, + "parent_failure": 0.0513671875, + "nll": 0.13477318211186434, + "corrected": 14, + "introduced": 14, + "P_gain": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "failure": 0.0478515625, + "parent_failure": 0.0482421875, + "nll": 0.12056943881861719, + "corrected": 20, + "introduced": 18, + "P_gain": 7.512019230769231e-06 + } + ], + "net_corrected": 2, + "P_gain": 7.512019230769231e-06, + "expected_full_P": 0.7674513596754807, + "paired_naive_P_standard_error": 3.0516766062738164e-05 + }, + { + "name": "parent_plus_beam_lambda0.01", + "arm": "parent_plus_beam", + "regularization": 0.01, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "failure": 0.0515625, + "parent_failure": 0.0513671875, + "nll": 0.13552675405405584, + "corrected": 8, + "introduced": 9, + "P_gain": -3.7560096153846156e-06 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "failure": 0.048828125, + "parent_failure": 0.0482421875, + "nll": 0.12101605822482794, + "corrected": 11, + "introduced": 14, + "P_gain": -1.1268028846153845e-05 + } + ], + "net_corrected": -4, + "P_gain": -1.502403846153846e-05, + "expected_full_P": 0.7674288236177884, + "paired_naive_P_standard_error": 2.4343535804648415e-05 + } + ], + "selected": { + "name": "parent_only_lambda0.0001", + "arm": "parent_only", + "regularization": 0.0001, + "conditions": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "failure": 0.05078125, + "parent_failure": 0.0513671875, + "nll": 0.1384792912248836, + "corrected": 5, + "introduced": 2, + "P_gain": 1.1268028846153845e-05 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "failure": 0.0482421875, + "parent_failure": 0.0482421875, + "nll": 0.12470995566102375, + "corrected": 1, + "introduced": 1, + "P_gain": 0.0 + } + ], + "net_corrected": 3, + "P_gain": 1.1268028846153845e-05, + "expected_full_P": 0.7674551156850961, + "paired_naive_P_standard_error": 1.1268028846153847e-05 + }, + "reference_P": 0.76744384765625, + "seconds": 1004.8447856903076, + "scope": "Six prespecified global choices across both d5r3 conditions, all other128 retained. Expected score only, no actual exported replay or publication yet. Standard errors omit selection and shot dependence. Compare then-current incumbent before any publication.", + "test_data_used": false + }, + "then_current_selection": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "then_current_failure": 0.0513671875, + "candidate_failure": 0.05078125, + "global_arm": "parent_only", + "global_regularization": 0.0001 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "then_current_failure": 0.0482421875, + "candidate_failure": 0.0482421875, + "global_arm": "parent_only", + "global_regularization": 0.0001 + } + ], + "frozen_parent_weight_copies": { + "weights/beam-calibration-parent-X-0.npz": { + "original_relative_path": "weights/confidence-joint1-1024.npz", + "sha256": "bf3eecca4cabbe147d19aca5c2539e527baf0683b8de673b360630d4517d3e9a" + }, + "weights/beam-calibration-parent-Z-1.npz": { + "original_relative_path": "weights/prior-pass1-pass5-0.npz", + "sha256": "20746e71c276e720074318b0978e6ea0ddc0df206954834f13c7f36354933cea" + } + }, + "runtime_export_sha256": { + "d5_prebeam_calibration_contextual.py": "3d2c62eda6cc837b5c6b381d6d769f3bc5a6e7d35450bcf0152b3a7ee2c57471", + "d5_contextual.py": "a3e6f859e6d4a350858c47ab362f5716155f3434e25661bb70e8e2896ab228c5", + "beam_calibration_core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7", + "beam_calibration_frontier.py": "45ce979892fad6eaa88325477fb063e6513e635f89370d8a6a9c930f56f09cb1" + }, + "controls": { + "control_cpu.json": { + "status": "passed", + "checks": [ + { + "mode": "parent_only", + "gradient_max_abs_difference": 8.656769745485349e-12, + "independent_scipy_probability_exact": true, + "order_subset_exact": true, + "neutral_decisions_exact": true, + "neutral_probability_max_abs": 1.1920928955078125e-07 + }, + { + "mode": "parent_plus_beam", + "gradient_max_abs_difference": 1.792266335343129e-11, + "independent_scipy_probability_exact": true, + "order_subset_exact": true, + "neutral_decisions_exact": true, + "neutral_probability_max_abs": 1.1920928955078125e-07 + } + ], + "unsigned_label_reference_loss": 0.22314355131420974, + "hardware_labels_accessed": false, + "optimizer_updates": 0, + "test_data_used": false, + "source_sha256": { + "core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7", + "control_cpu.py": "8e7dcb714f5e5ca8a1d86188fc24d569bd0456d65a42a86f8e7a1bd56a6a0f8f" + } + }, + "runtime_control_cpu.json": { + "status": "passed", + "device": "TFRT_CPU_0", + "checks": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "feature_width": 1, + "batch": 4, + "shots": 4, + "independent_composition_max_abs": 0.0, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": true, + "live_cached_max_abs": 2.384185791015625e-07, + "first_call_seconds": 0.8717937469482422 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "feature_width": 2, + "batch": 4, + "shots": 4, + "independent_composition_max_abs": 5.960464477539063e-08, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": false, + "live_cached_max_abs": 2.384185791015625e-07, + "first_call_seconds": 2.119344711303711 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "forced_empty_before_feature_fallback_exact": true + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "feature_width": 1, + "batch": 4, + "shots": 4, + "independent_composition_max_abs": 0.0, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": true, + "live_cached_max_abs": 3.5762786865234375e-07, + "first_call_seconds": 0.3764357566833496 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "feature_width": 2, + "batch": 4, + "shots": 4, + "independent_composition_max_abs": 2.9802322387695312e-08, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": false, + "live_cached_max_abs": 2.980232238769531e-07, + "first_call_seconds": 2.7272634506225586 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "forced_empty_before_feature_fallback_exact": true + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "retained_current_path_exact": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "retained_current_path_exact": true + } + ], + "peak_gpu_bytes": 0, + "scope": "Exported wrapper with specified nonzero synthetic correction coefficients; no hardware labels or fitting. Independent NumPy beam/reference-parent composition, parent-only path, order/subsets, live conditioning, forced empty-before-feature fallback and retained paths. GPU mode uses production B512.", + "exported_source_sha256": { + "d5_prebeam_calibration_contextual.py": "3d2c62eda6cc837b5c6b381d6d769f3bc5a6e7d35450bcf0152b3a7ee2c57471", + "d5_contextual.py": "a3e6f859e6d4a350858c47ab362f5716155f3434e25661bb70e8e2896ab228c5", + "beam_calibration_core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7", + "beam_calibration_frontier.py": "45ce979892fad6eaa88325477fb063e6513e635f89370d8a6a9c930f56f09cb1" + }, + "test_data_used": false, + "source_sha256": { + "beam_calibration/runtime.py": "a3e6f859e6d4a350858c47ab362f5716155f3434e25661bb70e8e2896ab228c5", + "beam_calibration/export.py": "ad0c3d9cdf2897b350e4b9abb44a044bff5a84d81003775d5e7d682571fd2cd4", + "beam_calibration/core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7", + "beam_calibration/runtime_control.py": "f93fe417f7b43a4f95314b84c6102f7a3eba6a4255600409f57555553bb1abc4", + "full_frontier/beam_jax.py": "45ce979892fad6eaa88325477fb063e6513e635f89370d8a6a9c930f56f09cb1" + } + }, + "runtime_control_gpu.json": { + "status": "passed", + "device": "cuda:0", + "checks": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "feature_width": 1, + "batch": 512, + "shots": 4, + "independent_composition_max_abs": 0.0, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": true, + "live_cached_max_abs": 0.0, + "first_call_seconds": 2.213339328765869 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "feature_width": 2, + "batch": 512, + "shots": 4, + "independent_composition_max_abs": 1.1920928955078125e-07, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": false, + "live_cached_max_abs": 0.0, + "first_call_seconds": 1.6267404556274414 + }, + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "forced_empty_before_feature_fallback_exact": true + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "feature_width": 1, + "batch": 512, + "shots": 4, + "independent_composition_max_abs": 0.0, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": true, + "live_cached_max_abs": 0.0, + "first_call_seconds": 0.9255428314208984 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "feature_width": 2, + "batch": 512, + "shots": 4, + "independent_composition_max_abs": 2.9802322387695312e-08, + "decisions_equal": true, + "order_subset_exact": true, + "no_new_beam_for_parent_only": false, + "live_cached_max_abs": 0.0, + "first_call_seconds": 1.5996739864349365 + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "forced_empty_before_feature_fallback_exact": true + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "retained_current_path_exact": true + }, + { + "condition": "surface_code_bZ_d5_r25_center_5_5", + "retained_current_path_exact": true + } + ], + "peak_gpu_bytes": 29294627584, + "scope": "Exported wrapper with specified nonzero synthetic correction coefficients; no hardware labels or fitting. Independent NumPy beam/reference-parent composition, parent-only path, order/subsets, live conditioning, forced empty-before-feature fallback and retained paths. GPU mode uses production B512.", + "exported_source_sha256": { + "d5_prebeam_calibration_contextual.py": "3d2c62eda6cc837b5c6b381d6d769f3bc5a6e7d35450bcf0152b3a7ee2c57471", + "d5_contextual.py": "a3e6f859e6d4a350858c47ab362f5716155f3434e25661bb70e8e2896ab228c5", + "beam_calibration_core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7", + "beam_calibration_frontier.py": "45ce979892fad6eaa88325477fb063e6513e635f89370d8a6a9c930f56f09cb1" + }, + "test_data_used": false, + "source_sha256": { + "beam_calibration/runtime.py": "a3e6f859e6d4a350858c47ab362f5716155f3434e25661bb70e8e2896ab228c5", + "beam_calibration/export.py": "ad0c3d9cdf2897b350e4b9abb44a044bff5a84d81003775d5e7d682571fd2cd4", + "beam_calibration/core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7", + "beam_calibration/runtime_control.py": "f93fe417f7b43a4f95314b84c6102f7a3eba6a4255600409f57555553bb1abc4", + "full_frontier/beam_jax.py": "45ce979892fad6eaa88325477fb063e6513e635f89370d8a6a9c930f56f09cb1" + } + } + }, + "test_data_used": false, + "queue_amendment": { + "created_utc": "2026-10-21T20:43:17.769949+00:00", + "previous_waiter_pid": 80427, + "previous_waiter_session": 95715, + "previous_queue_after": "full_frontier/resource_finished.json", + "new_queue": "GPUidle gap after completed block_physical resource study and failed/pretraining trajectorycontrol; finish calibrationverificationbeforetrajectoryrestart", + "reason": "Completed prespecifiedfitselectedparent-onlycalibration (no beam needed); verify strongestcandidate promptly whiletrajectorycontrolrecoveryprepared. Only operational scheduling changes, no training/selection/model changes.", + "original_source_lock_sha256": "a73ad807bf27cb8c65ed3b06fa287d2ce1fd1206b7a74f867221e35261b4edfa", + "test_data_used": false + }, + "verification_controller_sha256": "f5691254b8147b5e3b2202fd2fc20e0619726e4fea726bedc8f21b95453286ee" + }, + "package_validation": { + "performance": 0.7674551156850962, + "failure_by_distance": { + "d3": 0.2397442157451923, + "d5": 0.22534555288461539 + }, + "scorer": "Supplied qecbench.scoring on all 130 validation conditions and 665600 shots", + "contract_checks": [ + { + "condition": "surface_code_bX_d3_r01_center_3_5", + "shots": 1, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d3_r25_center_5_3", + "shots": 37, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d3_r13_center_5_7", + "shots": 1025, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r01_center_5_5", + "shots": 7, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bZ_d5_r09_center_5_5", + "shots": 257, + "maximum_probability_difference": 0.0 + }, + { + "condition": "surface_code_bX_d5_r25_center_5_5", + "shots": 17, + "maximum_probability_difference": 0.0 + } + ], + "prediction_generation": "All26 d5 conditions replayed from the assembled package; unchanged d3 predictions retained. Full trusted scoring and relocated arbitrary-ID/subset checks.", + "runtime_evidence": "Full133120-shot d5 replay took 409.54s on one H100; d3 paths unchanged from the recorded incumbent.", + "d5_validation_runtime_seconds": 409.5445261001587, + "runtime_vs_cached": { + "scope": "Assembled runtime versus cached candidate predictions, including physical-prior recomputation and compilation/batching differences; descriptive, not a causal precision attribution", + "maximum_probability_difference": 0.0, + "decision_differences": 0, + "source_sha256": "2e3e81d122f9d626d486d050c38d86bfd3e55bc6cd8e0e270b9e8eabbf69539a" + }, + "contract_execution": { + "requested_verifier_uid": 10001, + "effective_uid": 1000, + "effective_gid": 1000, + "supplementary_groups": [], + "identity_status": "Development process is already unprivileged and cannot change UID; verifier UID10001 was not executed", + "model_and_input_copy": "Owned by development UID 1000,directories0555,files0444,relocated under a fresh accessible temporary parent", + "output_directory": "Owned by execution UID 1000,mode0700", + "PYTHONPATH": "", + "backend": "Runtime default; full selected subset cases", + "scope": "Local contract check; not a Docker/network/mount-isolation test" + } + } +} diff --git a/shared/package-files/42/420c4b3088c9dacd21bc348011cac61d7cb283b9bee78ae72eed764ab094651c/blob b/shared/package-files/42/420c4b3088c9dacd21bc348011cac61d7cb283b9bee78ae72eed764ab094651c/blob new file mode 100644 index 0000000000000000000000000000000000000000..ab6170f7f623e269c442ceef76e21b1cc4fb8c6f --- /dev/null +++ b/shared/package-files/42/420c4b3088c9dacd21bc348011cac61d7cb283b9bee78ae72eed764ab094651c/blob @@ -0,0 +1,11 @@ +# Tcl package index file, version 1.0 +# This file is generated by the "pkg_mkIndex" command +# and sourced either when an application starts up or +# by a "package unknown" script. It invokes the +# "package ifneeded" command to set up package-related +# information so that packages will be loaded automatically +# in response to "package require" commands. When this +# script is sourced, the variable $dir must contain the +# full path name of this file's directory. + +package ifneeded http 1.0 [list tclPkgSetup $dir http 1.0 {{http.tcl source {httpCopyDone httpCopyStart httpEof httpEvent httpFinish httpMapReply httpProxyRequired http_code http_config http_data http_formatQuery http_get http_reset http_size http_status http_wait}}}] diff --git a/shared/package-files/42/420f05520934b69ed86053144bcded51235e1da284c6528192f107afb9516674/blob b/shared/package-files/42/420f05520934b69ed86053144bcded51235e1da284c6528192f107afb9516674/blob new file mode 100644 index 0000000000000000000000000000000000000000..036ec5cf8388536fa56c0f19ef6517cb5fdcc8d6 --- /dev/null +++ b/shared/package-files/42/420f05520934b69ed86053144bcded51235e1da284c6528192f107afb9516674/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_i0 : public TensorIteratorBase { + + + void meta(const at::Tensor & self); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/42/4210969f70fd62d78c425c5faec9ce171bbcad9d8e851023bf698ba81fdb88c0/blob b/shared/package-files/42/4210969f70fd62d78c425c5faec9ce171bbcad9d8e851023bf698ba81fdb88c0/blob new file mode 100644 index 0000000000000000000000000000000000000000..ef56baa4df211d6532f72280c5c56aa5ea5afdc5 --- /dev/null +++ b/shared/package-files/42/4210969f70fd62d78c425c5faec9ce171bbcad9d8e851023bf698ba81fdb88c0/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4210969f70fd62d78c425c5faec9ce171bbcad9d8e851023bf698ba81fdb88c0 +size 2071644 diff --git a/shared/package-files/42/4211f9bdae3a6b76d795f77c870fab1a2a7e2c9f5abedac6cd8af96339aa467a/blob b/shared/package-files/42/4211f9bdae3a6b76d795f77c870fab1a2a7e2c9f5abedac6cd8af96339aa467a/blob new file mode 100644 index 0000000000000000000000000000000000000000..c75551beddf2cdaaff420275d601d9913f1fcd68 Binary files /dev/null and b/shared/package-files/42/4211f9bdae3a6b76d795f77c870fab1a2a7e2c9f5abedac6cd8af96339aa467a/blob differ diff --git a/shared/package-files/42/4212be9cb2b2fdf5ade56c98dc3b9499aad1c206b1ac31e91ed2c625b0989910/blob b/shared/package-files/42/4212be9cb2b2fdf5ade56c98dc3b9499aad1c206b1ac31e91ed2c625b0989910/blob new file mode 100644 index 0000000000000000000000000000000000000000..dd785e95220b29f1109b00f705a15ccbd4e66fb9 --- /dev/null +++ b/shared/package-files/42/4212be9cb2b2fdf5ade56c98dc3b9499aad1c206b1ac31e91ed2c625b0989910/blob @@ -0,0 +1,143 @@ +from __future__ import annotations + +from collections.abc import Mapping +from enum import Enum +from typing import TYPE_CHECKING, Any, Optional, Union + +from formulaic.utils.variables import Variable, get_required_variables + +from .ordered_set import OrderedSet +from .term import Term + +if TYPE_CHECKING: + from .token import Token # pragma: no cover + + +class Factor: + """ + Factors are the indivisable atomic unit that make up formulas. + + Each instance of `Factor` is a specification that is evaluable by a + materializer to generate concrete vector(s). `Factors` are multiplied + together into `Term`s, which in turn represent the output columns of model + matrices. Note that `Factor` instances are entirely abstract of data. + + Attributes: + expr: The (string) expression to be evaluated by the materializer. + eval_method: An `EvalMethod` enum instance indicating the mechanism to + be used to evaluate the expression (one of: unknown, literal, lookup + or python). + kind: The kind of data represented (one of: unknown, constant, + numerical, categorical). + metadata: An additional (optional) dictionary of metadata (currently + unused). + token: The `Token` instance from which the the `Formula` object was + created. + """ + + class EvalMethod(Enum): + LITERAL = "literal" + LOOKUP = "lookup" + PYTHON = "python" + + class Kind(Enum): + UNKNOWN = "unknown" + CONSTANT = "constant" + NUMERICAL = "numerical" + CATEGORICAL = "categorical" + + __slots__ = ("expr", "_eval_method", "_kind", "metadata", "token") + + def __init__( + self, + expr: str = "", + *, + eval_method: Optional[Union[str, EvalMethod]] = None, + kind: Optional[Union[str, Kind]] = None, + metadata: Optional[dict] = None, + token: Optional[Token] = None, + ): + self.expr = expr + self.eval_method = eval_method # type: ignore + self.kind = kind # type: ignore + self.metadata = metadata or {} + self.token = token + + @property + def eval_method(self) -> EvalMethod: + return self._eval_method + + @eval_method.setter + def eval_method(self, eval_method: Union[str, EvalMethod]) -> None: + self._eval_method = Factor.EvalMethod(eval_method or "lookup") + + @property + def kind(self) -> Kind: + return self._kind + + @kind.setter + def kind(self, kind: Union[str, Factor.Kind]) -> None: + self._kind = Factor.Kind(kind or "unknown") + + def __eq__(self, other: Any) -> bool: + if isinstance(other, str): + return self.expr == other + if isinstance(other, Factor): + return self.expr == other.expr + return NotImplemented + + def __hash__(self) -> int: + return self.expr.__hash__() + + def __lt__(self, other: Any) -> bool: + if isinstance(other, Factor): + return self.expr < other.expr + return NotImplemented + + def to_terms( + self, *, context: Optional[Mapping[str, Any]] = None + ) -> OrderedSet[Term]: + """ + Convert this `Factor` instance into a `Term` instance, and expose it as + a single-element ordered set. + """ + return OrderedSet((Term([self]),)) + + @property + def required_variables(self) -> set[Variable]: + """ + The set of variables required to evaluate this token. + + If this is a Python token, and the code is malformed and unable to be + parsed, an empty set is returned. The code will fail more gracefully + later on. + + Attempts are made to restrict these variables only to those expected in + the data, and not, for example, those associated with transforms and/or + values present in the evaluation namespace by default (e.g. `y ~ C(x)` + would include only `y` and `x`). This may not always be possible for + more advanced formulae that insert constants into the formula via the + evaluation context rather than the data context. We also only consider + the root variable (e.g. `a.fillna(0)` -> `a` vs. `a.fillna`). + """ + if self.eval_method == Factor.EvalMethod.LOOKUP: + return {Variable(self.expr, roles={Variable.Role.VALUE})} + if self.eval_method == Factor.EvalMethod.PYTHON: + from formulaic.transforms import TRANSFORMS + + try: + # Filter out constants like `contr` that are already present in the + # TRANSFORMS namespace. + return set( + variable.root + for variable in get_required_variables(self.expr, TRANSFORMS) + if variable.root not in TRANSFORMS + ) + except Exception: # noqa: S110 + pass + return set() + + def __repr__(self) -> str: + if ":" in self.expr and self.eval_method == Factor.EvalMethod.LOOKUP: + return f"`{self.expr}`" + return self.expr diff --git a/shared/package-files/42/4216e58a8e7b292270facb5c3ce613471096b5167b57bc8208cb73f2ad899017/blob b/shared/package-files/42/4216e58a8e7b292270facb5c3ce613471096b5167b57bc8208cb73f2ad899017/blob new file mode 100644 index 0000000000000000000000000000000000000000..590bea0b5a36a4226258dbb4255f298ebb972079 --- /dev/null +++ b/shared/package-files/42/4216e58a8e7b292270facb5c3ce613471096b5167b57bc8208cb73f2ad899017/blob @@ -0,0 +1,32 @@ +from typing import Any, Dict, Optional + +from werkzeug.exceptions import HTTPException +from werkzeug.routing import Rule +from werkzeug.wrappers import Request as RequestBase, Response as ResponseBase + +class JSONMixin: + @property + def is_json(self) -> bool: ... + @property + def json(self): ... + def get_json(self, force: bool = ..., silent: bool = ..., cache: bool = ...): ... + def on_json_loading_failed(self, e: Any) -> None: ... + +class Request(RequestBase, JSONMixin): + url_rule: Optional[Rule] = ... + view_args: Dict[str, Any] = ... + routing_exception: Optional[HTTPException] = ... + # Request is making the max_content_length readonly, where it was not the + # case in its supertype. + # We would require something like https://github.com/python/typing/issues/241 + @property + def max_content_length(self) -> Optional[int]: ... # type: ignore + @property + def endpoint(self) -> Optional[str]: ... + @property + def blueprint(self) -> Optional[str]: ... + +class Response(ResponseBase, JSONMixin): + default_mimetype: Optional[str] = ... + @property + def max_cookie_size(self) -> int: ... diff --git a/shared/package-files/42/421eb0168da4eb0985ff26eafecde704322a45b657890af6edab05e0f910be0e/blob b/shared/package-files/42/421eb0168da4eb0985ff26eafecde704322a45b657890af6edab05e0f910be0e/blob new file mode 100644 index 0000000000000000000000000000000000000000..295e7f41144960c6b3b80b2c2c622fa8f8e9d1de --- /dev/null +++ b/shared/package-files/42/421eb0168da4eb0985ff26eafecde704322a45b657890af6edab05e0f910be0e/blob @@ -0,0 +1,6984 @@ +PT data: 15 variables per line; they are: +identifier, not used, constant, z1, z2, z3, z4, z5, z6, not used, z7, + z8, yPT, not used, not used + +RB data: 14 variables per line; they are: +identifier, constant, v1, v2, v3, v4, v5, v6, not used, v7, v8, yRB, + not used, not used + +See Table 1 in the article for the notation. + +BEGIN PT data (601 observations): + + 4 0 1. 1 37.0 10.000 0 3 18. 40.0 7 4 0. 0. 1. + 5 0 1. 0 27.0 4.000 0 4 14. 20.0 6 4 0. 0. 1. + 11 0 1. 0 32.0 15.000 1 1 12. 12.5 1 4 0. 0. 1. + 16 0 1. 1 57.0 15.000 1 5 18. 12.5 6 5 0. 0. 1. + 23 0 1. 1 22.0 0.750 0 2 17. 7.5 6 3 0. 0. 1. + 29 0 1. 0 32.0 1.500 0 2 17. 7.5 5 5 0. 0. 1. + 44 0 1. 0 22.0 0.750 0 2 12. 12.5 1 3 0. 0. 1. + 45 0 1. 1 57.0 15.000 1 2 14. 20.0 4 4 0. 0. 1. + 47 0 1. 0 32.0 15.000 1 4 16. 20.0 1 2 0. 0. 1. + 49 0 1. 1 22.0 1.500 0 4 14. 12.5 4 5 0. 0. 1. + 50 0 1. 1 37.0 15.000 1 2 20. 20.0 7 2 0. 0. 1. + 55 0 1. 1 27.0 4.000 1 4 18. 12.5 6 4 0. 0. 1. + 64 0 1. 1 47.0 15.000 1 5 17. 12.5 6 4 0. 0. 1. + 80 0 1. 0 22.0 1.500 0 2 17. 12.5 5 4 0. 0. 1. + 86 0 1. 0 27.0 4.000 0 4 14. 7.5 5 4 0. 0. 1. + 93 0 1. 0 37.0 15.000 1 1 17. 20.0 5 5 0. 0. 1. + 108 0 1. 0 37.0 15.000 1 2 18. 20.0 4 3 0. 0. 1. + 114 0 1. 0 22.0 0.750 0 3 16. 7.5 5 4 0. 0. 1. + 115 0 1. 0 22.0 1.500 0 2 16. 7.5 5 5 0. 0. 1. + 116 0 1. 0 27.0 10.000 1 2 14. 7.5 1 5 0. 0. 1. + 123 0 1. 0 22.0 1.500 0 2 16. 12.5 5 5 0. 0. 1. + 127 0 1. 0 22.0 1.500 0 2 16. 7.5 5 5 0. 0. 1. + 129 0 1. 0 27.0 10.000 1 4 16. 20.0 5 4 0. 0. 1. + 134 0 1. 0 32.0 10.000 1 3 14. 7.5 1 5 0. 0. 1. + 137 0 1. 1 37.0 4.000 1 2 20. 20.0 6 4 0. 0. 1. + 139 0 1. 0 22.0 1.500 0 2 18. 12.5 5 5 0. 0. 1. + 147 0 1. 0 27.0 7.000 0 4 16. 12.5 1 5 0. 0. 1. + 151 0 1. 1 42.0 15.000 1 5 20. 12.5 6 4 0. 0. 1. + 153 0 1. 1 27.0 4.000 1 3 16. 12.5 5 5 0. 0. 1. + 155 0 1. 0 27.0 4.000 1 3 17. 12.5 5 4 0. 0. 1. + 162 0 1. 1 42.0 15.000 1 4 20. 20.0 6 3 0. 0. 1. + 163 0 1. 0 22.0 1.500 0 3 16. 12.5 5 5 0. 0. 1. + 165 0 1. 1 27.0 0.417 0 4 17. 7.5 6 4 0. 0. 1. + 168 0 1. 0 42.0 15.000 1 5 14. 20.0 5 4 0. 0. 1. + 170 0 1. 1 32.0 4.000 1 1 18. 20.0 6 4 0. 0. 1. + 172 0 1. 0 22.0 1.500 0 4 16. 7.5 5 3 0. 0. 1. + 184 0 1. 0 42.0 15.000 1 3 12. 20.0 1 4 0. 0. 1. + 187 0 1. 0 22.0 4.000 0 4 17. 20.0 5 5 0. 0. 1. + 192 0 1. 1 22.0 1.500 1 1 14. 7.5 3 5 0. 0. 1. + 194 0 1. 0 22.0 0.750 0 3 16. 7.5 1 5 0. 0. 1. + 210 0 1. 1 32.0 10.000 1 5 20. 12.5 6 5 0. 0. 1. + 217 0 1. 1 52.0 15.000 1 5 18. 7.5 6 3 0. 0. 1. + 220 0 1. 0 22.0 0.417 0 5 14. 12.5 1 4 0. 0. 1. + 224 0 1. 0 27.0 4.000 1 2 18. 4.0 6 1 0. 0. 1. + 227 0 1. 0 32.0 7.000 1 5 17. 12.5 5 3 0. 0. 1. + 228 0 1. 1 22.0 4.000 0 3 16. 7.5 5 5 0. 0. 1. + 239 0 1. 0 27.0 7.000 1 4 18. 40.0 6 5 0. 0. 1. + 241 0 1. 0 42.0 15.000 1 2 18. 20.0 5 4 0. 0. 1. + 245 0 1. 1 27.0 1.500 1 4 16. 7.5 3 5 0. 0. 1. + 249 0 1. 1 42.0 15.000 1 2 20. 20.0 6 4 0. 0. 1. + 262 0 1. 0 22.0 0.750 0 5 14. 20.0 3 5 0. 0. 1. + 265 0 1. 1 32.0 7.000 1 2 20. 20.0 6 4 0. 0. 1. + 267 0 1. 1 27.0 4.000 1 5 20. 7.5 6 5 0. 0. 1. + 269 0 1. 1 27.0 10.000 1 4 20. 7.5 6 4 0. 0. 1. + 271 0 1. 1 22.0 4.000 0 1 18. 20.0 5 5 0. 0. 1. + 277 0 1. 0 37.0 15.000 1 4 14. 12.5 3 1 0. 0. 1. + 290 0 1. 1 22.0 1.500 1 5 16. 20.0 4 4 0. 0. 1. + 292 0 1. 0 37.0 15.000 1 4 17. 20.0 1 5 0. 0. 1. + 293 0 1. 0 27.0 0.750 0 4 17. 12.5 5 4 0. 0. 1. + 295 0 1. 1 32.0 10.000 1 4 20. 12.5 6 4 0. 0. 1. + 299 0 1. 0 47.0 15.000 1 5 14. 40.0 7 2 0. 0. 1. + 320 0 1. 1 37.0 10.000 1 3 20. 40.0 6 4 0. 0. 1. + 321 0 1. 0 22.0 0.750 0 2 16. 7.5 5 5 0. 0. 1. + 324 0 1. 1 27.0 4.000 0 2 18. 12.5 4 5 0. 0. 1. + 334 0 1. 1 32.0 7.000 0 4 20. 7.5 6 4 0. 0. 1. + 351 0 1. 1 42.0 15.000 1 2 17. 40.0 3 5 0. 0. 1. + 355 0 1. 1 37.0 10.000 1 4 20. 7.5 6 4 0. 0. 1. + 361 0 1. 0 47.0 15.000 1 3 17. 20.0 6 5 0. 0. 1. + 362 0 1. 0 22.0 1.500 0 5 16. 7.5 5 5 0. 0. 1. + 366 0 1. 0 27.0 1.500 0 2 16. 20.0 6 4 0. 0. 1. + 370 0 1. 0 27.0 4.000 0 3 17. 7.5 5 5 0. 0. 1. + 374 0 1. 0 32.0 10.000 1 5 14. 12.5 4 5 0. 0. 1. + 378 0 1. 0 22.0 0.125 0 2 12. 7.5 5 5 0. 0. 1. + 381 0 1. 1 47.0 15.000 1 4 14. 20.0 4 3 0. 0. 1. + 382 0 1. 1 32.0 15.000 1 1 14. 40.0 5 5 0. 0. 1. + 383 0 1. 1 27.0 7.000 1 4 16. 12.5 5 5 0. 0. 1. + 384 0 1. 0 22.0 1.500 1 3 16. 7.5 5 5 0. 0. 1. + 400 0 1. 1 27.0 4.000 1 3 17. 7.5 6 5 0. 0. 1. + 403 0 1. 0 22.0 1.500 0 3 16. 7.5 5 5 0. 0. 1. + 409 0 1. 1 57.0 15.000 1 2 14. 20.0 7 2 0. 0. 1. + 412 0 1. 1 17.5 1.500 1 3 18. 20.0 6 5 0. 0. 1. + 413 0 1. 1 57.0 15.000 1 4 20. 40.0 6 5 0. 0. 1. + 416 0 1. 0 22.0 0.750 0 2 16. 20.0 3 4 0. 0. 1. + 418 0 1. 1 42.0 4.000 0 4 17. 12.5 3 3 0. 0. 1. + 422 0 1. 0 22.0 1.500 1 4 12. 12.5 1 5 0. 0. 1. + 435 0 1. 0 22.0 0.417 0 1 17. 4.0 6 4 0. 0. 1. + 439 0 1. 0 32.0 15.000 1 4 17. 12.5 5 5 0. 0. 1. + 445 0 1. 0 27.0 1.500 0 3 18. 12.5 5 2 0. 0. 1. + 447 0 1. 0 22.0 1.500 1 3 14. 7.5 1 5 0. 0. 1. + 448 0 1. 0 37.0 15.000 1 3 14. 40.0 1 4 0. 0. 1. + 449 0 1. 0 32.0 15.000 1 4 14. 20.0 3 4 0. 0. 1. + 478 0 1. 1 37.0 10.000 1 2 14. 12.5 5 3 0. 0. 1. + 482 0 1. 1 37.0 10.000 1 4 16. 12.5 5 4 0. 0. 1. + 486 0 1. 1 57.0 15.000 1 5 20. 12.5 5 3 0. 0. 1. + 489 0 1. 1 27.0 0.417 0 1 16. 7.5 3 4 0. 0. 1. + 490 0 1. 0 42.0 15.000 1 5 14. 12.5 1 5 0. 0. 1. + 491 0 1. 1 57.0 15.000 1 3 16. 20.0 6 1 0. 0. 1. + 492 0 1. 1 37.0 10.000 1 1 16. 7.5 6 4 0. 0. 1. + 503 0 1. 1 37.0 15.000 1 3 17. 40.0 5 5 0. 0. 1. + 508 0 1. 1 37.0 15.000 1 4 20. 20.0 6 5 0. 0. 1. + 509 0 1. 0 27.0 10.000 1 5 14. 12.5 1 5 0. 0. 1. + 512 0 1. 1 37.0 10.000 1 2 18. 20.0 6 4 0. 0. 1. + 515 0 1. 0 22.0 0.125 0 4 12. 12.5 4 5 0. 0. 1. + 517 0 1. 1 57.0 15.000 1 5 20. 40.0 6 5 0. 0. 1. + 532 0 1. 0 37.0 15.000 1 4 18. 40.0 6 4 0. 0. 1. + 533 0 1. 1 22.0 4.000 1 4 14. 7.5 6 4 0. 0. 1. + 535 0 1. 1 27.0 7.000 1 4 18. 7.5 5 4 0. 0. 1. + 537 0 1. 1 57.0 15.000 1 4 20. 40.0 5 4 0. 0. 1. + 538 0 1. 1 32.0 15.000 1 3 14. 12.5 6 3 0. 0. 1. + 543 0 1. 0 22.0 1.500 0 2 14. 12.5 5 4 0. 0. 1. + 547 0 1. 0 32.0 7.000 1 4 17. 40.0 1 5 0. 0. 1. + 550 0 1. 0 37.0 15.000 1 4 17. 40.0 6 5 0. 0. 1. + 558 0 1. 0 32.0 1.500 0 5 18. 40.0 5 5 0. 0. 1. + 571 0 1. 1 42.0 10.000 1 5 20. 40.0 7 4 0. 0. 1. + 578 0 1. 0 27.0 7.000 0 3 16. 12.5 5 4 0. 0. 1. + 583 0 1. 1 37.0 15.000 0 4 20. 40.0 6 5 0. 0. 1. + 586 0 1. 1 37.0 15.000 1 4 14. 12.5 3 2 0. 0. 1. + 594 0 1. 1 32.0 10.000 0 5 18. 20.0 6 4 0. 0. 1. + 597 0 1. 0 22.0 0.750 0 4 16. 7.5 1 5 0. 0. 1. + 602 0 1. 0 27.0 7.000 1 4 12. 7.5 2 4 0. 0. 1. + 603 0 1. 0 27.0 7.000 1 2 16. 12.5 2 5 0. 0. 1. + 604 0 1. 0 42.0 15.000 1 5 18. 40.0 5 4 0. 0. 1. + 612 0 1. 1 42.0 15.000 1 4 17. 20.0 5 3 0. 0. 1. + 613 0 1. 0 27.0 7.000 1 2 16. 20.0 1 2 0. 0. 1. + 621 0 1. 0 22.0 1.500 0 3 16. 12.5 5 5 0. 0. 1. + 627 0 1. 1 37.0 15.000 1 5 20. 40.0 6 5 0. 0. 1. + 630 0 1. 0 22.0 0.125 0 2 14. 12.5 4 5 0. 0. 1. + 631 0 1. 1 27.0 1.500 0 4 16. 7.5 5 5 0. 0. 1. + 632 0 1. 1 32.0 1.500 0 2 18. 20.0 6 5 0. 0. 1. + 639 0 1. 1 27.0 1.500 0 2 17. 7.5 6 5 0. 0. 1. + 645 0 1. 0 27.0 10.000 1 4 16. 12.5 1 3 0. 0. 1. + 647 0 1. 1 42.0 15.000 1 4 18. 12.5 6 5 0. 0. 1. + 648 0 1. 0 27.0 1.500 0 2 16. 7.5 6 5 0. 0. 1. + 651 0 1. 1 27.0 4.000 0 2 18. 12.5 6 3 0. 0. 1. + 655 0 1. 0 32.0 10.000 1 3 14. 7.5 5 3 0. 0. 1. + 667 0 1. 0 32.0 15.000 1 3 18. 20.0 5 4 0. 0. 1. + 670 0 1. 0 22.0 0.750 0 2 18. 4.0 6 5 0. 0. 1. + 671 0 1. 0 37.0 15.000 1 2 16. 7.5 1 4 0. 0. 1. + 673 0 1. 1 27.0 4.000 1 4 20. 12.5 5 5 0. 0. 1. + 701 0 1. 1 27.0 4.000 0 1 20. 20.0 5 4 0. 0. 1. + 705 0 1. 0 27.0 10.000 1 2 12. 7.5 1 4 0. 0. 1. + 706 0 1. 0 32.0 15.000 1 5 18. 20.0 6 4 0. 0. 1. + 709 0 1. 1 27.0 7.000 1 5 12. 7.5 5 3 0. 0. 1. + 717 0 1. 1 52.0 15.000 1 2 18. 12.5 5 4 0. 0. 1. + 719 0 1. 1 27.0 4.000 0 3 20. 12.5 6 3 0. 0. 1. + 723 0 1. 1 37.0 4.000 1 1 18. 20.0 5 4 0. 0. 1. + 724 0 1. 1 27.0 4.000 1 4 14. 7.5 5 4 0. 0. 1. + 726 0 1. 0 52.0 15.000 1 5 12. 12.5 1 3 0. 0. 1. + 734 0 1. 0 57.0 15.000 1 4 16. 20.0 6 4 0. 0. 1. + 735 0 1. 1 27.0 7.000 1 1 16. 20.0 5 4 0. 0. 1. + 736 0 1. 1 37.0 7.000 1 4 20. 20.0 6 3 0. 0. 1. + 737 0 1. 1 22.0 0.750 0 2 14. 12.5 4 3 0. 0. 1. + 739 0 1. 1 32.0 4.000 1 2 18. 7.5 5 3 0. 0. 1. + 743 0 1. 1 37.0 15.000 1 4 20. 7.5 6 3 0. 0. 1. + 745 0 1. 1 22.0 0.750 1 2 14. 7.5 4 3 0. 0. 1. + 747 0 1. 1 42.0 15.000 1 4 20. 20.0 6 3 0. 0. 1. + 751 0 1. 0 52.0 15.000 1 5 17. 12.5 1 1 0. 0. 1. + 752 0 1. 0 37.0 15.000 1 4 14. 40.0 1 2 0. 0. 1. + 754 0 1. 1 27.0 7.000 1 4 14. 12.5 5 3 0. 0. 1. + 760 0 1. 1 32.0 4.000 1 2 16. 7.5 5 5 0. 0. 1. + 763 0 1. 0 27.0 4.000 1 2 18. 12.5 6 5 0. 0. 1. + 774 0 1. 0 27.0 4.000 1 2 18. 7.5 5 5 0. 0. 1. + 776 0 1. 1 37.0 15.000 1 5 18. 7.5 6 5 0. 0. 1. + 779 0 1. 0 47.0 15.000 1 5 12. 12.5 5 4 0. 0. 1. + 784 0 1. 0 32.0 10.000 1 3 17. 12.5 1 4 0. 0. 1. + 788 0 1. 0 27.0 1.500 1 4 17. 7.5 1 2 0. 0. 1. + 794 0 1. 0 57.0 15.000 1 2 18. 20.0 5 2 0. 0. 1. + 795 0 1. 0 22.0 1.500 0 4 14. 7.5 5 4 0. 0. 1. + 798 0 1. 1 42.0 15.000 1 3 14. 12.5 3 4 0. 0. 1. + 800 0 1. 1 57.0 15.000 1 4 9. 7.5 2 2 0. 0. 1. + 803 0 1. 1 57.0 15.000 1 4 20. 40.0 6 5 0. 0. 1. + 807 0 1. 0 22.0 0.125 0 4 14. 12.5 4 5 0. 0. 1. + 812 0 1. 0 32.0 10.000 1 4 14. 20.0 1 5 0. 0. 1. + 820 0 1. 0 42.0 15.000 1 3 18. 20.0 5 4 0. 0. 1. + 823 0 1. 0 27.0 1.500 0 2 18. 20.0 6 5 0. 0. 1. + 830 0 1. 1 32.0 0.125 1 2 18. 12.5 5 2 0. 0. 1. + 843 0 1. 0 27.0 4.000 0 3 16. 20.0 5 4 0. 0. 1. + 848 0 1. 0 27.0 10.000 1 2 16. 12.5 1 4 0. 0. 1. + 851 0 1. 0 32.0 7.000 1 4 16. 40.0 1 3 0. 0. 1. + 854 0 1. 0 37.0 15.000 1 4 14. 40.0 5 4 0. 0. 1. + 856 0 1. 0 42.0 15.000 1 5 17. 12.5 6 2 0. 0. 1. + 857 0 1. 1 32.0 1.500 1 4 14. 12.5 6 5 0. 0. 1. + 859 0 1. 0 32.0 4.000 1 3 17. 12.5 5 3 0. 0. 1. + 863 0 1. 0 37.0 7.000 0 4 18. 12.5 5 5 0. 0. 1. + 865 0 1. 0 22.0 0.417 1 3 14. 7.5 3 5 0. 0. 1. + 867 0 1. 0 27.0 7.000 1 4 14. 12.5 1 5 0. 0. 1. + 870 0 1. 1 27.0 0.750 0 3 16. 12.5 5 5 0. 0. 1. + 873 0 1. 1 27.0 4.000 1 2 20. 40.0 5 5 0. 0. 1. + 875 0 1. 1 32.0 10.000 1 4 16. 7.5 4 5 0. 0. 1. + 876 0 1. 1 32.0 15.000 1 1 14. 12.5 5 5 0. 0. 1. + 877 0 1. 1 22.0 0.750 0 3 17. 7.5 4 5 0. 0. 1. + 880 0 1. 0 27.0 7.000 1 4 17. 20.0 1 4 0. 0. 1. + 903 0 1. 1 27.0 0.417 1 4 20. 12.5 5 4 0. 0. 1. + 904 0 1. 1 37.0 15.000 1 4 20. 40.0 5 4 0. 0. 1. + 905 0 1. 0 37.0 15.000 1 2 14. 12.5 1 3 0. 0. 1. + 908 0 1. 1 22.0 4.000 1 1 18. 7.5 5 4 0. 0. 1. + 909 0 1. 1 37.0 15.000 1 4 17. 20.0 5 3 0. 0. 1. + 910 0 1. 0 22.0 1.500 0 2 14. 12.5 4 5 0. 0. 1. + 912 0 1. 1 52.0 15.000 1 4 14. 20.0 6 2 0. 0. 1. + 914 0 1. 0 22.0 1.500 0 4 17. 12.5 5 5 0. 0. 1. + 915 0 1. 1 32.0 4.000 1 5 14. 20.0 3 5 0. 0. 1. + 916 0 1. 1 32.0 4.000 1 2 14. 20.0 3 5 0. 0. 1. + 920 0 1. 0 22.0 1.500 0 3 16. 12.5 6 5 0. 0. 1. + 921 0 1. 1 27.0 0.750 0 2 18. 12.5 3 3 0. 0. 1. + 925 0 1. 0 22.0 7.000 1 2 14. 7.5 5 2 0. 0. 1. + 926 0 1. 0 27.0 0.750 0 2 17. 7.5 5 3 0. 0. 1. + 929 0 1. 0 37.0 15.000 1 4 12. 20.0 1 2 0. 0. 1. + 931 0 1. 0 22.0 1.500 0 1 14. 4.0 1 5 0. 0. 1. + 945 0 1. 0 37.0 10.000 0 2 12. 12.5 4 4 0. 0. 1. + 947 0 1. 0 37.0 15.000 1 4 18. 20.0 5 3 0. 0. 1. + 949 0 1. 0 42.0 15.000 1 3 12. 20.0 3 3 0. 0. 1. + 950 0 1. 1 22.0 4.000 0 2 18. 7.5 5 5 0. 0. 1. + 961 0 1. 1 52.0 7.000 1 2 20. 20.0 6 2 0. 0. 1. + 965 0 1. 1 27.0 0.750 0 2 17. 12.5 5 5 0. 0. 1. + 966 0 1. 0 27.0 4.000 0 2 17. 12.5 4 5 0. 0. 1. + 967 0 1. 1 42.0 1.500 0 5 20. 12.5 6 5 0. 0. 1. + 987 0 1. 1 22.0 1.500 0 4 17. 12.5 6 5 0. 0. 1. + 990 0 1. 1 22.0 4.000 0 4 17. 12.5 5 3 0. 0. 1. + 992 0 1. 0 22.0 4.000 1 1 14. 7.5 5 4 0. 0. 1. + 995 0 1. 1 37.0 15.000 1 5 20. 12.5 4 5 0. 0. 1. + 1009 0 1. 0 37.0 10.000 1 3 16. 20.0 6 3 0. 0. 1. + 1021 0 1. 1 42.0 15.000 1 4 17. 20.0 6 5 0. 0. 1. + 1026 0 1. 0 47.0 15.000 1 4 17. 20.0 5 5 0. 0. 1. + 1027 0 1. 1 22.0 1.500 0 4 16. 7.5 5 4 0. 0. 1. + 1030 0 1. 0 32.0 10.000 1 3 12. 12.5 1 4 0. 0. 1. + 1031 0 1. 0 22.0 7.000 1 1 14. 7.5 3 5 0. 0. 1. + 1034 0 1. 0 32.0 10.000 1 4 17. 12.5 5 4 0. 0. 1. + 1037 0 1. 1 27.0 1.500 1 2 16. 7.5 2 4 0. 0. 1. + 1038 0 1. 1 37.0 15.000 1 4 14. 12.5 5 5 0. 0. 1. + 1039 0 1. 1 42.0 4.000 1 3 14. 12.5 4 5 0. 0. 1. + 1045 0 1. 0 37.0 15.000 1 5 14. 20.0 5 4 0. 0. 1. + 1046 0 1. 0 32.0 7.000 1 4 17. 12.5 5 5 0. 0. 1. + 1054 0 1. 0 42.0 15.000 1 4 18. 40.0 6 5 0. 0. 1. + 1059 0 1. 1 27.0 4.000 0 4 18. 20.0 6 4 0. 0. 1. + 1063 0 1. 1 22.0 0.750 0 4 18. 12.5 6 5 0. 0. 1. + 1068 0 1. 1 27.0 4.000 1 4 14. 7.5 5 3 0. 0. 1. + 1070 0 1. 0 22.0 0.750 0 5 18. 4.0 1 5 0. 0. 1. + 1072 0 1. 0 52.0 15.000 1 5 9. 12.5 5 5 0. 0. 1. + 1073 0 1. 1 32.0 10.000 1 3 14. 12.5 5 5 0. 0. 1. + 1077 0 1. 0 37.0 15.000 1 4 16. 7.5 4 4 0. 0. 1. + 1081 0 1. 1 32.0 7.000 1 2 20. 20.0 5 4 0. 0. 1. + 1083 0 1. 0 42.0 15.000 1 3 18. 20.0 1 4 0. 0. 1. + 1084 0 1. 1 32.0 15.000 1 1 16. 12.5 5 5 0. 0. 1. + 1086 0 1. 1 27.0 4.000 1 3 18. 7.5 5 5 0. 0. 1. + 1087 0 1. 0 32.0 15.000 1 4 12. 7.5 3 4 0. 0. 1. + 1089 0 1. 1 22.0 0.750 1 3 14. 7.5 2 4 0. 0. 1. + 1096 0 1. 0 22.0 1.500 0 3 16. 7.5 5 3 0. 0. 1. + 1102 0 1. 0 42.0 15.000 1 4 14. 12.5 3 5 0. 0. 1. + 1103 0 1. 0 52.0 15.000 1 3 16. 20.0 5 4 0. 0. 1. + 1107 0 1. 1 37.0 15.000 1 5 20. 20.0 6 4 0. 0. 1. + 1109 0 1. 0 47.0 15.000 1 4 12. 12.5 2 3 0. 0. 1. + 1115 0 1. 1 57.0 15.000 1 2 20. 40.0 6 4 0. 0. 1. + 1119 0 1. 1 32.0 7.000 1 4 17. 20.0 5 5 0. 0. 1. + 1124 0 1. 0 27.0 7.000 1 4 17. 12.5 1 4 0. 0. 1. + 1126 0 1. 1 22.0 1.500 0 1 18. 7.5 6 5 0. 0. 1. + 1128 0 1. 0 22.0 4.000 1 3 9. 7.5 1 4 0. 0. 1. + 1129 0 1. 0 22.0 1.500 0 2 14. 7.5 1 5 0. 0. 1. + 1130 0 1. 1 42.0 15.000 1 2 20. 20.0 6 4 0. 0. 1. + 1133 0 1. 1 57.0 15.000 1 4 9. 12.5 2 4 0. 0. 1. + 1140 0 1. 0 27.0 7.000 1 2 18. 20.0 1 5 0. 0. 1. + 1143 0 1. 0 22.0 4.000 1 3 14. 7.5 1 5 0. 0. 1. + 1146 0 1. 1 37.0 15.000 1 4 14. 20.0 5 3 0. 0. 1. + 1153 0 1. 1 32.0 7.000 1 1 18. 4.0 6 4 0. 0. 1. + 1156 0 1. 0 22.0 1.500 0 2 14. 4.0 5 5 0. 0. 1. + 1157 0 1. 0 22.0 1.500 1 3 12. 4.0 1 3 0. 0. 1. + 1158 0 1. 1 52.0 15.000 1 2 14. 40.0 5 5 0. 0. 1. + 1160 0 1. 0 37.0 15.000 1 2 14. 20.0 1 1 0. 0. 1. + 1161 0 1. 0 32.0 10.000 1 2 14. 12.5 5 5 0. 0. 1. + 1166 0 1. 1 42.0 15.000 1 4 20. 12.5 4 5 0. 0. 1. + 1177 0 1. 0 27.0 4.000 1 3 18. 12.5 4 5 0. 0. 1. + 1178 0 1. 1 37.0 15.000 1 4 20. 40.0 6 5 0. 0. 1. + 1180 0 1. 1 27.0 1.500 0 3 18. 12.5 5 5 0. 0. 1. + 1187 0 1. 0 22.0 0.125 0 2 16. 7.5 6 3 0. 0. 1. + 1191 0 1. 1 32.0 10.000 1 2 20. 12.5 6 3 0. 0. 1. + 1195 0 1. 0 27.0 4.000 0 4 18. 20.0 5 4 0. 0. 1. + 1207 0 1. 0 27.0 7.000 1 2 12. 12.5 5 1 0. 0. 1. + 1208 0 1. 1 32.0 4.000 1 5 18. 7.5 6 3 0. 0. 1. + 1209 0 1. 0 37.0 15.000 1 2 17. 12.5 5 5 0. 0. 1. + 1211 0 1. 1 47.0 15.000 0 4 20. 20.0 6 4 0. 0. 1. + 1215 0 1. 1 27.0 1.500 0 1 18. 12.5 5 5 0. 0. 1. + 1221 0 1. 1 37.0 15.000 1 4 20. 20.0 6 4 0. 0. 1. + 1226 0 1. 0 32.0 15.000 1 4 18. 12.5 1 4 0. 0. 1. + 1229 0 1. 0 32.0 7.000 1 4 17. 40.0 5 4 0. 0. 1. + 1231 0 1. 0 42.0 15.000 1 3 14. 7.5 1 3 0. 0. 1. + 1234 0 1. 0 27.0 7.000 1 3 16. 12.5 1 4 0. 0. 1. + 1235 0 1. 1 27.0 1.500 0 3 16. 7.5 4 2 0. 0. 1. + 1242 0 1. 1 22.0 1.500 0 3 16. 7.5 3 5 0. 0. 1. + 1245 0 1. 1 27.0 4.000 1 3 16. 12.5 4 2 0. 0. 1. + 1260 0 1. 0 27.0 7.000 1 3 12. 12.5 1 2 0. 0. 1. + 1266 0 1. 0 37.0 15.000 1 2 18. 40.0 5 4 0. 0. 1. + 1271 0 1. 0 37.0 7.000 1 3 14. 20.0 4 4 0. 0. 1. + 1273 0 1. 1 22.0 1.500 0 2 16. 7.5 5 5 0. 0. 1. + 1276 0 1. 1 37.0 15.000 1 5 20. 40.0 5 4 0. 0. 1. + 1280 0 1. 0 22.0 1.500 0 4 16. 7.5 5 3 0. 0. 1. + 1282 0 1. 0 32.0 10.000 1 4 16. 20.0 1 5 0. 0. 1. + 1285 0 1. 1 27.0 4.000 0 2 17. 12.5 5 3 0. 0. 1. + 1295 0 1. 0 22.0 0.417 0 4 14. 12.5 5 5 0. 0. 1. + 1298 0 1. 0 27.0 4.000 0 2 18. 12.5 5 5 0. 0. 1. + 1299 0 1. 1 37.0 15.000 1 4 18. 7.5 5 3 0. 0. 1. + 1304 0 1. 1 37.0 10.000 1 5 20. 12.5 7 4 0. 0. 1. + 1305 0 1. 0 27.0 7.000 1 2 14. 12.5 4 2 0. 0. 1. + 1311 0 1. 1 32.0 4.000 1 2 16. 20.0 5 5 0. 0. 1. + 1314 0 1. 1 32.0 4.000 1 2 16. 12.5 6 4 0. 0. 1. + 1319 0 1. 1 22.0 1.500 0 3 18. 12.5 4 5 0. 0. 1. + 1322 0 1. 0 22.0 4.000 1 4 14. 12.5 3 4 0. 0. 1. + 1324 0 1. 0 17.5 0.750 0 2 18. 12.5 5 4 0. 0. 1. + 1327 0 1. 1 32.0 10.000 1 4 20. 7.5 4 5 0. 0. 1. + 1328 0 1. 0 32.0 0.750 0 5 14. 20.0 3 3 0. 0. 1. + 1330 0 1. 1 37.0 15.000 1 4 17. 7.5 5 3 0. 0. 1. + 1332 0 1. 1 32.0 4.000 0 3 14. 12.5 4 5 0. 0. 1. + 1333 0 1. 0 27.0 1.500 0 2 17. 20.0 3 2 0. 0. 1. + 1336 0 1. 0 22.0 7.000 1 4 14. 7.5 1 5 0. 0. 1. + 1341 0 1. 1 47.0 15.000 1 5 14. 20.0 6 5 0. 0. 1. + 1344 0 1. 1 27.0 4.000 1 1 16. 12.5 4 4 0. 0. 1. + 1352 0 1. 0 37.0 15.000 1 5 14. 12.5 1 3 0. 0. 1. + 1358 0 1. 1 42.0 4.000 1 4 18. 20.0 5 5 0. 0. 1. + 1359 0 1. 0 32.0 4.000 1 2 14. 12.5 1 5 0. 0. 1. + 1361 0 1. 1 52.0 15.000 1 2 14. 40.0 7 4 0. 0. 1. + 1364 0 1. 0 22.0 1.500 0 2 16. 7.5 1 4 0. 0. 1. + 1368 0 1. 1 52.0 15.000 1 4 12. 12.5 2 4 0. 0. 1. + 1384 0 1. 0 22.0 0.417 0 3 17. 12.5 1 5 0. 0. 1. + 1390 0 1. 0 22.0 1.500 0 2 16. 7.5 5 5 0. 0. 1. + 1393 0 1. 1 27.0 4.000 1 4 20. 12.5 6 4 0. 0. 1. + 1394 0 1. 0 32.0 15.000 1 4 14. 12.5 1 5 0. 0. 1. + 1402 0 1. 0 27.0 1.500 0 2 16. 20.0 3 5 0. 0. 1. + 1407 0 1. 1 32.0 4.000 0 1 20. 20.0 6 5 0. 0. 1. + 1408 0 1. 1 37.0 15.000 1 3 20. 20.0 6 4 0. 0. 1. + 1412 0 1. 0 32.0 10.000 0 2 16. 20.0 6 5 0. 0. 1. + 1413 0 1. 0 32.0 10.000 1 5 14. 12.5 5 5 0. 0. 1. + 1416 0 1. 1 37.0 1.500 1 4 18. 7.5 5 3 0. 0. 1. + 1417 0 1. 1 32.0 1.500 0 2 18. 12.5 4 4 0. 0. 1. + 1418 0 1. 0 32.0 10.000 1 4 14. 12.5 1 4 0. 0. 1. + 1419 0 1. 0 47.0 15.000 1 4 18. 20.0 5 4 0. 0. 1. + 1420 0 1. 0 27.0 10.000 1 5 12. 7.5 1 5 0. 0. 1. + 1423 0 1. 1 27.0 4.000 1 3 16. 12.5 4 5 0. 0. 1. + 1424 0 1. 0 37.0 15.000 1 4 12. 12.5 4 2 0. 0. 1. + 1432 0 1. 0 27.0 0.750 0 4 16. 12.5 5 5 0. 0. 1. + 1433 0 1. 0 37.0 15.000 1 4 16. 7.5 1 5 0. 0. 1. + 1437 0 1. 0 32.0 15.000 1 3 16. 12.5 1 5 0. 0. 1. + 1438 0 1. 0 27.0 10.000 1 2 16. 7.5 1 5 0. 0. 1. + 1439 0 1. 1 27.0 7.000 0 2 20. 20.0 6 5 0. 0. 1. + 1446 0 1. 0 37.0 15.000 1 2 14. 20.0 1 3 0. 0. 1. + 1450 0 1. 1 27.0 1.500 1 2 17. 7.5 4 4 0. 0. 1. + 1451 0 1. 0 22.0 0.750 1 2 14. 12.5 1 5 0. 0. 1. + 1452 0 1. 1 22.0 4.000 1 4 14. 7.5 2 4 0. 0. 1. + 1453 0 1. 1 42.0 0.125 0 4 17. 12.5 6 4 0. 0. 1. + 1456 0 1. 1 27.0 1.500 1 4 18. 7.5 6 5 0. 0. 1. + 1464 0 1. 1 27.0 7.000 1 3 16. 12.5 6 3 0. 0. 1. + 1469 0 1. 0 52.0 15.000 1 4 14. 7.5 1 3 0. 0. 1. + 1473 0 1. 1 27.0 1.500 0 5 20. 7.5 5 2 0. 0. 1. + 1481 0 1. 0 27.0 1.500 0 2 16. 7.5 5 5 0. 0. 1. + 1482 0 1. 0 27.0 1.500 0 3 17. 12.5 5 5 0. 0. 1. + 1496 0 1. 1 22.0 0.125 0 5 16. 7.5 4 4 0. 0. 1. + 1497 0 1. 0 27.0 4.000 1 4 16. 7.5 1 5 0. 0. 1. + 1504 0 1. 0 27.0 4.000 1 4 12. 7.5 1 5 0. 0. 1. + 1513 0 1. 0 47.0 15.000 1 2 14. 40.0 5 5 0. 0. 1. + 1515 0 1. 0 32.0 15.000 1 3 14. 12.5 5 3 0. 0. 1. + 1534 0 1. 1 42.0 7.000 1 2 16. 12.5 5 5 0. 0. 1. + 1535 0 1. 1 22.0 0.750 0 4 16. 7.5 6 4 0. 0. 1. + 1536 0 1. 1 27.0 0.125 0 3 20. 7.5 6 5 0. 0. 1. + 1540 0 1. 1 32.0 10.000 1 3 20. 20.0 6 5 0. 0. 1. + 1551 0 1. 0 22.0 0.417 0 5 14. 12.5 4 5 0. 0. 1. + 1555 0 1. 0 47.0 15.000 1 5 14. 12.5 1 4 0. 0. 1. + 1557 0 1. 0 32.0 10.000 1 3 14. 40.0 1 5 0. 0. 1. + 1566 0 1. 1 57.0 15.000 1 4 17. 12.5 5 5 0. 0. 1. + 1567 0 1. 1 27.0 4.000 1 3 20. 12.5 6 5 0. 0. 1. + 1576 0 1. 0 32.0 7.000 1 4 17. 12.5 1 5 0. 0. 1. + 1584 0 1. 0 37.0 10.000 1 4 16. 40.0 1 5 0. 0. 1. + 1585 0 1. 0 32.0 10.000 1 1 18. 20.0 1 4 0. 0. 1. + 1590 0 1. 0 22.0 4.000 0 3 14. 7.5 1 4 0. 0. 1. + 1594 0 1. 0 27.0 7.000 1 4 14. 7.5 3 2 0. 0. 1. + 1595 0 1. 1 57.0 15.000 1 5 18. 20.0 5 2 0. 0. 1. + 1603 0 1. 1 32.0 7.000 1 2 18. 7.5 5 5 0. 0. 1. + 1608 0 1. 0 27.0 1.500 0 4 17. 7.5 1 3 0. 0. 1. + 1609 0 1. 1 22.0 1.500 0 4 14. 7.5 5 5 0. 0. 1. + 1615 0 1. 0 22.0 1.500 1 4 14. 4.0 5 4 0. 0. 1. + 1616 0 1. 0 32.0 7.000 1 3 16. 12.5 1 5 0. 0. 1. + 1617 0 1. 0 47.0 15.000 1 3 16. 20.0 5 4 0. 0. 1. + 1620 0 1. 0 22.0 0.750 0 3 16. 40.0 1 5 0. 0. 1. + 1621 0 1. 0 22.0 1.500 1 2 14. 7.5 5 5 0. 0. 1. + 1637 0 1. 0 27.0 4.000 1 1 16. 7.5 5 5 0. 0. 1. + 1638 0 1. 1 52.0 15.000 1 4 16. 20.0 5 5 0. 0. 1. + 1650 0 1. 1 32.0 10.000 1 4 20. 40.0 6 5 0. 0. 1. + 1654 0 1. 1 47.0 15.000 1 4 16. 20.0 6 4 0. 0. 1. + 1665 0 1. 0 27.0 7.000 1 2 14. 7.5 1 2 0. 0. 1. + 1670 0 1. 0 22.0 1.500 0 4 14. 20.0 4 5 0. 0. 1. + 1671 0 1. 0 32.0 10.000 1 2 16. 20.0 5 4 0. 0. 1. + 1675 0 1. 0 22.0 0.750 0 2 16. 12.5 5 4 0. 0. 1. + 1688 0 1. 0 22.0 1.500 0 2 16. 12.5 5 5 0. 0. 1. + 1691 0 1. 0 42.0 15.000 1 3 18. 20.0 6 4 0. 0. 1. + 1695 0 1. 0 27.0 7.000 1 5 14. 20.0 4 5 0. 0. 1. + 1698 0 1. 1 42.0 15.000 1 4 16. 20.0 4 4 0. 0. 1. + 1704 0 1. 0 57.0 15.000 1 3 18. 20.0 5 2 0. 0. 1. + 1705 0 1. 1 42.0 15.000 1 3 18. 12.5 6 2 0. 0. 1. + 1711 0 1. 0 32.0 7.000 1 2 14. 7.5 1 2 0. 0. 1. + 1719 0 1. 1 22.0 4.000 0 5 12. 7.5 4 5 0. 0. 1. + 1723 0 1. 0 22.0 1.500 0 1 16. 7.5 6 5 0. 0. 1. + 1726 0 1. 0 22.0 0.750 0 1 14. 7.5 4 5 0. 0. 1. + 1749 0 1. 0 32.0 15.000 1 4 12. 20.0 1 5 0. 0. 1. + 1752 0 1. 1 22.0 1.500 0 2 18. 12.5 5 3 0. 0. 1. + 1754 0 1. 1 27.0 4.000 1 5 17. 7.5 2 5 0. 0. 1. + 1758 0 1. 0 27.0 4.000 1 4 12. 7.5 1 5 0. 0. 1. + 1761 0 1. 1 42.0 15.000 1 5 18. 7.5 5 4 0. 0. 1. + 1773 0 1. 1 32.0 1.500 0 2 20. 20.0 7 3 0. 0. 1. + 1775 0 1. 1 57.0 15.000 0 4 9. 7.5 3 1 0. 0. 1. + 1786 0 1. 1 37.0 7.000 0 4 18. 12.5 5 5 0. 0. 1. + 1793 0 1. 1 52.0 15.000 1 2 17. 20.0 5 4 0. 0. 1. + 1799 0 1. 1 47.0 15.000 1 4 17. 20.0 6 5 0. 0. 1. + 1803 0 1. 0 27.0 7.000 0 2 17. 20.0 5 4 0. 0. 1. + 1806 0 1. 0 27.0 7.000 1 4 14. 40.0 5 5 0. 0. 1. + 1807 0 1. 0 22.0 4.000 0 2 14. 12.5 3 3 0. 0. 1. + 1808 0 1. 1 37.0 7.000 1 2 20. 40.0 6 5 0. 0. 1. + 1814 0 1. 1 27.0 7.000 0 4 12. 7.5 4 3 0. 0. 1. + 1815 0 1. 1 42.0 10.000 1 4 18. 40.0 6 4 0. 0. 1. + 1818 0 1. 0 22.0 1.500 0 3 14. 7.5 1 5 0. 0. 1. + 1827 0 1. 0 22.0 4.000 1 2 14. 12.5 1 3 0. 0. 1. + 1834 0 1. 0 57.0 15.000 0 4 20. 20.0 6 5 0. 0. 1. + 1835 0 1. 1 37.0 15.000 1 4 14. 12.5 4 3 0. 0. 1. + 1843 0 1. 0 27.0 7.000 1 3 18. 12.5 5 5 0. 0. 1. + 1846 0 1. 0 17.5 10.000 0 4 14. 20.0 4 5 0. 0. 1. + 1850 0 1. 1 22.0 4.000 1 4 16. 12.5 5 5 0. 0. 1. + 1851 0 1. 0 27.0 4.000 1 2 16. 12.5 1 4 0. 0. 1. + 1854 0 1. 0 37.0 15.000 1 2 14. 12.5 5 1 0. 0. 1. + 1859 0 1. 0 22.0 1.500 0 5 14. 4.0 1 4 0. 0. 1. + 1861 0 1. 1 27.0 7.000 1 2 20. 7.5 5 4 0. 0. 1. + 1866 0 1. 1 27.0 4.000 1 4 14. 7.5 5 5 0. 0. 1. + 1873 0 1. 1 22.0 0.125 0 1 16. 7.5 3 5 0. 0. 1. + 1875 0 1. 0 27.0 7.000 1 4 14. 20.0 1 4 0. 0. 1. + 1885 0 1. 0 32.0 15.000 1 5 16. 12.5 5 3 0. 0. 1. + 1892 0 1. 1 32.0 10.000 1 4 18. 12.5 5 4 0. 0. 1. + 1895 0 1. 0 32.0 15.000 1 2 14. 7.5 3 4 0. 0. 1. + 1896 0 1. 0 22.0 1.500 0 3 17. 7.5 5 5 0. 0. 1. + 1897 0 1. 1 27.0 4.000 1 4 17. 7.5 4 4 0. 0. 1. + 1899 0 1. 0 52.0 15.000 1 5 14. 12.5 1 5 0. 0. 1. + 1904 0 1. 0 27.0 7.000 1 2 12. 20.0 1 2 0. 0. 1. + 1905 0 1. 0 27.0 7.000 1 3 12. 12.5 1 4 0. 0. 1. + 1908 0 1. 0 42.0 15.000 1 2 14. 20.0 1 4 0. 0. 1. + 1916 0 1. 0 42.0 15.000 1 4 14. 20.0 5 4 0. 0. 1. + 1918 0 1. 1 27.0 7.000 1 4 14. 7.5 3 3 0. 0. 1. + 1920 0 1. 1 27.0 7.000 1 2 20. 20.0 6 2 0. 0. 1. + 1930 0 1. 0 42.0 15.000 1 3 12. 20.0 3 3 0. 0. 1. + 1940 0 1. 1 27.0 4.000 1 3 16. 7.5 3 5 0. 0. 1. + 1947 0 1. 0 27.0 7.000 1 3 14. 40.0 1 4 0. 0. 1. + 1949 0 1. 0 22.0 1.500 0 2 14. 12.5 4 5 0. 0. 1. + 1951 0 1. 0 27.0 4.000 1 4 14. 12.5 1 4 0. 0. 1. + 1952 0 1. 0 22.0 4.000 0 4 14. 4.0 5 5 0. 0. 1. + 1960 0 1. 0 22.0 1.500 0 2 16. 20.0 4 5 0. 0. 1. + 9001 0 1. 1 47.0 15.000 0 4 14. 12.5 5 4 0. 0. 1. + 9012 0 1. 1 37.0 10.000 1 2 18. 12.5 6 2 0. 0. 1. + 9023 0 1. 1 37.0 15.000 1 3 17. 40.0 5 4 0. 0. 1. + 9029 0 1. 0 27.0 4.000 1 2 16. 7.5 1 4 0. 0. 1. + 6 3 1. 1 27.0 1.500 0 3 18. 20.0 4 4 3. 0. 1. + 12 3 1. 0 27.0 4.000 1 3 17. 12.5 1 5 3. 0. 1. + 43 4 1. 1 37.0 15.000 1 5 18. 12.5 6 2 7. 0. 1. + 53 6 1. 0 32.0 10.000 1 3 17. 40.0 5 2 12. 0. 1. + 67 1 1. 1 22.0 0.125 0 4 16. 20.0 5 5 1. 0. 1. + 79 1 1. 0 22.0 1.500 1 2 14. 4.0 1 5 1. 0. 1. + 122 6 1. 1 37.0 15.000 1 4 14. 7.5 5 2 12. 0. 1. + 126 4 1. 0 22.0 1.500 0 2 14. 4.0 3 4 7. 0. 1. + 133 2 1. 1 37.0 15.000 1 2 18. 20.0 6 4 2. 0. 1. + 138 3 1. 0 32.0 15.000 1 4 12. 12.5 3 2 3. 0. 1. + 154 1 1. 0 37.0 15.000 1 4 14. 12.5 4 2 1. 0. 1. + 159 4 1. 0 42.0 15.000 1 3 17. 40.0 1 4 7. 0. 1. + 174 6 1. 0 42.0 15.000 1 5 9. 12.5 4 1 12. 0. 1. + 176 5 1. 1 37.0 10.000 1 2 20. 40.0 6 2 12. 0. 1. + 181 6 1. 0 32.0 15.000 1 3 14. 12.5 1 2 12. 0. 1. + 182 3 1. 1 27.0 4.000 0 1 18. 7.5 6 5 3. 0. 1. + 186 4 1. 1 37.0 10.000 1 2 18. 40.0 7 3 7. 0. 1. + 189 4 1. 0 27.0 4.000 0 3 17. 7.5 5 5 7. 0. 1. + 204 1 1. 1 42.0 15.000 1 4 16. 20.0 5 5 1. 0. 1. + 215 1 1. 0 47.0 15.000 1 5 14. 12.5 4 5 1. 0. 1. + 232 4 1. 0 27.0 4.000 1 3 18. 12.5 5 4 7. 0. 1. + 233 1 1. 0 27.0 7.000 1 5 14. 4.0 1 4 1. 0. 1. + 252 6 1. 1 27.0 1.500 1 3 17. 20.0 5 4 12. 0. 1. + 253 5 1. 0 27.0 7.000 1 4 14. 12.5 6 2 12. 0. 1. + 274 3 1. 0 42.0 15.000 1 4 16. 20.0 5 4 3. 0. 1. + 275 4 1. 0 27.0 10.000 1 4 12. 12.5 7 3 7. 0. 1. + 287 1 1. 1 27.0 1.500 0 2 18. 12.5 5 2 1. 0. 1. + 288 1 1. 1 32.0 4.000 0 4 20. 20.0 6 4 1. 0. 1. + 325 1 1. 0 27.0 7.000 1 3 14. 7.5 1 3 1. 0. 1. + 328 3 1. 0 32.0 10.000 1 4 14. 7.5 1 4 3. 0. 1. + 344 3 1. 1 27.0 4.000 1 2 18. 12.5 7 2 3. 0. 1. + 353 1 1. 0 17.5 0.750 0 5 14. 7.5 4 5 1. 0. 1. + 354 1 1. 0 32.0 10.000 1 4 18. 20.0 1 5 1. 0. 1. + 367 4 1. 0 32.0 7.000 1 2 17. 20.0 6 4 7. 0. 1. + 369 4 1. 1 37.0 15.000 1 2 20. 20.0 6 4 7. 0. 1. + 390 4 1. 0 37.0 10.000 0 1 20. 20.0 5 3 7. 0. 1. + 392 5 1. 0 32.0 10.000 1 2 16. 12.5 5 5 12. 0. 1. + 423 4 1. 1 52.0 15.000 1 2 20. 40.0 6 4 7. 0. 1. + 432 4 1. 0 42.0 15.000 1 1 12. 12.5 1 3 7. 0. 1. + 436 1 1. 1 52.0 15.000 1 2 20. 40.0 6 3 1. 0. 1. + 483 2 1. 1 37.0 15.000 1 3 18. 12.5 6 5 2. 0. 1. + 513 5 1. 0 22.0 4.000 0 3 12. 12.5 3 4 12. 0. 1. + 516 6 1. 1 27.0 7.000 1 1 18. 12.5 6 2 12. 0. 1. + 518 1 1. 1 27.0 4.000 1 3 18. 12.5 5 5 1. 0. 1. + 520 7 1. 1 47.0 15.000 1 4 17. 12.5 6 5 12. 0. 1. + 526 6 1. 0 42.0 15.000 1 4 12. 20.0 1 1 12. 0. 1. + 528 4 1. 1 27.0 4.000 0 3 14. 7.5 3 4 7. 0. 1. + 553 4 1. 0 32.0 7.000 1 4 18. 12.5 4 5 7. 0. 1. + 576 1 1. 1 32.0 0.417 1 3 12. 7.5 3 4 1. 0. 1. + 611 3 1. 1 47.0 15.000 1 5 16. 12.5 5 4 3. 0. 1. + 625 5 1. 1 37.0 15.000 1 2 20. 40.0 5 4 12. 0. 1. + 635 4 1. 1 22.0 4.000 1 2 17. 7.5 6 4 7. 0. 1. + 646 1 1. 1 27.0 4.000 0 2 14. 12.5 4 5 1. 0. 1. + 657 4 1. 0 52.0 15.000 1 5 16. 12.5 1 3 7. 0. 1. + 659 1 1. 1 27.0 4.000 0 3 14. 12.5 3 3 1. 0. 1. + 666 1 1. 0 27.0 10.000 1 4 16. 12.5 1 4 1. 0. 1. + 679 1 1. 1 32.0 7.000 1 3 14. 20.0 7 4 1. 0. 1. + 729 4 1. 1 32.0 7.000 1 2 18. 20.0 4 1 7. 0. 1. + 755 3 1. 1 22.0 1.500 0 1 14. 20.0 3 2 3. 0. 1. + 758 4 1. 1 22.0 4.000 1 3 18. 12.5 6 4 7. 0. 1. + 770 4 1. 1 42.0 15.000 1 4 20. 40.0 6 4 7. 0. 1. + 786 2 1. 0 57.0 15.000 1 1 18. 40.0 5 4 2. 0. 1. + 797 4 1. 0 32.0 4.000 1 3 18. 12.5 5 2 7. 0. 1. + 811 1 1. 1 27.0 4.000 1 1 16. 20.0 4 4 1. 0. 1. + 834 4 1. 1 32.0 7.000 1 4 16. 12.5 1 4 7. 0. 1. + 858 2 1. 1 57.0 15.000 1 1 17. 20.0 4 4 2. 0. 1. + 885 4 1. 0 42.0 15.000 1 4 14. 20.0 5 2 7. 0. 1. + 893 4 1. 1 37.0 10.000 1 1 18. 12.5 5 3 7. 0. 1. + 927 3 1. 1 42.0 15.000 1 3 17. 12.5 6 1 3. 0. 1. + 928 1 1. 0 52.0 15.000 1 3 14. 12.5 4 4 1. 0. 1. + 933 2 1. 0 27.0 7.000 1 3 17. 12.5 5 3 2. 0. 1. + 951 6 1. 1 32.0 7.000 1 2 12. 20.0 4 2 12. 0. 1. + 968 1 1. 1 22.0 4.000 0 4 14. 7.5 2 5 1. 0. 1. + 972 3 1. 1 27.0 7.000 1 3 18. 12.5 6 4 3. 0. 1. + 975 6 1. 0 37.0 15.000 1 1 18. 12.5 5 5 12. 0. 1. + 977 4 1. 0 32.0 15.000 1 3 17. 20.0 1 3 7. 0. 1. + 981 4 1. 0 27.0 7.000 0 2 17. 20.0 5 5 7. 0. 1. + 986 1 1. 0 32.0 7.000 1 3 17. 12.5 5 3 1. 0. 1. + 1002 1 1. 1 32.0 1.500 1 2 14. 7.5 2 4 1. 0. 1. + 1007 6 1. 0 42.0 15.000 1 4 14. 12.5 1 2 12. 0. 1. + 1011 4 1. 1 32.0 10.000 1 3 14. 20.0 5 4 7. 0. 1. + 1035 4 1. 1 37.0 4.000 1 1 20. 20.0 6 3 7. 0. 1. + 1050 1 1. 0 27.0 4.000 1 2 16. 12.5 5 3 1. 0. 1. + 1056 5 1. 0 42.0 15.000 1 3 14. 20.0 4 3 12. 0. 1. + 1057 1 1. 1 27.0 10.000 1 5 20. 20.0 6 5 1. 0. 1. + 1075 6 1. 1 37.0 10.000 1 2 20. 40.0 6 2 12. 0. 1. + 1080 6 1. 0 27.0 7.000 1 1 14. 12.5 3 3 12. 0. 1. + 1125 3 1. 0 27.0 7.000 1 4 12. 7.5 1 2 3. 0. 1. + 1131 3 1. 1 32.0 10.000 1 2 14. 12.5 4 4 3. 0. 1. + 1138 7 1. 0 17.5 0.750 1 2 12. 7.5 1 3 12. 0. 1. + 1150 5 1. 0 32.0 15.000 1 3 18. 40.0 5 4 12. 0. 1. + 1163 2 1. 0 22.0 7.000 0 4 14. 20.0 4 3 2. 0. 1. + 1169 1 1. 1 32.0 7.000 1 4 20. 20.0 6 5 1. 0. 1. + 1198 4 1. 1 27.0 4.000 1 2 18. 12.5 6 2 7. 0. 1. + 1204 1 1. 0 22.0 1.500 1 5 14. 7.5 5 3 1. 0. 1. + 1218 7 1. 0 32.0 15.000 0 3 17. 7.5 5 1 12. 0. 1. + 1230 5 1. 0 42.0 15.000 1 2 12. 20.0 1 2 12. 0. 1. + 1236 4 1. 1 42.0 15.000 1 3 20. 40.0 5 4 7. 0. 1. + 1247 6 1. 1 32.0 10.000 0 2 18. 20.0 4 2 12. 0. 1. + 1259 5 1. 0 32.0 15.000 1 3 9. 12.5 1 1 12. 0. 1. + 1294 4 1. 1 57.0 15.000 1 5 20. 12.5 4 5 7. 0. 1. + 1353 5 1. 1 47.0 15.000 1 4 20. 40.0 6 4 12. 0. 1. + 1370 2 1. 0 42.0 15.000 1 2 17. 20.0 6 3 2. 0. 1. + 1427 6 1. 1 37.0 15.000 1 3 17. 40.0 6 3 12. 0. 1. + 1445 5 1. 1 37.0 15.000 1 5 17. 12.5 5 2 12. 0. 1. + 1460 4 1. 1 27.0 10.000 1 2 20. 12.5 6 4 7. 0. 1. + 1480 2 1. 1 37.0 15.000 1 2 16. 20.0 5 4 2. 0. 1. + 1505 6 1. 0 32.0 15.000 1 1 14. 20.0 5 2 12. 0. 1. + 1543 4 1. 1 32.0 10.000 1 3 17. 7.5 6 3 7. 0. 1. + 1548 2 1. 1 37.0 15.000 1 4 18. 12.5 5 1 2. 0. 1. + 1550 4 1. 0 27.0 1.500 0 2 17. 12.5 5 5 7. 0. 1. + 1561 3 1. 0 47.0 15.000 1 2 17. 20.0 5 2 3. 0. 1. + 1564 6 1. 1 37.0 15.000 1 2 17. 20.0 5 4 12. 0. 1. + 1573 5 1. 0 27.0 4.000 0 2 14. 20.0 5 5 12. 0. 1. + 1575 2 1. 0 27.0 10.000 1 4 14. 12.5 1 5 2. 0. 1. + 1599 1 1. 0 22.0 4.000 1 3 16. 12.5 1 3 1. 0. 1. + 1622 6 1. 1 52.0 7.000 0 4 16. 7.5 5 5 12. 0. 1. + 1629 2 1. 0 27.0 4.000 1 1 16. 7.5 3 5 2. 0. 1. + 1664 4 1. 0 37.0 15.000 1 2 17. 40.0 6 4 7. 0. 1. + 1669 2 1. 0 27.0 4.000 0 1 17. 4.0 3 1 2. 0. 1. + 1674 7 1. 0 17.5 0.750 1 2 12. 7.5 3 5 12. 0. 1. + 1682 4 1. 0 32.0 15.000 1 5 18. 12.5 5 4 7. 0. 1. + 1685 4 1. 0 22.0 4.000 0 1 16. 7.5 3 5 7. 0. 1. + 1697 2 1. 1 32.0 4.000 1 4 18. 20.0 6 4 2. 0. 1. + 1716 1 1. 0 22.0 1.500 1 3 18. 20.0 5 2 1. 0. 1. + 1730 3 1. 0 42.0 15.000 1 2 17. 40.0 5 4 3. 0. 1. + 1731 1 1. 1 32.0 7.000 1 4 16. 12.5 4 4 1. 0. 1. + 1732 5 1. 1 37.0 15.000 0 3 14. 20.0 6 2 12. 0. 1. + 1743 1 1. 1 42.0 15.000 1 3 16. 40.0 6 3 1. 0. 1. + 1751 1 1. 1 27.0 4.000 1 1 18. 7.5 5 4 1. 0. 1. + 1757 2 1. 1 37.0 15.000 1 4 20. 40.0 7 3 2. 0. 1. + 1763 4 1. 1 37.0 15.000 1 3 20. 40.0 6 4 7. 0. 1. + 1766 3 1. 1 22.0 1.500 0 2 12. 12.5 3 3 3. 0. 1. + 1772 3 1. 1 32.0 4.000 1 3 20. 20.0 6 2 3. 0. 1. + 1776 2 1. 1 32.0 15.000 1 5 20. 20.0 6 5 2. 0. 1. + 1782 5 1. 0 52.0 15.000 1 1 18. 40.0 5 5 12. 0. 1. + 1784 5 1. 1 47.0 15.000 0 1 18. 40.0 6 5 12. 0. 1. + 1791 3 1. 0 32.0 15.000 1 4 16. 12.5 4 4 3. 0. 1. + 1831 4 1. 0 32.0 15.000 1 3 14. 12.5 3 2 7. 0. 1. + 1840 4 1. 0 27.0 7.000 1 4 16. 20.0 1 2 7. 0. 1. + 1844 5 1. 1 42.0 15.000 1 3 18. 12.5 6 2 12. 0. 1. + 1856 4 1. 0 42.0 15.000 1 2 14. 12.5 3 2 7. 0. 1. + 1876 5 1. 1 27.0 7.000 1 2 17. 12.5 5 4 12. 0. 1. + 1929 3 1. 1 32.0 10.000 1 4 14. 7.5 4 3 3. 0. 1. + 1935 4 1. 1 47.0 15.000 1 3 16. 20.0 4 2 7. 0. 1. + 1938 1 1. 1 22.0 1.500 1 1 12. 7.5 2 5 1. 0. 1. + 1941 4 1. 0 32.0 10.000 1 2 18. 7.5 5 4 7. 0. 1. + 1954 2 1. 1 32.0 10.000 1 2 17. 20.0 6 5 2. 0. 1. + 1959 2 1. 1 22.0 7.000 1 3 18. 20.0 6 2 2. 0. 1. + 9010 1 1. 0 32.0 15.000 1 3 14. 40.0 1 5 1. 0. 1. +END OF PT DATA + +BEGIN RB DATA (6366 observations): + + 3. 1. 3. 32.0 9.0 3.0 3. 17.0 40.0 2. 5. 0.1111111 0. 1. + 12. 1. 3. 27.0 13.0 3.0 1. 14.0 20.0 3. 4. 3.2307692 0. 1. + 51. 1. 4. 22.0 2.5 0.0 1. 16.0 11.5 3. 5. 1.3999996 0. 1. + 53. 1. 4. 37.0 16.5 4.0 3. 16.0 20.0 5. 5. 0.7272727 0. 1. + 54. 1. 5. 27.0 9.0 1.0 1. 14.0 14.0 3. 4. 4.6666660 0. 1. + 74. 1. 4. 27.0 9.0 0.0 2. 14.0 20.0 3. 4. 4.6666660 0. 1. + 81. 1. 5. 37.0 23.0 5.5 2. 12.0 20.0 5. 4. 0.8521735 0. 1. + 83. 1. 5. 37.0 23.0 5.5 2. 12.0 20.0 2. 3. 1.8260860 0. 1. + 89. 1. 3. 22.0 2.5 0.0 2. 12.0 11.5 3. 3. 4.7999992 0. 1. + 102. 1. 3. 27.0 6.0 0.0 1. 16.0 20.0 3. 5. 1.3333330 0. 1. + 135. 1. 2. 27.0 6.0 2.0 1. 16.0 20.0 3. 5. 3.2666645 0. 1. + 137. 1. 5. 27.0 6.0 2.0 3. 14.0 14.0 3. 5. 2.0416660 0. 1. + 144. 1. 3. 37.0 16.5 5.5 1. 12.0 11.5 2. 3. 0.4848484 0. 1. + 160. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 2. 2.0000000 0. 1. + 168. 1. 4. 22.0 6.0 1.0 1. 14.0 14.0 4. 4. 3.2666645 0. 1. + 182. 1. 4. 37.0 9.0 2.0 2. 14.0 40.0 3. 6. 1.3611107 0. 1. + 202. 1. 4. 27.0 6.0 1.0 1. 12.0 20.0 3. 5. 2.0000000 0. 1. + 228. 1. 1. 37.0 23.0 5.5 4. 14.0 14.0 5. 2. 1.8260860 0. 1. + 239. 1. 2. 42.0 23.0 2.0 2. 20.0 20.0 4. 4. 1.8260860 0. 1. + 243. 1. 4. 37.0 6.0 0.0 2. 16.0 20.0 5. 4. 2.0416660 0. 1. + 248. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 7.8399963 0. 1. + 251. 1. 3. 37.0 16.5 5.5 2. 9.0 40.0 3. 2. 2.5454540 0. 1. + 264. 1. 3. 42.0 23.0 5.5 3. 12.0 14.0 5. 4. 0.5326087 0. 1. + 266. 1. 2. 27.0 9.0 2.0 4. 20.0 20.0 3. 4. 0.6222222 0. 1. + 280. 1. 4. 27.0 6.0 1.0 2. 12.0 11.5 5. 4. 0.5833333 0. 1. + 284. 1. 5. 27.0 2.5 0.0 3. 16.0 14.0 4. 1. 4.7999992 0. 1. + 286. 1. 2. 27.0 6.0 2.0 2. 12.0 11.5 2. 5. 0.1666666 0. 1. + 289. 1. 5. 37.0 13.0 1.0 3. 12.0 11.5 3. 4. 0.6153846 0. 1. + 293. 1. 2. 32.0 16.5 2.0 2. 12.0 14.0 4. 2. 1.1878777 0. 1. + 296. 1. 3. 27.0 6.0 1.0 1. 14.0 14.0 3. 6. 11.1999989 0. 1. + 297. 1. 3. 32.0 16.5 4.0 3. 14.0 20.0 5. 5. 1.1878777 0. 1. + 300. 1. 3. 27.0 9.0 2.0 1. 14.0 20.0 3. 4. 2.1777763 0. 1. + 308. 1. 3. 37.0 16.5 3.0 3. 14.0 14.0 3. 2. 0.4848484 0. 1. + 312. 1. 4. 32.0 16.5 5.5 4. 12.0 14.0 2. 4. 0.7272727 0. 1. + 320. 1. 5. 42.0 16.5 4.0 3. 16.0 40.0 4. 6. 0.7272727 0. 1. + 322. 1. 3. 27.0 9.0 2.0 2. 12.0 14.0 5. 2. 1.3333330 0. 1. + 332. 1. 3. 17.5 0.5 0.0 1. 12.0 11.5 3. 2. 7.0000000 0. 1. + 339. 1. 4. 42.0 23.0 5.5 2. 20.0 4.0 3. 2. 0.5217391 0. 1. + 354. 1. 5. 37.0 16.5 3.0 3. 12.0 20.0 3. 5. 0.2121212 0. 1. + 359. 1. 4. 22.0 2.5 1.0 2. 14.0 20.0 3. 5. 0.4000000 0. 1. + 361. 1. 4. 27.0 2.5 0.0 2. 16.0 20.0 4. 1. 1.3999996 0. 1. + 368. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 6. 3.1999998 0. 1. + 370. 1. 4. 37.0 13.0 3.0 2. 16.0 40.0 4. 5. 1.5076914 0. 1. + 373. 1. 4. 22.0 2.5 0.0 2. 16.0 14.0 3. 4. 7.8399963 0. 1. + 386. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 1. 2. 7.8399963 0. 1. + 387. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 2. 0.4000000 0. 1. + 410. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 5. 4.8999996 0. 1. + 411. 1. 3. 42.0 23.0 4.0 3. 16.0 40.0 5. 5. 0.0434783 0. 1. + 425. 1. 5. 32.0 13.0 3.0 3. 14.0 14.0 4. 4. 0.0769231 0. 1. + 431. 1. 5. 22.0 6.0 2.0 2. 14.0 14.0 3. 4. 0.5833333 0. 1. + 471. 1. 3. 27.0 2.5 1.0 4. 17.0 6.5 4. 6. 4.7999992 0. 1. + 473. 1. 2. 42.0 23.0 3.0 3. 14.0 20.0 3. 5. 0.8521735 0. 1. + 478. 1. 4. 22.0 2.5 0.0 1. 17.0 40.0 6. 6. 4.7999992 0. 1. + 496. 1. 2. 42.0 23.0 3.0 3. 14.0 20.0 3. 5. 2.9217386 0. 1. + 510. 1. 4. 42.0 23.0 2.0 2. 14.0 14.0 4. 4. 0.5217391 0. 1. + 512. 1. 4. 42.0 23.0 3.0 3. 12.0 20.0 5. 4. 0.5326087 0. 1. + 516. 1. 4. 37.0 16.5 2.0 3. 14.0 20.0 3. 4. 0.4848484 0. 1. + 521. 1. 4. 27.0 2.5 0.0 2. 20.0 20.0 4. 5. 7.8399963 0. 1. + 529. 1. 2. 32.0 9.0 2.0 2. 12.0 9.0 2. 2. 1.3333330 0. 1. + 533. 1. 4. 42.0 13.0 0.0 1. 14.0 20.0 3. 4. 1.5076914 0. 1. + 536. 1. 4. 22.0 6.0 2.0 1. 12.0 11.5 3. 4. 1.3333330 0. 1. + 544. 1. 5. 32.0 16.5 3.0 3. 14.0 20.0 2. 4. 1.1878777 0. 1. + 546. 1. 4. 42.0 13.0 0.0 2. 12.0 11.5 3. 2. 1.5076914 0. 1. + 547. 1. 5. 27.0 9.0 1.0 3. 14.0 20.0 5. 5. 1.3333330 0. 1. + 565. 1. 5. 22.0 6.0 2.0 2. 12.0 14.0 2. 5. 7.0000000 0. 1. + 575. 1. 2. 27.0 16.5 2.0 3. 16.0 20.0 4. 5. 0.7272727 0. 1. + 577. 1. 5. 37.0 13.0 2.0 1. 12.0 14.0 3. 4. 1.5076914 0. 1. + 584. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 4. 2.0416660 0. 1. + 587. 1. 2. 27.0 2.5 1.0 1. 12.0 11.5 2. 3. 26.8799896 0. 1. + 588. 1. 5. 42.0 23.0 5.5 4. 20.0 40.0 5. 4. 0.5326087 0. 1. + 612. 1. 5. 27.0 6.0 0.0 2. 16.0 20.0 5. 2. 2.0000000 0. 1. + 616. 1. 5. 37.0 16.5 3.0 2. 14.0 20.0 3. 5. 0.2121212 0. 1. + 618. 1. 2. 32.0 9.0 2.0 2. 16.0 20.0 3. 5. 1.3333330 0. 1. + 630. 1. 3. 37.0 16.5 5.5 3. 12.0 20.0 5. 5. 2.5454540 0. 1. + 633. 1. 5. 27.0 6.0 2.0 2. 12.0 20.0 3. 4. 0.1666666 0. 1. + 648. 1. 5. 32.0 16.5 3.0 1. 12.0 20.0 4. 4. 0.4848484 0. 1. + 652. 1. 5. 27.0 9.0 2.0 1. 14.0 11.5 5. 1. 1.3333330 0. 1. + 672. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 5. 5. 0.4000000 0. 1. + 674. 1. 5. 32.0 16.5 2.0 4. 14.0 14.0 5. 2. 0.4848484 0. 1. + 706. 1. 2. 22.0 6.0 2.0 2. 14.0 9.0 2. 5. 0.1666666 0. 1. + 715. 1. 3. 32.0 13.0 3.0 1. 12.0 11.5 4. 5. 1.5076914 0. 1. + 733. 1. 5. 32.0 16.5 3.0 2. 12.0 20.0 3. 4. 0.0606061 0. 1. + 734. 1. 3. 27.0 6.0 2.0 1. 14.0 11.5 3. 6. 2.0416660 0. 1. + 736. 1. 5. 22.0 2.5 0.0 1. 20.0 14.0 4. 4. 0.4000000 0. 1. + 740. 1. 3. 32.0 9.0 2.0 3. 14.0 20.0 3. 5. 0.8888888 0. 1. + 771. 1. 3. 22.0 2.5 1.0 2. 14.0 11.5 3. 2. 4.7999992 0. 1. + 775. 1. 3. 22.0 2.5 0.0 2. 16.0 9.0 3. 4. 4.7999992 0. 1. + 779. 1. 5. 27.0 9.0 2.0 1. 16.0 40.0 4. 6. 1.3333330 0. 1. + 780. 1. 3. 42.0 23.0 2.0 2. 12.0 14.0 2. 2. 0.1521739 0. 1. + 784. 1. 3. 37.0 16.5 3.0 2. 17.0 20.0 3. 2. 1.1878777 0. 1. + 808. 1. 5. 32.0 13.0 2.0 2. 12.0 20.0 2. 6. 0.9423077 0. 1. + 822. 1. 1. 27.0 13.0 2.0 2. 12.0 11.5 4. 4. 1.5076914 0. 1. + 825. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 3. 2. 0.4000000 0. 1. + 827. 1. 5. 27.0 9.0 0.0 1. 14.0 20.0 4. 4. 0.1111111 0. 1. + 839. 1. 5. 32.0 13.0 2.0 2. 16.0 20.0 3. 3. 0.9423077 0. 1. + 860. 1. 4. 27.0 9.0 2.0 2. 14.0 20.0 3. 5. 0.3888888 0. 1. + 865. 1. 3. 22.0 2.5 1.0 3. 14.0 11.5 5. 4. 4.8999996 0. 1. + 866. 1. 2. 37.0 23.0 2.0 2. 12.0 40.0 5. 5. 0.5326087 0. 1. + 882. 1. 2. 27.0 6.0 2.0 1. 14.0 20.0 3. 5. 2.0416660 0. 1. + 922. 1. 4. 27.0 2.5 1.0 2. 12.0 11.5 5. 2. 4.8999996 0. 1. + 946. 1. 3. 37.0 13.0 5.5 2. 12.0 40.0 5. 5. 5.1692305 0. 1. + 948. 1. 5. 37.0 16.5 4.0 1. 12.0 40.0 3. 6. 1.6969690 0. 1. + 954. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 5. 1.3999996 0. 1. + 955. 1. 4. 42.0 13.0 0.0 1. 14.0 11.5 5. 5. 0.0769231 0. 1. + 961. 1. 5. 27.0 9.0 1.0 1. 14.0 20.0 5. 5. 2.1777763 0. 1. + 980. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 3. 4. 1.3999996 0. 1. + 1000. 1. 4. 22.0 2.5 1.0 2. 14.0 20.0 5. 4. 7.8399963 0. 1. + 1011. 1. 4. 27.0 6.0 2.0 3. 16.0 20.0 4. 6. 0.5833333 0. 1. + 1013. 1. 2. 32.0 16.5 1.0 2. 14.0 40.0 3. 5. 2.7151508 0. 1. + 1024. 1. 3. 27.0 13.0 2.0 1. 14.0 20.0 3. 4. 0.9423077 0. 1. + 1029. 1. 4. 22.0 0.5 0.0 2. 12.0 20.0 3. 2. 7.0000000 0. 1. + 1035. 1. 5. 27.0 6.0 1.0 1. 16.0 20.0 4. 3. 3.2666645 0. 1. + 1037. 1. 2. 27.0 9.0 2.0 2. 14.0 11.5 3. 5. 4.6666660 0. 1. + 1041. 1. 3. 27.0 9.0 2.0 2. 12.0 14.0 3. 4. 2.1777763 0. 1. + 1047. 1. 4. 32.0 16.5 3.0 3. 12.0 20.0 2. 3. 0.4848484 0. 1. + 1049. 1. 5. 22.0 2.5 0.0 1. 12.0 20.0 3. 3. 1.3999996 0. 1. + 1071. 1. 4. 22.0 2.5 1.0 2. 14.0 11.5 4. 4. 3.1999998 0. 1. + 1072. 1. 1. 22.0 2.5 0.0 2. 9.0 6.5 2. 4. 11.1999998 0. 1. + 1074. 1. 3. 32.0 13.0 2.0 1. 20.0 40.0 6. 6. 1.5076914 0. 1. + 1101. 1. 5. 32.0 9.0 1.0 2. 14.0 40.0 3. 5. 1.3333330 0. 1. + 1118. 1. 5. 27.0 2.5 0.0 1. 20.0 20.0 6. 4. 1.3999996 0. 1. + 1125. 1. 4. 27.0 9.0 2.0 2. 14.0 9.0 2. 5. 0.3888888 0. 1. + 1128. 1. 4. 27.0 6.0 0.0 3. 12.0 11.5 5. 2. 2.0000000 0. 1. + 1129. 1. 2. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 4.8999996 0. 1. + 1130. 1. 3. 27.0 9.0 2.0 3. 17.0 9.0 4. 6. 1.3611107 0. 1. + 1151. 1. 4. 27.0 6.0 2.0 1. 14.0 40.0 3. 4. 2.0416660 0. 1. + 1152. 1. 5. 22.0 2.5 1.0 1. 12.0 20.0 2. 2. 1.3999996 0. 1. + 1158. 1. 4. 27.0 16.5 4.0 3. 12.0 40.0 2. 6. 0.2121212 0. 1. + 1165. 1. 2. 27.0 6.0 1.0 2. 14.0 11.5 4. 3. 3.2666645 0. 1. + 1187. 1. 2. 32.0 6.0 1.0 1. 17.0 11.5 4. 4. 7.4666672 0. 1. + 1194. 1. 5. 27.0 6.0 2.0 2. 16.0 20.0 4. 3. 0.5833333 0. 1. + 1202. 1. 4. 42.0 23.0 3.0 3. 17.0 20.0 4. 4. 0.5217391 0. 1. + 1207. 1. 4. 32.0 9.0 2.0 1. 16.0 20.0 4. 6. 0.1111111 0. 1. + 1223. 1. 3. 42.0 23.0 4.0 3. 14.0 20.0 4. 3. 0.5217391 0. 1. + 1232. 1. 5. 27.0 6.0 2.0 1. 12.0 9.0 5. 2. 2.0000000 0. 1. + 1233. 1. 2. 42.0 23.0 4.0 4. 20.0 40.0 4. 5. 0.1521739 0. 1. + 1251. 1. 3. 32.0 6.0 0.0 2. 20.0 40.0 4. 5. 4.6666660 0. 1. + 1259. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 3. 2. 1.3999996 0. 1. + 1261. 1. 2. 42.0 16.5 3.0 3. 12.0 20.0 3. 5. 1.1878777 0. 1. + 1269. 1. 4. 37.0 23.0 3.0 2. 12.0 20.0 5. 4. 1.8260860 0. 1. + 1271. 1. 3. 27.0 2.5 0.0 2. 17.0 14.0 4. 4. 1.3999996 0. 1. + 1278. 1. 3. 32.0 13.0 3.0 3. 20.0 40.0 4. 6. 3.2307692 0. 1. + 1288. 1. 3. 27.0 2.5 0.0 2. 14.0 40.0 3. 4. 4.7999992 0. 1. + 1296. 1. 3. 42.0 16.5 2.0 1. 16.0 40.0 3. 5. 1.1878777 0. 1. + 1301. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 5. 5. 0.4000000 0. 1. + 1314. 1. 5. 27.0 6.0 0.0 3. 14.0 20.0 3. 5. 0.5833333 0. 1. + 1320. 1. 3. 22.0 2.5 0.0 1. 12.0 11.5 2. 4. 7.8399963 0. 1. + 1325. 1. 4. 27.0 6.0 0.0 3. 14.0 40.0 2. 4. 11.1999989 0. 1. + 1333. 1. 3. 27.0 9.0 2.0 2. 16.0 14.0 3. 4. 1.3611107 0. 1. + 1334. 1. 2. 27.0 9.0 1.0 2. 14.0 20.0 2. 2. 4.9777775 0. 1. + 1337. 1. 3. 22.0 2.5 0.0 3. 12.0 20.0 3. 3. 4.7999992 0. 1. + 1339. 1. 4. 32.0 16.5 4.0 4. 14.0 20.0 3. 5. 2.7151508 0. 1. + 1349. 1. 5. 32.0 2.5 2.0 2. 14.0 20.0 3. 4. 0.4000000 0. 1. + 1351. 1. 4. 27.0 2.5 0.0 2. 14.0 40.0 3. 5. 0.4000000 0. 1. + 1356. 1. 5. 32.0 9.0 3.0 3. 16.0 11.5 4. 4. 0.1111111 0. 1. + 1364. 1. 3. 32.0 13.0 2.0 2. 12.0 20.0 3. 5. 0.2692307 0. 1. + 1368. 1. 3. 32.0 16.5 3.0 3. 12.0 20.0 3. 2. 0.7272727 0. 1. + 1369. 1. 5. 42.0 23.0 2.0 2. 14.0 20.0 5. 5. 0.5217391 0. 1. + 1370. 1. 3. 27.0 16.5 4.0 3. 14.0 20.0 4. 2. 0.7424242 0. 1. + 1374. 1. 3. 32.0 16.5 4.0 2. 20.0 20.0 4. 4. 0.7272727 0. 1. + 1378. 1. 4. 22.0 2.5 2.0 2. 14.0 14.0 5. 2. 4.7999992 0. 1. + 1392. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 3. 4. 7.4666672 0. 1. + 1396. 1. 4. 37.0 16.5 3.0 4. 16.0 40.0 5. 5. 0.2121212 0. 1. + 1410. 1. 3. 22.0 2.5 0.0 2. 12.0 6.5 3. 5. 1.3999996 0. 1. + 1411. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 3. 5. 1.5076914 0. 1. + 1422. 1. 5. 42.0 23.0 5.5 3. 17.0 20.0 4. 4. 0.5217391 0. 1. + 1455. 1. 2. 27.0 6.0 2.0 3. 12.0 11.5 2. 2. 1.3333330 0. 1. + 1465. 1. 5. 22.0 2.5 1.0 2. 16.0 20.0 3. 6. 1.3999996 0. 1. + 1486. 1. 3. 42.0 23.0 2.0 3. 12.0 11.5 2. 2. 0.5326087 0. 1. + 1495. 1. 5. 42.0 23.0 3.0 1. 14.0 40.0 3. 5. 1.8260860 0. 1. + 1499. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 3. 4. 4.8999996 0. 1. + 1516. 1. 3. 27.0 9.0 1.0 4. 14.0 20.0 5. 5. 0.1111111 0. 1. + 1519. 1. 2. 37.0 23.0 3.0 3. 12.0 20.0 2. 4. 4.1739130 0. 1. + 1553. 1. 3. 32.0 9.0 3.0 3. 14.0 20.0 4. 5. 0.3888888 0. 1. + 1554. 1. 5. 37.0 16.5 4.0 3. 12.0 14.0 3. 4. 1.1878777 0. 1. + 1559. 1. 3. 27.0 9.0 2.0 2. 12.0 14.0 5. 2. 1.3333330 0. 1. + 1560. 1. 3. 27.0 6.0 1.0 2. 17.0 6.5 2. 2. 1.3333330 0. 1. + 1563. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 3. 3. 1.3999996 0. 1. + 1568. 1. 5. 27.0 6.0 0.0 2. 17.0 20.0 4. 5. 1.3333330 0. 1. + 1591. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 4. 2. 4.8999996 0. 1. + 1595. 1. 4. 27.0 6.0 0.0 2. 12.0 20.0 3. 4. 4.6666660 0. 1. + 1610. 1. 3. 32.0 9.0 1.0 2. 12.0 20.0 3. 3. 0.1111111 0. 1. + 1611. 1. 1. 42.0 23.0 4.0 3. 12.0 20.0 3. 5. 0.8521735 0. 1. + 1612. 1. 2. 22.0 6.0 2.0 2. 12.0 20.0 3. 4. 1.3333330 0. 1. + 1617. 1. 4. 32.0 16.5 2.0 2. 12.0 14.0 2. 2. 0.4848484 0. 1. + 1635. 1. 4. 32.0 13.0 3.0 3. 14.0 11.5 2. 2. 0.9423077 0. 1. + 1639. 1. 5. 27.0 9.0 2.0 1. 12.0 20.0 3. 3. 0.3888888 0. 1. + 1649. 1. 3. 42.0 23.0 3.0 2. 12.0 20.0 3. 2. 0.5217391 0. 1. + 1673. 1. 3. 37.0 16.5 1.0 3. 20.0 20.0 6. 6. 2.7151508 0. 1. + 1674. 1. 5. 32.0 13.0 2.0 1. 12.0 20.0 5. 2. 0.9423077 0. 1. + 1677. 1. 4. 27.0 13.0 3.0 1. 12.0 9.0 4. 2. 3.4461536 0. 1. + 1688. 1. 2. 37.0 13.0 0.0 2. 14.0 20.0 3. 5. 0.9230769 0. 1. + 1690. 1. 3. 27.0 9.0 1.0 1. 12.0 11.5 2. 2. 3.1111107 0. 1. + 1708. 1. 5. 27.0 6.0 0.0 1. 14.0 40.0 5. 5. 3.2666645 0. 1. + 1711. 1. 2. 42.0 23.0 2.0 3. 12.0 14.0 5. 2. 0.8521735 0. 1. + 1712. 1. 5. 27.0 6.0 0.0 2. 16.0 11.5 3. 4. 0.5833333 0. 1. + 1713. 1. 4. 22.0 2.5 0.0 4. 16.0 14.0 5. 4. 7.8399963 0. 1. + 1720. 1. 5. 22.0 2.5 0.0 2. 16.0 6.5 4. 4. 1.3999996 0. 1. + 1724. 1. 5. 42.0 13.0 0.0 3. 12.0 11.5 3. 2. 1.5076914 0. 1. + 1742. 1. 4. 22.0 2.5 1.0 1. 16.0 20.0 3. 4. 1.3999996 0. 1. + 1757. 1. 4. 32.0 9.0 1.0 3. 16.0 14.0 3. 5. 1.3611107 0. 1. + 1773. 1. 4. 27.0 9.0 2.0 2. 12.0 11.5 4. 2. 0.3888888 0. 1. + 1793. 1. 5. 27.0 6.0 0.0 1. 16.0 14.0 5. 2. 2.0416660 0. 1. + 1796. 1. 4. 32.0 16.5 3.0 2. 14.0 20.0 5. 4. 2.5454540 0. 1. + 1802. 1. 2. 42.0 2.5 0.0 4. 20.0 40.0 6. 5. 4.7999992 0. 1. + 1805. 1. 2. 42.0 23.0 5.5 4. 14.0 14.0 3. 6. 0.3478261 0. 1. + 1822. 1. 4. 42.0 23.0 4.0 2. 12.0 20.0 3. 2. 0.3478261 0. 1. + 1827. 1. 3. 22.0 2.5 0.0 3. 16.0 20.0 5. 5. 4.7999992 0. 1. + 1837. 1. 2. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 1.3999996 0. 1. + 1844. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 3. 3. 4.7999992 0. 1. + 1852. 1. 4. 32.0 16.5 4.0 3. 14.0 11.5 4. 4. 0.2121212 0. 1. + 1855. 1. 5. 32.0 13.0 2.0 4. 17.0 14.0 4. 5. 0.9423077 0. 1. + 1863. 1. 4. 32.0 13.0 3.0 4. 12.0 20.0 3. 5. 1.5076914 0. 1. + 1872. 1. 5. 27.0 9.0 2.0 1. 14.0 11.5 4. 4. 1.3611107 0. 1. + 1889. 1. 4. 27.0 6.0 1.0 4. 16.0 11.5 3. 4. 0.5833333 0. 1. + 1891. 1. 4. 27.0 9.0 2.0 3. 12.0 11.5 2. 4. 1.3333330 0. 1. + 1904. 1. 1. 37.0 16.5 3.0 2. 17.0 11.5 4. 4. 0.7424242 0. 1. + 1922. 1. 3. 27.0 9.0 3.0 2. 12.0 20.0 4. 5. 1.3611107 0. 1. + 1926. 1. 2. 27.0 6.0 0.0 2. 14.0 20.0 3. 4. 4.6666660 0. 1. + 1942. 1. 3. 22.0 2.5 1.0 2. 14.0 9.0 2. 2. 25.5999908 0. 1. + 1950. 1. 4. 22.0 2.5 1.0 3. 12.0 9.0 3. 4. 4.8999996 0. 1. + 1953. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 4. 4. 1.3999996 0. 1. + 1967. 1. 1. 42.0 23.0 2.0 3. 12.0 11.5 3. 5. 0.5217391 0. 1. + 1968. 1. 5. 27.0 6.0 2.0 4. 14.0 40.0 5. 5. 3.2666645 0. 1. + 1969. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 4. 2. 0.5833333 0. 1. + 1993. 1. 4. 37.0 23.0 2.0 3. 12.0 40.0 3. 5. 0.1521739 0. 1. + 2003. 1. 4. 22.0 6.0 2.0 2. 12.0 11.5 3. 4. 0.1666666 0. 1. + 2011. 1. 1. 32.0 13.0 1.0 3. 14.0 6.5 3. 1. 0.9423077 0. 1. + 2020. 1. 5. 22.0 6.0 1.0 1. 16.0 20.0 3. 5. 0.5833333 0. 1. + 2022. 1. 5. 27.0 6.0 0.0 1. 14.0 40.0 3. 5. 2.0000000 0. 1. + 2034. 1. 5. 27.0 6.0 1.0 1. 17.0 40.0 4. 5. 3.2666645 0. 1. + 2046. 1. 4. 37.0 16.5 1.0 2. 14.0 20.0 2. 5. 1.1878777 0. 1. + 2051. 1. 4. 27.0 9.0 2.0 2. 12.0 9.0 2. 2. 2.1777763 0. 1. + 2052. 1. 4. 42.0 23.0 4.0 1. 12.0 40.0 3. 4. 0.1521739 0. 1. + 2086. 1. 4. 32.0 13.0 0.0 3. 12.0 20.0 2. 2. 2.1538458 0. 1. + 2096. 1. 5. 32.0 13.0 2.0 3. 12.0 11.5 2. 2. 0.9230769 0. 1. + 2113. 1. 4. 42.0 23.0 4.0 1. 17.0 11.5 4. 4. 0.8521735 0. 1. + 2123. 1. 4. 37.0 23.0 4.0 2. 14.0 20.0 4. 3. 0.5326087 0. 1. + 2124. 1. 4. 32.0 16.5 2.0 2. 14.0 20.0 3. 6. 1.1878777 0. 1. + 2129. 1. 4. 27.0 13.0 4.0 3. 12.0 40.0 2. 4. 3.2307692 0. 1. + 2135. 1. 5. 37.0 23.0 3.0 2. 12.0 11.5 3. 2. 0.1521739 0. 1. + 2147. 1. 2. 32.0 13.0 0.0 3. 9.0 11.5 6. 2. 0.0769231 0. 1. + 2153. 1. 5. 32.0 13.0 2.0 1. 14.0 40.0 4. 6. 3.4461536 0. 1. + 2155. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 4. 2. 0.1666666 0. 1. + 2156. 1. 5. 27.0 2.5 0.0 3. 20.0 20.0 4. 5. 4.7999992 0. 1. + 2160. 1. 2. 42.0 23.0 3.0 3. 14.0 20.0 4. 2. 0.5217391 0. 1. + 2176. 1. 3. 27.0 6.0 0.0 1. 14.0 20.0 3. 2. 0.5833333 0. 1. + 2195. 1. 4. 27.0 6.0 1.0 2. 12.0 9.0 3. 4. 2.0416660 0. 1. + 2196. 1. 2. 22.0 2.5 0.0 3. 12.0 11.5 3. 3. 3.1999998 0. 1. + 2217. 1. 3. 27.0 2.5 0.0 3. 12.0 11.5 2. 2. 7.8399963 0. 1. + 2223. 1. 4. 42.0 23.0 2.0 2. 17.0 40.0 5. 2. 0.8521735 0. 1. + 2235. 1. 5. 32.0 13.0 2.0 1. 14.0 14.0 2. 5. 0.9230769 0. 1. + 2240. 1. 5. 32.0 13.0 0.0 1. 12.0 20.0 5. 4. 2.1538458 0. 1. + 2244. 1. 4. 27.0 9.0 2.0 2. 16.0 11.5 4. 5. 0.3888888 0. 1. + 2255. 1. 5. 42.0 23.0 4.0 3. 17.0 40.0 4. 4. 0.1521739 0. 1. + 2268. 1. 3. 27.0 9.0 3.0 1. 16.0 20.0 4. 5. 0.1111111 0. 1. + 2270. 1. 5. 42.0 13.0 0.0 2. 14.0 20.0 5. 3. 0.9230769 0. 1. + 2271. 1. 5. 32.0 16.5 2.0 2. 16.0 40.0 5. 5. 0.2121212 0. 1. + 2276. 1. 1. 42.0 23.0 2.0 1. 12.0 14.0 3. 3. 1.8260860 0. 1. + 2277. 1. 4. 27.0 6.0 0.0 1. 12.0 11.5 3. 4. 0.5833333 0. 1. + 2279. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 5. 4. 1.9478254 0. 1. + 2280. 1. 4. 27.0 9.0 2.0 3. 16.0 20.0 4. 5. 1.3333330 0. 1. + 2281. 1. 2. 32.0 13.0 3.0 3. 20.0 20.0 4. 5. 0.0769231 0. 1. + 2283. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 2. 11.1999998 0. 1. + 2286. 1. 3. 32.0 16.5 3.0 2. 12.0 20.0 3. 2. 0.7272727 0. 1. + 2289. 1. 5. 27.0 6.0 1.0 3. 12.0 14.0 5. 2. 2.0000000 0. 1. + 2290. 1. 3. 27.0 2.5 0.0 1. 12.0 20.0 3. 4. 3.1999998 0. 1. + 2315. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 6. 1.3999996 0. 1. + 2319. 1. 3. 32.0 13.0 0.0 2. 16.0 40.0 4. 5. 0.9230769 0. 1. + 2324. 1. 4. 37.0 16.5 2.0 2. 20.0 40.0 4. 2. 0.7424242 0. 1. + 2330. 1. 4. 27.0 6.0 1.0 2. 17.0 20.0 4. 5. 2.0416660 0. 1. + 2355. 1. 4. 37.0 23.0 4.0 2. 12.0 20.0 3. 2. 0.1521739 0. 1. + 2363. 1. 4. 22.0 2.5 2.0 2. 14.0 9.0 3. 5. 4.8999996 0. 1. + 2381. 1. 3. 27.0 6.0 1.0 3. 17.0 20.0 4. 4. 1.3333330 0. 1. + 2393. 1. 4. 32.0 16.5 3.0 4. 12.0 11.5 3. 5. 1.1878777 0. 1. + 2400. 1. 5. 22.0 6.0 2.0 3. 14.0 20.0 3. 5. 7.4666672 0. 1. + 2407. 1. 4. 32.0 13.0 2.0 3. 14.0 6.5 3. 2. 0.0769231 0. 1. + 2420. 1. 4. 27.0 9.0 1.0 1. 14.0 20.0 2. 5. 1.3611107 0. 1. + 2426. 1. 3. 32.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.7272727 0. 1. + 2432. 1. 4. 27.0 13.0 2.0 2. 12.0 14.0 3. 2. 0.0769231 0. 1. + 2448. 1. 5. 27.0 9.0 1.0 3. 12.0 20.0 2. 3. 0.3888888 0. 1. + 2455. 1. 3. 27.0 9.0 0.0 1. 12.0 20.0 3. 4. 16.0000000 0. 1. + 2511. 1. 4. 27.0 9.0 0.0 3. 14.0 40.0 5. 6. 4.9777775 0. 1. + 2514. 1. 3. 22.0 2.5 0.0 1. 12.0 9.0 3. 2. 7.8399963 0. 1. + 2539. 1. 3. 32.0 13.0 2.0 3. 20.0 20.0 4. 5. 0.0769231 0. 1. + 2541. 1. 4. 42.0 23.0 5.5 2. 14.0 20.0 5. 3. 0.5326087 0. 1. + 2546. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 3. 4. 4.8999996 0. 1. + 2547. 1. 5. 27.0 9.0 1.0 2. 14.0 20.0 4. 5. 0.3888888 0. 1. + 2556. 1. 5. 37.0 13.0 2.0 3. 14.0 40.0 4. 3. 0.2692307 0. 1. + 2575. 1. 5. 27.0 2.5 1.0 3. 16.0 6.5 3. 3. 1.3999996 0. 1. + 2577. 1. 4. 27.0 6.0 0.0 2. 14.0 11.5 3. 2. 0.5833333 0. 1. + 2589. 1. 5. 22.0 2.5 0.0 2. 12.0 6.5 4. 4. 7.8399963 0. 1. + 2590. 1. 5. 27.0 6.0 1.0 3. 12.0 11.5 2. 3. 1.3333330 0. 1. + 2607. 1. 4. 32.0 9.0 2.0 2. 16.0 20.0 5. 5. 1.3333330 0. 1. + 2608. 1. 4. 32.0 6.0 2.0 3. 14.0 20.0 4. 2. 2.0416660 0. 1. + 2609. 1. 2. 22.0 2.5 1.0 2. 17.0 11.5 2. 2. 11.1999998 0. 1. + 2628. 1. 5. 27.0 2.5 0.0 2. 17.0 40.0 5. 5. 4.7999992 0. 1. + 2640. 1. 5. 37.0 16.5 3.0 2. 14.0 14.0 4. 4. 1.1878777 0. 1. + 2642. 1. 3. 27.0 2.5 1.0 3. 14.0 14.0 5. 3. 4.7999992 0. 1. + 2653. 1. 4. 27.0 6.0 1.0 1. 14.0 20.0 3. 4. 0.1666666 0. 1. + 2655. 1. 5. 27.0 6.0 2.0 3. 12.0 20.0 2. 4. 3.2666645 0. 1. + 2666. 1. 4. 42.0 23.0 3.0 2. 12.0 14.0 3. 2. 1.2173910 0. 1. + 2667. 1. 3. 27.0 6.0 2.0 3. 14.0 11.5 3. 5. 0.5833333 0. 1. + 2669. 1. 5. 22.0 6.0 1.0 3. 14.0 14.0 1. 4. 2.0000000 0. 1. + 2670. 1. 5. 37.0 23.0 3.0 2. 12.0 20.0 3. 4. 0.5326087 0. 1. + 2687. 1. 3. 37.0 16.5 3.0 3. 12.0 11.5 3. 4. 1.1878777 0. 1. + 2690. 1. 4. 42.0 23.0 4.0 2. 9.0 11.5 4. 4. 0.5217391 0. 1. + 2699. 1. 4. 42.0 23.0 3.0 3. 12.0 11.5 3. 5. 0.5217391 0. 1. + 2704. 1. 4. 37.0 23.0 2.0 2. 16.0 40.0 4. 6. 0.1521739 0. 1. + 2710. 1. 5. 32.0 16.5 4.0 1. 12.0 11.5 2. 1. 0.4848484 0. 1. + 2719. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 2. 6. 1.3333330 0. 1. + 2757. 1. 3. 32.0 16.5 2.0 2. 12.0 11.5 2. 2. 1.1878777 0. 1. + 2770. 1. 2. 27.0 6.0 1.0 2. 12.0 11.5 3. 2. 0.5833333 0. 1. + 2782. 1. 4. 22.0 2.5 0.0 1. 14.0 20.0 3. 4. 4.7999992 0. 1. + 2808. 1. 3. 22.0 6.0 1.0 2. 14.0 6.5 3. 2. 0.5833333 0. 1. + 2814. 1. 2. 27.0 6.0 0.0 3. 12.0 14.0 3. 3. 0.1666666 0. 1. + 2818. 1. 4. 27.0 6.0 1.0 2. 12.0 14.0 2. 5. 3.2666645 0. 1. + 2821. 1. 3. 22.0 2.5 1.0 1. 12.0 20.0 5. 5. 4.8999996 0. 1. + 2824. 1. 2. 37.0 16.5 3.0 2. 14.0 14.0 3. 5. 1.1878777 0. 1. + 2844. 1. 5. 32.0 13.0 2.0 2. 16.0 40.0 4. 2. 3.2307692 0. 1. + 2846. 1. 5. 22.0 2.5 0.0 1. 12.0 6.5 3. 2. 1.3999996 0. 1. + 2865. 1. 4. 22.0 6.0 1.0 3. 14.0 20.0 4. 1. 0.5833333 0. 1. + 2868. 1. 4. 22.0 0.5 0.0 2. 12.0 20.0 5. 2. 2.0000000 0. 1. + 2877. 1. 3. 27.0 2.5 0.0 2. 20.0 20.0 4. 4. 1.3999996 0. 1. + 2886. 1. 5. 27.0 2.5 0.0 3. 12.0 9.0 2. 2. 1.3999996 0. 1. + 2898. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 1.3999996 0. 1. + 2921. 1. 4. 42.0 16.5 2.0 1. 16.0 40.0 4. 5. 2.7151508 0. 1. + 2929. 1. 5. 32.0 13.0 1.0 2. 12.0 11.5 5. 2. 1.5076914 0. 1. + 2933. 1. 5. 32.0 13.0 3.0 3. 14.0 20.0 3. 5. 0.9230769 0. 1. + 2944. 1. 5. 32.0 2.5 0.0 3. 14.0 14.0 4. 2. 4.7999992 0. 1. + 2955. 1. 3. 32.0 13.0 1.0 1. 16.0 40.0 4. 5. 0.9423077 0. 1. + 2970. 1. 5. 42.0 23.0 2.0 3. 14.0 20.0 5. 6. 1.2173910 0. 1. + 2975. 1. 4. 27.0 6.0 1.0 1. 14.0 20.0 3. 2. 2.0416660 0. 1. + 2978. 1. 3. 37.0 16.5 4.0 3. 12.0 20.0 2. 5. 1.1878777 0. 1. + 2986. 1. 5. 37.0 16.5 2.0 2. 12.0 11.5 2. 4. 0.2121212 0. 1. + 2987. 1. 2. 32.0 9.0 1.0 2. 12.0 11.5 3. 3. 1.3333330 0. 1. + 3004. 1. 2. 32.0 13.0 0.0 2. 14.0 20.0 5. 4. 0.2692307 0. 1. + 3037. 1. 4. 22.0 0.5 0.0 1. 12.0 20.0 3. 4. 2.0000000 0. 1. + 3059. 1. 4. 22.0 6.0 0.0 1. 12.0 20.0 3. 4. 0.1666666 0. 1. + 3079. 1. 3. 37.0 16.5 3.0 3. 12.0 40.0 2. 2. 0.2121212 0. 1. + 3097. 1. 3. 27.0 2.5 0.0 2. 17.0 40.0 4. 5. 3.1999998 0. 1. + 3103. 1. 3. 22.0 2.5 0.0 2. 17.0 20.0 5. 4. 0.4000000 0. 1. + 3104. 1. 4. 32.0 16.5 2.0 2. 14.0 20.0 3. 4. 0.7272727 0. 1. + 3114. 1. 4. 42.0 16.5 2.0 3. 17.0 20.0 5. 6. 0.4848484 0. 1. + 3121. 1. 4. 32.0 16.5 5.5 3. 12.0 11.5 2. 2. 1.1878777 0. 1. + 3124. 1. 3. 32.0 13.0 2.0 3. 14.0 11.5 2. 2. 0.6153846 0. 1. + 3135. 1. 4. 42.0 23.0 2.0 2. 20.0 40.0 4. 5. 0.8521735 0. 1. + 3137. 1. 3. 32.0 9.0 1.0 2. 16.0 20.0 4. 3. 4.6666660 0. 1. + 3143. 1. 4. 22.0 2.5 0.0 2. 14.0 40.0 3. 2. 1.3999996 0. 1. + 3149. 1. 3. 37.0 16.5 3.0 3. 12.0 40.0 3. 3. 5.8181810 0. 1. + 3150. 1. 3. 42.0 23.0 3.0 1. 14.0 40.0 3. 4. 0.5217391 0. 1. + 3154. 1. 1. 32.0 16.5 3.0 3. 12.0 20.0 4. 2. 0.7424242 0. 1. + 3155. 1. 2. 37.0 16.5 5.5 2. 12.0 11.5 2. 5. 2.5454540 0. 1. + 3163. 1. 5. 32.0 9.0 0.0 3. 12.0 20.0 3. 5. 2.1777763 0. 1. + 3164. 1. 2. 32.0 16.5 4.0 2. 14.0 20.0 3. 5. 2.7151508 0. 1. + 3169. 1. 3. 22.0 2.5 0.0 2. 17.0 6.5 4. 1. 16.7999878 0. 1. + 3172. 1. 5. 32.0 2.5 0.0 2. 16.0 40.0 5. 5. 4.8999996 0. 1. + 3174. 1. 3. 27.0 6.0 1.0 1. 17.0 14.0 4. 5. 0.1666666 0. 1. + 3203. 1. 4. 27.0 6.0 0.0 1. 17.0 20.0 4. 1. 3.2666645 0. 1. + 3205. 1. 3. 37.0 16.5 2.0 2. 14.0 20.0 4. 2. 0.2121212 0. 1. + 3257. 1. 4. 37.0 16.5 2.0 1. 14.0 20.0 3. 3. 0.2121212 0. 1. + 3269. 1. 5. 42.0 23.0 2.0 3. 14.0 14.0 3. 4. 0.5217391 0. 1. + 3271. 1. 4. 32.0 13.0 2.0 1. 17.0 40.0 4. 2. 0.9230769 0. 1. + 3284. 1. 3. 27.0 9.0 0.0 1. 14.0 14.0 3. 5. 4.9777775 0. 1. + 3302. 1. 3. 32.0 13.0 2.0 1. 12.0 40.0 3. 6. 0.9423077 0. 1. + 3303. 1. 3. 27.0 6.0 2.0 3. 17.0 20.0 4. 6. 2.0416660 0. 1. + 3311. 1. 2. 37.0 16.5 3.0 2. 12.0 14.0 2. 4. 0.7272727 0. 1. + 3315. 1. 2. 22.0 6.0 2.0 1. 14.0 11.5 3. 4. 0.1666666 0. 1. + 3341. 1. 3. 17.5 2.5 1.0 3. 12.0 6.5 4. 2. 4.8999996 0. 1. + 3356. 1. 3. 27.0 6.0 3.0 2. 14.0 20.0 2. 2. 0.1666666 0. 1. + 3359. 1. 3. 22.0 2.5 0.0 1. 12.0 20.0 2. 5. 1.3999996 0. 1. + 3363. 1. 4. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 1.8260860 0. 1. + 3364. 1. 2. 27.0 6.0 2.0 3. 14.0 14.0 3. 3. 2.0000000 0. 1. + 3380. 1. 4. 32.0 16.5 5.5 2. 14.0 20.0 3. 2. 2.5454540 0. 1. + 3413. 1. 4. 27.0 2.5 0.0 3. 12.0 14.0 3. 5. 0.4000000 0. 1. + 3420. 1. 4. 27.0 6.0 2.0 3. 12.0 14.0 3. 2. 2.0000000 0. 1. + 3428. 1. 4. 27.0 2.5 0.0 3. 16.0 20.0 4. 5. 4.7999992 0. 1. + 3442. 1. 5. 27.0 6.0 0.0 1. 16.0 11.5 4. 5. 4.6666660 0. 1. + 3454. 1. 2. 22.0 6.0 2.0 2. 12.0 20.0 2. 3. 0.5833333 0. 1. + 3471. 1. 3. 27.0 2.5 0.0 1. 20.0 20.0 4. 4. 4.7999992 0. 1. + 3475. 1. 4. 32.0 16.5 3.0 3. 14.0 20.0 3. 5. 0.7272727 0. 1. + 3493. 1. 5. 32.0 13.0 1.0 3. 17.0 20.0 4. 4. 0.9423077 0. 1. + 3494. 1. 3. 22.0 2.5 1.0 2. 12.0 6.5 2. 4. 7.8399963 0. 1. + 3513. 1. 4. 22.0 2.5 0.0 1. 14.0 20.0 3. 3. 1.3999996 0. 1. + 3518. 1. 5. 32.0 9.0 2.0 3. 16.0 20.0 4. 4. 1.3333330 0. 1. + 3525. 1. 5. 32.0 2.5 0.0 3. 14.0 20.0 5. 4. 0.4000000 0. 1. + 3541. 1. 5. 27.0 9.0 2.0 1. 14.0 14.0 2. 4. 1.3333330 0. 1. + 3545. 1. 4. 32.0 9.0 1.0 2. 14.0 20.0 5. 5. 0.8888888 0. 1. + 3546. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 1.3999996 0. 1. + 3555. 1. 4. 42.0 23.0 1.0 3. 12.0 14.0 3. 3. 2.9217386 0. 1. + 3558. 1. 4. 27.0 9.0 2.0 2. 16.0 20.0 4. 4. 1.3333330 0. 1. + 3561. 1. 4. 32.0 16.5 3.0 2. 17.0 11.5 4. 2. 0.4848484 0. 1. + 3563. 1. 4. 27.0 6.0 2.0 2. 16.0 9.0 4. 5. 7.4666672 0. 1. + 3574. 1. 4. 37.0 16.5 2.0 2. 14.0 20.0 4. 5. 0.7272727 0. 1. + 3590. 1. 5. 27.0 6.0 1.0 3. 16.0 14.0 4. 4. 4.6666660 0. 1. + 3596. 1. 2. 27.0 6.0 1.0 2. 12.0 6.5 2. 2. 4.6666660 0. 1. + 3604. 1. 4. 22.0 2.5 1.0 1. 12.0 11.5 2. 2. 3.1999998 0. 1. + 3605. 1. 3. 37.0 13.0 1.0 2. 12.0 11.5 3. 2. 0.9423077 0. 1. + 3627. 1. 4. 42.0 23.0 2.0 2. 14.0 20.0 3. 5. 0.1521739 0. 1. + 3634. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 3. 2. 0.4000000 0. 1. + 3639. 1. 3. 42.0 23.0 2.0 1. 17.0 40.0 4. 6. 4.1739130 0. 1. + 3649. 1. 4. 32.0 16.5 2.0 3. 12.0 14.0 3. 4. 0.7272727 0. 1. + 3664. 1. 1. 32.0 16.5 3.0 3. 14.0 20.0 3. 4. 0.0606061 0. 1. + 3670. 1. 5. 27.0 13.0 2.0 3. 12.0 20.0 3. 2. 0.9230769 0. 1. + 3671. 1. 3. 27.0 6.0 0.0 1. 17.0 40.0 5. 4. 3.2666645 0. 1. + 3711. 1. 5. 42.0 23.0 5.5 2. 14.0 14.0 4. 4. 0.5326087 0. 1. + 3717. 1. 4. 32.0 16.5 1.0 3. 16.0 14.0 4. 5. 0.0606061 0. 1. + 3728. 1. 2. 22.0 2.5 0.0 1. 12.0 11.5 3. 2. 4.7999992 0. 1. + 3729. 1. 2. 42.0 23.0 1.0 3. 14.0 9.0 4. 2. 0.5326087 0. 1. + 3733. 1. 2. 22.0 6.0 0.0 2. 12.0 11.5 3. 4. 0.5833333 0. 1. + 3737. 1. 4. 27.0 6.0 0.0 1. 16.0 20.0 5. 1. 0.5833333 0. 1. + 3740. 1. 4. 42.0 23.0 1.0 4. 17.0 20.0 3. 2. 1.8260860 0. 1. + 3754. 1. 5. 42.0 23.0 2.0 1. 12.0 20.0 3. 2. 0.3478261 0. 1. + 3772. 1. 4. 27.0 6.0 2.0 2. 16.0 40.0 4. 2. 2.0000000 0. 1. + 3779. 1. 3. 22.0 2.5 0.0 1. 12.0 20.0 3. 2. 1.3999996 0. 1. + 3784. 1. 3. 27.0 13.0 3.0 2. 14.0 14.0 5. 5. 3.4461536 0. 1. + 3800. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 4. 5. 2.1538458 0. 1. + 3810. 1. 4. 27.0 9.0 3.0 3. 14.0 20.0 4. 3. 0.3888888 0. 1. + 3822. 1. 3. 32.0 9.0 1.0 2. 14.0 14.0 3. 4. 0.3888888 0. 1. + 3824. 1. 3. 27.0 9.0 2.0 1. 14.0 14.0 4. 2. 1.3333330 0. 1. + 3836. 1. 5. 37.0 16.5 5.5 3. 12.0 11.5 2. 2. 1.1878777 0. 1. + 3844. 1. 3. 27.0 6.0 1.0 4. 14.0 11.5 3. 5. 4.6666660 0. 1. + 3860. 1. 2. 27.0 9.0 1.0 1. 14.0 20.0 5. 3. 4.6666660 0. 1. + 3875. 1. 4. 27.0 2.5 0.0 2. 17.0 40.0 4. 6. 7.8399963 0. 1. + 3882. 1. 4. 32.0 13.0 1.0 1. 20.0 11.5 4. 4. 1.5076914 0. 1. + 3889. 1. 1. 42.0 23.0 4.0 3. 12.0 40.0 3. 4. 1.9478254 0. 1. + 3897. 1. 4. 32.0 16.5 1.0 1. 14.0 20.0 5. 5. 0.7424242 0. 1. + 3899. 1. 1. 42.0 23.0 5.5 2. 12.0 11.5 2. 2. 0.5217391 0. 1. + 3940. 1. 4. 37.0 13.0 1.0 2. 12.0 20.0 3. 5. 1.5076914 0. 1. + 3943. 1. 4. 32.0 16.5 2.0 2. 14.0 40.0 5. 5. 1.1878777 0. 1. + 3944. 1. 4. 42.0 23.0 3.0 2. 14.0 20.0 4. 4. 0.0434783 0. 1. + 3946. 1. 5. 27.0 6.0 1.0 3. 14.0 20.0 3. 6. 2.0416660 0. 1. + 3950. 1. 3. 37.0 16.5 4.0 3. 12.0 20.0 3. 2. 0.7272727 0. 1. + 3961. 1. 3. 37.0 23.0 3.0 3. 9.0 6.5 4. 2. 0.1521739 0. 1. + 3963. 1. 4. 37.0 16.5 2.0 2. 12.0 11.5 3. 4. 2.5454540 0. 1. + 3967. 1. 3. 27.0 6.0 2.0 1. 14.0 11.5 4. 5. 1.3333330 0. 1. + 3971. 1. 4. 37.0 13.0 0.0 3. 12.0 14.0 3. 2. 1.5076914 0. 1. + 3975. 1. 2. 27.0 2.5 1.0 3. 16.0 20.0 4. 4. 4.8999996 0. 1. + 3977. 1. 4. 42.0 23.0 5.5 3. 12.0 40.0 5. 5. 0.5326087 0. 1. + 3978. 1. 3. 32.0 16.5 3.0 2. 12.0 20.0 2. 2. 0.7424242 0. 1. + 4001. 1. 4. 37.0 16.5 3.0 2. 12.0 40.0 5. 2. 0.2121212 0. 1. + 4012. 1. 3. 42.0 13.0 0.0 3. 12.0 14.0 4. 4. 0.9230769 0. 1. + 4025. 1. 4. 37.0 13.0 4.0 3. 14.0 11.5 4. 2. 0.6153846 0. 1. + 4041. 1. 2. 32.0 16.5 4.0 2. 14.0 40.0 5. 4. 1.1878777 0. 1. + 4047. 1. 3. 27.0 13.0 2.0 1. 14.0 20.0 4. 4. 2.1538458 0. 1. + 4053. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 4. 5. 0.4000000 0. 1. + 4063. 1. 4. 22.0 2.5 1.0 2. 14.0 14.0 4. 5. 0.4000000 0. 1. + 4083. 1. 3. 32.0 2.5 0.0 1. 16.0 40.0 4. 5. 17.9199982 0. 1. + 4088. 1. 5. 27.0 6.0 2.0 3. 14.0 14.0 3. 5. 3.2666645 0. 1. + 4091. 1. 5. 32.0 16.5 3.0 4. 12.0 20.0 2. 3. 0.0606061 0. 1. + 4097. 1. 2. 42.0 23.0 2.0 3. 16.0 40.0 4. 5. 0.5217391 0. 1. + 4099. 1. 5. 22.0 6.0 2.0 3. 14.0 20.0 2. 4. 0.5833333 0. 1. + 4100. 1. 5. 42.0 23.0 2.0 1. 14.0 40.0 4. 5. 0.0434783 0. 1. + 4121. 1. 4. 22.0 6.0 0.0 2. 14.0 20.0 3. 3. 0.5833333 0. 1. + 4130. 1. 3. 32.0 16.5 4.0 3. 14.0 20.0 3. 4. 0.7272727 0. 1. + 4146. 1. 3. 32.0 16.5 2.0 2. 14.0 20.0 3. 5. 0.7272727 0. 1. + 4158. 1. 4. 42.0 16.5 1.0 3. 17.0 20.0 4. 5. 0.7272727 0. 1. + 4168. 1. 1. 37.0 16.5 3.0 2. 12.0 11.5 3. 5. 0.2121212 0. 1. + 4192. 1. 3. 32.0 13.0 1.0 3. 20.0 11.5 4. 4. 0.0769231 0. 1. + 4201. 1. 3. 27.0 2.5 0.0 3. 14.0 20.0 5. 5. 1.3999996 0. 1. + 4206. 1. 5. 22.0 2.5 2.0 1. 14.0 20.0 5. 4. 16.7999878 0. 1. + 4209. 1. 3. 42.0 23.0 5.5 3. 12.0 6.5 3. 2. 0.5217391 0. 1. + 4220. 1. 4. 27.0 9.0 2.0 3. 12.0 9.0 2. 2. 0.3888888 0. 1. + 4226. 1. 3. 32.0 16.5 2.0 3. 12.0 14.0 2. 4. 1.1878777 0. 1. + 4233. 1. 4. 32.0 16.5 3.0 2. 14.0 20.0 3. 4. 2.5454540 0. 1. + 4252. 1. 3. 27.0 2.5 2.0 2. 16.0 9.0 4. 4. 1.3999996 0. 1. + 4269. 1. 4. 32.0 6.0 2.0 2. 14.0 40.0 4. 4. 4.6666660 0. 1. + 4275. 1. 1. 42.0 23.0 2.0 1. 12.0 6.5 2. 3. 1.9478254 0. 1. + 4277. 1. 4. 22.0 2.5 0.0 2. 16.0 11.5 5. 1. 3.1999998 0. 1. + 4283. 1. 3. 22.0 6.0 0.0 2. 12.0 20.0 3. 4. 2.0000000 0. 1. + 4285. 1. 2. 42.0 23.0 5.5 3. 17.0 20.0 4. 4. 2.9217386 0. 1. + 4293. 1. 3. 27.0 13.0 2.0 2. 12.0 14.0 2. 4. 3.2307692 0. 1. + 4294. 1. 4. 27.0 9.0 2.0 3. 12.0 11.5 2. 2. 0.3888888 0. 1. + 4298. 1. 5. 32.0 16.5 3.0 3. 17.0 40.0 4. 4. 2.5454540 0. 1. + 4302. 1. 5. 32.0 16.5 2.0 1. 14.0 40.0 4. 6. 0.0606061 0. 1. + 4312. 1. 5. 32.0 16.5 3.0 3. 14.0 20.0 2. 5. 1.1878777 0. 1. + 4313. 1. 3. 27.0 9.0 2.0 2. 12.0 20.0 2. 3. 1.3611107 0. 1. + 4315. 1. 2. 27.0 6.0 1.0 3. 12.0 9.0 4. 4. 0.5833333 0. 1. + 4316. 1. 4. 22.0 2.5 2.0 2. 12.0 9.0 5. 2. 7.8399963 0. 1. + 4317. 1. 5. 27.0 6.0 2.0 4. 20.0 11.5 4. 4. 3.2666645 0. 1. + 4334. 1. 3. 22.0 2.5 0.0 2. 14.0 20.0 3. 2. 4.7999992 0. 1. + 4338. 1. 2. 32.0 9.0 0.0 1. 16.0 40.0 5. 4. 7.4666662 0. 1. + 4356. 1. 4. 37.0 16.5 2.0 3. 16.0 11.5 3. 6. 0.7272727 0. 1. + 4373. 1. 4. 42.0 23.0 2.0 3. 12.0 14.0 3. 2. 1.2173910 0. 1. + 4377. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 7.8399963 0. 1. + 4378. 1. 5. 32.0 9.0 1.0 2. 14.0 11.5 2. 4. 1.3333330 0. 1. + 4393. 1. 4. 37.0 16.5 2.0 3. 12.0 11.5 3. 6. 0.4848484 0. 1. + 4406. 1. 3. 22.0 2.5 0.0 3. 12.0 20.0 3. 4. 1.3999996 0. 1. + 4419. 1. 4. 37.0 16.5 4.0 2. 12.0 20.0 3. 5. 0.7272727 0. 1. + 4422. 1. 4. 27.0 2.5 0.0 3. 17.0 14.0 4. 1. 1.3999996 0. 1. + 4424. 1. 3. 27.0 6.0 0.0 1. 14.0 20.0 3. 5. 2.0416660 0. 1. + 4432. 1. 5. 32.0 16.5 2.0 2. 20.0 20.0 4. 4. 0.7424242 0. 1. + 4443. 1. 2. 22.0 2.5 1.0 2. 12.0 6.5 5. 5. 0.4000000 0. 1. + 4466. 1. 4. 42.0 16.5 2.0 1. 14.0 9.0 5. 4. 0.7424242 0. 1. + 4483. 1. 5. 42.0 13.0 3.0 4. 14.0 14.0 2. 2. 1.5076914 0. 1. + 4485. 1. 5. 32.0 13.0 1.0 3. 16.0 14.0 6. 6. 0.2692307 0. 1. + 4487. 1. 5. 37.0 13.0 0.0 1. 14.0 40.0 4. 5. 0.0769231 0. 1. + 4490. 1. 2. 22.0 6.0 0.0 1. 20.0 11.5 6. 4. 3.2666645 0. 1. + 4498. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 3. 4. 4.8999996 0. 1. + 4537. 1. 4. 32.0 16.5 1.0 2. 12.0 20.0 3. 4. 0.7272727 0. 1. + 4551. 1. 4. 27.0 6.0 2.0 2. 12.0 14.0 2. 2. 1.3333330 0. 1. + 4553. 1. 2. 37.0 16.5 2.0 2. 12.0 40.0 3. 3. 0.7272727 0. 1. + 4559. 1. 3. 22.0 6.0 2.0 3. 12.0 11.5 3. 2. 3.2666645 0. 1. + 4563. 1. 4. 27.0 13.0 2.0 2. 16.0 40.0 4. 5. 3.2307692 0. 1. + 4569. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 2. 5. 2.0000000 0. 1. + 4594. 1. 4. 17.5 0.5 0.0 3. 14.0 9.0 3. 4. 7.0000000 0. 1. + 4605. 1. 5. 27.0 2.5 0.0 2. 17.0 11.5 5. 1. 7.8399963 0. 1. + 4608. 1. 5. 27.0 9.0 1.0 3. 14.0 9.0 3. 4. 1.3333330 0. 1. + 4617. 1. 2. 22.0 2.5 1.0 3. 12.0 14.0 2. 2. 4.7999992 0. 1. + 4620. 1. 4. 42.0 23.0 5.5 3. 9.0 14.0 2. 4. 0.8521735 0. 1. + 4630. 1. 3. 32.0 16.5 3.0 3. 14.0 11.5 4. 5. 1.6969690 0. 1. + 4632. 1. 4. 37.0 13.0 1.0 1. 12.0 20.0 5. 5. 0.9423077 0. 1. + 4651. 1. 2. 32.0 16.5 3.0 2. 12.0 20.0 3. 5. 0.7272727 0. 1. + 4677. 1. 4. 32.0 13.0 2.0 2. 14.0 40.0 2. 5. 0.2692307 0. 1. + 4686. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 1. 1. 0.4000000 0. 1. + 4695. 1. 5. 22.0 2.5 0.0 2. 12.0 6.5 3. 2. 4.8999996 0. 1. + 4707. 1. 4. 32.0 16.5 3.0 2. 12.0 20.0 4. 2. 1.1878777 0. 1. + 4710. 1. 4. 37.0 16.5 3.0 2. 12.0 14.0 3. 3. 0.2121212 0. 1. + 4726. 1. 5. 42.0 23.0 4.0 3. 14.0 40.0 5. 5. 0.5217391 0. 1. + 4729. 1. 5. 27.0 9.0 2.0 1. 9.0 20.0 3. 4. 0.3888888 0. 1. + 4738. 1. 5. 32.0 9.0 0.0 2. 17.0 20.0 3. 2. 0.1111111 0. 1. + 4742. 1. 2. 42.0 23.0 3.0 4. 12.0 20.0 4. 5. 0.1521739 0. 1. + 4749. 1. 4. 42.0 23.0 2.0 3. 12.0 20.0 3. 2. 0.5217391 0. 1. + 4783. 1. 5. 27.0 6.0 0.0 3. 14.0 20.0 3. 4. 1.3333330 0. 1. + 4784. 1. 4. 22.0 6.0 0.0 3. 14.0 14.0 3. 3. 0.1666666 0. 1. + 4786. 1. 2. 32.0 16.5 5.5 2. 12.0 11.5 3. 2. 2.7151508 0. 1. + 4790. 1. 4. 22.0 2.5 1.0 2. 14.0 14.0 2. 4. 3.1999998 0. 1. + 4795. 1. 5. 37.0 23.0 4.0 3. 12.0 40.0 3. 3. 0.5326087 0. 1. + 4799. 1. 4. 32.0 13.0 3.0 2. 12.0 20.0 3. 5. 0.2692307 0. 1. + 4813. 1. 4. 32.0 16.5 2.0 2. 12.0 11.5 3. 4. 1.1878777 0. 1. + 4817. 1. 4. 27.0 6.0 1.0 2. 17.0 14.0 3. 5. 0.5833333 0. 1. + 4823. 1. 2. 27.0 13.0 2.0 3. 12.0 20.0 5. 5. 3.2307692 0. 1. + 4829. 1. 4. 37.0 16.5 2.0 2. 14.0 20.0 4. 5. 1.1878777 0. 1. + 4835. 1. 4. 27.0 6.0 0.0 4. 16.0 20.0 4. 6. 3.2666645 0. 1. + 4838. 1. 4. 37.0 23.0 3.0 3. 12.0 20.0 5. 3. 0.1521739 0. 1. + 4843. 1. 3. 27.0 2.5 0.0 1. 14.0 20.0 4. 6. 38.3999939 0. 1. + 4857. 1. 3. 27.0 9.0 1.0 2. 12.0 20.0 3. 4. 2.1777763 0. 1. + 4860. 1. 2. 37.0 23.0 4.0 2. 12.0 20.0 5. 2. 0.1521739 0. 1. + 4870. 1. 3. 37.0 23.0 3.0 3. 12.0 14.0 2. 2. 0.8521735 0. 1. + 4871. 1. 3. 32.0 13.0 2.0 3. 17.0 11.5 4. 4. 0.0769231 0. 1. + 4881. 1. 2. 37.0 16.5 4.0 3. 12.0 14.0 2. 4. 1.1878777 0. 1. + 4885. 1. 4. 27.0 9.0 2.0 3. 12.0 11.5 3. 3. 1.3333330 0. 1. + 4888. 1. 4. 42.0 23.0 3.0 3. 12.0 11.5 2. 2. 0.8521735 0. 1. + 4895. 1. 5. 42.0 23.0 3.0 3. 14.0 20.0 3. 5. 0.5326087 0. 1. + 4897. 1. 2. 27.0 6.0 0.0 2. 12.0 40.0 3. 5. 2.0000000 0. 1. + 4903. 1. 1. 27.0 2.5 0.0 2. 16.0 6.5 3. 1. 4.7999992 0. 1. + 4907. 1. 5. 32.0 16.5 2.0 1. 12.0 40.0 3. 3. 0.2121212 0. 1. + 4913. 1. 4. 32.0 16.5 3.0 2. 14.0 40.0 4. 5. 2.5454540 0. 1. + 4924. 1. 3. 22.0 6.0 0.0 2. 12.0 4.0 2. 2. 0.1666666 0. 1. + 4935. 1. 3. 27.0 2.5 2.0 2. 14.0 11.5 4. 4. 0.4000000 0. 1. + 4937. 1. 3. 42.0 23.0 1.0 3. 14.0 40.0 3. 2. 0.3478261 0. 1. + 4943. 1. 5. 42.0 23.0 4.0 2. 14.0 20.0 3. 5. 0.1521739 0. 1. + 4950. 1. 1. 27.0 6.0 2.0 2. 14.0 11.5 2. 3. 0.5833333 0. 1. + 4959. 1. 4. 32.0 13.0 2.0 2. 12.0 11.5 2. 5. 0.2692307 0. 1. + 4964. 1. 4. 32.0 13.0 2.0 1. 12.0 20.0 5. 5. 0.9423077 0. 1. + 4969. 1. 5. 32.0 16.5 3.0 2. 12.0 14.0 2. 4. 0.0606061 0. 1. + 4975. 1. 5. 42.0 23.0 2.0 1. 20.0 40.0 4. 3. 0.1521739 0. 1. + 4976. 1. 4. 27.0 9.0 2.0 2. 12.0 11.5 3. 4. 1.3333330 0. 1. + 4979. 1. 4. 37.0 16.5 3.0 3. 16.0 20.0 3. 2. 2.7151508 0. 1. + 4980. 1. 5. 37.0 16.5 5.5 1. 16.0 40.0 4. 4. 0.7272727 0. 1. + 4988. 1. 3. 42.0 9.0 2.0 1. 12.0 9.0 4. 4. 0.8888888 0. 1. + 5014. 1. 4. 27.0 6.0 1.0 3. 14.0 14.0 4. 3. 0.5833333 0. 1. + 5020. 1. 3. 27.0 9.0 2.0 3. 12.0 11.5 2. 4. 2.1777763 0. 1. + 5024. 1. 4. 27.0 6.0 2.0 2. 16.0 20.0 5. 5. 3.2666645 0. 1. + 5032. 1. 4. 37.0 16.5 4.0 3. 14.0 40.0 4. 5. 2.7151508 0. 1. + 5033. 1. 4. 32.0 16.5 3.0 3. 14.0 14.0 3. 4. 1.1878777 0. 1. + 5045. 1. 4. 27.0 6.0 1.0 2. 16.0 20.0 3. 5. 0.1666666 0. 1. + 5046. 1. 5. 42.0 23.0 2.0 2. 12.0 9.0 4. 4. 0.8521735 0. 1. + 5047. 1. 4. 32.0 13.0 1.0 3. 14.0 14.0 3. 2. 0.9423077 0. 1. + 5060. 1. 2. 27.0 6.0 1.0 2. 12.0 14.0 3. 2. 0.5833333 0. 1. + 5098. 1. 3. 22.0 2.5 0.0 2. 12.0 9.0 3. 4. 0.4000000 0. 1. + 5104. 1. 3. 27.0 6.0 0.0 2. 17.0 20.0 2. 4. 4.6666660 0. 1. + 5108. 1. 5. 37.0 23.0 4.0 2. 12.0 20.0 3. 5. 0.3478261 0. 1. + 5109. 1. 3. 32.0 16.5 3.0 4. 12.0 40.0 5. 4. 2.5454540 0. 1. + 5131. 1. 4. 22.0 2.5 0.0 2. 12.0 6.5 2. 2. 4.8999996 0. 1. + 5132. 1. 2. 22.0 6.0 2.0 3. 12.0 20.0 5. 3. 7.4666672 0. 1. + 5146. 1. 4. 27.0 9.0 2.0 3. 14.0 14.0 3. 2. 0.1111111 0. 1. + 5150. 1. 4. 22.0 2.5 0.0 1. 20.0 20.0 6. 5. 1.3999996 0. 1. + 5152. 1. 3. 42.0 23.0 5.5 4. 12.0 20.0 2. 5. 0.1521739 0. 1. + 5157. 1. 3. 42.0 23.0 3.0 2. 20.0 40.0 6. 5. 0.5217391 0. 1. + 5166. 1. 3. 22.0 2.5 1.0 3. 12.0 11.5 3. 2. 3.1999998 0. 1. + 5186. 1. 4. 32.0 9.0 2.0 2. 14.0 11.5 3. 5. 1.3333330 0. 1. + 5195. 1. 3. 32.0 16.5 1.0 3. 12.0 14.0 3. 4. 0.4848484 0. 1. + 5205. 1. 3. 27.0 6.0 2.0 1. 14.0 14.0 3. 3. 11.1999989 0. 1. + 5207. 1. 3. 27.0 6.0 1.0 3. 14.0 20.0 3. 4. 0.1666666 0. 1. + 5210. 1. 4. 37.0 16.5 3.0 1. 14.0 40.0 5. 5. 0.0606061 0. 1. + 5214. 1. 4. 32.0 13.0 2.0 2. 16.0 20.0 5. 6. 0.2692307 0. 1. + 5222. 1. 3. 22.0 2.5 0.0 1. 17.0 11.5 4. 4. 1.3999996 0. 1. + 5225. 1. 3. 27.0 6.0 0.0 3. 14.0 20.0 3. 4. 3.2666645 0. 1. + 5254. 1. 3. 42.0 23.0 3.0 2. 14.0 40.0 5. 6. 1.8260860 0. 1. + 5255. 1. 5. 32.0 13.0 3.0 3. 14.0 11.5 2. 2. 0.0769231 0. 1. + 5264. 1. 5. 27.0 2.5 1.0 2. 14.0 9.0 3. 4. 3.1999998 0. 1. + 5267. 1. 3. 27.0 9.0 3.0 1. 14.0 20.0 3. 4. 1.3333330 0. 1. + 5268. 1. 2. 22.0 2.5 0.0 2. 12.0 20.0 3. 4. 16.7999878 0. 1. + 5299. 1. 1. 42.0 23.0 5.5 2. 12.0 20.0 5. 5. 0.5326087 0. 1. + 5302. 1. 3. 22.0 2.5 0.0 1. 14.0 11.5 2. 4. 0.4000000 0. 1. + 5314. 1. 4. 27.0 2.5 0.0 1. 17.0 40.0 5. 6. 4.8999996 0. 1. + 5320. 1. 5. 27.0 6.0 0.0 2. 16.0 20.0 3. 5. 2.0416660 0. 1. + 5325. 1. 3. 27.0 6.0 1.0 2. 14.0 11.5 4. 4. 2.0416660 0. 1. + 5335. 1. 2. 42.0 23.0 1.0 1. 14.0 20.0 3. 4. 0.5217391 0. 1. + 5363. 1. 4. 27.0 6.0 0.0 4. 14.0 20.0 3. 4. 7.4666672 0. 1. + 5366. 1. 3. 22.0 6.0 1.0 1. 14.0 14.0 3. 4. 2.0416660 0. 1. + 5384. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 1.3999996 0. 1. + 5426. 1. 3. 27.0 2.5 4.0 2. 14.0 20.0 3. 2. 16.7999878 0. 1. + 5436. 1. 4. 27.0 6.0 3.0 2. 14.0 11.5 2. 4. 2.0000000 0. 1. + 5445. 1. 3. 32.0 16.5 2.0 3. 14.0 20.0 3. 5. 1.6969690 0. 1. + 5463. 1. 5. 22.0 2.5 0.0 3. 14.0 40.0 3. 6. 7.8399963 0. 1. + 5465. 1. 5. 32.0 13.0 1.0 2. 14.0 40.0 3. 5. 0.9230769 0. 1. + 5492. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 2. 4.7999992 0. 1. + 5510. 1. 3. 32.0 13.0 2.0 1. 14.0 20.0 3. 5. 0.9230769 0. 1. + 5542. 1. 1. 37.0 23.0 4.0 2. 12.0 40.0 2. 2. 0.5217391 0. 1. + 5545. 1. 2. 22.0 2.5 1.0 3. 14.0 4.0 4. 4. 0.4000000 0. 1. + 5548. 1. 4. 42.0 23.0 3.0 4. 12.0 14.0 3. 4. 1.8260860 0. 1. + 5550. 1. 4. 27.0 6.0 2.0 2. 14.0 11.5 5. 5. 2.0416660 0. 1. + 5551. 1. 5. 37.0 16.5 2.0 4. 16.0 20.0 3. 4. 0.0606061 0. 1. + 5552. 1. 4. 22.0 6.0 0.0 3. 12.0 14.0 3. 3. 2.0416660 0. 1. + 5570. 1. 3. 32.0 16.5 3.0 2. 14.0 20.0 5. 3. 0.2121212 0. 1. + 5578. 1. 4. 27.0 9.0 3.0 3. 12.0 20.0 3. 4. 2.1777763 0. 1. + 5593. 1. 5. 27.0 6.0 0.0 1. 16.0 20.0 4. 4. 0.1666666 0. 1. + 5600. 1. 2. 22.0 6.0 3.0 3. 12.0 6.5 3. 2. 3.2666645 0. 1. + 5607. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 4. 5. 0.4000000 0. 1. + 5608. 1. 5. 42.0 23.0 4.0 4. 14.0 14.0 1. 6. 0.8521735 0. 1. + 5619. 1. 4. 32.0 9.0 1.0 1. 16.0 20.0 4. 5. 2.1777763 0. 1. + 5644. 1. 4. 22.0 2.5 2.0 3. 12.0 20.0 2. 2. 11.1999998 0. 1. + 5653. 1. 3. 42.0 23.0 5.5 3. 14.0 20.0 3. 5. 0.8521735 0. 1. + 5654. 1. 3. 22.0 2.5 1.0 1. 12.0 20.0 5. 4. 4.7999992 0. 1. + 5658. 1. 5. 27.0 9.0 2.0 2. 17.0 20.0 2. 2. 2.1777763 0. 1. + 5670. 1. 3. 22.0 2.5 0.0 1. 12.0 9.0 2. 4. 3.1999998 0. 1. + 5674. 1. 4. 32.0 13.0 1.0 2. 12.0 20.0 3. 3. 0.2692307 0. 1. + 5677. 1. 4. 37.0 16.5 1.0 2. 12.0 20.0 3. 4. 4.0727262 0. 1. + 5700. 1. 5. 32.0 9.0 3.0 2. 17.0 20.0 4. 6. 0.1111111 0. 1. + 5714. 1. 4. 27.0 9.0 1.0 2. 12.0 11.5 2. 3. 1.3333330 0. 1. + 5740. 1. 3. 27.0 2.5 1.0 3. 14.0 20.0 3. 2. 4.8999996 0. 1. + 5747. 1. 2. 22.0 2.5 1.0 2. 16.0 14.0 4. 3. 1.3999996 0. 1. + 5752. 1. 1. 42.0 16.5 5.5 3. 14.0 20.0 5. 5. 0.7424242 0. 1. + 5768. 1. 3. 27.0 13.0 2.0 2. 9.0 11.5 2. 4. 0.2692307 0. 1. + 5769. 1. 4. 42.0 23.0 3.0 4. 14.0 11.5 3. 2. 0.5217391 0. 1. + 5783. 1. 3. 27.0 9.0 2.0 2. 12.0 20.0 3. 4. 7.4666662 0. 1. + 5792. 1. 3. 27.0 6.0 2.0 2. 14.0 6.5 3. 1. 2.0416660 0. 1. + 5818. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.4000000 0. 1. + 5821. 1. 3. 27.0 2.5 0.0 3. 16.0 20.0 3. 5. 3.1999998 0. 1. + 5833. 1. 3. 22.0 2.5 0.0 3. 16.0 20.0 4. 2. 0.4000000 0. 1. + 5842. 1. 3. 42.0 23.0 3.0 1. 12.0 20.0 3. 3. 2.9217386 0. 1. + 5854. 1. 5. 42.0 23.0 2.0 2. 12.0 14.0 2. 5. 0.1521739 0. 1. + 5880. 1. 4. 27.0 2.5 0.0 1. 17.0 40.0 4. 4. 4.8999996 0. 1. + 5891. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.1666666 0. 1. + 5894. 1. 4. 32.0 16.5 4.0 2. 14.0 20.0 4. 4. 0.7272727 0. 1. + 5897. 1. 4. 27.0 6.0 0.0 3. 12.0 14.0 3. 2. 3.2666645 0. 1. + 5903. 1. 4. 32.0 9.0 2.0 2. 14.0 20.0 3. 4. 2.1777763 0. 1. + 6002. 1. 3. 27.0 9.0 2.0 1. 14.0 20.0 3. 4. 0.8888888 0. 1. + 6006. 1. 3. 27.0 2.5 1.0 2. 16.0 20.0 2. 2. 1.3999996 0. 1. + 6008. 1. 5. 27.0 13.0 2.0 2. 9.0 14.0 2. 4. 0.9230769 0. 1. + 6014. 1. 2. 27.0 13.0 2.0 2. 12.0 20.0 3. 4. 1.5076914 0. 1. + 6025. 1. 3. 42.0 16.5 4.0 2. 14.0 40.0 3. 5. 0.2121212 0. 1. + 6030. 1. 3. 32.0 9.0 2.0 1. 14.0 11.5 3. 2. 1.3611107 0. 1. + 6032. 1. 5. 32.0 13.0 0.0 2. 12.0 40.0 3. 5. 0.2692307 0. 1. + 6050. 1. 1. 27.0 9.0 2.0 2. 12.0 11.5 2. 4. 2.1777763 0. 1. + 6051. 1. 3. 32.0 13.0 3.0 2. 12.0 11.5 3. 2. 0.9423077 0. 1. + 6066. 1. 5. 27.0 2.5 0.0 3. 14.0 40.0 5. 5. 1.3999996 0. 1. + 6070. 1. 4. 32.0 6.0 1.0 1. 16.0 14.0 4. 4. 0.1666666 0. 1. + 6076. 1. 5. 27.0 13.0 3.0 1. 14.0 14.0 3. 4. 3.4461536 0. 1. + 6109. 1. 5. 27.0 2.5 0.0 3. 20.0 20.0 6. 6. 1.3999996 0. 1. + 6122. 1. 5. 32.0 16.5 4.0 2. 12.0 11.5 2. 4. 1.1878777 0. 1. + 6125. 1. 4. 37.0 13.0 0.0 2. 12.0 20.0 3. 3. 1.5076914 0. 1. + 6132. 1. 3. 22.0 2.5 0.0 3. 16.0 40.0 4. 4. 0.4000000 0. 1. + 6140. 1. 5. 37.0 13.0 2.0 4. 17.0 40.0 4. 6. 0.9230769 0. 1. + 6144. 1. 4. 22.0 2.5 2.0 1. 12.0 40.0 3. 4. 0.4000000 0. 1. + 6147. 1. 1. 42.0 16.5 2.0 4. 16.0 20.0 5. 2. 0.2121212 0. 1. + 6152. 1. 3. 37.0 16.5 3.0 3. 17.0 14.0 4. 4. 2.7151508 0. 1. + 6171. 1. 4. 22.0 2.5 0.0 3. 17.0 20.0 3. 4. 0.4000000 0. 1. + 6173. 1. 5. 32.0 13.0 2.0 2. 20.0 20.0 4. 2. 1.5076914 0. 1. + 6190. 1. 3. 37.0 16.5 2.0 3. 17.0 40.0 4. 5. 2.5454540 0. 1. + 6192. 1. 4. 32.0 16.5 4.0 3. 12.0 20.0 2. 4. 0.2121212 0. 1. + 6225. 1. 4. 32.0 16.5 2.0 2. 14.0 20.0 3. 5. 0.7272727 0. 1. + 6228. 1. 5. 37.0 16.5 2.0 4. 17.0 20.0 3. 3. 0.7272727 0. 1. + 6231. 1. 3. 27.0 9.0 2.0 1. 12.0 20.0 3. 5. 0.3888888 0. 1. + 6254. 1. 3. 42.0 23.0 3.0 3. 9.0 14.0 3. 5. 1.9478254 0. 1. + 6260. 1. 4. 32.0 9.0 2.0 1. 20.0 40.0 4. 5. 1.3333330 0. 1. + 6266. 1. 4. 22.0 6.0 2.0 2. 12.0 11.5 3. 3. 0.5833333 0. 1. + 6267. 1. 1. 32.0 13.0 2.0 2. 16.0 20.0 6. 5. 1.5076914 0. 1. + 6270. 1. 4. 22.0 2.5 0.0 1. 12.0 20.0 2. 2. 4.7999992 0. 1. + 6274. 1. 4. 27.0 9.0 2.0 1. 12.0 11.5 3. 4. 0.3888888 0. 1. + 6281. 1. 3. 27.0 6.0 0.0 2. 14.0 20.0 4. 5. 2.0000000 0. 1. + 6292. 1. 4. 32.0 13.0 4.0 2. 12.0 11.5 3. 5. 0.0769231 0. 1. + 6305. 1. 5. 42.0 23.0 3.0 4. 12.0 20.0 2. 4. 1.2173910 0. 1. + 6313. 1. 2. 37.0 16.5 3.0 1. 14.0 20.0 3. 4. 1.1878777 0. 1. + 6318. 1. 3. 32.0 9.0 0.0 2. 14.0 20.0 3. 5. 1.3333330 0. 1. + 6328. 1. 4. 37.0 16.5 2.0 3. 14.0 20.0 3. 6. 0.7272727 0. 1. + 6339. 1. 1. 32.0 16.5 4.0 3. 12.0 11.5 3. 5. 1.1878777 0. 1. + 6353. 1. 3. 37.0 16.5 1.0 3. 14.0 20.0 3. 5. 1.1878777 0. 1. + 6366. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 4. 5. 1.3999996 0. 1. + 6380. 1. 4. 22.0 6.0 2.0 2. 12.0 6.5 2. 2. 0.5833333 0. 1. + 6391. 1. 3. 22.0 2.5 1.0 3. 12.0 14.0 3. 2. 3.1999998 0. 1. + 6411. 1. 5. 27.0 6.0 1.0 3. 16.0 9.0 4. 1. 0.1666666 0. 1. + 6427. 1. 5. 27.0 9.0 2.0 2. 20.0 40.0 6. 5. 0.3888888 0. 1. + 6428. 1. 4. 22.0 6.0 1.0 2. 12.0 20.0 5. 4. 4.6666660 0. 1. + 6450. 1. 1. 32.0 16.5 3.0 1. 20.0 20.0 4. 2. 0.7272727 0. 1. + 6501. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 4. 4. 4.8999996 0. 1. + 6504. 1. 4. 42.0 16.5 3.0 2. 14.0 20.0 3. 5. 1.1878777 0. 1. + 6505. 1. 4. 32.0 13.0 2.0 4. 16.0 20.0 4. 6. 0.2692307 0. 1. + 6508. 1. 4. 32.0 9.0 2.0 2. 16.0 11.5 4. 5. 0.3888888 0. 1. + 6511. 1. 2. 42.0 23.0 4.0 1. 12.0 11.5 3. 4. 0.8521735 0. 1. + 6516. 1. 3. 42.0 16.5 2.0 2. 14.0 20.0 4. 4. 0.7272727 0. 1. + 6536. 1. 4. 42.0 16.5 1.0 3. 14.0 20.0 4. 5. 0.7272727 0. 1. + 6545. 1. 4. 32.0 13.0 3.0 2. 16.0 20.0 4. 5. 0.9230769 0. 1. + 6550. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 5. 5. 4.7999992 0. 1. + 6560. 1. 4. 27.0 6.0 1.0 1. 14.0 14.0 3. 4. 3.2666645 0. 1. + 6561. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 5. 1.3333330 0. 1. + 6566. 1. 4. 27.0 6.0 0.0 3. 20.0 20.0 6. 6. 2.0000000 0. 1. + 6572. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 4. 3.2666645 0. 1. + 6581. 1. 4. 27.0 6.0 2.0 2. 12.0 9.0 4. 4. 2.0416660 0. 1. + 6590. 1. 4. 42.0 23.0 1.0 3. 14.0 20.0 3. 4. 0.5217391 0. 1. + 6591. 1. 5. 22.0 6.0 1.0 3. 12.0 6.5 3. 3. 2.0000000 0. 1. + 6600. 1. 3. 37.0 16.5 3.0 3. 14.0 20.0 4. 5. 0.0606061 0. 1. + 6605. 1. 4. 27.0 9.0 2.0 3. 14.0 20.0 4. 4. 0.8888888 0. 1. + 6611. 1. 4. 42.0 13.0 0.0 3. 12.0 14.0 2. 4. 0.9423077 0. 1. + 6618. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 3. 5. 1.3999996 0. 1. + 6621. 1. 2. 32.0 13.0 3.0 2. 16.0 20.0 4. 2. 2.1538458 0. 1. + 6624. 1. 4. 37.0 16.5 4.0 2. 12.0 20.0 5. 5. 1.1878777 0. 1. + 6640. 1. 2. 22.0 2.5 0.0 2. 16.0 11.5 2. 5. 7.8399963 0. 1. + 6644. 1. 5. 42.0 23.0 1.0 3. 12.0 14.0 5. 2. 0.5217391 0. 1. + 6663. 1. 3. 27.0 6.0 2.0 1. 16.0 20.0 4. 5. 2.0000000 0. 1. + 6664. 1. 3. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 1.3999996 0. 1. + 6666. 1. 4. 32.0 9.0 2.0 1. 14.0 40.0 3. 5. 1.3333330 0. 1. + 6668. 1. 4. 27.0 9.0 1.0 1. 14.0 20.0 3. 5. 0.8888888 0. 1. + 6681. 1. 5. 27.0 6.0 0.0 3. 12.0 20.0 3. 4. 0.5833333 0. 1. + 6692. 1. 4. 37.0 13.0 2.0 3. 17.0 14.0 4. 6. 0.2692307 0. 1. + 6693. 1. 3. 42.0 23.0 2.0 2. 14.0 20.0 3. 4. 0.8521735 0. 1. + 6703. 1. 5. 22.0 2.5 0.0 1. 17.0 9.0 5. 1. 0.4000000 0. 1. + 6710. 1. 2. 37.0 23.0 5.5 2. 14.0 20.0 3. 5. 0.1521739 0. 1. + 6714. 1. 4. 32.0 2.5 0.0 2. 12.0 14.0 3. 2. 4.7999992 0. 1. + 6717. 1. 4. 27.0 2.5 0.0 3. 12.0 20.0 3. 3. 1.3999996 0. 1. + 6720. 1. 2. 27.0 2.5 0.0 2. 14.0 14.0 3. 5. 1.3999996 0. 1. + 6726. 1. 3. 22.0 2.5 0.0 3. 14.0 20.0 3. 6. 3.1999998 0. 1. + 6730. 1. 3. 42.0 23.0 5.5 2. 12.0 14.0 4. 2. 1.9478254 0. 1. + 6743. 1. 3. 37.0 16.5 3.0 3. 14.0 14.0 3. 3. 8.7272720 0. 1. + 6747. 1. 2. 27.0 9.0 0.0 2. 14.0 20.0 3. 4. 4.6666660 0. 1. + 6770. 1. 2. 37.0 16.5 3.0 1. 12.0 14.0 3. 2. 2.5454540 0. 1. + 6782. 1. 3. 22.0 2.5 2.0 3. 17.0 20.0 4. 2. 3.1999998 0. 1. + 6788. 1. 4. 22.0 6.0 0.0 3. 12.0 9.0 3. 4. 2.0416660 0. 1. + 6797. 1. 4. 37.0 16.5 4.0 1. 14.0 20.0 5. 4. 0.7272727 0. 1. + 6809. 1. 4. 27.0 9.0 3.0 3. 14.0 20.0 3. 2. 0.1111111 0. 1. + 6813. 1. 4. 22.0 2.5 0.0 1. 14.0 20.0 2. 5. 0.4000000 0. 1. + 6819. 1. 2. 42.0 23.0 4.0 2. 14.0 40.0 3. 5. 0.8521735 0. 1. + 6851. 1. 5. 27.0 6.0 0.0 2. 14.0 14.0 5. 2. 0.5833333 0. 1. + 6854. 1. 2. 27.0 6.0 1.0 1. 12.0 20.0 3. 5. 0.5833333 0. 1. + 6859. 1. 3. 32.0 16.5 2.0 2. 12.0 20.0 3. 2. 0.7272727 0. 1. + 6866. 1. 4. 37.0 23.0 5.5 2. 12.0 14.0 4. 2. 0.5326087 0. 1. + 6871. 1. 4. 17.5 2.5 0.0 1. 12.0 11.5 4. 2. 17.9199982 0. 1. + 6872. 1. 5. 22.0 2.5 1.0 1. 14.0 20.0 3. 5. 57.5999908 0. 1. + 6876. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 5. 4. 1.3999996 0. 1. + 6877. 1. 3. 27.0 9.0 2.0 2. 14.0 14.0 3. 5. 4.6666660 0. 1. + 6881. 1. 2. 32.0 9.0 2.0 2. 16.0 20.0 4. 5. 2.1777763 0. 1. + 6883. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 2. 2. 0.4000000 0. 1. + 6904. 1. 3. 22.0 2.5 1.0 3. 14.0 20.0 5. 4. 0.4000000 0. 1. + 6920. 1. 3. 27.0 9.0 2.0 3. 12.0 11.5 5. 5. 7.4666662 0. 1. + 6921. 1. 4. 27.0 16.5 5.5 2. 14.0 20.0 4. 4. 0.0606061 0. 1. + 6929. 1. 4. 32.0 13.0 2.0 3. 14.0 20.0 3. 5. 0.2692307 0. 1. + 6937. 1. 4. 27.0 9.0 2.0 2. 16.0 20.0 3. 4. 0.8888888 0. 1. + 6947. 1. 5. 32.0 13.0 2.0 2. 17.0 14.0 4. 4. 2.1538458 0. 1. + 6949. 1. 4. 27.0 6.0 1.0 3. 14.0 40.0 4. 1. 7.4666672 0. 1. + 6952. 1. 4. 32.0 13.0 3.0 4. 12.0 20.0 3. 5. 0.2692307 0. 1. + 6954. 1. 3. 27.0 2.5 1.0 2. 16.0 20.0 4. 2. 4.7999992 0. 1. + 6973. 1. 3. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 0.5326087 0. 1. + 6975. 1. 4. 27.0 2.5 0.0 1. 12.0 11.5 3. 2. 0.4000000 0. 1. + 6982. 1. 4. 22.0 2.5 0.0 1. 14.0 20.0 4. 4. 4.7999992 0. 1. + 6998. 1. 5. 32.0 13.0 2.0 1. 14.0 20.0 2. 2. 1.5076914 0. 1. + 7013. 1. 3. 32.0 9.0 2.0 2. 14.0 20.0 3. 5. 1.3333330 0. 1. + 7031. 1. 3. 37.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.7424242 0. 1. + 7040. 1. 2. 42.0 23.0 3.0 3. 14.0 20.0 3. 4. 0.8521735 0. 1. + 7048. 1. 5. 32.0 16.5 2.0 4. 17.0 14.0 4. 4. 0.2121212 0. 1. + 7054. 1. 4. 22.0 2.5 1.0 3. 12.0 11.5 5. 3. 4.8999996 0. 1. + 7059. 1. 5. 27.0 9.0 2.0 2. 14.0 20.0 3. 4. 0.1111111 0. 1. + 7066. 1. 4. 32.0 16.5 3.0 2. 16.0 40.0 5. 6. 0.7424242 0. 1. + 7069. 1. 5. 32.0 16.5 4.0 3. 12.0 20.0 3. 5. 0.0606061 0. 1. + 7091. 1. 3. 32.0 16.5 3.0 2. 12.0 20.0 5. 5. 0.7424242 0. 1. + 7113. 1. 4. 42.0 23.0 2.0 3. 20.0 20.0 4. 4. 0.0434783 0. 1. + 7115. 1. 4. 37.0 16.5 4.0 1. 14.0 20.0 4. 5. 0.2121212 0. 1. + 7120. 1. 5. 27.0 2.5 0.0 2. 12.0 9.0 3. 3. 0.4000000 0. 1. + 7126. 1. 3. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.4000000 0. 1. + 7148. 1. 5. 37.0 23.0 5.5 2. 12.0 20.0 2. 4. 0.1521739 0. 1. + 7150. 1. 4. 42.0 23.0 2.0 2. 12.0 20.0 3. 5. 1.2173910 0. 1. + 7157. 1. 4. 22.0 6.0 2.0 1. 12.0 11.5 2. 4. 11.1999989 0. 1. + 7160. 1. 5. 27.0 6.0 1.0 4. 12.0 14.0 5. 5. 0.5833333 0. 1. + 7172. 1. 5. 42.0 23.0 3.0 3. 12.0 9.0 3. 2. 0.5326087 0. 1. + 7183. 1. 3. 27.0 6.0 2.0 2. 14.0 20.0 4. 4. 0.1666666 0. 1. + 7186. 1. 4. 27.0 6.0 2.0 1. 16.0 40.0 4. 5. 2.0000000 0. 1. + 7196. 1. 2. 42.0 16.5 1.0 2. 20.0 40.0 4. 4. 0.7272727 0. 1. + 7198. 1. 2. 37.0 16.5 4.0 2. 14.0 20.0 3. 5. 1.1878777 0. 1. + 7200. 1. 1. 32.0 13.0 2.0 1. 12.0 14.0 2. 4. 0.0769231 0. 1. + 7203. 1. 3. 37.0 16.5 4.0 4. 14.0 11.5 5. 3. 0.4848484 0. 1. + 7244. 1. 4. 27.0 9.0 1.0 1. 12.0 11.5 3. 4. 4.6666660 0. 1. + 7245. 1. 2. 27.0 2.5 0.0 3. 14.0 6.5 5. 4. 4.7999992 0. 1. + 7249. 1. 3. 32.0 16.5 5.5 4. 12.0 11.5 3. 2. 0.2121212 0. 1. + 7254. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 2. 2. 3.1999998 0. 1. + 7259. 1. 4. 27.0 6.0 0.0 3. 17.0 9.0 4. 4. 3.2666645 0. 1. + 7260. 1. 5. 32.0 9.0 0.0 3. 20.0 20.0 6. 4. 0.1111111 0. 1. + 7291. 1. 3. 22.0 6.0 0.0 2. 17.0 20.0 4. 3. 4.6666660 0. 1. + 7298. 1. 4. 22.0 2.5 2.0 2. 12.0 11.5 3. 2. 3.1999998 0. 1. + 7301. 1. 4. 42.0 23.0 1.0 2. 14.0 20.0 3. 6. 2.9217386 0. 1. + 7303. 1. 3. 27.0 6.0 0.0 2. 14.0 20.0 3. 4. 7.0000000 0. 1. + 7335. 1. 4. 37.0 23.0 5.5 2. 9.0 20.0 3. 4. 0.8521735 0. 1. + 7354. 1. 4. 22.0 2.5 1.0 3. 14.0 20.0 5. 5. 7.8399963 0. 1. + 7355. 1. 5. 27.0 9.0 2.0 2. 14.0 14.0 5. 4. 1.3333330 0. 1. + 7365. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 3. 4. 4.8999996 0. 1. + 7423. 1. 3. 27.0 9.0 2.0 3. 14.0 20.0 3. 5. 1.3333330 0. 1. + 7435. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 3. 4. 0.1666666 0. 1. + 7444. 1. 4. 27.0 6.0 2.0 3. 14.0 6.5 4. 5. 0.5833333 0. 1. + 7448. 1. 3. 42.0 23.0 2.0 2. 14.0 20.0 3. 5. 0.8521735 0. 1. + 7470. 1. 4. 22.0 6.0 1.0 2. 12.0 20.0 3. 4. 0.5833333 0. 1. + 7487. 1. 4. 32.0 13.0 3.0 2. 14.0 20.0 2. 5. 0.2692307 0. 1. + 7493. 1. 5. 42.0 23.0 4.0 3. 14.0 14.0 2. 2. 0.0434783 0. 1. + 7506. 1. 4. 27.0 13.0 2.0 3. 12.0 20.0 5. 4. 0.9230769 0. 1. + 7517. 1. 4. 27.0 9.0 1.0 2. 14.0 20.0 5. 4. 2.1777763 0. 1. + 7540. 1. 4. 27.0 9.0 1.0 2. 12.0 14.0 3. 3. 1.3333330 0. 1. + 7551. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 1.3999996 0. 1. + 7552. 1. 3. 32.0 13.0 2.0 3. 12.0 20.0 3. 5. 0.6153846 0. 1. + 7555. 1. 3. 42.0 23.0 4.0 2. 12.0 20.0 3. 4. 0.8521735 0. 1. + 7564. 1. 3. 27.0 6.0 0.0 2. 16.0 40.0 4. 4. 0.1666666 0. 1. + 7578. 1. 5. 42.0 23.0 2.0 2. 14.0 20.0 3. 3. 0.1521739 0. 1. + 7579. 1. 3. 37.0 16.5 5.5 3. 12.0 14.0 2. 2. 0.4848484 0. 1. + 7607. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 3. 4. 17.9199982 0. 1. + 7613. 1. 5. 42.0 23.0 2.0 2. 12.0 14.0 3. 2. 0.5326087 0. 1. + 7619. 1. 5. 27.0 2.5 0.0 1. 16.0 14.0 5. 2. 1.3999996 0. 1. + 7638. 1. 4. 32.0 23.0 3.0 4. 12.0 11.5 2. 2. 0.5326087 0. 1. + 7652. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 4. 6. 7.8399963 0. 1. + 7662. 1. 4. 37.0 16.5 5.5 2. 14.0 14.0 2. 3. 1.1878777 0. 1. + 7690. 1. 4. 22.0 2.5 1.0 3. 12.0 6.5 2. 2. 4.8999996 0. 1. + 7691. 1. 2. 27.0 6.0 2.0 2. 12.0 11.5 3. 2. 2.0000000 0. 1. + 7705. 1. 5. 32.0 16.5 3.0 3. 16.0 20.0 2. 4. 0.2121212 0. 1. + 7714. 1. 3. 27.0 6.0 1.0 3. 14.0 11.5 3. 2. 3.2666645 0. 1. + 7715. 1. 3. 27.0 2.5 2.0 1. 14.0 11.5 3. 5. 1.3999996 0. 1. + 7728. 1. 5. 42.0 23.0 5.5 3. 16.0 20.0 4. 4. 0.5326087 0. 1. + 7737. 1. 3. 17.5 2.5 0.0 1. 12.0 11.5 3. 4. 7.8399963 0. 1. + 7740. 1. 3. 37.0 23.0 3.0 2. 12.0 20.0 3. 5. 0.8521735 0. 1. + 7763. 1. 5. 27.0 6.0 0.0 3. 17.0 9.0 3. 1. 0.1666666 0. 1. + 7769. 1. 4. 37.0 16.5 1.0 2. 12.0 20.0 3. 5. 2.7151508 0. 1. + 7789. 1. 3. 32.0 16.5 2.0 2. 12.0 40.0 3. 6. 0.7424242 0. 1. + 7803. 1. 3. 27.0 2.5 0.0 1. 17.0 20.0 4. 6. 4.7999992 0. 1. + 7808. 1. 4. 32.0 16.5 4.0 3. 12.0 11.5 2. 4. 0.7424242 0. 1. + 7809. 1. 3. 32.0 16.5 2.0 2. 12.0 20.0 3. 4. 1.1878777 0. 1. + 7813. 1. 4. 17.5 2.5 1.0 1. 12.0 6.5 3. 2. 4.7999992 0. 1. + 7821. 1. 3. 22.0 2.5 1.0 2. 12.0 6.5 5. 2. 7.8399963 0. 1. + 7823. 1. 5. 37.0 16.5 2.0 2. 16.0 20.0 4. 4. 0.7272727 0. 1. + 7829. 1. 5. 37.0 16.5 2.0 3. 12.0 11.5 3. 2. 0.7272727 0. 1. + 7834. 1. 5. 22.0 2.5 0.0 4. 14.0 20.0 3. 3. 0.4000000 0. 1. + 7846. 1. 4. 27.0 2.5 0.0 1. 14.0 20.0 3. 2. 4.8999996 0. 1. + 7860. 1. 4. 22.0 2.5 1.0 2. 14.0 20.0 4. 2. 0.4000000 0. 1. + 7864. 1. 4. 37.0 16.5 3.0 3. 12.0 14.0 2. 4. 0.7272727 0. 1. + 7866. 1. 3. 22.0 6.0 1.0 3. 16.0 20.0 4. 4. 3.2666645 0. 1. + 7883. 1. 4. 27.0 6.0 1.0 1. 14.0 20.0 3. 5. 0.5833333 0. 1. + 7886. 1. 1. 42.0 23.0 3.0 3. 12.0 14.0 3. 4. 1.8260860 0. 1. + 7889. 1. 3. 22.0 6.0 2.0 3. 12.0 11.5 2. 4. 3.2666645 0. 1. + 7897. 1. 3. 22.0 2.5 1.0 2. 12.0 4.0 4. 1. 0.4000000 0. 1. + 7899. 1. 4. 22.0 2.5 1.0 3. 16.0 11.5 3. 3. 4.7999992 0. 1. + 7900. 1. 2. 22.0 2.5 2.0 1. 12.0 11.5 2. 4. 3.1999998 0. 1. + 7902. 1. 5. 22.0 2.5 1.0 3. 14.0 9.0 2. 5. 4.8999996 0. 1. + 7916. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 1.3999996 0. 1. + 7922. 1. 4. 42.0 23.0 5.5 3. 12.0 11.5 5. 5. 0.5217391 0. 1. + 7927. 1. 3. 27.0 9.0 1.0 1. 14.0 9.0 3. 5. 0.1111111 0. 1. + 7940. 1. 3. 37.0 23.0 4.0 2. 12.0 9.0 3. 2. 1.9478254 0. 1. + 7949. 1. 4. 37.0 16.5 3.0 3. 12.0 20.0 5. 2. 0.7424242 0. 1. + 7950. 1. 5. 22.0 2.5 1.0 2. 14.0 11.5 4. 1. 7.8399963 0. 1. + 7954. 1. 2. 27.0 2.5 0.0 1. 14.0 20.0 3. 3. 11.1999998 0. 1. + 7956. 1. 5. 22.0 2.5 1.0 2. 16.0 11.5 4. 4. 1.3999996 0. 1. + 7965. 1. 4. 22.0 2.5 1.0 3. 12.0 6.5 3. 3. 4.7999992 0. 1. + 7966. 1. 4. 27.0 6.0 2.0 2. 14.0 11.5 3. 5. 0.1666666 0. 1. + 7988. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 4. 0.4000000 0. 1. + 7997. 1. 4. 27.0 6.0 1.0 3. 16.0 9.0 3. 3. 1.3333330 0. 1. + 8000. 1. 5. 42.0 23.0 3.0 2. 17.0 11.5 5. 5. 0.0434783 0. 1. + 8005. 1. 5. 37.0 16.5 4.0 2. 12.0 20.0 3. 2. 1.6969690 0. 1. + 8008. 1. 2. 27.0 6.0 0.0 1. 14.0 40.0 3. 4. 7.0000000 0. 1. + 8013. 1. 4. 32.0 16.5 3.0 4. 14.0 20.0 3. 5. 1.1878777 0. 1. + 8016. 1. 5. 37.0 16.5 5.5 3. 20.0 40.0 4. 6. 0.7424242 0. 1. + 8026. 1. 5. 27.0 2.5 2.0 2. 16.0 20.0 3. 2. 0.4000000 0. 1. + 8027. 1. 3. 27.0 9.0 2.0 2. 14.0 20.0 3. 6. 4.6666660 0. 1. + 8031. 1. 4. 32.0 13.0 4.0 3. 12.0 20.0 3. 4. 0.2692307 0. 1. + 8035. 1. 5. 27.0 9.0 1.0 3. 12.0 20.0 3. 4. 2.1777763 0. 1. + 8037. 1. 5. 32.0 6.0 3.0 1. 14.0 6.5 3. 2. 4.6666660 0. 1. + 8038. 1. 4. 32.0 16.5 3.0 1. 12.0 11.5 3. 4. 1.6969690 0. 1. + 8042. 1. 3. 27.0 9.0 0.0 1. 12.0 14.0 3. 5. 7.4666662 0. 1. + 8047. 1. 4. 32.0 13.0 1.0 3. 14.0 9.0 3. 5. 1.5076914 0. 1. + 8070. 1. 3. 42.0 23.0 2.0 3. 9.0 6.5 2. 2. 0.5217391 0. 1. + 8071. 1. 3. 22.0 6.0 1.0 2. 12.0 11.5 3. 2. 1.3333330 0. 1. + 8084. 1. 4. 37.0 23.0 3.0 3. 12.0 20.0 5. 2. 0.3478261 0. 1. + 8090. 1. 5. 42.0 23.0 3.0 3. 16.0 40.0 4. 2. 0.3478261 0. 1. + 8098. 1. 2. 22.0 6.0 0.0 2. 12.0 14.0 3. 3. 3.2666645 0. 1. + 8111. 1. 3. 37.0 13.0 2.0 2. 12.0 20.0 3. 5. 0.2692307 0. 1. + 8128. 1. 3. 32.0 13.0 2.0 2. 16.0 6.5 3. 5. 0.9230769 0. 1. + 8129. 1. 3. 22.0 2.5 0.0 2. 12.0 20.0 3. 3. 0.4000000 0. 1. + 8133. 1. 3. 42.0 23.0 5.5 3. 14.0 20.0 3. 4. 0.5326087 0. 1. + 8136. 1. 2. 32.0 16.5 2.0 2. 16.0 20.0 4. 6. 0.7424242 0. 1. + 8141. 1. 4. 27.0 6.0 2.0 3. 14.0 20.0 5. 4. 2.0000000 0. 1. + 8144. 1. 4. 37.0 16.5 3.0 4. 16.0 20.0 4. 5. 0.7424242 0. 1. + 8149. 1. 5. 37.0 23.0 3.0 1. 12.0 40.0 3. 5. 0.3478261 0. 1. + 8150. 1. 3. 22.0 2.5 0.0 3. 14.0 11.5 3. 3. 3.1999998 0. 1. + 8153. 1. 3. 22.0 2.5 0.0 2. 12.0 14.0 3. 5. 4.7999992 0. 1. + 8159. 1. 4. 22.0 9.0 3.0 2. 14.0 20.0 3. 3. 0.3888888 0. 1. + 8161. 1. 3. 42.0 23.0 2.0 1. 12.0 40.0 2. 5. 0.0434783 0. 1. + 8162. 1. 4. 32.0 13.0 1.0 1. 12.0 11.5 3. 2. 1.5076914 0. 1. + 8163. 1. 3. 22.0 2.5 1.0 2. 12.0 9.0 2. 4. 11.1999998 0. 1. + 8169. 1. 2. 37.0 13.0 3.0 2. 14.0 40.0 4. 2. 0.0769231 0. 1. + 8170. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 5. 5. 0.1521739 0. 1. + 8184. 1. 2. 37.0 16.5 3.0 3. 16.0 6.5 4. 2. 0.7272727 0. 1. + 8188. 1. 3. 27.0 6.0 1.0 2. 14.0 20.0 4. 4. 2.0000000 0. 1. + 8196. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 4. 4. 3.1999998 0. 1. + 8210. 1. 3. 22.0 2.5 1.0 3. 14.0 14.0 4. 3. 4.7999992 0. 1. + 8215. 1. 4. 32.0 13.0 3.0 1. 14.0 14.0 3. 4. 0.2692307 0. 1. + 8220. 1. 5. 27.0 9.0 2.0 1. 16.0 9.0 3. 5. 1.3611107 0. 1. + 8223. 1. 4. 22.0 2.5 0.0 3. 14.0 6.5 3. 2. 7.8399963 0. 1. + 8225. 1. 5. 42.0 23.0 3.0 3. 12.0 11.5 5. 2. 0.1521739 0. 1. + 8231. 1. 3. 22.0 2.5 1.0 3. 14.0 20.0 3. 2. 1.3999996 0. 1. + 8236. 1. 4. 27.0 6.0 1.0 2. 17.0 20.0 4. 2. 3.2666645 0. 1. + 8251. 1. 4. 37.0 16.5 3.0 3. 14.0 14.0 4. 2. 0.7424242 0. 1. + 8256. 1. 5. 27.0 6.0 1.0 3. 14.0 20.0 3. 2. 2.0000000 0. 1. + 8261. 1. 4. 22.0 2.5 4.0 3. 12.0 20.0 2. 4. 0.4000000 0. 1. + 8263. 1. 2. 32.0 9.0 2.0 2. 14.0 20.0 4. 5. 2.1777763 0. 1. + 8265. 1. 4. 22.0 2.5 1.0 3. 17.0 6.5 4. 1. 4.8999996 0. 1. + 8269. 1. 4. 27.0 6.0 0.0 2. 20.0 20.0 6. 6. 2.0416660 0. 1. + 8281. 1. 3. 27.0 2.5 0.0 2. 12.0 40.0 3. 6. 7.8399963 0. 1. + 8289. 1. 4. 22.0 2.5 2.0 2. 12.0 11.5 4. 2. 1.3999996 0. 1. + 8290. 1. 2. 22.0 6.0 1.0 2. 14.0 9.0 3. 5. 7.4666672 0. 1. + 8307. 1. 4. 32.0 6.0 1.0 3. 12.0 20.0 3. 4. 0.5833333 0. 1. + 8309. 1. 5. 22.0 6.0 0.0 2. 14.0 6.5 3. 1. 2.0416660 0. 1. + 8333. 1. 4. 32.0 9.0 2.0 2. 12.0 20.0 3. 2. 0.8888888 0. 1. + 8336. 1. 2. 42.0 23.0 4.0 2. 17.0 6.5 4. 2. 0.1521739 0. 1. + 8337. 1. 1. 37.0 23.0 4.0 2. 9.0 20.0 2. 5. 0.8521735 0. 1. + 8352. 1. 4. 37.0 23.0 2.0 2. 14.0 11.5 4. 4. 0.1521739 0. 1. + 8355. 1. 4. 27.0 9.0 0.0 2. 17.0 20.0 4. 5. 2.1777763 0. 1. + 8370. 1. 2. 22.0 6.0 2.0 2. 12.0 11.5 4. 4. 0.1666666 0. 1. + 8383. 1. 3. 27.0 6.0 3.0 3. 14.0 11.5 3. 5. 2.0416660 0. 1. + 8384. 1. 4. 22.0 2.5 5.5 3. 12.0 11.5 3. 2. 1.3999996 0. 1. + 8392. 1. 5. 22.0 6.0 2.0 3. 12.0 6.5 3. 5. 0.5833333 0. 1. + 8416. 1. 3. 27.0 6.0 1.0 2. 16.0 14.0 4. 4. 0.5833333 0. 1. + 8419. 1. 3. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 3.1999998 0. 1. + 8422. 1. 4. 32.0 16.5 5.5 2. 12.0 20.0 3. 5. 0.2121212 0. 1. + 8423. 1. 4. 27.0 9.0 2.0 3. 12.0 11.5 3. 2. 0.8888888 0. 1. + 8431. 1. 2. 37.0 23.0 3.0 3. 12.0 20.0 3. 4. 0.0434783 0. 1. + 8454. 1. 3. 37.0 23.0 4.0 3. 12.0 40.0 5. 2. 0.0434783 0. 1. + 8458. 1. 3. 32.0 16.5 5.5 2. 12.0 9.0 3. 3. 2.5454540 0. 1. + 8473. 1. 3. 22.0 2.5 0.0 2. 16.0 6.5 5. 4. 1.3999996 0. 1. + 8479. 1. 5. 37.0 23.0 4.0 3. 12.0 20.0 2. 2. 1.2173910 0. 1. + 8483. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 1.3999996 0. 1. + 8484. 1. 5. 27.0 9.0 1.0 3. 12.0 14.0 2. 2. 0.3888888 0. 1. + 8492. 1. 5. 32.0 13.0 3.0 1. 12.0 20.0 2. 2. 0.6153846 0. 1. + 8496. 1. 3. 32.0 16.5 2.0 3. 12.0 11.5 2. 2. 1.1878777 0. 1. + 8504. 1. 5. 32.0 16.5 2.0 1. 16.0 20.0 4. 2. 4.0727262 0. 1. + 8510. 1. 4. 27.0 6.0 0.0 2. 16.0 11.5 4. 2. 2.0000000 0. 1. + 8523. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 3. 5. 1.3999996 0. 1. + 8536. 1. 2. 22.0 2.5 0.0 3. 14.0 14.0 3. 2. 4.7999992 0. 1. + 8538. 1. 4. 37.0 16.5 2.0 3. 14.0 20.0 3. 5. 8.7272720 0. 1. + 8541. 1. 5. 27.0 6.0 1.0 4. 16.0 14.0 4. 4. 2.0416660 0. 1. + 8551. 1. 3. 22.0 6.0 1.0 3. 12.0 14.0 4. 4. 4.6666660 0. 1. + 8556. 1. 2. 32.0 9.0 2.0 3. 14.0 20.0 2. 4. 1.3611107 0. 1. + 8562. 1. 4. 27.0 6.0 2.0 1. 14.0 6.5 3. 1. 3.2666645 0. 1. + 8565. 1. 3. 27.0 2.5 0.0 1. 17.0 40.0 5. 4. 16.7999878 0. 1. + 8587. 1. 2. 22.0 6.0 1.0 3. 12.0 11.5 3. 5. 2.0416660 0. 1. + 8589. 1. 3. 27.0 9.0 2.0 3. 12.0 9.0 2. 2. 2.1777763 0. 1. + 8593. 1. 3. 37.0 23.0 4.0 1. 17.0 20.0 4. 4. 0.5217391 0. 1. + 8596. 1. 3. 42.0 23.0 5.5 4. 20.0 20.0 4. 4. 0.5326087 0. 1. + 8602. 1. 5. 22.0 2.5 1.0 3. 12.0 20.0 6. 2. 26.8799896 0. 1. + 8617. 1. 4. 37.0 16.5 3.0 2. 12.0 20.0 2. 2. 0.7272727 0. 1. + 8633. 1. 5. 27.0 6.0 0.0 2. 12.0 20.0 3. 2. 11.1999989 0. 1. + 8646. 1. 3. 22.0 2.5 0.0 2. 14.0 20.0 5. 2. 11.1999998 0. 1. + 8657. 1. 3. 32.0 16.5 3.0 2. 14.0 40.0 5. 5. 2.7151508 0. 1. + 8673. 1. 5. 27.0 6.0 0.0 3. 16.0 20.0 5. 5. 3.2666645 0. 1. + 8687. 1. 2. 42.0 23.0 3.0 2. 12.0 20.0 3. 4. 0.0434783 0. 1. + 8697. 1. 4. 27.0 2.5 0.0 3. 20.0 20.0 4. 5. 7.8399963 0. 1. + 8722. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 3. 5. 0.4000000 0. 1. + 8738. 1. 3. 27.0 6.0 1.0 3. 12.0 20.0 3. 4. 0.5833333 0. 1. + 8749. 1. 5. 32.0 13.0 1.0 2. 14.0 20.0 4. 3. 0.9423077 0. 1. + 8752. 1. 2. 32.0 2.5 0.0 3. 20.0 20.0 4. 4. 1.3999996 0. 1. + 8757. 1. 2. 27.0 9.0 2.0 2. 16.0 20.0 4. 5. 0.1111111 0. 1. + 8787. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 3. 1.3999996 0. 1. + 8795. 1. 4. 27.0 2.5 0.0 2. 17.0 20.0 4. 5. 0.4000000 0. 1. + 8805. 1. 4. 27.0 0.5 0.0 3. 12.0 6.5 3. 4. 2.0000000 0. 1. + 8811. 1. 4. 32.0 13.0 2.0 4. 14.0 20.0 4. 5. 0.2692307 0. 1. + 8813. 1. 3. 27.0 9.0 1.0 3. 12.0 11.5 2. 2. 2.1777763 0. 1. + 8814. 1. 3. 32.0 13.0 2.0 2. 12.0 11.5 3. 5. 3.4461536 0. 1. + 8815. 1. 5. 27.0 9.0 2.0 2. 12.0 20.0 3. 5. 0.3888888 0. 1. + 8816. 1. 5. 22.0 6.0 1.0 2. 12.0 11.5 3. 2. 1.3333330 0. 1. + 8825. 1. 3. 32.0 13.0 0.0 1. 12.0 14.0 3. 4. 3.4461536 0. 1. + 8842. 1. 3. 37.0 23.0 2.0 3. 14.0 20.0 4. 5. 0.3478261 0. 1. + 8861. 1. 5. 32.0 16.5 1.0 3. 12.0 40.0 3. 2. 1.1878777 0. 1. + 8863. 1. 3. 32.0 16.5 3.0 1. 14.0 40.0 3. 6. 1.1878777 0. 1. + 8866. 1. 5. 22.0 6.0 0.0 1. 14.0 11.5 4. 4. 7.0000000 0. 1. + 8867. 1. 4. 37.0 13.0 0.0 2. 20.0 40.0 2. 6. 5.1692305 0. 1. + 8889. 1. 3. 42.0 23.0 3.0 2. 14.0 40.0 5. 4. 0.5217391 0. 1. + 8892. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 7.8399963 0. 1. + 8897. 1. 4. 27.0 13.0 3.0 3. 14.0 14.0 6. 5. 5.1692305 0. 1. + 8898. 1. 2. 42.0 23.0 1.0 1. 20.0 40.0 6. 6. 1.9478254 0. 1. + 8899. 1. 2. 27.0 9.0 2.0 3. 14.0 14.0 2. 2. 1.3611107 0. 1. + 8907. 1. 5. 27.0 6.0 1.0 2. 14.0 11.5 4. 2. 2.0416660 0. 1. + 8913. 1. 5. 37.0 13.0 4.0 2. 12.0 20.0 4. 5. 1.5076914 0. 1. + 8914. 1. 2. 22.0 6.0 1.0 2. 14.0 20.0 3. 2. 3.2666645 0. 1. + 8915. 1. 3. 17.5 2.5 0.0 4. 14.0 11.5 3. 4. 3.1999998 0. 1. + 8916. 1. 5. 22.0 2.5 1.0 3. 14.0 6.5 2. 4. 16.7999878 0. 1. + 8922. 1. 3. 27.0 6.0 0.0 3. 14.0 20.0 3. 4. 2.0000000 0. 1. + 8929. 1. 5. 27.0 9.0 0.0 1. 14.0 20.0 3. 5. 2.1777763 0. 1. + 8930. 1. 3. 32.0 13.0 3.0 2. 14.0 40.0 3. 6. 1.5076914 0. 1. + 8931. 1. 4. 37.0 23.0 3.0 3. 12.0 11.5 3. 4. 0.5217391 0. 1. + 8933. 1. 4. 42.0 23.0 1.0 2. 12.0 40.0 5. 5. 0.3478261 0. 1. + 8938. 1. 3. 32.0 9.0 2.0 3. 16.0 14.0 3. 5. 2.1777763 0. 1. + 8944. 1. 5. 42.0 23.0 3.0 4. 14.0 40.0 5. 6. 0.5217391 0. 1. + 8947. 1. 4. 27.0 9.0 2.0 2. 12.0 14.0 3. 4. 1.3611107 0. 1. + 8949. 1. 4. 32.0 16.5 3.0 3. 14.0 20.0 5. 5. 1.1878777 0. 1. + 8959. 1. 2. 22.0 2.5 0.0 1. 14.0 11.5 3. 4. 11.1999998 0. 1. + 8960. 1. 3. 37.0 16.5 3.0 2. 12.0 20.0 3. 5. 5.8181810 0. 1. + 8964. 1. 3. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.4000000 0. 1. + 8969. 1. 4. 27.0 6.0 0.0 1. 17.0 40.0 4. 6. 3.2666645 0. 1. + 8971. 1. 5. 32.0 13.0 3.0 3. 14.0 40.0 6. 6. 0.2692307 0. 1. + 8975. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 4. 2. 2.9217386 0. 1. + 8985. 1. 5. 22.0 2.5 1.0 3. 14.0 9.0 3. 2. 1.3999996 0. 1. + 8993. 1. 4. 42.0 23.0 2.0 3. 12.0 14.0 3. 5. 1.8260860 0. 1. + 9012. 1. 4. 32.0 16.5 2.0 4. 14.0 20.0 3. 5. 0.7272727 0. 1. + 9028. 1. 3. 27.0 2.5 2.0 1. 14.0 20.0 4. 2. 3.1999998 0. 1. + 9036. 1. 5. 42.0 16.5 2.0 1. 20.0 40.0 4. 4. 0.2121212 0. 1. + 9037. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 5. 4. 0.4000000 0. 1. + 9044. 1. 3. 22.0 2.5 0.0 1. 14.0 14.0 5. 4. 4.7999992 0. 1. + 9046. 1. 4. 27.0 2.5 0.0 2. 16.0 40.0 3. 5. 3.1999998 0. 1. + 9051. 1. 3. 27.0 6.0 1.0 3. 14.0 14.0 3. 4. 0.5833333 0. 1. + 9053. 1. 4. 42.0 23.0 2.0 3. 14.0 40.0 3. 5. 0.5326087 0. 1. + 9081. 1. 2. 37.0 2.5 1.0 3. 14.0 14.0 3. 2. 1.3999996 0. 1. + 9083. 1. 2. 42.0 23.0 2.0 3. 14.0 20.0 3. 5. 0.5326087 0. 1. + 9093. 1. 1. 42.0 23.0 2.0 1. 14.0 40.0 5. 5. 1.8260860 0. 1. + 9095. 1. 5. 27.0 13.0 1.0 1. 12.0 14.0 2. 4. 0.9423077 0. 1. + 9104. 1. 5. 32.0 9.0 1.0 3. 20.0 20.0 3. 3. 4.9777775 0. 1. + 9106. 1. 3. 27.0 9.0 1.0 1. 16.0 20.0 5. 4. 0.3888888 0. 1. + 9109. 1. 4. 27.0 9.0 2.0 2. 12.0 20.0 4. 4. 2.1777763 0. 1. + 9134. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 6. 5. 2.0416660 0. 1. + 9163. 1. 4. 27.0 9.0 1.0 2. 20.0 14.0 3. 5. 2.1777763 0. 1. + 9172. 1. 2. 37.0 16.5 3.0 2. 20.0 20.0 4. 4. 0.2121212 0. 1. + 9178. 1. 3. 27.0 9.0 2.0 3. 14.0 20.0 3. 5. 0.3888888 0. 1. + 9180. 1. 5. 27.0 6.0 1.0 2. 14.0 40.0 4. 6. 0.5833333 0. 1. + 9185. 1. 3. 37.0 23.0 2.0 2. 14.0 20.0 5. 4. 0.5326087 0. 1. + 9226. 1. 4. 27.0 13.0 1.0 4. 14.0 11.5 3. 5. 0.9230769 0. 1. + 9229. 1. 4. 22.0 0.5 0.0 1. 12.0 9.0 2. 4. 24.0000000 0. 1. + 9234. 1. 5. 42.0 23.0 5.5 4. 12.0 14.0 3. 4. 0.1521739 0. 1. + 9238. 1. 4. 32.0 13.0 2.0 1. 14.0 20.0 5. 6. 0.9423077 0. 1. + 9239. 1. 4. 27.0 9.0 2.0 1. 16.0 11.5 4. 4. 0.8888888 0. 1. + 9243. 1. 5. 22.0 6.0 2.0 3. 12.0 11.5 2. 5. 0.1666666 0. 1. + 9253. 1. 2. 37.0 16.5 2.0 1. 12.0 40.0 3. 6. 1.1878777 0. 1. + 9280. 1. 3. 32.0 13.0 2.0 2. 16.0 20.0 3. 5. 1.5076914 0. 1. + 9281. 1. 4. 27.0 9.0 0.0 1. 12.0 20.0 3. 5. 2.1777763 0. 1. + 9284. 1. 3. 42.0 23.0 2.0 3. 16.0 40.0 5. 6. 0.8521735 0. 1. + 9292. 1. 4. 27.0 9.0 2.0 3. 14.0 14.0 3. 4. 2.1777763 0. 1. + 9296. 1. 5. 22.0 6.0 0.0 3. 12.0 40.0 3. 5. 0.1666666 0. 1. + 9298. 1. 4. 42.0 23.0 3.0 3. 12.0 20.0 3. 4. 0.5217391 0. 1. + 9301. 1. 4. 37.0 16.5 2.0 2. 12.0 40.0 3. 5. 0.2121212 0. 1. + 9303. 1. 4. 42.0 16.5 1.0 2. 16.0 40.0 2. 6. 0.2121212 0. 1. + 9312. 1. 4. 37.0 16.5 5.5 2. 14.0 20.0 4. 5. 0.7424242 0. 1. + 9326. 1. 2. 32.0 13.0 1.0 2. 17.0 20.0 3. 3. 1.5076914 0. 1. + 9341. 1. 2. 32.0 9.0 2.0 1. 16.0 40.0 5. 5. 0.3888888 0. 1. + 9368. 1. 4. 42.0 23.0 2.0 1. 14.0 40.0 5. 6. 2.7826080 0. 1. + 9373. 1. 4. 42.0 23.0 2.0 2. 12.0 9.0 3. 4. 0.1521739 0. 1. + 9381. 1. 5. 22.0 2.5 0.0 1. 12.0 11.5 3. 4. 4.8999996 0. 1. + 9386. 1. 4. 27.0 6.0 1.0 2. 14.0 20.0 4. 2. 1.3333330 0. 1. + 9388. 1. 4. 22.0 6.0 2.0 4. 12.0 11.5 3. 2. 0.1666666 0. 1. + 9393. 1. 5. 37.0 23.0 4.0 3. 12.0 20.0 3. 4. 2.7826080 0. 1. + 9419. 1. 3. 42.0 23.0 2.0 1. 20.0 40.0 4. 4. 0.8521735 0. 1. + 9423. 1. 4. 32.0 9.0 0.0 2. 20.0 40.0 4. 4. 0.1111111 0. 1. + 9424. 1. 4. 22.0 2.5 0.0 1. 16.0 20.0 2. 4. 3.1999998 0. 1. + 9441. 1. 5. 27.0 6.0 1.0 3. 14.0 20.0 3. 3. 2.0000000 0. 1. + 9446. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 3. 7.8399963 0. 1. + 9456. 1. 5. 22.0 2.5 1.0 2. 12.0 9.0 2. 2. 1.3999996 0. 1. + 9464. 1. 5. 27.0 6.0 0.0 1. 17.0 20.0 5. 2. 0.5833333 0. 1. + 9469. 1. 3. 32.0 13.0 2.0 4. 12.0 9.0 2. 5. 1.5076914 0. 1. + 9486. 1. 4. 32.0 16.5 2.0 3. 14.0 20.0 5. 4. 0.7424242 0. 1. + 9496. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 4. 5. 0.2692307 0. 1. + 9497. 1. 4. 32.0 16.5 2.0 4. 14.0 6.5 2. 1. 0.4848484 0. 1. + 9500. 1. 3. 32.0 13.0 2.0 2. 20.0 40.0 4. 5. 0.2692307 0. 1. + 9515. 1. 3. 42.0 23.0 4.0 3. 20.0 11.5 4. 5. 0.8521735 0. 1. + 9518. 1. 5. 27.0 9.0 1.0 1. 20.0 40.0 6. 6. 0.8888888 0. 1. + 9531. 1. 4. 32.0 16.5 2.0 2. 12.0 20.0 3. 4. 1.1878777 0. 1. + 9540. 1. 5. 42.0 23.0 3.0 3. 17.0 40.0 4. 5. 0.0434783 0. 1. + 9555. 1. 3. 32.0 13.0 4.0 2. 12.0 11.5 2. 4. 0.2692307 0. 1. + 9568. 1. 3. 32.0 16.5 2.0 1. 14.0 14.0 3. 4. 2.5454540 0. 1. + 9576. 1. 5. 32.0 6.0 1.0 1. 14.0 20.0 4. 5. 0.5833333 0. 1. + 9580. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 3. 5. 0.5833333 0. 1. + 9581. 1. 2. 27.0 9.0 1.0 1. 17.0 11.5 1. 4. 3.1111107 0. 1. + 9584. 1. 5. 27.0 6.0 0.0 2. 16.0 40.0 5. 6. 0.5833333 0. 1. + 9606. 1. 4. 27.0 16.5 2.0 3. 9.0 11.5 2. 4. 0.7424242 0. 1. + 9610. 1. 4. 32.0 13.0 1.0 3. 20.0 9.0 2. 2. 0.9423077 0. 1. + 9614. 1. 4. 37.0 16.5 2.0 2. 12.0 20.0 3. 3. 1.1878777 0. 1. + 9619. 1. 3. 27.0 6.0 0.0 4. 12.0 9.0 3. 5. 1.3333330 0. 1. + 9628. 1. 3. 37.0 23.0 4.0 2. 12.0 20.0 3. 4. 2.9217386 0. 1. + 9630. 1. 3. 27.0 6.0 0.0 3. 14.0 40.0 3. 3. 2.0000000 0. 1. + 9635. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 5. 4.7999992 0. 1. + 9637. 1. 4. 32.0 9.0 1.0 2. 12.0 20.0 3. 4. 2.1777763 0. 1. + 9649. 1. 4. 27.0 9.0 1.0 3. 17.0 20.0 4. 6. 2.1777763 0. 1. + 9652. 1. 5. 27.0 13.0 2.0 2. 12.0 40.0 4. 5. 0.9230769 0. 1. + 9660. 1. 5. 22.0 2.5 2.0 1. 12.0 20.0 3. 2. 1.3999996 0. 1. + 9661. 1. 4. 22.0 6.0 2.0 2. 12.0 9.0 3. 4. 0.5833333 0. 1. + 9663. 1. 2. 32.0 16.5 1.0 4. 12.0 40.0 5. 5. 1.1878777 0. 1. + 9686. 1. 3. 27.0 2.5 0.0 2. 20.0 20.0 4. 1. 1.3999996 0. 1. + 9691. 1. 3. 27.0 13.0 1.0 2. 12.0 14.0 5. 5. 3.2307692 0. 1. + 9713. 1. 4. 37.0 23.0 1.0 1. 16.0 20.0 5. 5. 1.2173910 0. 1. + 9714. 1. 4. 27.0 6.0 0.0 3. 16.0 11.5 2. 1. 2.0000000 0. 1. + 9715. 1. 4. 22.0 6.0 0.0 2. 14.0 20.0 3. 5. 4.6666660 0. 1. + 9723. 1. 5. 42.0 16.5 2.0 3. 20.0 40.0 6. 6. 0.7272727 0. 1. + 9736. 1. 2. 37.0 16.5 1.0 2. 16.0 20.0 4. 5. 1.1878777 0. 1. + 9743. 1. 1. 32.0 13.0 3.0 3. 12.0 14.0 2. 4. 0.0769231 0. 1. + 9750. 1. 5. 22.0 2.5 1.0 3. 12.0 20.0 3. 4. 4.8999996 0. 1. + 9767. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 4.7999992 0. 1. + 9770. 1. 3. 22.0 2.5 0.0 2. 16.0 20.0 4. 4. 4.8999996 0. 1. + 9773. 1. 5. 37.0 16.5 2.0 3. 12.0 20.0 5. 5. 4.0727262 0. 1. + 9779. 1. 4. 17.5 2.5 0.0 2. 12.0 11.5 2. 5. 4.7999992 0. 1. + 9780. 1. 5. 42.0 23.0 2.0 3. 17.0 20.0 5. 2. 0.5326087 0. 1. + 9797. 1. 3. 32.0 13.0 2.0 3. 14.0 40.0 5. 2. 3.2307692 0. 1. + 9807. 1. 3. 42.0 23.0 3.0 2. 12.0 9.0 4. 4. 1.2173910 0. 1. + 9810. 1. 4. 27.0 2.5 0.0 3. 14.0 14.0 3. 4. 1.3999996 0. 1. + 9813. 1. 5. 42.0 13.0 0.0 2. 12.0 14.0 5. 5. 0.9230769 0. 1. + 9825. 1. 2. 32.0 9.0 2.0 4. 16.0 20.0 4. 4. 2.1777763 0. 1. + 9832. 1. 3. 27.0 6.0 1.0 3. 14.0 20.0 3. 4. 3.2666645 0. 1. + 9838. 1. 2. 27.0 9.0 3.0 3. 12.0 11.5 5. 4. 2.1777763 0. 1. + 9846. 1. 3. 27.0 6.0 2.0 3. 14.0 20.0 4. 6. 0.5833333 0. 1. + 9864. 1. 5. 27.0 9.0 2.0 1. 14.0 20.0 3. 4. 4.9777775 0. 1. + 9877. 1. 2. 27.0 13.0 1.0 3. 12.0 20.0 3. 2. 0.0769231 0. 1. + 9896. 1. 4. 27.0 13.0 2.0 2. 12.0 14.0 3. 4. 0.0769231 0. 1. + 9905. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 4. 4.7999992 0. 1. + 9906. 1. 4. 27.0 9.0 0.0 3. 12.0 9.0 2. 4. 4.6666660 0. 1. + 9922. 1. 3. 27.0 9.0 2.0 3. 12.0 20.0 4. 5. 0.3888888 0. 1. + 9925. 1. 3. 22.0 2.5 0.0 2. 17.0 11.5 2. 6. 3.1999998 0. 1. + 9930. 1. 3. 27.0 6.0 1.0 3. 14.0 20.0 3. 3. 2.0416660 0. 1. + 9933. 1. 4. 27.0 6.0 0.0 2. 14.0 14.0 5. 3. 2.0000000 0. 1. + 9937. 1. 4. 32.0 16.5 3.0 3. 14.0 20.0 5. 5. 0.0606061 0. 1. + 9938. 1. 4. 32.0 16.5 2.0 3. 12.0 20.0 5. 5. 0.7424242 0. 1. + 9942. 1. 3. 42.0 16.5 2.0 4. 16.0 20.0 5. 5. 0.2121212 0. 1. + 9948. 1. 3. 32.0 6.0 2.0 3. 14.0 14.0 3. 4. 2.0000000 0. 1. + 9950. 1. 3. 37.0 23.0 4.0 4. 9.0 20.0 5. 5. 0.5326087 0. 1. + 9962. 1. 1. 42.0 16.5 1.0 2. 12.0 20.0 3. 5. 1.1878777 0. 1. + 9963. 1. 2. 42.0 23.0 5.5 3. 14.0 20.0 2. 2. 0.5217391 0. 1. + 9966. 1. 5. 37.0 16.5 4.0 4. 14.0 20.0 3. 3. 0.0606061 0. 1. + 9968. 1. 5. 42.0 23.0 1.0 3. 14.0 14.0 3. 5. 0.8521735 0. 1. + 9975. 1. 3. 22.0 2.5 1.0 2. 12.0 4.0 2. 2. 7.8399963 0. 1. + 9991. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 5. 4. 4.8999996 0. 1. + 9995. 1. 2. 27.0 6.0 1.0 2. 14.0 20.0 3. 4. 0.1666666 0. 1. + 10007. 1. 1. 32.0 13.0 2.0 2. 16.0 20.0 4. 6. 0.0769231 0. 1. + 10008. 1. 3. 32.0 16.5 2.0 2. 16.0 14.0 4. 2. 1.1878777 0. 1. + 10024. 1. 5. 27.0 9.0 1.0 3. 14.0 14.0 3. 5. 2.1777763 0. 1. + 10046. 1. 3. 22.0 6.0 1.0 1. 12.0 11.5 3. 2. 3.2666645 0. 1. + 10054. 1. 4. 27.0 6.0 2.0 3. 12.0 11.5 3. 2. 1.3333330 0. 1. + 10066. 1. 4. 37.0 16.5 2.0 4. 17.0 40.0 6. 6. 0.4848484 0. 1. + 10073. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 3. 3. 0.4000000 0. 1. + 10085. 1. 1. 42.0 23.0 3.0 3. 14.0 20.0 3. 5. 0.8521735 0. 1. + 10088. 1. 2. 22.0 2.5 0.0 2. 12.0 20.0 3. 5. 4.7999992 0. 1. + 10093. 1. 4. 37.0 13.0 1.0 3. 20.0 14.0 4. 2. 1.5076914 0. 1. + 10098. 1. 2. 27.0 6.0 1.0 2. 12.0 11.5 2. 2. 0.5833333 0. 1. + 10103. 1. 5. 27.0 9.0 2.0 3. 20.0 11.5 4. 4. 0.3888888 0. 1. + 10115. 1. 3. 42.0 23.0 3.0 3. 12.0 20.0 2. 2. 1.8260860 0. 1. + 10116. 1. 3. 42.0 16.5 2.0 3. 14.0 20.0 3. 2. 0.7272727 0. 1. + 10123. 1. 2. 32.0 16.5 1.0 1. 17.0 40.0 4. 6. 0.2121212 0. 1. + 10124. 1. 4. 22.0 2.5 1.0 2. 14.0 14.0 3. 5. 0.4000000 0. 1. + 10125. 1. 5. 42.0 23.0 3.0 4. 16.0 20.0 3. 4. 0.8521735 0. 1. + 10134. 1. 4. 27.0 13.0 2.0 3. 14.0 14.0 3. 5. 3.2307692 0. 1. + 10146. 1. 1. 32.0 13.0 1.0 2. 12.0 40.0 3. 3. 0.0769231 0. 1. + 10147. 1. 3. 42.0 23.0 5.5 2. 14.0 40.0 5. 6. 0.5217391 0. 1. + 10170. 1. 5. 37.0 23.0 2.0 3. 12.0 20.0 3. 5. 1.8260860 0. 1. + 10188. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 4. 1. 4.8999996 0. 1. + 10199. 1. 3. 27.0 6.0 0.0 2. 14.0 11.5 3. 6. 2.0000000 0. 1. + 10219. 1. 4. 22.0 2.5 1.0 1. 14.0 6.5 2. 2. 1.3999996 0. 1. + 10224. 1. 5. 37.0 13.0 2.0 1. 12.0 20.0 3. 4. 0.9423077 0. 1. + 10228. 1. 4. 42.0 23.0 3.0 2. 14.0 11.5 3. 3. 0.8521735 0. 1. + 10237. 1. 3. 27.0 6.0 2.0 3. 20.0 40.0 4. 2. 0.5833333 0. 1. + 10245. 1. 4. 27.0 6.0 2.0 2. 12.0 20.0 2. 5. 2.0416660 0. 1. + 10253. 1. 2. 27.0 2.5 1.0 3. 14.0 9.0 2. 4. 7.8399963 0. 1. + 10265. 1. 5. 42.0 23.0 4.0 1. 12.0 40.0 5. 6. 0.1521739 0. 1. + 10268. 1. 3. 42.0 13.0 0.0 3. 17.0 20.0 3. 2. 0.9230769 0. 1. + 10273. 1. 5. 27.0 6.0 0.0 3. 14.0 9.0 3. 5. 0.5833333 0. 1. + 10284. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 2. 1.3999996 0. 1. + 10285. 1. 3. 27.0 13.0 3.0 3. 12.0 11.5 4. 4. 5.1692305 0. 1. + 10297. 1. 3. 32.0 9.0 0.0 2. 14.0 20.0 3. 4. 0.8888888 0. 1. + 10300. 1. 1. 37.0 16.5 1.0 3. 14.0 11.5 2. 5. 0.2121212 0. 1. + 10309. 1. 3. 37.0 23.0 2.0 3. 12.0 20.0 5. 5. 0.8521735 0. 1. + 10317. 1. 2. 32.0 16.5 2.0 2. 12.0 14.0 3. 4. 0.7272727 0. 1. + 10337. 1. 3. 27.0 6.0 0.0 1. 16.0 11.5 4. 1. 7.4666672 0. 1. + 10343. 1. 4. 42.0 16.5 3.0 2. 14.0 20.0 5. 4. 0.7424242 0. 1. + 10352. 1. 1. 42.0 16.5 1.0 3. 12.0 40.0 5. 5. 1.1878777 0. 1. + 10355. 1. 3. 32.0 16.5 3.0 4. 12.0 11.5 4. 2. 0.7272727 0. 1. + 10370. 1. 5. 27.0 6.0 1.0 4. 14.0 20.0 3. 3. 2.0416660 0. 1. + 10380. 1. 2. 32.0 16.5 2.0 2. 14.0 20.0 2. 3. 4.0727262 0. 1. + 10385. 1. 2. 17.5 2.5 0.0 2. 12.0 20.0 3. 2. 16.7999878 0. 1. + 10404. 1. 4. 32.0 16.5 2.0 3. 14.0 20.0 3. 4. 0.7424242 0. 1. + 10434. 1. 3. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 7.8399963 0. 1. + 10457. 1. 5. 27.0 6.0 0.0 3. 16.0 20.0 3. 6. 2.0000000 0. 1. + 10478. 1. 5. 37.0 23.0 3.0 3. 12.0 20.0 3. 5. 0.1521739 0. 1. + 10483. 1. 3. 32.0 13.0 0.0 2. 12.0 20.0 5. 2. 0.2692307 0. 1. + 10492. 1. 4. 42.0 23.0 1.0 2. 14.0 20.0 5. 5. 0.0434783 0. 1. + 10498. 1. 1. 42.0 23.0 2.0 3. 14.0 20.0 3. 4. 2.9217386 0. 1. + 10499. 1. 2. 37.0 23.0 3.0 2. 12.0 20.0 3. 3. 1.9478254 0. 1. + 10500. 1. 4. 22.0 0.5 0.0 3. 16.0 11.5 4. 6. 7.0000000 0. 1. + 10519. 1. 5. 27.0 9.0 2.0 2. 14.0 11.5 3. 4. 0.1111111 0. 1. + 10525. 1. 4. 22.0 0.5 0.0 1. 14.0 20.0 5. 4. 16.0000000 0. 1. + 10530. 1. 3. 27.0 9.0 2.0 2. 17.0 20.0 4. 4. 1.3611107 0. 1. + 10532. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 3. 5. 1.2173910 0. 1. + 10540. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 5. 5. 1.3999996 0. 1. + 10545. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 17.9199982 0. 1. + 10546. 1. 4. 27.0 13.0 2.0 3. 14.0 20.0 5. 5. 0.9423077 0. 1. + 10550. 1. 4. 27.0 6.0 1.0 3. 16.0 20.0 4. 6. 2.0416660 0. 1. + 10551. 1. 3. 42.0 23.0 3.0 2. 14.0 20.0 2. 2. 0.5217391 0. 1. + 10572. 1. 3. 27.0 6.0 2.0 1. 12.0 9.0 4. 3. 2.0416660 0. 1. + 10579. 1. 5. 42.0 23.0 2.0 2. 16.0 20.0 3. 5. 0.8521735 0. 1. + 10590. 1. 3. 42.0 23.0 2.0 4. 14.0 40.0 3. 6. 0.0434783 0. 1. + 10594. 1. 5. 32.0 16.5 1.0 3. 14.0 14.0 3. 5. 0.2121212 0. 1. + 10604. 1. 4. 27.0 6.0 2.0 3. 14.0 20.0 5. 5. 0.1666666 0. 1. + 10605. 1. 2. 37.0 23.0 3.0 1. 14.0 40.0 5. 5. 0.1521739 0. 1. + 10614. 1. 4. 22.0 6.0 1.0 3. 14.0 6.5 3. 1. 3.2666645 0. 1. + 10616. 1. 2. 27.0 9.0 2.0 3. 12.0 14.0 3. 4. 1.3333330 0. 1. + 10617. 1. 5. 27.0 9.0 2.0 1. 14.0 20.0 4. 4. 2.1777763 0. 1. + 10625. 1. 4. 27.0 2.5 0.0 3. 14.0 40.0 3. 4. 16.7999878 0. 1. + 10638. 1. 5. 37.0 16.5 2.0 2. 14.0 40.0 3. 5. 0.7272727 0. 1. + 10649. 1. 3. 22.0 2.5 1.0 2. 14.0 6.5 2. 2. 0.4000000 0. 1. + 10655. 1. 4. 27.0 2.5 1.0 2. 16.0 20.0 3. 6. 0.4000000 0. 1. + 10659. 1. 1. 27.0 6.0 1.0 1. 12.0 9.0 3. 5. 0.1666666 0. 1. + 10669. 1. 4. 37.0 16.5 5.5 3. 17.0 9.0 4. 2. 0.2121212 0. 1. + 10672. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 4. 3. 4.8999996 0. 1. + 10689. 1. 2. 22.0 2.5 1.0 1. 14.0 20.0 2. 6. 1.3999996 0. 1. + 10694. 1. 5. 42.0 16.5 2.0 3. 12.0 20.0 3. 3. 0.7424242 0. 1. + 10711. 1. 3. 22.0 6.0 1.0 2. 12.0 20.0 4. 4. 1.3333330 0. 1. + 10712. 1. 3. 37.0 23.0 3.0 3. 12.0 20.0 3. 4. 1.9478254 0. 1. + 10714. 1. 4. 27.0 6.0 1.0 3. 14.0 20.0 3. 2. 2.0416660 0. 1. + 10736. 1. 2. 32.0 16.5 4.0 2. 12.0 20.0 3. 4. 1.1878777 0. 1. + 10741. 1. 3. 27.0 9.0 1.0 2. 14.0 20.0 3. 5. 0.3888888 0. 1. + 10752. 1. 5. 32.0 16.5 3.0 3. 16.0 20.0 4. 6. 0.2121212 0. 1. + 10769. 1. 5. 22.0 6.0 1.0 2. 12.0 6.5 3. 2. 0.5833333 0. 1. + 10775. 1. 3. 27.0 13.0 3.0 2. 12.0 20.0 2. 4. 0.2692307 0. 1. + 10777. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 3. 1.3999996 0. 1. + 10788. 1. 4. 32.0 2.5 0.0 2. 14.0 40.0 5. 6. 1.3999996 0. 1. + 10795. 1. 3. 27.0 6.0 1.0 2. 14.0 11.5 3. 5. 2.0416660 0. 1. + 10797. 1. 3. 27.0 6.0 2.0 3. 12.0 14.0 3. 6. 0.1666666 0. 1. + 10807. 1. 2. 32.0 13.0 2.0 3. 12.0 20.0 3. 3. 0.2692307 0. 1. + 10808. 1. 4. 32.0 16.5 2.0 3. 14.0 20.0 2. 5. 0.2121212 0. 1. + 10826. 1. 3. 27.0 6.0 2.0 2. 12.0 20.0 5. 2. 2.0000000 0. 1. + 10827. 1. 4. 27.0 9.0 2.0 1. 17.0 14.0 4. 5. 2.1777763 0. 1. + 10836. 1. 4. 37.0 16.5 2.0 2. 12.0 14.0 4. 4. 1.1878777 0. 1. + 10841. 1. 3. 22.0 2.5 0.0 3. 16.0 9.0 3. 4. 4.7999992 0. 1. + 10857. 1. 4. 27.0 9.0 2.0 2. 14.0 20.0 5. 5. 1.3611107 0. 1. + 10893. 1. 3. 32.0 16.5 4.0 2. 12.0 11.5 3. 5. 1.6969690 0. 1. + 10897. 1. 3. 27.0 9.0 2.0 4. 14.0 14.0 3. 2. 2.1777763 0. 1. + 10898. 1. 4. 32.0 13.0 2.0 2. 16.0 20.0 2. 5. 0.2692307 0. 1. + 10905. 1. 2. 37.0 23.0 2.0 3. 14.0 20.0 3. 5. 0.5217391 0. 1. + 10922. 1. 4. 22.0 2.5 0.0 1. 17.0 11.5 3. 4. 17.9199982 0. 1. + 10928. 1. 4. 27.0 6.0 0.0 1. 17.0 14.0 4. 4. 0.1666666 0. 1. + 10933. 1. 4. 27.0 6.0 1.0 2. 12.0 20.0 3. 6. 7.0000000 0. 1. + 10935. 1. 3. 22.0 6.0 0.0 3. 12.0 9.0 3. 2. 0.5833333 0. 1. + 10947. 1. 3. 42.0 23.0 3.0 2. 12.0 11.5 3. 2. 1.8260860 0. 1. + 10964. 1. 4. 27.0 6.0 3.0 3. 16.0 9.0 3. 2. 2.0416660 0. 1. + 10966. 1. 4. 32.0 16.5 3.0 3. 12.0 20.0 3. 3. 1.1878777 0. 1. + 10971. 1. 3. 27.0 13.0 2.0 3. 12.0 9.0 5. 5. 3.4461536 0. 1. + 10972. 1. 3. 27.0 16.5 2.0 4. 14.0 11.5 3. 4. 0.2121212 0. 1. + 10991. 1. 3. 27.0 6.0 3.0 2. 14.0 9.0 2. 2. 0.1666666 0. 1. + 11004. 1. 5. 22.0 2.5 0.0 3. 12.0 6.5 5. 2. 0.4000000 0. 1. + 11012. 1. 4. 42.0 23.0 2.0 2. 16.0 20.0 5. 5. 1.2173910 0. 1. + 11020. 1. 1. 22.0 2.5 1.0 3. 14.0 20.0 3. 5. 4.8999996 0. 1. + 11021. 1. 4. 42.0 23.0 3.0 3. 16.0 14.0 4. 3. 0.1521739 0. 1. + 11056. 1. 3. 32.0 16.5 2.0 4. 16.0 20.0 4. 4. 0.7424242 0. 1. + 11068. 1. 3. 32.0 16.5 2.0 4. 12.0 14.0 3. 3. 0.7272727 0. 1. + 11072. 1. 4. 22.0 2.5 1.0 2. 14.0 11.5 3. 3. 4.7999992 0. 1. + 11086. 1. 3. 22.0 6.0 1.0 3. 14.0 20.0 3. 5. 0.5833333 0. 1. + 11099. 1. 4. 27.0 6.0 0.0 2. 12.0 11.5 3. 4. 0.1666666 0. 1. + 11104. 1. 5. 32.0 16.5 4.0 4. 9.0 11.5 2. 4. 0.0606061 0. 1. + 11122. 1. 1. 27.0 6.0 1.0 3. 20.0 14.0 4. 4. 2.0000000 0. 1. + 11123. 1. 2. 22.0 2.5 0.0 1. 14.0 20.0 3. 2. 4.8999996 0. 1. + 11127. 1. 5. 27.0 9.0 3.0 4. 14.0 20.0 2. 5. 0.3888888 0. 1. + 11142. 1. 3. 27.0 6.0 1.0 2. 16.0 20.0 3. 1. 7.0000000 0. 1. + 11150. 1. 4. 32.0 16.5 2.0 1. 16.0 40.0 5. 5. 2.5454540 0. 1. + 11156. 1. 5. 27.0 6.0 0.0 3. 12.0 14.0 3. 3. 2.0416660 0. 1. + 11179. 1. 4. 42.0 23.0 2.0 3. 12.0 6.5 5. 2. 0.5326087 0. 1. + 11182. 1. 3. 27.0 9.0 2.0 2. 12.0 14.0 3. 4. 2.1777763 0. 1. + 11192. 1. 4. 27.0 9.0 0.0 3. 14.0 20.0 3. 3. 2.1777763 0. 1. + 11193. 1. 4. 27.0 13.0 2.0 3. 17.0 20.0 4. 2. 3.4461536 0. 1. + 11210. 1. 5. 32.0 16.5 2.0 3. 17.0 14.0 4. 4. 1.1878777 0. 1. + 11215. 1. 4. 27.0 6.0 1.0 2. 12.0 14.0 5. 4. 3.2666645 0. 1. + 11217. 1. 4. 42.0 23.0 4.0 4. 12.0 40.0 5. 5. 0.5326087 0. 1. + 11222. 1. 1. 42.0 23.0 2.0 4. 14.0 9.0 3. 2. 0.3478261 0. 1. + 11233. 1. 2. 22.0 2.5 1.0 3. 14.0 20.0 3. 4. 1.3999996 0. 1. + 11234. 1. 1. 32.0 9.0 3.0 2. 14.0 20.0 4. 4. 1.3611107 0. 1. + 11245. 1. 3. 27.0 6.0 1.0 3. 12.0 6.5 4. 3. 0.5833333 0. 1. + 11252. 1. 4. 27.0 2.5 0.0 1. 16.0 14.0 4. 1. 4.7999992 0. 1. + 11255. 1. 5. 42.0 23.0 2.0 1. 17.0 14.0 4. 5. 0.5217391 0. 1. + 11257. 1. 5. 32.0 16.5 2.0 3. 14.0 20.0 3. 5. 0.4848484 0. 1. + 11269. 1. 4. 32.0 16.5 2.0 4. 12.0 40.0 3. 4. 2.5454540 0. 1. + 11281. 1. 5. 42.0 23.0 3.0 3. 14.0 20.0 4. 2. 0.5326087 0. 1. + 11285. 1. 4. 37.0 16.5 2.0 1. 16.0 40.0 3. 5. 0.7272727 0. 1. + 11288. 1. 2. 32.0 9.0 0.0 2. 12.0 9.0 3. 4. 0.1111111 0. 1. + 11302. 1. 4. 37.0 16.5 2.0 4. 12.0 20.0 3. 4. 0.4848484 0. 1. + 11310. 1. 3. 32.0 6.0 3.0 2. 14.0 9.0 3. 4. 0.5833333 0. 1. + 11314. 1. 5. 37.0 23.0 2.0 2. 14.0 40.0 3. 5. 0.3478261 0. 1. + 11315. 1. 2. 32.0 13.0 0.0 2. 12.0 20.0 3. 4. 1.5076914 0. 1. + 11365. 1. 4. 32.0 13.0 2.0 3. 14.0 20.0 3. 4. 3.2307692 0. 1. + 11372. 1. 4. 37.0 16.5 3.0 3. 14.0 14.0 3. 3. 0.2121212 0. 1. + 11382. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 5. 4.7999992 0. 1. + 11384. 1. 5. 42.0 23.0 4.0 2. 14.0 11.5 3. 4. 0.8521735 0. 1. + 11406. 1. 3. 32.0 16.5 2.0 4. 12.0 20.0 3. 5. 1.1878777 0. 1. + 11409. 1. 4. 42.0 23.0 4.0 3. 9.0 14.0 3. 5. 1.9478254 0. 1. + 11418. 1. 5. 22.0 2.5 1.0 2. 12.0 11.5 3. 4. 4.8999996 0. 1. + 11429. 1. 2. 32.0 9.0 0.0 2. 14.0 6.5 3. 4. 0.8888888 0. 1. + 11433. 1. 5. 32.0 13.0 1.0 2. 14.0 20.0 3. 5. 0.2692307 0. 1. + 11449. 1. 2. 32.0 16.5 3.0 2. 12.0 11.5 5. 2. 0.7424242 0. 1. + 11459. 1. 5. 27.0 6.0 1.0 1. 14.0 20.0 5. 5. 2.0000000 0. 1. + 11461. 1. 4. 42.0 23.0 4.0 2. 14.0 14.0 3. 4. 0.8521735 0. 1. + 11465. 1. 3. 27.0 6.0 1.0 2. 14.0 11.5 5. 2. 3.2666645 0. 1. + 11470. 1. 3. 32.0 13.0 1.0 1. 16.0 20.0 4. 2. 0.6153846 0. 1. + 11472. 1. 2. 27.0 6.0 2.0 3. 12.0 6.5 3. 5. 0.1666666 0. 1. + 11473. 1. 4. 27.0 9.0 2.0 3. 12.0 11.5 4. 4. 1.3611107 0. 1. + 11486. 1. 5. 22.0 2.5 1.0 1. 14.0 9.0 3. 2. 11.1999998 0. 1. + 11489. 1. 2. 22.0 2.5 1.0 3. 14.0 20.0 5. 6. 7.8399963 0. 1. + 11509. 1. 5. 22.0 2.5 0.0 1. 16.0 11.5 5. 4. 0.4000000 0. 1. + 11520. 1. 4. 37.0 23.0 4.0 3. 14.0 40.0 3. 5. 1.9478254 0. 1. + 11522. 1. 2. 32.0 16.5 4.0 3. 12.0 6.5 3. 4. 0.7424242 0. 1. + 11524. 1. 3. 22.0 6.0 1.0 3. 12.0 11.5 3. 4. 2.0416660 0. 1. + 11529. 1. 3. 32.0 9.0 2.0 3. 12.0 9.0 3. 4. 16.0000000 0. 1. + 11531. 1. 1. 27.0 2.5 0.0 2. 12.0 11.5 4. 3. 4.8999996 0. 1. + 11542. 1. 5. 42.0 23.0 2.0 3. 14.0 20.0 3. 4. 0.5217391 0. 1. + 11555. 1. 4. 27.0 13.0 1.0 2. 12.0 14.0 3. 4. 0.0769231 0. 1. + 11557. 1. 4. 32.0 9.0 2.0 3. 17.0 4.0 3. 4. 1.3611107 0. 1. + 11585. 1. 5. 42.0 23.0 4.0 4. 14.0 20.0 5. 4. 0.5326087 0. 1. + 11588. 1. 4. 27.0 6.0 2.0 3. 12.0 6.5 2. 2. 2.0416660 0. 1. + 11590. 1. 5. 32.0 16.5 2.0 4. 16.0 40.0 5. 6. 1.6969690 0. 1. + 11591. 1. 5. 27.0 9.0 2.0 1. 16.0 20.0 2. 5. 0.3888888 0. 1. + 11597. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 2. 1. 2.0416660 0. 1. + 11600. 1. 5. 32.0 13.0 2.0 1. 12.0 14.0 3. 4. 0.0769231 0. 1. + 11620. 1. 3. 42.0 23.0 2.0 3. 12.0 20.0 3. 5. 0.1521739 0. 1. + 11629. 1. 4. 27.0 16.5 4.0 3. 17.0 40.0 4. 6. 2.5454540 0. 1. + 11634. 1. 3. 37.0 16.5 2.0 3. 12.0 14.0 3. 4. 0.7272727 0. 1. + 11650. 1. 5. 27.0 6.0 2.0 3. 14.0 14.0 4. 2. 3.2666645 0. 1. + 11653. 1. 2. 17.5 2.5 1.0 3. 12.0 9.0 3. 2. 1.3999996 0. 1. + 11669. 1. 4. 22.0 2.5 1.0 2. 14.0 9.0 3. 5. 1.3999996 0. 1. + 11675. 1. 5. 27.0 6.0 1.0 3. 14.0 20.0 3. 3. 2.0416660 0. 1. + 11699. 1. 5. 27.0 6.0 2.0 2. 12.0 9.0 4. 4. 0.1666666 0. 1. + 11705. 1. 3. 37.0 23.0 3.0 4. 12.0 20.0 5. 2. 0.8521735 0. 1. + 11710. 1. 3. 27.0 6.0 3.0 2. 16.0 11.5 4. 4. 0.5833333 0. 1. + 11727. 1. 3. 22.0 2.5 1.0 2. 12.0 9.0 3. 2. 1.3999996 0. 1. + 11734. 1. 5. 27.0 13.0 3.0 1. 12.0 14.0 3. 5. 1.5076914 0. 1. + 11736. 1. 4. 27.0 9.0 1.0 4. 14.0 14.0 3. 3. 1.3611107 0. 1. + 11752. 1. 1. 37.0 23.0 5.5 2. 12.0 20.0 3. 4. 0.5217391 0. 1. + 11754. 1. 5. 42.0 23.0 3.0 1. 16.0 20.0 4. 6. 0.8521735 0. 1. + 11755. 1. 4. 27.0 2.5 0.0 1. 16.0 40.0 5. 6. 7.8399963 0. 1. + 11764. 1. 4. 32.0 13.0 2.0 2. 12.0 40.0 5. 4. 0.9423077 0. 1. + 11765. 1. 3. 27.0 9.0 2.0 2. 14.0 20.0 5. 5. 1.3611107 0. 1. + 11766. 1. 4. 22.0 2.5 0.0 1. 14.0 6.5 3. 4. 4.8999996 0. 1. + 11769. 1. 4. 22.0 2.5 0.0 1. 12.0 4.0 3. 2. 1.3999996 0. 1. + 11773. 1. 4. 27.0 6.0 1.0 3. 17.0 14.0 4. 5. 0.1666666 0. 1. + 11781. 1. 4. 37.0 23.0 5.5 2. 12.0 14.0 3. 4. 0.5217391 0. 1. + 11799. 1. 5. 32.0 16.5 2.0 1. 12.0 11.5 2. 4. 0.2121212 0. 1. + 11818. 1. 2. 22.0 6.0 2.0 4. 17.0 14.0 3. 5. 2.0000000 0. 1. + 11831. 1. 2. 22.0 2.5 0.0 1. 17.0 9.0 4. 4. 26.8799896 0. 1. + 11838. 1. 4. 27.0 6.0 0.0 3. 14.0 11.5 2. 2. 7.4666672 0. 1. + 11846. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 1.3999996 0. 1. + 11864. 1. 5. 42.0 23.0 3.0 3. 12.0 14.0 3. 5. 2.7826080 0. 1. + 11866. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 5. 4. 0.9423077 0. 1. + 11869. 1. 5. 32.0 13.0 2.0 2. 14.0 9.0 5. 4. 1.5076914 0. 1. + 11896. 1. 3. 42.0 23.0 5.5 3. 20.0 40.0 6. 4. 2.9217386 0. 1. + 11897. 1. 5. 22.0 2.5 1.0 1. 12.0 6.5 3. 5. 1.3999996 0. 1. + 11900. 1. 2. 22.0 2.5 0.0 1. 16.0 11.5 3. 5. 17.9199982 0. 1. + 11902. 1. 3. 42.0 23.0 2.0 3. 16.0 40.0 4. 5. 0.1521739 0. 1. + 11913. 1. 3. 27.0 6.0 0.0 2. 12.0 20.0 3. 4. 4.6666660 0. 1. + 11920. 1. 3. 27.0 13.0 0.0 3. 12.0 20.0 3. 5. 0.9423077 0. 1. + 11925. 1. 4. 22.0 2.5 0.0 2. 12.0 6.5 2. 4. 4.7999992 0. 1. + 11954. 1. 3. 32.0 13.0 2.0 3. 14.0 11.5 3. 3. 1.5076914 0. 1. + 11959. 1. 5. 37.0 16.5 3.0 2. 12.0 20.0 3. 5. 0.7272727 0. 1. + 11968. 1. 3. 27.0 9.0 1.0 3. 14.0 40.0 3. 3. 2.1777763 0. 1. + 11974. 1. 5. 42.0 23.0 2.0 2. 12.0 40.0 5. 4. 0.8521735 0. 1. + 11987. 1. 5. 27.0 2.5 0.0 1. 17.0 14.0 4. 5. 4.8999996 0. 1. + 11994. 1. 3. 32.0 0.5 0.0 2. 16.0 14.0 4. 5. 24.5000000 0. 1. + 11999. 1. 4. 32.0 13.0 2.0 3. 12.0 11.5 3. 1. 0.0769231 0. 1. + 12013. 1. 3. 42.0 23.0 5.5 3. 12.0 14.0 3. 2. 0.1521739 0. 1. + 12017. 1. 1. 42.0 23.0 2.0 3. 14.0 11.5 3. 5. 0.8521735 0. 1. + 12022. 1. 3. 37.0 16.5 2.0 1. 17.0 20.0 4. 2. 0.7272727 0. 1. + 12028. 1. 4. 27.0 9.0 1.0 1. 14.0 20.0 3. 4. 1.3611107 0. 1. + 12038. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 1.3999996 0. 1. + 12044. 1. 4. 37.0 23.0 5.5 2. 14.0 20.0 3. 6. 1.2173910 0. 1. + 12050. 1. 5. 32.0 9.0 3.0 2. 14.0 11.5 2. 6. 0.3888888 0. 1. + 12072. 1. 4. 37.0 9.0 3.0 3. 16.0 40.0 4. 2. 2.1777763 0. 1. + 12101. 1. 5. 37.0 16.5 3.0 3. 16.0 11.5 3. 4. 1.6969690 0. 1. + 12102. 1. 4. 32.0 13.0 2.0 2. 12.0 20.0 5. 5. 0.2692307 0. 1. + 12105. 1. 3. 37.0 23.0 3.0 4. 12.0 20.0 3. 5. 0.5217391 0. 1. + 12111. 1. 4. 42.0 23.0 3.0 4. 16.0 20.0 4. 2. 1.2173910 0. 1. + 12118. 1. 3. 27.0 6.0 1.0 2. 12.0 11.5 3. 4. 0.5833333 0. 1. + 12119. 1. 5. 42.0 23.0 2.0 3. 16.0 20.0 3. 5. 0.5326087 0. 1. + 12131. 1. 5. 27.0 6.0 1.0 3. 20.0 20.0 5. 6. 1.3333330 0. 1. + 12135. 1. 3. 37.0 16.5 3.0 2. 12.0 20.0 3. 2. 2.7151508 0. 1. + 12136. 1. 3. 27.0 13.0 2.0 3. 12.0 9.0 3. 5. 0.9230769 0. 1. + 12147. 1. 5. 37.0 23.0 3.0 1. 12.0 20.0 3. 4. 0.0434783 0. 1. + 12168. 1. 3. 42.0 23.0 5.5 3. 12.0 20.0 3. 4. 0.0434783 0. 1. + 12174. 1. 2. 27.0 9.0 0.0 2. 17.0 11.5 2. 3. 1.3611107 0. 1. + 12177. 1. 2. 22.0 2.5 0.0 3. 12.0 6.5 2. 3. 0.4000000 0. 1. + 12181. 1. 4. 27.0 13.0 2.0 2. 12.0 11.5 3. 2. 0.0769231 0. 1. + 12188. 1. 4. 32.0 9.0 1.0 1. 16.0 40.0 4. 5. 4.9777775 0. 1. + 12212. 1. 3. 32.0 9.0 3.0 3. 14.0 40.0 3. 6. 2.1777763 0. 1. + 12216. 1. 4. 32.0 13.0 1.0 3. 14.0 20.0 5. 5. 0.2692307 0. 1. + 12218. 1. 5. 22.0 2.5 0.0 3. 16.0 6.5 4. 1. 1.3999996 0. 1. + 12222. 1. 3. 27.0 6.0 1.0 2. 17.0 11.5 4. 4. 4.6666660 0. 1. + 12225. 1. 4. 27.0 2.5 0.0 2. 16.0 14.0 4. 2. 7.8399963 0. 1. + 12230. 1. 3. 27.0 6.0 0.0 1. 16.0 40.0 4. 4. 1.3333330 0. 1. + 12240. 1. 3. 42.0 16.5 4.0 3. 16.0 14.0 2. 4. 0.2121212 0. 1. + 12245. 1. 1. 27.0 2.5 1.0 3. 16.0 20.0 4. 4. 1.3999996 0. 1. + 12247. 1. 5. 27.0 9.0 1.0 2. 14.0 20.0 4. 4. 3.1111107 0. 1. + 12252. 1. 4. 42.0 23.0 2.0 3. 12.0 14.0 3. 5. 1.8260860 0. 1. + 12278. 1. 4. 27.0 13.0 2.0 2. 12.0 20.0 3. 4. 0.9230769 0. 1. + 12307. 1. 5. 32.0 13.0 1.0 1. 14.0 14.0 4. 4. 0.9423077 0. 1. + 12308. 1. 4. 22.0 2.5 1.0 2. 14.0 6.5 3. 4. 7.8399963 0. 1. + 12309. 1. 2. 27.0 9.0 2.0 2. 14.0 20.0 5. 5. 4.6666660 0. 1. + 12321. 1. 5. 22.0 2.5 0.0 4. 14.0 9.0 3. 4. 4.8999996 0. 1. + 12329. 1. 3. 37.0 16.5 3.0 3. 14.0 14.0 3. 3. 0.2121212 0. 1. + 12374. 1. 3. 27.0 6.0 1.0 3. 14.0 11.5 3. 4. 7.0000000 0. 1. + 12380. 1. 4. 32.0 13.0 2.0 1. 12.0 20.0 2. 4. 3.4461536 0. 1. + 12399. 1. 3. 42.0 23.0 2.0 2. 16.0 20.0 4. 5. 0.5217391 0. 1. + 12406. 1. 4. 37.0 16.5 3.0 3. 12.0 40.0 3. 5. 0.2121212 0. 1. + 12415. 1. 4. 32.0 13.0 2.0 1. 12.0 11.5 2. 4. 1.5076914 0. 1. + 12419. 1. 3. 42.0 23.0 5.5 2. 12.0 20.0 3. 4. 2.9217386 0. 1. + 12432. 1. 3. 27.0 9.0 1.0 1. 14.0 6.5 3. 4. 1.3611107 0. 1. + 12438. 1. 5. 32.0 16.5 2.0 3. 12.0 9.0 3. 2. 0.7424242 0. 1. + 12478. 1. 5. 32.0 16.5 1.0 2. 14.0 20.0 5. 5. 0.2121212 0. 1. + 12484. 1. 5. 27.0 6.0 2.0 2. 20.0 14.0 6. 6. 4.6666660 0. 1. + 12496. 1. 4. 27.0 6.0 2.0 3. 12.0 9.0 3. 2. 0.1666666 0. 1. + 12497. 1. 3. 22.0 6.0 1.0 3. 14.0 9.0 5. 4. 0.5833333 0. 1. + 12499. 1. 5. 27.0 16.5 3.0 3. 14.0 40.0 5. 5. 0.2121212 0. 1. + 12514. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 5. 6. 4.8999996 0. 1. + 12524. 1. 3. 42.0 23.0 5.5 3. 14.0 40.0 3. 5. 0.5217391 0. 1. + 12525. 1. 4. 37.0 23.0 3.0 2. 12.0 40.0 3. 3. 0.5217391 0. 1. + 12529. 1. 1. 42.0 16.5 3.0 4. 17.0 20.0 4. 4. 1.1878777 0. 1. + 12536. 1. 3. 27.0 2.5 0.0 2. 16.0 9.0 4. 2. 4.7999992 0. 1. + 12549. 1. 2. 27.0 6.0 2.0 2. 12.0 11.5 5. 1. 0.1666666 0. 1. + 12577. 1. 5. 27.0 9.0 3.0 2. 16.0 14.0 4. 4. 0.1111111 0. 1. + 12582. 1. 5. 27.0 6.0 2.0 2. 12.0 20.0 5. 3. 0.5833333 0. 1. + 12583. 1. 3. 32.0 16.5 3.0 1. 14.0 14.0 2. 2. 0.4848484 0. 1. + 12591. 1. 4. 27.0 6.0 2.0 2. 14.0 6.5 3. 4. 0.5833333 0. 1. + 12595. 1. 4. 27.0 0.5 0.0 3. 17.0 20.0 4. 6. 7.0000000 0. 1. + 12596. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 3. 3. 3.2666645 0. 1. + 12599. 1. 5. 42.0 23.0 2.0 1. 14.0 40.0 6. 6. 2.9217386 0. 1. + 12600. 1. 4. 27.0 6.0 2.0 4. 14.0 20.0 5. 4. 0.1666666 0. 1. + 12603. 1. 5. 27.0 6.0 1.0 2. 16.0 11.5 4. 5. 2.0416660 0. 1. + 12607. 1. 3. 42.0 13.0 0.0 3. 17.0 40.0 4. 5. 0.2692307 0. 1. + 12615. 1. 3. 42.0 23.0 3.0 3. 12.0 14.0 2. 2. 1.2173910 0. 1. + 12639. 1. 5. 27.0 6.0 1.0 1. 16.0 14.0 4. 4. 2.0416660 0. 1. + 12643. 1. 5. 22.0 6.0 0.0 3. 14.0 6.5 3. 4. 2.0416660 0. 1. + 12649. 1. 3. 42.0 23.0 3.0 2. 14.0 20.0 3. 4. 0.8521735 0. 1. + 12669. 1. 4. 22.0 6.0 0.0 2. 16.0 14.0 4. 5. 0.5833333 0. 1. + 12671. 1. 5. 32.0 13.0 2.0 1. 14.0 20.0 3. 5. 3.2307692 0. 1. + 12673. 1. 3. 22.0 6.0 2.0 3. 14.0 11.5 2. 2. 11.1999989 0. 1. + 12679. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 3. 2. 1.3999996 0. 1. + 12701. 1. 2. 42.0 23.0 5.5 2. 14.0 20.0 3. 2. 0.0434783 0. 1. + 12705. 1. 4. 37.0 23.0 3.0 1. 14.0 20.0 3. 4. 0.8521735 0. 1. + 12716. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 4. 7.8399963 0. 1. + 12720. 1. 5. 27.0 2.5 0.0 1. 17.0 20.0 4. 5. 0.4000000 0. 1. + 12723. 1. 4. 27.0 9.0 1.0 2. 16.0 9.0 3. 5. 0.3888888 0. 1. + 12754. 1. 4. 27.0 9.0 3.0 3. 14.0 20.0 3. 4. 1.3611107 0. 1. + 12761. 1. 4. 42.0 23.0 4.0 2. 16.0 14.0 4. 5. 0.8521735 0. 1. + 12765. 1. 4. 37.0 16.5 4.0 3. 14.0 20.0 3. 2. 0.7424242 0. 1. + 12783. 1. 4. 32.0 9.0 0.0 2. 12.0 14.0 3. 3. 1.3333330 0. 1. + 12785. 1. 4. 32.0 13.0 0.0 2. 14.0 20.0 3. 6. 0.9423077 0. 1. + 12786. 1. 2. 22.0 6.0 2.0 2. 12.0 11.5 3. 4. 0.5833333 0. 1. + 12792. 1. 3. 42.0 23.0 3.0 2. 14.0 40.0 5. 5. 0.5326087 0. 1. + 12808. 1. 4. 32.0 13.0 0.0 3. 14.0 20.0 3. 5. 0.9230769 0. 1. + 12821. 1. 4. 37.0 16.5 4.0 3. 14.0 11.5 3. 4. 0.7424242 0. 1. + 12836. 1. 3. 37.0 23.0 3.0 2. 12.0 20.0 3. 5. 0.8521735 0. 1. + 12843. 1. 4. 32.0 16.5 2.0 1. 14.0 20.0 3. 4. 2.5454540 0. 1. + 12856. 1. 4. 27.0 6.0 1.0 2. 16.0 20.0 3. 5. 2.0000000 0. 1. + 12858. 1. 4. 22.0 2.5 0.0 2. 16.0 6.5 4. 5. 3.1999998 0. 1. + 12861. 1. 2. 22.0 2.5 0.0 3. 12.0 14.0 3. 2. 1.3999996 0. 1. + 12864. 1. 4. 27.0 6.0 1.0 2. 14.0 20.0 3. 3. 1.3333330 0. 1. + 12872. 1. 3. 32.0 16.5 2.0 2. 12.0 11.5 3. 2. 2.7151508 0. 1. + 12875. 1. 5. 17.5 2.5 2.0 2. 12.0 11.5 2. 5. 4.7999992 0. 1. + 12880. 1. 3. 22.0 2.5 0.0 3. 20.0 9.0 3. 1. 7.8399963 0. 1. + 12907. 1. 2. 37.0 23.0 3.0 3. 12.0 20.0 3. 2. 0.8521735 0. 1. + 12938. 1. 4. 32.0 16.5 5.5 3. 14.0 20.0 5. 5. 0.7424242 0. 1. + 12953. 1. 3. 42.0 23.0 3.0 4. 14.0 14.0 3. 5. 0.1521739 0. 1. + 12986. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 2. 3. 4.8999996 0. 1. + 12990. 1. 4. 27.0 9.0 0.0 2. 14.0 20.0 3. 4. 3.1111107 0. 1. + 12992. 1. 3. 22.0 2.5 2.0 2. 12.0 14.0 3. 4. 0.4000000 0. 1. + 12994. 1. 3. 42.0 23.0 2.0 4. 14.0 11.5 4. 6. 1.2173910 0. 1. + 13000. 1. 5. 42.0 23.0 5.5 2. 14.0 14.0 3. 2. 0.5326087 0. 1. + 13002. 1. 4. 27.0 6.0 0.0 3. 14.0 20.0 6. 6. 2.0416660 0. 1. + 13015. 1. 4. 42.0 23.0 4.0 3. 14.0 20.0 3. 4. 0.5217391 0. 1. + 13028. 1. 3. 32.0 16.5 2.0 2. 12.0 20.0 3. 5. 0.3393939 0. 1. + 13041. 1. 3. 27.0 2.5 0.0 1. 16.0 20.0 3. 4. 4.8999996 0. 1. + 13050. 1. 3. 32.0 13.0 2.0 4. 14.0 20.0 4. 2. 5.1692305 0. 1. + 13051. 1. 2. 37.0 16.5 2.0 2. 14.0 40.0 3. 5. 1.1878777 0. 1. + 13053. 1. 4. 22.0 6.0 2.0 2. 12.0 20.0 2. 4. 2.0000000 0. 1. + 13059. 1. 4. 32.0 9.0 3.0 1. 16.0 20.0 2. 4. 0.1111111 0. 1. + 13062. 1. 3. 42.0 23.0 4.0 2. 12.0 40.0 3. 5. 0.3478261 0. 1. + 13089. 1. 3. 32.0 13.0 2.0 3. 12.0 9.0 3. 3. 2.1538458 0. 1. + 13102. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 2. 1. 0.4000000 0. 1. + 13110. 1. 3. 37.0 16.5 2.0 2. 12.0 20.0 2. 2. 0.7272727 0. 1. + 13113. 1. 3. 27.0 6.0 0.0 2. 14.0 40.0 3. 5. 2.0000000 0. 1. + 13139. 1. 4. 42.0 23.0 3.0 3. 12.0 11.5 5. 4. 2.9217386 0. 1. + 13141. 1. 4. 42.0 23.0 3.0 2. 14.0 40.0 5. 4. 1.2173910 0. 1. + 13147. 1. 2. 42.0 23.0 5.5 4. 14.0 14.0 2. 5. 0.1521739 0. 1. + 13153. 1. 5. 27.0 6.0 0.0 2. 12.0 40.0 5. 4. 0.5833333 0. 1. + 13158. 1. 4. 32.0 16.5 1.0 2. 14.0 40.0 3. 4. 0.7424242 0. 1. + 13171. 1. 4. 37.0 16.5 3.0 3. 12.0 20.0 4. 2. 1.6969690 0. 1. + 13175. 1. 5. 42.0 23.0 5.5 3. 14.0 40.0 3. 6. 0.1521739 0. 1. + 13190. 1. 3. 37.0 16.5 3.0 2. 14.0 20.0 5. 4. 0.7272727 0. 1. + 13199. 1. 2. 37.0 13.0 1.0 1. 16.0 20.0 4. 4. 0.9423077 0. 1. + 13225. 1. 4. 27.0 6.0 0.0 3. 16.0 40.0 5. 6. 0.5833333 0. 1. + 13242. 1. 4. 42.0 23.0 4.0 3. 16.0 20.0 4. 2. 0.8521735 0. 1. + 13253. 1. 5. 27.0 2.5 0.0 2. 14.0 9.0 3. 4. 3.1999998 0. 1. + 13282. 1. 2. 42.0 23.0 3.0 1. 12.0 14.0 3. 5. 2.9217386 0. 1. + 13294. 1. 5. 37.0 13.0 2.0 1. 14.0 20.0 3. 6. 0.2692307 0. 1. + 13301. 1. 4. 32.0 16.5 2.0 1. 12.0 40.0 5. 2. 1.1878777 0. 1. + 13310. 1. 4. 37.0 16.5 3.0 1. 14.0 14.0 3. 2. 0.4848484 0. 1. + 13316. 1. 3. 27.0 2.5 0.0 1. 14.0 20.0 5. 4. 1.3999996 0. 1. + 13334. 1. 4. 22.0 2.5 0.0 1. 14.0 6.5 3. 3. 4.8999996 0. 1. + 13343. 1. 4. 37.0 16.5 2.0 2. 14.0 20.0 3. 5. 1.1878777 0. 1. + 13349. 1. 3. 27.0 6.0 2.0 2. 12.0 20.0 3. 4. 0.1666666 0. 1. + 13350. 1. 4. 22.0 6.0 1.0 2. 12.0 20.0 3. 4. 0.1666666 0. 1. + 13352. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 4. 5. 0.2692307 0. 1. + 13358. 1. 2. 37.0 23.0 3.0 3. 12.0 14.0 5. 2. 0.5326087 0. 1. + 13369. 1. 2. 37.0 16.5 2.0 3. 14.0 20.0 3. 5. 2.5454540 0. 1. + 13370. 1. 4. 32.0 16.5 2.0 2. 14.0 20.0 5. 4. 0.7272727 0. 1. + 13378. 1. 5. 37.0 16.5 5.5 4. 20.0 40.0 4. 6. 0.7424242 0. 1. + 13382. 1. 3. 32.0 16.5 3.0 2. 12.0 11.5 3. 2. 1.1878777 0. 1. + 13389. 1. 3. 27.0 9.0 4.0 3. 14.0 20.0 3. 5. 2.1777763 0. 1. + 13393. 1. 3. 37.0 13.0 0.0 1. 14.0 20.0 5. 4. 3.2307692 0. 1. + 13394. 1. 2. 27.0 2.5 2.0 2. 14.0 11.5 4. 5. 4.8999996 0. 1. + 13407. 1. 4. 27.0 9.0 2.0 1. 14.0 11.5 3. 4. 0.8888888 0. 1. + 13416. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 3. 4. 0.3478261 0. 1. + 13436. 1. 5. 42.0 23.0 2.0 1. 14.0 40.0 5. 5. 0.8521735 0. 1. + 13438. 1. 4. 42.0 23.0 4.0 2. 12.0 20.0 3. 3. 0.5217391 0. 1. + 13447. 1. 4. 37.0 16.5 4.0 3. 14.0 14.0 3. 5. 0.2121212 0. 1. + 13450. 1. 4. 32.0 16.5 3.0 2. 12.0 11.5 2. 2. 1.1878777 0. 1. + 13466. 1. 2. 37.0 23.0 2.0 2. 12.0 20.0 4. 4. 0.0434783 0. 1. + 13473. 1. 4. 42.0 23.0 1.0 3. 20.0 40.0 4. 4. 0.5217391 0. 1. + 13477. 1. 4. 22.0 2.5 1.0 2. 14.0 14.0 4. 4. 4.8999996 0. 1. + 13500. 1. 1. 32.0 13.0 2.0 2. 14.0 40.0 4. 4. 2.1538458 0. 1. + 13509. 1. 3. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 1.8260860 0. 1. + 13529. 1. 4. 22.0 2.5 0.0 2. 16.0 11.5 3. 2. 1.3999996 0. 1. + 13542. 1. 5. 37.0 23.0 3.0 3. 12.0 20.0 3. 5. 0.1521739 0. 1. + 13551. 1. 3. 22.0 2.5 0.0 2. 14.0 20.0 2. 2. 4.8999996 0. 1. + 13552. 1. 1. 42.0 23.0 3.0 3. 12.0 11.5 5. 5. 1.9478254 0. 1. + 13564. 1. 3. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 4.8999996 0. 1. + 13593. 1. 3. 37.0 23.0 2.0 3. 12.0 14.0 3. 5. 1.9478254 0. 1. + 13605. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 5. 4. 0.4000000 0. 1. + 13610. 1. 5. 32.0 9.0 2.0 3. 14.0 20.0 5. 4. 0.1111111 0. 1. + 13631. 1. 1. 37.0 16.5 4.0 2. 14.0 20.0 3. 6. 1.1878777 0. 1. + 13632. 1. 3. 42.0 23.0 1.0 3. 12.0 20.0 3. 4. 0.8521735 0. 1. + 13642. 1. 5. 27.0 9.0 2.0 1. 12.0 11.5 3. 2. 1.3611107 0. 1. + 13643. 1. 4. 22.0 2.5 1.0 2. 14.0 11.5 2. 4. 17.9199982 0. 1. + 13644. 1. 5. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 0.8521735 0. 1. + 13665. 1. 4. 27.0 6.0 1.0 3. 14.0 20.0 5. 5. 2.0000000 0. 1. + 13666. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 3. 1. 1.3999996 0. 1. + 13681. 1. 3. 37.0 16.5 2.0 3. 16.0 20.0 3. 4. 0.7272727 0. 1. + 13696. 1. 3. 32.0 16.5 2.0 3. 12.0 20.0 5. 5. 2.5454540 0. 1. + 13699. 1. 5. 37.0 16.5 3.0 3. 14.0 14.0 2. 5. 0.7272727 0. 1. + 13710. 1. 3. 27.0 6.0 2.0 1. 16.0 9.0 4. 3. 0.5833333 0. 1. + 13715. 1. 4. 27.0 9.0 1.0 2. 20.0 40.0 4. 4. 0.1111111 0. 1. + 13719. 1. 4. 27.0 6.0 0.0 2. 14.0 9.0 3. 4. 2.0416660 0. 1. + 13733. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 3. 4. 0.9423077 0. 1. + 13745. 1. 4. 42.0 23.0 2.0 2. 12.0 20.0 4. 4. 1.2173910 0. 1. + 13756. 1. 2. 37.0 16.5 2.0 2. 12.0 20.0 5. 4. 0.4848484 0. 1. + 13765. 1. 4. 27.0 2.5 0.0 2. 17.0 20.0 5. 5. 0.4000000 0. 1. + 13775. 1. 4. 37.0 16.5 2.0 2. 17.0 40.0 4. 5. 0.2121212 0. 1. + 13777. 1. 4. 32.0 13.0 2.0 2. 12.0 20.0 3. 3. 0.9230769 0. 1. + 13788. 1. 4. 32.0 9.0 2.0 1. 14.0 20.0 3. 4. 1.3611107 0. 1. + 13790. 1. 4. 32.0 9.0 2.0 2. 14.0 20.0 3. 5. 0.1111111 0. 1. + 13794. 1. 4. 32.0 13.0 2.0 3. 12.0 14.0 5. 5. 0.9423077 0. 1. + 13823. 1. 4. 32.0 13.0 3.0 2. 14.0 14.0 3. 2. 2.1538458 0. 1. + 13829. 1. 4. 22.0 2.5 1.0 1. 14.0 9.0 2. 2. 1.3999996 0. 1. + 13833. 1. 5. 27.0 16.5 2.0 3. 12.0 11.5 5. 4. 0.2121212 0. 1. + 13837. 1. 4. 32.0 2.5 0.0 3. 14.0 40.0 2. 6. 4.8999996 0. 1. + 13843. 1. 3. 32.0 16.5 1.0 2. 14.0 14.0 2. 4. 0.2121212 0. 1. + 13844. 1. 3. 37.0 16.5 3.0 2. 16.0 14.0 4. 3. 1.1878777 0. 1. + 13859. 1. 5. 42.0 23.0 4.0 2. 12.0 40.0 5. 5. 0.8521735 0. 1. + 13880. 1. 5. 27.0 6.0 2.0 3. 14.0 14.0 3. 4. 3.2666645 0. 1. + 13890. 1. 4. 22.0 2.5 1.0 3. 12.0 20.0 3. 2. 1.3999996 0. 1. + 13895. 1. 4. 42.0 23.0 3.0 1. 20.0 20.0 6. 6. 1.2173910 0. 1. + 13898. 1. 4. 32.0 9.0 2.0 1. 17.0 20.0 4. 5. 2.1777763 0. 1. + 13899. 1. 5. 32.0 2.5 0.0 2. 20.0 40.0 6. 6. 1.3999996 0. 1. + 13902. 1. 3. 27.0 6.0 1.0 2. 14.0 20.0 3. 6. 0.5833333 0. 1. + 13907. 1. 1. 22.0 2.5 0.0 1. 14.0 6.5 4. 4. 4.8999996 0. 1. + 13913. 1. 3. 32.0 16.5 2.0 2. 14.0 11.5 3. 2. 0.7424242 0. 1. + 13917. 1. 4. 42.0 23.0 2.0 2. 12.0 20.0 3. 3. 0.1521739 0. 1. + 13920. 1. 4. 22.0 6.0 1.0 3. 14.0 14.0 3. 5. 0.5833333 0. 1. + 13941. 1. 5. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 0.5326087 0. 1. + 13947. 1. 3. 27.0 13.0 2.0 2. 12.0 11.5 4. 3. 3.4461536 0. 1. + 13953. 1. 4. 32.0 13.0 2.0 2. 14.0 14.0 5. 4. 0.2692307 0. 1. + 13955. 1. 3. 27.0 2.5 0.0 3. 14.0 20.0 3. 4. 3.1999998 0. 1. + 13956. 1. 2. 22.0 2.5 0.0 3. 12.0 9.0 3. 2. 0.4000000 0. 1. + 13964. 1. 5. 42.0 23.0 2.0 2. 20.0 20.0 4. 4. 1.8260860 0. 1. + 13979. 1. 3. 27.0 6.0 1.0 2. 14.0 20.0 2. 2. 0.5833333 0. 1. + 14001. 1. 5. 42.0 23.0 2.0 2. 20.0 14.0 3. 6. 0.5326087 0. 1. + 14003. 1. 3. 37.0 23.0 4.0 1. 12.0 20.0 3. 2. 0.3478261 0. 1. + 14020. 1. 5. 42.0 23.0 4.0 4. 20.0 40.0 6. 6. 6.2608690 0. 1. + 14036. 1. 5. 27.0 6.0 0.0 1. 17.0 20.0 4. 5. 1.3333330 0. 1. + 14046. 1. 3. 32.0 13.0 2.0 1. 17.0 40.0 4. 6. 0.2692307 0. 1. + 14047. 1. 2. 27.0 2.5 0.0 1. 14.0 20.0 5. 5. 1.3999996 0. 1. + 14048. 1. 4. 27.0 9.0 3.0 2. 12.0 20.0 3. 6. 1.3333330 0. 1. + 14067. 1. 5. 27.0 6.0 1.0 1. 14.0 20.0 3. 5. 2.0000000 0. 1. + 14078. 1. 4. 22.0 0.5 0.0 2. 14.0 11.5 4. 5. 24.5000000 0. 1. + 14084. 1. 4. 17.5 2.5 1.0 2. 12.0 11.5 3. 2. 1.3999996 0. 1. + 14089. 1. 3. 27.0 2.5 1.0 2. 14.0 20.0 3. 4. 1.3999996 0. 1. + 14099. 1. 5. 32.0 16.5 3.0 2. 14.0 14.0 2. 4. 0.0606061 0. 1. + 14113. 1. 4. 42.0 23.0 5.5 1. 14.0 40.0 3. 5. 0.5326087 0. 1. + 14121. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 4. 4.8999996 0. 1. + 14175. 1. 5. 42.0 23.0 2.0 2. 20.0 40.0 1. 5. 0.1521739 0. 1. + 14180. 1. 5. 42.0 23.0 3.0 3. 14.0 20.0 3. 5. 0.0434783 0. 1. + 14181. 1. 2. 42.0 23.0 3.0 3. 16.0 20.0 4. 4. 0.1521739 0. 1. + 14191. 1. 4. 32.0 16.5 4.0 2. 12.0 11.5 3. 5. 0.4848484 0. 1. + 14194. 1. 4. 37.0 23.0 4.0 2. 12.0 20.0 3. 4. 0.8521735 0. 1. + 14199. 1. 4. 42.0 23.0 2.0 1. 14.0 20.0 5. 3. 0.5326087 0. 1. + 14206. 1. 5. 22.0 2.5 0.0 4. 14.0 11.5 3. 4. 1.3999996 0. 1. + 14231. 1. 4. 22.0 2.5 0.0 1. 16.0 11.5 3. 5. 1.3999996 0. 1. + 14235. 1. 4. 42.0 23.0 3.0 3. 14.0 40.0 5. 5. 1.9478254 0. 1. + 14237. 1. 4. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 1.9478254 0. 1. + 14247. 1. 2. 22.0 2.5 0.0 2. 14.0 11.5 3. 5. 0.4000000 0. 1. + 14252. 1. 3. 42.0 23.0 3.0 1. 20.0 40.0 4. 4. 0.0434783 0. 1. + 14265. 1. 3. 37.0 16.5 3.0 4. 12.0 20.0 3. 2. 2.5454540 0. 1. + 14271. 1. 4. 27.0 16.5 2.0 1. 12.0 11.5 3. 2. 0.2121212 0. 1. + 14275. 1. 3. 27.0 6.0 1.0 1. 16.0 14.0 4. 1. 3.2666645 0. 1. + 14277. 1. 5. 32.0 13.0 2.0 2. 14.0 14.0 4. 4. 0.9230769 0. 1. + 14299. 1. 4. 32.0 13.0 3.0 2. 12.0 6.5 2. 4. 0.6153846 0. 1. + 14305. 1. 5. 42.0 13.0 0.0 1. 16.0 40.0 3. 6. 1.5076914 0. 1. + 14307. 1. 4. 32.0 9.0 2.0 3. 14.0 20.0 3. 4. 2.1777763 0. 1. + 14319. 1. 3. 42.0 16.5 1.0 3. 17.0 20.0 3. 3. 0.7424242 0. 1. + 14337. 1. 4. 42.0 23.0 3.0 1. 14.0 20.0 3. 5. 0.8521735 0. 1. + 14338. 1. 1. 32.0 13.0 3.0 3. 14.0 20.0 3. 4. 1.5076914 0. 1. + 14339. 1. 4. 27.0 6.0 2.0 2. 14.0 20.0 3. 5. 1.3333330 0. 1. + 14348. 1. 4. 27.0 6.0 2.0 2. 14.0 11.5 5. 4. 3.2666645 0. 1. + 14349. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 3. 5. 1.3999996 0. 1. + 14356. 1. 4. 22.0 2.5 0.0 1. 16.0 40.0 4. 2. 1.3999996 0. 1. + 14361. 1. 4. 27.0 6.0 3.0 3. 14.0 6.5 4. 2. 2.0416660 0. 1. + 14367. 1. 4. 42.0 23.0 2.0 1. 16.0 40.0 4. 5. 0.1521739 0. 1. + 14378. 1. 3. 27.0 6.0 1.0 4. 14.0 20.0 5. 4. 0.5833333 0. 1. + 14382. 1. 3. 32.0 13.0 0.0 2. 16.0 40.0 3. 6. 0.9230769 0. 1. + 14388. 1. 1. 27.0 6.0 2.0 3. 14.0 14.0 3. 2. 3.2666645 0. 1. + 14392. 1. 3. 32.0 13.0 2.0 2. 14.0 20.0 3. 2. 2.1538458 0. 1. + 14395. 1. 3. 37.0 16.5 4.0 2. 14.0 40.0 4. 4. 0.7424242 0. 1. + 14398. 1. 4. 37.0 16.5 3.0 4. 14.0 6.5 4. 4. 0.2121212 0. 1. + 14400. 1. 4. 32.0 16.5 4.0 3. 14.0 11.5 3. 5. 0.2121212 0. 1. + 14402. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 3. 5. 4.7999992 0. 1. + 14422. 1. 3. 22.0 2.5 0.0 2. 14.0 6.5 3. 1. 0.4000000 0. 1. + 14432. 1. 5. 32.0 23.0 2.0 3. 14.0 40.0 5. 6. 0.5217391 0. 1. + 14437. 1. 3. 27.0 9.0 1.0 3. 14.0 11.5 3. 2. 1.3333330 0. 1. + 14445. 1. 5. 37.0 23.0 3.0 2. 14.0 20.0 5. 4. 0.3478261 0. 1. + 14458. 1. 3. 27.0 6.0 1.0 3. 20.0 20.0 4. 4. 3.2666645 0. 1. + 14472. 1. 1. 27.0 9.0 1.0 3. 14.0 9.0 2. 4. 0.3888888 0. 1. + 14473. 1. 4. 32.0 13.0 4.0 2. 16.0 14.0 4. 2. 0.2692307 0. 1. + 14478. 1. 3. 32.0 16.5 3.0 3. 14.0 14.0 5. 4. 4.0727262 0. 1. + 14501. 1. 4. 42.0 23.0 3.0 3. 14.0 14.0 4. 5. 0.1521739 0. 1. + 14502. 1. 4. 32.0 16.5 4.0 2. 14.0 20.0 2. 5. 1.6969690 0. 1. + 14505. 1. 3. 27.0 9.0 4.0 4. 14.0 14.0 4. 4. 0.3888888 0. 1. + 14510. 1. 4. 27.0 6.0 1.0 2. 12.0 11.5 2. 4. 0.1666666 0. 1. + 14514. 1. 2. 22.0 6.0 1.0 3. 14.0 11.5 3. 5. 2.0000000 0. 1. + 14534. 1. 4. 22.0 2.5 1.0 2. 14.0 9.0 3. 5. 1.3999996 0. 1. + 14535. 1. 3. 22.0 2.5 1.0 3. 14.0 11.5 3. 4. 3.1999998 0. 1. + 14543. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 3. 2. 1.3999996 0. 1. + 14547. 1. 5. 37.0 23.0 3.0 1. 12.0 40.0 5. 2. 1.8260860 0. 1. + 14553. 1. 3. 27.0 9.0 1.0 1. 14.0 20.0 3. 6. 4.6666660 0. 1. + 14554. 1. 4. 27.0 2.5 0.0 1. 14.0 20.0 5. 5. 7.8399963 0. 1. + 14557. 1. 5. 27.0 2.5 0.0 1. 16.0 20.0 4. 2. 1.3999996 0. 1. + 14559. 1. 3. 22.0 6.0 2.0 3. 12.0 11.5 3. 2. 0.5833333 0. 1. + 14561. 1. 4. 37.0 23.0 2.0 2. 12.0 20.0 3. 2. 0.1521739 0. 1. + 14564. 1. 3. 22.0 2.5 0.0 2. 14.0 9.0 3. 4. 4.7999992 0. 1. + 14568. 1. 5. 27.0 2.5 0.0 2. 17.0 14.0 4. 5. 1.3999996 0. 1. + 14590. 1. 4. 22.0 2.5 0.0 1. 14.0 9.0 5. 2. 4.8999996 0. 1. + 14606. 1. 4. 27.0 6.0 1.0 2. 14.0 20.0 3. 3. 7.0000000 0. 1. + 14610. 1. 4. 27.0 6.0 2.0 2. 14.0 20.0 4. 4. 0.5833333 0. 1. + 14618. 1. 4. 32.0 13.0 0.0 2. 12.0 20.0 3. 3. 3.2307692 0. 1. + 14622. 1. 4. 27.0 9.0 2.0 2. 12.0 20.0 2. 4. 1.3611107 0. 1. + 14625. 1. 3. 22.0 2.5 0.0 1. 14.0 11.5 3. 2. 7.8399963 0. 1. + 14638. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 2. 4. 7.8399963 0. 1. + 14650. 1. 3. 37.0 23.0 4.0 2. 14.0 20.0 3. 4. 1.9478254 0. 1. + 14657. 1. 5. 27.0 9.0 3.0 2. 16.0 9.0 4. 4. 1.3333330 0. 1. + 14658. 1. 4. 22.0 2.5 0.0 2. 12.0 6.5 2. 2. 1.3999996 0. 1. + 14662. 1. 2. 32.0 16.5 3.0 1. 14.0 14.0 4. 4. 1.1878777 0. 1. + 14722. 1. 3. 27.0 9.0 2.0 2. 12.0 20.0 3. 2. 1.3611107 0. 1. + 14739. 1. 4. 32.0 16.5 3.0 1. 16.0 40.0 4. 5. 0.7272727 0. 1. + 14755. 1. 3. 27.0 9.0 1.0 2. 12.0 14.0 5. 4. 0.1111111 0. 1. + 14756. 1. 5. 22.0 2.5 0.0 1. 14.0 4.0 2. 2. 7.8399963 0. 1. + 14783. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 5. 5. 0.5326087 0. 1. + 14790. 1. 5. 27.0 6.0 1.0 4. 16.0 11.5 4. 1. 0.1666666 0. 1. + 14793. 1. 4. 22.0 2.5 0.0 1. 12.0 11.5 2. 2. 4.8999996 0. 1. + 14804. 1. 3. 22.0 0.5 0.0 1. 14.0 11.5 5. 5. 7.0000000 0. 1. + 14805. 1. 5. 42.0 23.0 5.5 3. 14.0 40.0 5. 4. 1.9478254 0. 1. + 14837. 1. 4. 37.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.2121212 0. 1. + 14888. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 3. 3. 3.1999998 0. 1. + 14895. 1. 3. 22.0 6.0 1.0 2. 12.0 20.0 3. 2. 2.0416660 0. 1. + 14906. 1. 4. 42.0 23.0 4.0 3. 17.0 40.0 6. 3. 2.7826080 0. 1. + 14912. 1. 4. 22.0 6.0 0.0 4. 14.0 20.0 5. 4. 2.0416660 0. 1. + 14915. 1. 2. 27.0 9.0 3.0 3. 14.0 14.0 4. 4. 0.1111111 0. 1. + 14917. 1. 3. 27.0 6.0 1.0 1. 14.0 14.0 5. 4. 7.0000000 0. 1. + 14929. 1. 5. 42.0 23.0 5.5 3. 16.0 40.0 4. 6. 0.0434783 0. 1. + 14951. 1. 4. 37.0 13.0 3.0 1. 12.0 20.0 4. 4. 0.6153846 0. 1. + 14954. 1. 4. 37.0 16.5 2.0 3. 12.0 14.0 5. 5. 0.7272727 0. 1. + 14992. 1. 4. 37.0 13.0 3.0 3. 16.0 11.5 3. 4. 0.2692307 0. 1. + 15040. 1. 5. 22.0 6.0 2.0 2. 12.0 11.5 2. 4. 4.6666660 0. 1. + 15042. 1. 4. 27.0 2.5 0.0 2. 17.0 20.0 4. 6. 16.7999878 0. 1. + 15043. 1. 2. 22.0 6.0 2.0 3. 14.0 14.0 3. 5. 3.2666645 0. 1. + 15050. 1. 3. 22.0 6.0 1.0 2. 12.0 11.5 4. 4. 1.3333330 0. 1. + 15057. 1. 5. 32.0 9.0 2.0 2. 14.0 11.5 4. 4. 0.1111111 0. 1. + 15059. 1. 3. 27.0 9.0 3.0 2. 12.0 20.0 3. 2. 0.3888888 0. 1. + 15061. 1. 3. 32.0 13.0 2.0 3. 14.0 14.0 3. 5. 0.2692307 0. 1. + 15062. 1. 2. 27.0 9.0 1.0 2. 16.0 20.0 4. 5. 4.9777775 0. 1. + 15068. 1. 4. 27.0 6.0 1.0 1. 17.0 20.0 3. 5. 0.5833333 0. 1. + 15087. 1. 4. 32.0 2.5 0.0 2. 20.0 20.0 6. 6. 16.7999878 0. 1. + 15088. 1. 5. 32.0 13.0 2.0 1. 12.0 20.0 3. 5. 0.9423077 0. 1. + 15091. 1. 4. 32.0 16.5 1.0 1. 14.0 20.0 5. 5. 1.6969690 0. 1. + 15095. 1. 5. 27.0 2.5 0.0 3. 12.0 9.0 4. 5. 0.4000000 0. 1. + 15102. 1. 3. 42.0 23.0 4.0 3. 16.0 40.0 4. 2. 0.3478261 0. 1. + 15106. 1. 4. 22.0 6.0 1.0 3. 14.0 11.5 3. 4. 2.0416660 0. 1. + 15108. 1. 4. 27.0 6.0 0.0 3. 14.0 20.0 3. 4. 0.1666666 0. 1. + 15122. 1. 4. 17.5 2.5 0.0 2. 12.0 6.5 3. 4. 7.8399963 0. 1. + 15125. 1. 4. 22.0 2.5 0.0 1. 12.0 20.0 3. 4. 0.4000000 0. 1. + 15131. 1. 1. 37.0 13.0 3.0 1. 17.0 40.0 5. 6. 0.0769231 0. 1. + 15134. 1. 2. 32.0 16.5 2.0 1. 12.0 20.0 5. 2. 2.7151508 0. 1. + 15137. 1. 3. 37.0 23.0 3.0 3. 12.0 40.0 3. 5. 0.1521739 0. 1. + 15138. 1. 5. 27.0 9.0 1.0 3. 12.0 40.0 3. 5. 1.3611107 0. 1. + 15139. 1. 4. 27.0 6.0 1.0 1. 12.0 20.0 3. 3. 3.2666645 0. 1. + 15144. 1. 3. 37.0 23.0 4.0 2. 12.0 40.0 3. 2. 1.8260860 0. 1. + 15149. 1. 4. 37.0 23.0 5.5 3. 12.0 14.0 5. 5. 0.1521739 0. 1. + 15158. 1. 1. 22.0 2.5 1.0 1. 12.0 20.0 3. 4. 1.3999996 0. 1. + 15177. 1. 3. 22.0 2.5 0.0 1. 12.0 20.0 3. 5. 4.7999992 0. 1. + 15184. 1. 4. 27.0 2.5 0.0 1. 16.0 11.5 4. 2. 7.8399963 0. 1. + 15192. 1. 4. 32.0 13.0 1.0 3. 16.0 14.0 3. 5. 0.6153846 0. 1. + 15193. 1. 4. 27.0 2.5 0.0 2. 12.0 20.0 3. 4. 7.8399963 0. 1. + 15199. 1. 2. 32.0 9.0 0.0 2. 16.0 14.0 3. 2. 1.3611107 0. 1. + 15243. 1. 5. 42.0 23.0 4.0 1. 20.0 40.0 4. 5. 0.5217391 0. 1. + 15258. 1. 4. 22.0 6.0 1.0 1. 12.0 14.0 3. 5. 2.0000000 0. 1. + 15259. 1. 3. 42.0 23.0 4.0 2. 14.0 20.0 3. 5. 0.3478261 0. 1. + 15285. 1. 5. 27.0 6.0 0.0 3. 12.0 11.5 3. 4. 2.0416660 0. 1. + 15293. 1. 4. 42.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.2121212 0. 1. + 15301. 1. 5. 22.0 2.5 0.0 2. 16.0 6.5 4. 1. 3.1999998 0. 1. + 15305. 1. 4. 42.0 23.0 5.5 4. 20.0 14.0 4. 2. 0.1521739 0. 1. + 15308. 1. 5. 27.0 9.0 2.0 3. 14.0 20.0 4. 5. 0.3888888 0. 1. + 15315. 1. 4. 27.0 2.5 1.0 3. 16.0 20.0 6. 5. 4.7999992 0. 1. + 15327. 1. 3. 27.0 9.0 0.0 3. 16.0 20.0 5. 5. 1.3333330 0. 1. + 15330. 1. 5. 37.0 23.0 3.0 2. 14.0 40.0 3. 5. 0.1521739 0. 1. + 15331. 1. 4. 37.0 16.5 2.0 3. 17.0 40.0 4. 2. 1.6969690 0. 1. + 15335. 1. 3. 27.0 6.0 1.0 1. 17.0 20.0 4. 5. 2.0416660 0. 1. + 15337. 1. 5. 32.0 16.5 3.0 4. 14.0 14.0 3. 6. 0.7272727 0. 1. + 15338. 1. 5. 37.0 16.5 2.0 3. 12.0 14.0 3. 4. 0.7424242 0. 1. + 15339. 1. 3. 27.0 6.0 1.0 4. 17.0 20.0 4. 5. 7.0000000 0. 1. + 15341. 1. 3. 37.0 16.5 3.0 2. 14.0 20.0 3. 4. 2.5454540 0. 1. + 15342. 1. 5. 27.0 9.0 1.0 1. 14.0 6.5 3. 4. 0.3888888 0. 1. + 15345. 1. 3. 32.0 9.0 3.0 2. 14.0 20.0 5. 5. 1.3611107 0. 1. + 15351. 1. 2. 42.0 23.0 3.0 2. 12.0 40.0 3. 5. 0.8521735 0. 1. + 15363. 1. 4. 32.0 13.0 2.0 1. 14.0 14.0 3. 5. 1.5076914 0. 1. + 15367. 1. 4. 22.0 2.5 1.0 2. 14.0 9.0 3. 2. 4.7999992 0. 1. + 15374. 1. 5. 27.0 9.0 2.0 2. 12.0 14.0 3. 6. 0.3888888 0. 1. + 15375. 1. 5. 32.0 16.5 2.0 1. 12.0 20.0 3. 6. 0.0606061 0. 1. + 15385. 1. 4. 32.0 16.5 2.0 2. 12.0 20.0 2. 4. 1.6969690 0. 1. + 15392. 1. 4. 42.0 23.0 3.0 2. 12.0 20.0 3. 5. 1.9478254 0. 1. + 15395. 1. 4. 32.0 9.0 2.0 3. 9.0 20.0 3. 5. 1.3333330 0. 1. + 15396. 1. 2. 27.0 6.0 2.0 3. 12.0 14.0 3. 4. 2.0416660 0. 1. + 15398. 1. 5. 42.0 23.0 2.0 3. 16.0 40.0 4. 5. 0.2434782 0. 1. + 15399. 1. 4. 37.0 23.0 3.0 4. 12.0 20.0 5. 4. 0.5326087 0. 1. + 15412. 1. 4. 32.0 16.5 3.0 2. 12.0 20.0 5. 5. 3.8787870 0. 1. + 15422. 1. 3. 27.0 9.0 1.0 2. 12.0 20.0 3. 4. 7.1111107 0. 1. + 15425. 1. 2. 37.0 13.0 2.0 3. 14.0 14.0 3. 4. 0.9230769 0. 1. + 15449. 1. 4. 32.0 16.5 3.0 3. 14.0 20.0 4. 3. 0.2121212 0. 1. + 15467. 1. 3. 32.0 16.5 4.0 3. 12.0 11.5 2. 2. 1.1878777 0. 1. + 15485. 1. 3. 42.0 23.0 4.0 2. 12.0 20.0 4. 4. 1.8260860 0. 1. + 15489. 1. 3. 42.0 23.0 3.0 3. 17.0 40.0 4. 6. 0.0434783 0. 1. + 15497. 1. 5. 27.0 9.0 3.0 1. 14.0 11.5 3. 6. 1.3333330 0. 1. + 15502. 1. 4. 27.0 6.0 1.0 3. 14.0 9.0 4. 5. 0.5833333 0. 1. + 15503. 1. 3. 22.0 2.5 0.0 2. 12.0 20.0 3. 5. 1.3999996 0. 1. + 15509. 1. 3. 22.0 2.5 0.0 2. 14.0 6.5 5. 4. 0.4000000 0. 1. + 15511. 1. 4. 32.0 16.5 3.0 3. 9.0 40.0 5. 5. 0.2121212 0. 1. + 15519. 1. 4. 27.0 2.5 0.0 3. 16.0 20.0 4. 6. 4.8999996 0. 1. + 15525. 1. 3. 27.0 6.0 1.0 2. 12.0 11.5 3. 5. 0.5833333 0. 1. + 15528. 1. 3. 32.0 16.5 2.0 3. 16.0 20.0 4. 4. 0.7424242 0. 1. + 15531. 1. 5. 42.0 23.0 3.0 3. 12.0 6.5 4. 2. 1.2173910 0. 1. + 15536. 1. 3. 27.0 6.0 1.0 3. 16.0 20.0 2. 2. 2.0000000 0. 1. + 15540. 1. 4. 27.0 9.0 2.0 3. 14.0 11.5 5. 5. 1.3333330 0. 1. + 15545. 1. 4. 27.0 9.0 1.0 4. 12.0 11.5 3. 2. 3.1111107 0. 1. + 15549. 1. 3. 37.0 13.0 2.0 3. 16.0 11.5 2. 4. 1.5076914 0. 1. + 15551. 1. 4. 22.0 6.0 1.0 2. 14.0 20.0 3. 5. 0.5833333 0. 1. + 15557. 1. 5. 37.0 13.0 2.0 3. 14.0 14.0 5. 5. 0.6153846 0. 1. + 15573. 1. 3. 22.0 2.5 0.0 1. 14.0 9.0 3. 1. 4.8999996 0. 1. + 15583. 1. 4. 37.0 16.5 3.0 3. 12.0 20.0 5. 5. 0.2121212 0. 1. + 15584. 1. 1. 32.0 13.0 2.0 2. 17.0 20.0 4. 6. 3.2307692 0. 1. + 15587. 1. 3. 22.0 2.5 0.0 3. 14.0 11.5 5. 4. 3.1999998 0. 1. + 15592. 1. 3. 22.0 6.0 1.0 3. 12.0 6.5 4. 2. 2.0000000 0. 1. + 15593. 1. 4. 22.0 2.5 1.0 3. 14.0 6.5 2. 2. 16.7999878 0. 1. + 15596. 1. 2. 42.0 23.0 2.0 1. 14.0 40.0 3. 5. 0.1521739 0. 1. + 15611. 1. 1. 42.0 23.0 3.0 1. 17.0 40.0 4. 5. 1.8260860 0. 1. + 15613. 1. 3. 37.0 16.5 3.0 3. 16.0 20.0 6. 4. 1.6969690 0. 1. + 15621. 1. 4. 27.0 6.0 0.0 2. 12.0 11.5 3. 4. 7.0000000 0. 1. + 15635. 1. 3. 37.0 16.5 4.0 1. 12.0 40.0 3. 6. 0.7272727 0. 1. + 15643. 1. 4. 27.0 6.0 2.0 2. 12.0 14.0 3. 2. 0.1666666 0. 1. + 15644. 1. 3. 32.0 9.0 0.0 1. 16.0 40.0 4. 5. 7.4666662 0. 1. + 15662. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 4. 4. 0.4000000 0. 1. + 15663. 1. 2. 37.0 16.5 2.0 4. 12.0 11.5 3. 3. 0.2121212 0. 1. + 15665. 1. 3. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 1.3999996 0. 1. + 15672. 1. 4. 27.0 6.0 2.0 1. 14.0 20.0 2. 2. 2.0416660 0. 1. + 15673. 1. 3. 32.0 16.5 3.0 2. 12.0 14.0 4. 2. 0.7424242 0. 1. + 15678. 1. 2. 27.0 2.5 0.0 2. 16.0 20.0 4. 5. 17.9199982 0. 1. + 15686. 1. 3. 42.0 23.0 5.5 2. 20.0 11.5 4. 3. 0.1521739 0. 1. + 15694. 1. 1. 37.0 16.5 2.0 3. 14.0 11.5 3. 5. 0.7272727 0. 1. + 15695. 1. 4. 22.0 6.0 2.0 2. 12.0 14.0 3. 5. 3.2666645 0. 1. + 15696. 1. 4. 42.0 23.0 2.0 3. 20.0 20.0 4. 4. 0.8521735 0. 1. + 15734. 1. 3. 22.0 2.5 0.0 2. 14.0 11.5 3. 3. 3.1999998 0. 1. + 15735. 1. 4. 27.0 9.0 0.0 3. 17.0 20.0 5. 6. 1.3333330 0. 1. + 15742. 1. 5. 27.0 2.5 0.0 2. 16.0 40.0 3. 2. 11.1999998 0. 1. + 15761. 1. 5. 27.0 9.0 2.0 3. 14.0 14.0 3. 3. 0.3888888 0. 1. + 15768. 1. 2. 27.0 6.0 1.0 1. 16.0 20.0 4. 5. 2.0000000 0. 1. + 15801. 1. 3. 42.0 23.0 2.0 2. 14.0 14.0 3. 5. 0.5217391 0. 1. + 15805. 1. 4. 27.0 9.0 2.0 3. 12.0 14.0 3. 5. 1.3611107 0. 1. + 15811. 1. 3. 37.0 23.0 5.5 2. 12.0 11.5 2. 5. 0.3478261 0. 1. + 15816. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 3. 4. 3.2666645 0. 1. + 15827. 1. 3. 27.0 2.5 0.0 3. 12.0 9.0 3. 5. 4.7999992 0. 1. + 15838. 1. 1. 27.0 2.5 0.0 2. 14.0 20.0 3. 2. 4.8999996 0. 1. + 15846. 1. 3. 27.0 6.0 1.0 3. 16.0 40.0 5. 4. 2.0000000 0. 1. + 15862. 1. 4. 27.0 6.0 2.0 3. 16.0 20.0 4. 2. 3.2666645 0. 1. + 15864. 1. 4. 27.0 13.0 3.0 4. 14.0 11.5 2. 4. 1.5076914 0. 1. + 15883. 1. 3. 27.0 9.0 2.0 3. 16.0 20.0 4. 5. 4.6666660 0. 1. + 15892. 1. 5. 27.0 13.0 3.0 2. 14.0 20.0 5. 4. 0.9423077 0. 1. + 15904. 1. 5. 22.0 6.0 1.0 3. 12.0 6.5 4. 2. 7.0000000 0. 1. + 15906. 1. 1. 32.0 16.5 2.0 3. 16.0 20.0 4. 4. 0.7272727 0. 1. + 15914. 1. 1. 42.0 23.0 3.0 3. 20.0 20.0 4. 4. 0.8521735 0. 1. + 15918. 1. 3. 27.0 2.5 0.0 1. 16.0 40.0 5. 5. 3.1999998 0. 1. + 15939. 1. 5. 42.0 23.0 5.5 3. 14.0 40.0 4. 5. 0.0434783 0. 1. + 15940. 1. 3. 22.0 6.0 1.0 1. 16.0 6.5 3. 4. 3.2666645 0. 1. + 15947. 1. 1. 22.0 2.5 0.0 1. 12.0 11.5 3. 2. 1.3999996 0. 1. + 15949. 1. 2. 22.0 2.5 1.0 2. 14.0 9.0 3. 4. 11.1999998 0. 1. + 15953. 1. 5. 27.0 2.5 0.0 1. 17.0 6.5 4. 4. 1.3999996 0. 1. + 15963. 1. 2. 27.0 6.0 1.0 3. 12.0 20.0 3. 6. 3.2666645 0. 1. + 15968. 1. 3. 37.0 9.0 2.0 1. 17.0 20.0 4. 3. 0.3888888 0. 1. + 15982. 1. 3. 42.0 23.0 2.0 3. 12.0 11.5 3. 3. 1.8260860 0. 1. + 15998. 1. 4. 37.0 16.5 4.0 3. 17.0 20.0 4. 2. 1.1878777 0. 1. + 16011. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 5. 5. 0.2692307 0. 1. + 16015. 1. 5. 27.0 9.0 2.0 3. 14.0 14.0 4. 4. 1.3333330 0. 1. + 16025. 1. 5. 42.0 16.5 4.0 3. 16.0 20.0 5. 4. 0.0606061 0. 1. + 16074. 1. 1. 37.0 13.0 1.0 4. 16.0 20.0 3. 5. 1.5076914 0. 1. + 16089. 1. 5. 32.0 9.0 3.0 2. 16.0 20.0 4. 5. 0.3888888 0. 1. + 16093. 1. 3. 22.0 2.5 0.0 2. 12.0 20.0 3. 3. 25.5999908 0. 1. + 16105. 1. 3. 27.0 2.5 0.0 4. 14.0 11.5 5. 6. 0.4000000 0. 1. + 16110. 1. 3. 22.0 2.5 0.0 2. 12.0 20.0 3. 5. 1.3999996 0. 1. + 16113. 1. 2. 32.0 16.5 2.0 1. 16.0 40.0 6. 6. 0.7272727 0. 1. + 16126. 1. 4. 32.0 9.0 1.0 3. 14.0 20.0 3. 5. 0.8888888 0. 1. + 16138. 1. 2. 42.0 16.5 2.0 3. 12.0 14.0 3. 3. 1.1878777 0. 1. + 16153. 1. 4. 37.0 16.5 3.0 2. 12.0 11.5 5. 2. 4.0727262 0. 1. + 16174. 1. 2. 37.0 16.5 3.0 2. 12.0 14.0 3. 5. 0.2121212 0. 1. + 16177. 1. 4. 22.0 2.5 1.0 3. 12.0 11.5 3. 4. 1.3999996 0. 1. + 16193. 1. 3. 32.0 16.5 3.0 1. 12.0 20.0 5. 4. 0.7272727 0. 1. + 16208. 1. 3. 32.0 9.0 1.0 1. 14.0 20.0 2. 4. 2.1777763 0. 1. + 16215. 1. 1. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 0.8521735 0. 1. + 16217. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 2. 7.8399963 0. 1. + 16231. 1. 3. 42.0 23.0 4.0 1. 14.0 20.0 3. 5. 0.1521739 0. 1. + 16242. 1. 4. 27.0 9.0 2.0 2. 12.0 14.0 1. 5. 3.1111107 0. 1. + 16246. 1. 4. 27.0 9.0 1.0 3. 14.0 20.0 3. 5. 3.1111107 0. 1. + 16256. 1. 4. 22.0 2.5 0.0 1. 16.0 20.0 4. 4. 1.3999996 0. 1. + 16265. 1. 4. 37.0 16.5 5.5 3. 12.0 20.0 2. 4. 0.2121212 0. 1. + 16271. 1. 3. 22.0 6.0 2.0 1. 12.0 11.5 3. 4. 1.3333330 0. 1. + 16277. 1. 1. 42.0 16.5 5.5 2. 12.0 20.0 2. 5. 0.2121212 0. 1. + 16278. 1. 3. 32.0 9.0 2.0 4. 17.0 11.5 4. 2. 2.1777763 0. 1. + 16280. 1. 4. 32.0 13.0 2.0 2. 12.0 20.0 3. 5. 0.9423077 0. 1. + 16287. 1. 3. 37.0 16.5 2.0 2. 16.0 20.0 4. 5. 1.1878777 0. 1. + 16289. 1. 3. 37.0 16.5 3.0 3. 17.0 40.0 4. 6. 0.7272727 0. 1. + 16299. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 5. 4. 1.5076914 0. 1. + 16300. 1. 3. 42.0 23.0 3.0 1. 14.0 40.0 4. 4. 1.2173910 0. 1. + 16303. 1. 1. 32.0 16.5 2.0 3. 14.0 11.5 4. 2. 2.5454540 0. 1. + 16307. 1. 1. 42.0 23.0 2.0 3. 12.0 20.0 3. 4. 0.8521735 0. 1. + 16309. 1. 5. 37.0 6.0 2.0 3. 17.0 40.0 4. 4. 0.5833333 0. 1. + 16320. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 5. 16.7999878 0. 1. + 16331. 1. 3. 32.0 16.5 2.0 1. 12.0 11.5 3. 4. 0.7272727 0. 1. + 16343. 1. 1. 27.0 6.0 2.0 2. 12.0 9.0 2. 2. 0.5833333 0. 1. + 16346. 1. 3. 42.0 23.0 4.0 2. 12.0 14.0 3. 5. 0.8521735 0. 1. + 16349. 1. 5. 27.0 6.0 2.0 1. 14.0 11.5 4. 4. 2.0416660 0. 1. + 16354. 1. 4. 27.0 6.0 2.0 2. 12.0 14.0 3. 2. 3.2666645 0. 1. + 16359. 1. 4. 22.0 2.5 0.0 1. 16.0 11.5 3. 4. 3.1999998 0. 1. + 16363. 1. 4. 27.0 9.0 0.0 2. 12.0 20.0 3. 4. 1.3611107 0. 1. + 16370. 1. 4. 22.0 6.0 0.0 1. 14.0 20.0 5. 6. 2.0000000 0. 1. + 16387. 1. 3. 42.0 16.5 2.0 1. 14.0 20.0 3. 6. 0.7272727 0. 1. + 16390. 1. 3. 32.0 16.5 4.0 1. 12.0 20.0 3. 4. 1.6969690 0. 1. + 16395. 1. 1. 22.0 2.5 1.0 1. 12.0 14.0 3. 4. 7.8399963 0. 1. + 16410. 1. 4. 37.0 16.5 3.0 2. 12.0 40.0 3. 5. 2.5454540 0. 1. + 16426. 1. 3. 22.0 6.0 3.0 2. 14.0 11.5 3. 2. 3.2666645 0. 1. + 16430. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 3. 5. 7.8399963 0. 1. + 16434. 1. 2. 22.0 2.5 0.0 3. 14.0 20.0 3. 3. 4.8999996 0. 1. + 16447. 1. 3. 22.0 2.5 0.0 3. 16.0 9.0 4. 4. 1.3999996 0. 1. + 16455. 1. 3. 22.0 0.5 0.0 1. 14.0 9.0 3. 2. 39.1999817 0. 1. + 16456. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.4000000 0. 1. + 16457. 1. 4. 27.0 9.0 2.0 2. 14.0 6.5 4. 2. 1.3611107 0. 1. + 16459. 1. 5. 37.0 16.5 2.0 3. 14.0 40.0 3. 5. 1.1878777 0. 1. + 16465. 1. 4. 32.0 13.0 1.0 3. 14.0 20.0 4. 5. 0.9423077 0. 1. + 16483. 1. 3. 32.0 13.0 4.0 3. 12.0 9.0 5. 4. 0.2692307 0. 1. + 16484. 1. 3. 27.0 6.0 3.0 3. 14.0 14.0 3. 5. 2.0416660 0. 1. + 16494. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 3. 4. 0.9230769 0. 1. + 16496. 1. 2. 42.0 23.0 2.0 2. 14.0 20.0 5. 5. 0.8521735 0. 1. + 16499. 1. 4. 37.0 16.5 2.0 3. 12.0 20.0 4. 4. 0.7272727 0. 1. + 16501. 1. 5. 27.0 2.5 1.0 3. 12.0 14.0 4. 5. 4.8999996 0. 1. + 16518. 1. 3. 22.0 2.5 1.0 1. 12.0 6.5 2. 2. 0.4000000 0. 1. + 16519. 1. 2. 27.0 6.0 2.0 2. 14.0 9.0 4. 4. 0.5833333 0. 1. + 16545. 1. 3. 42.0 23.0 3.0 2. 14.0 20.0 3. 3. 0.8521735 0. 1. + 16546. 1. 2. 22.0 2.5 1.0 2. 14.0 14.0 2. 2. 7.8399963 0. 1. + 16547. 1. 5. 22.0 6.0 1.0 2. 17.0 4.0 4. 2. 7.0000000 0. 1. + 16554. 1. 5. 32.0 13.0 2.0 2. 14.0 9.0 2. 2. 0.6153846 0. 1. + 16581. 1. 1. 32.0 16.5 2.0 2. 17.0 40.0 4. 2. 0.7272727 0. 1. + 16593. 1. 2. 32.0 16.5 3.0 2. 14.0 20.0 4. 5. 0.2121212 0. 1. + 16608. 1. 3. 37.0 16.5 2.0 3. 14.0 20.0 5. 2. 0.7424242 0. 1. + 16614. 1. 4. 42.0 23.0 5.5 1. 12.0 20.0 3. 5. 0.8521735 0. 1. + 16627. 1. 4. 42.0 23.0 3.0 4. 14.0 20.0 3. 4. 0.5217391 0. 1. + 16639. 1. 4. 27.0 6.0 0.0 2. 16.0 14.0 4. 4. 1.3333330 0. 1. + 16648. 1. 4. 27.0 2.5 2.0 2. 16.0 14.0 4. 5. 1.3999996 0. 1. + 16650. 1. 3. 27.0 9.0 1.0 2. 12.0 14.0 2. 2. 0.3888888 0. 1. + 16653. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 4. 4. 2.0000000 0. 1. + 16659. 1. 4. 27.0 9.0 2.0 2. 12.0 14.0 4. 5. 0.3888888 0. 1. + 16666. 1. 2. 27.0 6.0 0.0 3. 14.0 20.0 3. 6. 2.0000000 0. 1. + 16672. 1. 4. 27.0 9.0 2.0 3. 16.0 40.0 4. 6. 1.3611107 0. 1. + 16677. 1. 4. 22.0 2.5 1.0 3. 14.0 6.5 5. 1. 0.4000000 0. 1. + 16710. 1. 2. 27.0 2.5 1.0 1. 14.0 20.0 5. 4. 7.8399963 0. 1. + 16715. 1. 4. 37.0 16.5 3.0 3. 14.0 11.5 3. 4. 0.2121212 0. 1. + 16717. 1. 5. 32.0 13.0 2.0 1. 14.0 20.0 3. 6. 0.9230769 0. 1. + 16719. 1. 2. 27.0 9.0 0.0 2. 17.0 14.0 4. 5. 1.3611107 0. 1. + 16732. 1. 4. 32.0 16.5 3.0 3. 12.0 20.0 3. 3. 0.7272727 0. 1. + 16739. 1. 5. 42.0 23.0 3.0 3. 12.0 20.0 3. 5. 1.2173910 0. 1. + 16741. 1. 1. 37.0 16.5 1.0 3. 12.0 20.0 2. 3. 0.7424242 0. 1. + 16742. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 2. 4. 4.8999996 0. 1. + 16752. 1. 4. 37.0 16.5 1.0 3. 14.0 40.0 3. 6. 0.7424242 0. 1. + 16754. 1. 5. 32.0 13.0 1.0 1. 20.0 14.0 2. 6. 1.5076914 0. 1. + 16785. 1. 5. 27.0 6.0 2.0 2. 14.0 20.0 4. 5. 0.5833333 0. 1. + 16820. 1. 4. 27.0 2.5 0.0 1. 20.0 9.0 6. 1. 7.8399963 0. 1. + 16826. 1. 4. 42.0 23.0 4.0 3. 12.0 11.5 2. 3. 0.3478261 0. 1. + 16829. 1. 3. 27.0 9.0 1.0 3. 17.0 11.5 5. 5. 2.1777763 0. 1. + 16864. 1. 3. 22.0 2.5 1.0 2. 12.0 6.5 2. 2. 3.1999998 0. 1. + 16881. 1. 4. 27.0 6.0 0.0 2. 14.0 40.0 3. 6. 2.0416660 0. 1. + 16904. 1. 4. 32.0 13.0 2.0 1. 12.0 20.0 3. 5. 3.4461536 0. 1. + 16906. 1. 2. 32.0 9.0 1.0 2. 16.0 14.0 3. 3. 0.1111111 0. 1. + 16909. 1. 2. 27.0 6.0 1.0 1. 14.0 20.0 4. 6. 2.0416660 0. 1. + 16910. 1. 3. 22.0 2.5 1.0 1. 14.0 6.5 2. 2. 1.3999996 0. 1. + 16917. 1. 5. 22.0 0.5 0.0 1. 12.0 14.0 3. 4. 2.0000000 0. 1. + 16924. 1. 5. 22.0 2.5 0.0 2. 20.0 11.5 4. 1. 7.8399963 0. 1. + 16926. 1. 5. 22.0 6.0 0.0 3. 14.0 14.0 3. 2. 0.5833333 0. 1. + 16930. 1. 5. 42.0 23.0 2.0 3. 17.0 20.0 4. 2. 0.1521739 0. 1. + 16931. 1. 1. 22.0 2.5 1.0 2. 14.0 20.0 3. 2. 4.7999992 0. 1. + 16936. 1. 3. 27.0 6.0 1.0 2. 12.0 14.0 3. 4. 3.2666645 0. 1. + 16940. 1. 3. 22.0 6.0 0.0 3. 14.0 20.0 5. 4. 2.0000000 0. 1. + 16942. 1. 4. 27.0 9.0 2.0 2. 16.0 11.5 4. 4. 2.1777763 0. 1. + 16944. 1. 3. 22.0 6.0 1.0 2. 9.0 11.5 2. 2. 0.1666666 0. 1. + 16968. 1. 4. 32.0 16.5 3.0 2. 16.0 20.0 5. 5. 0.2121212 0. 1. + 16974. 1. 5. 37.0 16.5 1.0 3. 14.0 20.0 3. 2. 0.4848484 0. 1. + 16976. 1. 2. 27.0 9.0 2.0 3. 14.0 11.5 2. 2. 0.8888888 0. 1. + 16980. 1. 4. 32.0 13.0 0.0 2. 14.0 20.0 3. 5. 0.2692307 0. 1. + 16981. 1. 4. 37.0 23.0 5.5 3. 14.0 20.0 4. 5. 0.8521735 0. 1. + 16983. 1. 4. 27.0 13.0 2.0 3. 12.0 20.0 3. 5. 0.2692307 0. 1. + 16985. 1. 3. 27.0 9.0 1.0 1. 16.0 20.0 3. 6. 1.3611107 0. 1. + 16987. 1. 3. 32.0 13.0 3.0 2. 14.0 11.5 3. 4. 0.2692307 0. 1. + 17000. 1. 2. 27.0 9.0 1.0 3. 14.0 20.0 3. 5. 1.3611107 0. 1. + 17029. 1. 3. 22.0 6.0 2.0 2. 12.0 9.0 3. 2. 1.3333330 0. 1. + 17030. 1. 3. 32.0 16.5 2.0 2. 12.0 11.5 3. 5. 0.0606061 0. 1. + 17036. 1. 3. 42.0 23.0 2.0 3. 12.0 20.0 2. 3. 2.9217386 0. 1. + 17042. 1. 4. 27.0 6.0 1.0 3. 14.0 20.0 3. 3. 2.0416660 0. 1. + 17058. 1. 2. 27.0 13.0 2.0 1. 12.0 40.0 4. 5. 1.5076914 0. 1. + 17061. 1. 3. 42.0 23.0 3.0 2. 12.0 20.0 3. 4. 0.1521739 0. 1. + 17063. 1. 2. 42.0 23.0 4.0 2. 12.0 20.0 5. 5. 0.5217391 0. 1. + 17071. 1. 5. 42.0 23.0 4.0 4. 14.0 20.0 3. 2. 0.1521739 0. 1. + 17082. 1. 4. 27.0 6.0 1.0 1. 12.0 40.0 5. 6. 7.0000000 0. 1. + 17104. 1. 3. 42.0 23.0 1.0 2. 14.0 40.0 5. 6. 0.5326087 0. 1. + 17109. 1. 1. 32.0 13.0 0.0 3. 14.0 20.0 3. 5. 0.9423077 0. 1. + 17114. 1. 5. 32.0 13.0 2.0 3. 14.0 20.0 4. 2. 0.9230769 0. 1. + 17125. 1. 3. 27.0 6.0 0.0 1. 16.0 20.0 3. 2. 2.0416660 0. 1. + 17134. 1. 3. 27.0 9.0 2.0 3. 14.0 20.0 5. 5. 1.3333330 0. 1. + 17136. 1. 3. 27.0 6.0 1.0 3. 16.0 40.0 4. 5. 0.5833333 0. 1. + 17138. 1. 4. 22.0 2.5 0.0 1. 12.0 6.5 3. 2. 1.3999996 0. 1. + 17140. 1. 2. 42.0 23.0 2.0 3. 12.0 14.0 5. 5. 0.8521735 0. 1. + 17141. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 5. 4. 3.1999998 0. 1. + 17163. 1. 4. 27.0 9.0 2.0 2. 20.0 11.5 4. 6. 0.3888888 0. 1. + 17181. 1. 2. 27.0 2.5 1.0 2. 14.0 6.5 2. 4. 1.3999996 0. 1. + 17200. 1. 4. 37.0 23.0 4.0 3. 14.0 20.0 3. 3. 4.1739130 0. 1. + 17201. 1. 3. 27.0 9.0 1.0 2. 14.0 20.0 3. 4. 1.3333330 0. 1. + 17203. 1. 5. 22.0 2.5 0.0 2. 12.0 6.5 3. 2. 1.3999996 0. 1. + 17228. 1. 4. 27.0 6.0 1.0 2. 12.0 40.0 3. 4. 0.1666666 0. 1. + 17238. 1. 5. 32.0 13.0 1.0 3. 14.0 14.0 5. 5. 0.9230769 0. 1. + 17250. 1. 5. 32.0 13.0 1.0 2. 12.0 20.0 3. 4. 0.2692307 0. 1. + 17288. 1. 4. 27.0 2.5 0.0 3. 14.0 20.0 5. 4. 4.7999992 0. 1. + 17289. 1. 4. 27.0 9.0 1.0 3. 14.0 20.0 3. 5. 0.1111111 0. 1. + 17310. 1. 5. 32.0 13.0 2.0 2. 12.0 20.0 5. 3. 0.9423077 0. 1. + 17311. 1. 4. 27.0 2.5 0.0 3. 12.0 20.0 3. 3. 0.4000000 0. 1. + 17317. 1. 3. 32.0 13.0 2.0 2. 14.0 20.0 3. 3. 0.2692307 0. 1. + 17329. 1. 4. 27.0 6.0 1.0 3. 12.0 11.5 3. 4. 0.5833333 0. 1. + 17343. 1. 5. 37.0 23.0 4.0 3. 16.0 40.0 5. 5. 0.5217391 0. 1. + 17347. 1. 4. 27.0 9.0 2.0 2. 12.0 20.0 5. 5. 2.1777763 0. 1. + 17360. 1. 2. 42.0 16.5 3.0 3. 16.0 20.0 3. 5. 2.5454540 0. 1. + 17374. 1. 4. 27.0 6.0 0.0 2. 14.0 14.0 3. 5. 2.0416660 0. 1. + 17378. 1. 3. 22.0 2.5 1.0 3. 12.0 9.0 5. 5. 0.4000000 0. 1. + 17379. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 3. 5. 1.5076914 0. 1. + 17397. 1. 3. 27.0 6.0 1.0 2. 14.0 14.0 3. 4. 3.2666645 0. 1. + 17416. 1. 3. 27.0 13.0 1.0 1. 12.0 14.0 3. 3. 0.6153846 0. 1. + 17417. 1. 3. 27.0 6.0 0.0 1. 16.0 40.0 6. 6. 2.0416660 0. 1. + 17422. 1. 3. 32.0 16.5 3.0 2. 14.0 20.0 3. 4. 1.1878777 0. 1. + 17424. 1. 5. 42.0 23.0 3.0 3. 14.0 20.0 3. 4. 0.8521735 0. 1. + 17425. 1. 4. 22.0 6.0 0.0 3. 12.0 14.0 3. 5. 0.5833333 0. 1. + 17435. 1. 4. 32.0 16.5 2.0 3. 12.0 20.0 3. 4. 0.2121212 0. 1. + 17436. 1. 1. 37.0 16.5 3.0 2. 14.0 14.0 4. 4. 0.2121212 0. 1. + 17437. 1. 3. 22.0 2.5 0.0 3. 16.0 6.5 3. 4. 4.8999996 0. 1. + 17438. 1. 3. 27.0 6.0 0.0 3. 17.0 11.5 5. 5. 3.2666645 0. 1. + 17447. 1. 3. 37.0 16.5 2.0 3. 16.0 20.0 5. 3. 0.0606061 0. 1. + 17448. 1. 2. 32.0 13.0 3.0 2. 12.0 20.0 3. 2. 0.9423077 0. 1. + 17455. 1. 4. 37.0 23.0 2.0 3. 14.0 20.0 5. 2. 0.1521739 0. 1. + 17456. 1. 4. 27.0 9.0 2.0 4. 17.0 11.5 4. 4. 1.3611107 0. 1. + 17491. 1. 4. 27.0 9.0 1.0 2. 14.0 20.0 3. 5. 0.1111111 0. 1. + 17493. 1. 2. 42.0 16.5 5.5 2. 16.0 40.0 3. 5. 2.5454540 0. 1. + 17510. 1. 4. 32.0 16.5 3.0 4. 14.0 20.0 3. 4. 4.0727262 0. 1. + 17518. 1. 4. 27.0 6.0 1.0 3. 14.0 9.0 3. 2. 2.0000000 0. 1. + 17519. 1. 4. 42.0 23.0 3.0 2. 12.0 9.0 3. 4. 1.9478254 0. 1. + 17525. 1. 5. 32.0 16.5 3.0 2. 12.0 40.0 3. 5. 1.6969690 0. 1. + 17527. 1. 5. 32.0 16.5 3.0 1. 14.0 20.0 2. 4. 0.0606061 0. 1. + 17532. 1. 4. 37.0 16.5 2.0 2. 14.0 20.0 3. 2. 0.7272727 0. 1. + 17543. 1. 2. 22.0 6.0 2.0 3. 12.0 20.0 3. 4. 2.0000000 0. 1. + 17552. 1. 4. 32.0 16.5 3.0 4. 14.0 20.0 3. 3. 0.0606061 0. 1. + 17571. 1. 2. 37.0 23.0 3.0 3. 12.0 14.0 3. 2. 0.1521739 0. 1. + 17590. 1. 5. 27.0 6.0 2.0 2. 12.0 9.0 4. 4. 0.5833333 0. 1. + 17599. 1. 5. 32.0 16.5 2.0 2. 17.0 14.0 4. 3. 0.0606061 0. 1. + 17607. 1. 3. 32.0 16.5 2.0 2. 12.0 11.5 4. 4. 1.1878777 0. 1. + 17617. 1. 4. 27.0 9.0 2.0 3. 12.0 9.0 3. 4. 0.8888888 0. 1. + 17621. 1. 4. 32.0 16.5 1.0 3. 14.0 20.0 5. 2. 1.6969690 0. 1. + 17622. 1. 4. 27.0 9.0 2.0 2. 16.0 11.5 4. 5. 2.1777763 0. 1. + 17628. 1. 4. 22.0 2.5 0.0 1. 16.0 20.0 3. 2. 0.4000000 0. 1. + 17631. 1. 3. 37.0 23.0 4.0 2. 14.0 20.0 3. 5. 0.8521735 0. 1. + 17689. 1. 5. 27.0 13.0 2.0 2. 12.0 14.0 2. 5. 0.9423077 0. 1. + 17692. 1. 5. 32.0 16.5 4.0 3. 14.0 20.0 3. 4. 0.7272727 0. 1. + 17703. 1. 2. 37.0 16.5 3.0 2. 14.0 20.0 5. 3. 0.2121212 0. 1. + 17710. 1. 5. 32.0 6.0 1.0 3. 14.0 20.0 3. 5. 0.5833333 0. 1. + 17711. 1. 3. 22.0 2.5 0.0 2. 16.0 11.5 3. 3. 4.8999996 0. 1. + 17713. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 2. 4.7999992 0. 1. + 17717. 1. 2. 32.0 13.0 1.0 2. 12.0 40.0 3. 2. 1.5076914 0. 1. + 17724. 1. 3. 42.0 13.0 0.0 3. 17.0 20.0 5. 2. 1.5076914 0. 1. + 17735. 1. 3. 22.0 2.5 0.0 1. 16.0 20.0 3. 5. 7.8399963 0. 1. + 17736. 1. 3. 42.0 23.0 3.0 2. 17.0 14.0 4. 4. 1.2173910 0. 1. + 17737. 1. 2. 27.0 13.0 2.0 1. 14.0 20.0 3. 5. 4.9230766 0. 1. + 17757. 1. 4. 22.0 2.5 1.0 1. 14.0 6.5 3. 1. 1.3999996 0. 1. + 17766. 1. 5. 22.0 2.5 1.0 3. 14.0 20.0 4. 5. 0.4000000 0. 1. + 17792. 1. 4. 42.0 23.0 1.0 3. 14.0 6.5 3. 2. 0.1521739 0. 1. + 17801. 1. 5. 32.0 9.0 2.0 1. 17.0 14.0 6. 6. 2.1777763 0. 1. + 17809. 1. 4. 32.0 16.5 3.0 2. 12.0 40.0 3. 2. 2.5454540 0. 1. + 17819. 1. 3. 27.0 2.5 1.0 3. 14.0 20.0 3. 6. 1.3999996 0. 1. + 17830. 1. 3. 37.0 16.5 4.0 2. 14.0 14.0 3. 2. 0.2121212 0. 1. + 17838. 1. 3. 32.0 16.5 3.0 3. 14.0 20.0 3. 5. 0.7424242 0. 1. + 17846. 1. 3. 32.0 23.0 3.0 3. 14.0 40.0 3. 2. 1.2173910 0. 1. + 17853. 1. 5. 22.0 2.5 0.0 1. 12.0 4.0 2. 2. 1.3999996 0. 1. + 17882. 1. 3. 32.0 16.5 3.0 2. 12.0 40.0 5. 5. 4.0727262 0. 1. + 17894. 1. 4. 27.0 2.5 0.0 1. 17.0 40.0 4. 3. 1.3999996 0. 1. + 17902. 1. 3. 27.0 6.0 0.0 2. 20.0 20.0 6. 6. 3.2666645 0. 1. + 17903. 1. 5. 27.0 13.0 0.0 3. 14.0 14.0 3. 4. 0.0769231 0. 1. + 17912. 1. 5. 37.0 16.5 3.0 4. 14.0 40.0 5. 5. 0.2121212 0. 1. + 17915. 1. 4. 37.0 16.5 3.0 1. 14.0 14.0 3. 3. 0.7272727 0. 1. + 17918. 1. 5. 32.0 13.0 1.0 3. 14.0 14.0 5. 2. 3.2307692 0. 1. + 17919. 1. 4. 27.0 6.0 0.0 2. 14.0 20.0 3. 6. 2.0000000 0. 1. + 17920. 1. 3. 27.0 0.5 0.0 1. 14.0 20.0 3. 3. 24.0000000 0. 1. + 17926. 1. 3. 22.0 2.5 2.0 3. 14.0 11.5 2. 2. 4.8999996 0. 1. + 17931. 1. 4. 37.0 23.0 4.0 4. 12.0 20.0 3. 3. 0.1521739 0. 1. + 17944. 1. 5. 32.0 16.5 2.0 3. 14.0 20.0 4. 5. 1.1878777 0. 1. + 17966. 1. 5. 32.0 13.0 3.0 3. 14.0 20.0 3. 6. 0.9230769 0. 1. + 17985. 1. 4. 32.0 13.0 3.0 1. 20.0 20.0 5. 5. 1.5076914 0. 1. + 17986. 1. 3. 27.0 6.0 0.0 1. 12.0 11.5 3. 4. 0.5833333 0. 1. + 17991. 1. 5. 22.0 2.5 0.0 3. 14.0 40.0 3. 2. 1.3999996 0. 1. + 17994. 1. 4. 32.0 23.0 3.0 2. 9.0 20.0 4. 5. 1.2173910 0. 1. + 18001. 1. 3. 37.0 23.0 2.0 2. 12.0 20.0 5. 4. 0.5217391 0. 1. + 19007. 1. 2. 22.0 2.5 2.0 2. 12.0 6.5 2. 2. 4.8999996 0. 1. + 19011. 1. 4. 32.0 13.0 0.0 3. 14.0 20.0 3. 5. 1.5076914 0. 1. + 19017. 1. 5. 27.0 2.5 0.0 3. 14.0 14.0 3. 5. 0.4000000 0. 1. + 7. 1. 4. 32.0 9.0 2.0 3. 14.0 9.0 2. 4. 0.0 0. 1. + 14. 1. 4. 27.0 6.0 0.0 2. 14.0 6.5 3. 4. 0.0 0. 1. + 16. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 3. 2. 0.0 0. 1. + 17. 1. 5. 42.0 23.0 4.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 26. 1. 5. 27.0 2.5 1.0 3. 20.0 14.0 2. 2. 0.0 0. 1. + 27. 1. 4. 27.0 6.0 1.0 2. 14.0 11.5 2. 4. 0.0 0. 1. + 28. 1. 4. 42.0 23.0 5.5 2. 12.0 11.5 3. 2. 0.0 0. 1. + 42. 1. 5. 27.0 2.5 0.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 43. 1. 5. 32.0 13.0 2.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 46. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 4. 4. 0.0 0. 1. + 47. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 49. 1. 3. 27.0 6.0 1.0 2. 17.0 11.5 5. 4. 0.0 0. 1. + 52. 1. 3. 27.0 2.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 55. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 56. 1. 5. 22.0 2.5 0.0 1. 17.0 20.0 4. 2. 0.0 0. 1. + 59. 1. 4. 27.0 2.5 1.0 1. 16.0 11.5 2. 4. 0.0 0. 1. + 60. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 5. 4. 0.0 0. 1. + 62. 1. 4. 32.0 13.0 4.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 66. 1. 5. 17.5 0.5 0.0 4. 16.0 20.0 3. 4. 0.0 0. 1. + 71. 1. 5. 27.0 6.0 2.0 3. 14.0 14.0 5. 5. 0.0 0. 1. + 76. 1. 5. 22.0 6.0 2.0 2. 17.0 20.0 4. 2. 0.0 0. 1. + 77. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 4. 2. 0.0 0. 1. + 79. 1. 3. 27.0 9.0 0.0 2. 16.0 11.5 5. 2. 0.0 0. 1. + 80. 1. 4. 27.0 2.5 1.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 86. 1. 5. 22.0 2.5 0.0 1. 12.0 14.0 3. 4. 0.0 0. 1. + 87. 1. 5. 22.0 6.0 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 88. 1. 5. 27.0 6.0 2.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 90. 1. 5. 27.0 6.0 2.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 93. 1. 4. 27.0 2.5 0.0 1. 12.0 20.0 3. 2. 0.0 0. 1. + 96. 1. 3. 22.0 2.5 1.0 1. 14.0 6.5 4. 2. 0.0 0. 1. + 97. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 99. 1. 5. 22.0 2.5 1.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 100. 1. 5. 27.0 6.0 1.0 4. 14.0 20.0 5. 6. 0.0 0. 1. + 120. 1. 4. 42.0 23.0 5.5 2. 12.0 20.0 3. 5. 0.0 0. 1. + 125. 1. 5. 27.0 9.0 2.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 136. 1. 5. 32.0 9.0 2.0 2. 12.0 20.0 4. 5. 0.0 0. 1. + 142. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 145. 1. 5. 32.0 9.0 4.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 146. 1. 5. 27.0 2.5 0.0 2. 16.0 11.5 2. 4. 0.0 0. 1. + 154. 1. 3. 27.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 158. 1. 4. 27.0 9.0 0.0 2. 12.0 20.0 4. 4. 0.0 0. 1. + 167. 1. 5. 32.0 6.0 1.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 169. 1. 4. 22.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 170. 1. 4. 32.0 9.0 2.0 2. 14.0 20.0 4. 2. 0.0 0. 1. + 173. 1. 4. 22.0 2.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 174. 1. 5. 42.0 23.0 4.0 3. 14.0 20.0 4. 6. 0.0 0. 1. + 175. 1. 4. 27.0 2.5 2.0 3. 14.0 11.5 4. 3. 0.0 0. 1. + 183. 1. 5. 22.0 2.5 0.0 4. 16.0 9.0 4. 1. 0.0 0. 1. + 187. 1. 5. 17.5 0.5 0.0 2. 14.0 9.0 4. 5. 0.0 0. 1. + 191. 1. 3. 22.0 0.5 0.0 2. 16.0 20.0 3. 2. 0.0 0. 1. + 196. 1. 5. 22.0 0.5 0.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 197. 1. 3. 32.0 13.0 0.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 199. 1. 4. 27.0 2.5 0.0 4. 16.0 20.0 4. 6. 0.0 0. 1. + 200. 1. 5. 42.0 23.0 5.5 1. 14.0 14.0 3. 3. 0.0 0. 1. + 201. 1. 4. 37.0 16.5 3.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 208. 1. 5. 32.0 16.5 3.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 212. 1. 4. 32.0 9.0 2.0 2. 14.0 20.0 4. 3. 0.0 0. 1. + 215. 1. 3. 22.0 2.5 0.0 1. 12.0 14.0 3. 4. 0.0 0. 1. + 218. 1. 4. 37.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 224. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 232. 1. 5. 32.0 9.0 2.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 233. 1. 5. 32.0 13.0 2.0 1. 16.0 40.0 4. 5. 0.0 0. 1. + 235. 1. 5. 37.0 16.5 3.0 3. 16.0 20.0 5. 4. 0.0 0. 1. + 252. 1. 5. 22.0 0.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 255. 1. 5. 42.0 16.5 2.0 3. 17.0 40.0 4. 4. 0.0 0. 1. + 259. 1. 3. 27.0 6.0 1.0 3. 12.0 6.5 3. 2. 0.0 0. 1. + 262. 1. 5. 22.0 2.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 265. 1. 5. 27.0 9.0 3.0 4. 16.0 11.5 4. 5. 0.0 0. 1. + 270. 1. 5. 42.0 23.0 1.0 4. 17.0 40.0 4. 5. 0.0 0. 1. + 272. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 278. 1. 5. 42.0 23.0 1.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 282. 1. 5. 27.0 2.5 0.0 1. 16.0 20.0 6. 6. 0.0 0. 1. + 285. 1. 5. 27.0 2.5 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 290. 1. 5. 17.5 2.5 0.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 294. 1. 5. 22.0 6.0 0.0 1. 12.0 11.5 2. 3. 0.0 0. 1. + 309. 1. 3. 32.0 13.0 2.0 2. 14.0 11.5 2. 2. 0.0 0. 1. + 311. 1. 5. 27.0 2.5 0.0 1. 17.0 20.0 4. 5. 0.0 0. 1. + 318. 1. 4. 32.0 2.5 0.0 2. 16.0 20.0 4. 3. 0.0 0. 1. + 323. 1. 5. 22.0 2.5 1.0 1. 12.0 6.5 3. 3. 0.0 0. 1. + 327. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 3. 0.0 0. 1. + 329. 1. 5. 42.0 16.5 3.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 331. 1. 5. 27.0 6.0 1.0 2. 14.0 6.5 4. 4. 0.0 0. 1. + 335. 1. 5. 32.0 9.0 2.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 341. 1. 5. 32.0 16.5 3.0 1. 16.0 20.0 4. 2. 0.0 0. 1. + 344. 1. 4. 27.0 2.5 0.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 350. 1. 5. 27.0 9.0 3.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 353. 1. 4. 27.0 2.5 0.0 3. 14.0 40.0 4. 5. 0.0 0. 1. + 357. 1. 3. 37.0 16.5 4.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 364. 1. 5. 22.0 2.5 0.0 2. 17.0 40.0 5. 5. 0.0 0. 1. + 382. 1. 5. 32.0 9.0 2.0 2. 17.0 20.0 5. 5. 0.0 0. 1. + 383. 1. 5. 22.0 2.5 1.0 1. 12.0 9.0 3. 4. 0.0 0. 1. + 385. 1. 3. 27.0 6.0 2.0 2. 14.0 9.0 5. 6. 0.0 0. 1. + 395. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 397. 1. 5. 27.0 9.0 2.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 407. 1. 4. 27.0 2.5 0.0 2. 14.0 11.5 3. 3. 0.0 0. 1. + 408. 1. 5. 22.0 2.5 1.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 409. 1. 4. 27.0 2.5 0.0 3. 12.0 20.0 2. 5. 0.0 0. 1. + 415. 1. 5. 27.0 6.0 2.0 3. 14.0 11.5 2. 4. 0.0 0. 1. + 421. 1. 5. 22.0 2.5 2.0 1. 14.0 14.0 4. 3. 0.0 0. 1. + 423. 1. 4. 42.0 23.0 3.0 2. 16.0 40.0 3. 5. 0.0 0. 1. + 430. 1. 4. 32.0 6.0 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 436. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 443. 1. 5. 22.0 2.5 0.0 3. 16.0 14.0 3. 4. 0.0 0. 1. + 445. 1. 5. 27.0 6.0 0.0 1. 16.0 20.0 4. 2. 0.0 0. 1. + 449. 1. 4. 42.0 23.0 3.0 2. 9.0 20.0 5. 5. 0.0 0. 1. + 454. 1. 5. 22.0 0.5 0.0 2. 16.0 11.5 3. 3. 0.0 0. 1. + 455. 1. 3. 22.0 2.5 0.0 2. 16.0 14.0 5. 5. 0.0 0. 1. + 456. 1. 5. 27.0 9.0 2.0 1. 12.0 20.0 2. 3. 0.0 0. 1. + 459. 1. 5. 32.0 16.5 2.0 1. 12.0 14.0 2. 5. 0.0 0. 1. + 460. 1. 2. 32.0 16.5 1.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 462. 1. 3. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 464. 1. 4. 22.0 2.5 1.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 469. 1. 4. 27.0 6.0 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 475. 1. 5. 22.0 0.5 0.0 1. 16.0 6.5 4. 1. 0.0 0. 1. + 477. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 485. 1. 5. 37.0 16.5 3.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 486. 1. 4. 42.0 23.0 3.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 488. 1. 5. 27.0 2.5 0.0 2. 20.0 20.0 4. 6. 0.0 0. 1. + 492. 1. 4. 32.0 6.0 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 494. 1. 5. 27.0 9.0 0.0 2. 12.0 20.0 4. 5. 0.0 0. 1. + 498. 1. 4. 32.0 6.0 1.0 3. 12.0 40.0 6. 6. 0.0 0. 1. + 499. 1. 3. 32.0 13.0 2.0 2. 16.0 14.0 3. 2. 0.0 0. 1. + 500. 1. 4. 37.0 16.5 4.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 501. 1. 5. 32.0 13.0 2.0 3. 12.0 20.0 5. 4. 0.0 0. 1. + 507. 1. 3. 22.0 2.5 2.0 1. 12.0 9.0 3. 2. 0.0 0. 1. + 511. 1. 5. 27.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 514. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 517. 1. 5. 37.0 13.0 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 524. 1. 5. 22.0 2.5 0.0 1. 12.0 11.5 3. 4. 0.0 0. 1. + 525. 1. 4. 37.0 16.5 2.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 528. 1. 5. 37.0 16.5 2.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 532. 1. 5. 27.0 6.0 2.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 543. 1. 1. 22.0 2.5 1.0 2. 17.0 4.0 2. 2. 0.0 0. 1. + 548. 1. 3. 32.0 13.0 3.0 1. 14.0 11.5 3. 5. 0.0 0. 1. + 554. 1. 4. 27.0 2.5 1.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 556. 1. 5. 32.0 6.0 2.0 2. 16.0 11.5 4. 5. 0.0 0. 1. + 562. 1. 5. 22.0 2.5 0.0 1. 12.0 11.5 3. 5. 0.0 0. 1. + 564. 1. 5. 32.0 9.0 4.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 566. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 3. 1. 0.0 0. 1. + 567. 1. 5. 17.5 0.5 0.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 569. 1. 5. 27.0 0.5 0.0 1. 17.0 20.0 4. 5. 0.0 0. 1. + 572. 1. 5. 22.0 0.5 0.0 4. 16.0 6.5 6. 2. 0.0 0. 1. + 581. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 582. 1. 5. 37.0 16.5 1.0 2. 14.0 20.0 4. 3. 0.0 0. 1. + 589. 1. 3. 42.0 16.5 3.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 591. 1. 5. 27.0 6.0 1.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 593. 1. 5. 42.0 23.0 2.0 3. 17.0 20.0 5. 4. 0.0 0. 1. + 594. 1. 4. 22.0 0.5 0.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 597. 1. 2. 37.0 16.5 3.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 598. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 599. 1. 5. 27.0 2.5 0.0 1. 16.0 40.0 4. 4. 0.0 0. 1. + 600. 1. 4. 27.0 2.5 1.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 601. 1. 3. 42.0 13.0 0.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 602. 1. 3. 42.0 16.5 1.0 4. 20.0 40.0 6. 6. 0.0 0. 1. + 603. 1. 4. 42.0 23.0 4.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 610. 1. 5. 27.0 6.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 611. 1. 5. 37.0 23.0 5.5 3. 12.0 20.0 2. 5. 0.0 0. 1. + 615. 1. 5. 27.0 9.0 2.0 2. 14.0 14.0 2. 2. 0.0 0. 1. + 617. 1. 4. 27.0 13.0 4.0 2. 12.0 6.5 3. 2. 0.0 0. 1. + 620. 1. 3. 27.0 6.0 1.0 1. 17.0 40.0 4. 5. 0.0 0. 1. + 627. 1. 5. 32.0 9.0 2.0 3. 12.0 11.5 4. 4. 0.0 0. 1. + 629. 1. 5. 27.0 2.5 0.0 1. 14.0 14.0 5. 4. 0.0 0. 1. + 631. 1. 4. 27.0 9.0 2.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 632. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 3. 3. 0.0 0. 1. + 637. 1. 4. 42.0 23.0 4.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 638. 1. 3. 27.0 2.5 0.0 1. 17.0 11.5 4. 5. 0.0 0. 1. + 640. 1. 4. 27.0 6.0 1.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 647. 1. 3. 27.0 6.0 2.0 1. 12.0 11.5 2. 2. 0.0 0. 1. + 651. 1. 3. 42.0 9.0 1.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 659. 1. 5. 42.0 23.0 3.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 660. 1. 4. 22.0 6.0 2.0 1. 12.0 20.0 3. 6. 0.0 0. 1. + 661. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 663. 1. 4. 27.0 9.0 2.0 3. 12.0 6.5 2. 5. 0.0 0. 1. + 668. 1. 5. 22.0 2.5 0.0 4. 16.0 11.5 5. 1. 0.0 0. 1. + 692. 1. 5. 27.0 6.0 2.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 693. 1. 5. 22.0 2.5 0.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 698. 1. 5. 22.0 0.5 0.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 699. 1. 5. 32.0 6.0 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 704. 1. 5. 42.0 23.0 4.0 2. 16.0 40.0 5. 5. 0.0 0. 1. + 708. 1. 5. 42.0 16.5 1.0 3. 17.0 14.0 4. 5. 0.0 0. 1. + 709. 1. 5. 27.0 16.5 4.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 711. 1. 5. 27.0 6.0 2.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 718. 1. 5. 37.0 23.0 3.0 2. 14.0 11.5 3. 6. 0.0 0. 1. + 722. 1. 3. 27.0 6.0 2.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 724. 1. 5. 32.0 6.0 0.0 1. 16.0 40.0 5. 5. 0.0 0. 1. + 730. 1. 4. 32.0 9.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 731. 1. 4. 27.0 9.0 5.5 1. 12.0 9.0 4. 3. 0.0 0. 1. + 741. 1. 4. 22.0 2.5 1.0 1. 12.0 14.0 5. 4. 0.0 0. 1. + 742. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 743. 1. 5. 42.0 23.0 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 747. 1. 4. 32.0 6.0 2.0 3. 14.0 14.0 4. 4. 0.0 0. 1. + 754. 1. 4. 22.0 2.5 0.0 1. 16.0 6.5 3. 4. 0.0 0. 1. + 761. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 765. 1. 4. 37.0 16.5 2.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 767. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 768. 1. 2. 42.0 23.0 5.5 1. 20.0 40.0 2. 5. 0.0 0. 1. + 770. 1. 4. 27.0 2.5 1.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 782. 1. 4. 27.0 16.5 4.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 792. 1. 4. 22.0 2.5 0.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 795. 1. 5. 32.0 9.0 2.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 797. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 798. 1. 5. 42.0 23.0 5.5 3. 16.0 20.0 2. 5. 0.0 0. 1. + 799. 1. 5. 27.0 2.5 0.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 804. 1. 5. 27.0 2.5 1.0 1. 14.0 20.0 4. 6. 0.0 0. 1. + 810. 1. 4. 22.0 0.5 0.0 3. 16.0 9.0 5. 1. 0.0 0. 1. + 811. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 815. 1. 5. 22.0 0.5 0.0 1. 16.0 11.5 3. 6. 0.0 0. 1. + 823. 1. 3. 42.0 23.0 3.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 828. 1. 5. 27.0 2.5 1.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 829. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 835. 1. 4. 27.0 6.0 2.0 3. 16.0 9.0 4. 4. 0.0 0. 1. + 842. 1. 3. 22.0 6.0 3.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 849. 1. 4. 22.0 2.5 0.0 4. 12.0 20.0 3. 2. 0.0 0. 1. + 852. 1. 5. 42.0 23.0 2.0 3. 12.0 6.5 3. 4. 0.0 0. 1. + 853. 1. 4. 27.0 2.5 0.0 2. 16.0 11.5 4. 5. 0.0 0. 1. + 862. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 864. 1. 5. 22.0 0.5 0.0 2. 14.0 6.5 2. 4. 0.0 0. 1. + 867. 1. 5. 32.0 16.5 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 868. 1. 4. 27.0 2.5 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 871. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 878. 1. 5. 32.0 9.0 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 879. 1. 5. 17.5 2.5 0.0 3. 12.0 6.5 3. 2. 0.0 0. 1. + 886. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 890. 1. 5. 22.0 2.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 893. 1. 5. 32.0 9.0 2.0 3. 17.0 20.0 4. 2. 0.0 0. 1. + 897. 1. 5. 22.0 0.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 906. 1. 5. 37.0 16.5 3.0 4. 14.0 20.0 4. 2. 0.0 0. 1. + 912. 1. 5. 27.0 2.5 0.0 2. 16.0 14.0 2. 4. 0.0 0. 1. + 913. 1. 5. 37.0 13.0 3.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 914. 1. 4. 32.0 6.0 1.0 2. 14.0 20.0 5. 6. 0.0 0. 1. + 916. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 5. 5. 0.0 0. 1. + 918. 1. 5. 32.0 2.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 921. 1. 5. 32.0 16.5 2.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 926. 1. 4. 27.0 2.5 1.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 930. 1. 4. 27.0 6.0 1.0 3. 17.0 9.0 4. 4. 0.0 0. 1. + 931. 1. 2. 42.0 23.0 4.0 3. 9.0 11.5 2. 2. 0.0 0. 1. + 932. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 5. 4. 0.0 0. 1. + 936. 1. 4. 27.0 2.5 0.0 1. 16.0 4.0 4. 4. 0.0 0. 1. + 940. 1. 5. 27.0 6.0 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 941. 1. 3. 22.0 2.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 950. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 951. 1. 4. 22.0 2.5 0.0 3. 17.0 20.0 5. 4. 0.0 0. 1. + 959. 1. 5. 42.0 23.0 5.5 4. 12.0 20.0 3. 5. 0.0 0. 1. + 962. 1. 4. 32.0 13.0 3.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 963. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 965. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 3. 5. 0.0 0. 1. + 966. 1. 4. 27.0 2.5 1.0 2. 16.0 11.5 4. 5. 0.0 0. 1. + 973. 1. 5. 42.0 23.0 4.0 1. 17.0 40.0 3. 5. 0.0 0. 1. + 974. 1. 4. 32.0 13.0 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 975. 1. 3. 17.5 2.5 0.0 1. 16.0 14.0 4. 2. 0.0 0. 1. + 982. 1. 4. 42.0 23.0 3.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 983. 1. 5. 27.0 9.0 2.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 984. 1. 5. 22.0 2.5 1.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 986. 1. 4. 27.0 6.0 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 987. 1. 5. 32.0 9.0 0.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 996. 1. 5. 22.0 2.5 0.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 997. 1. 5. 37.0 16.5 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 1005. 1. 4. 22.0 6.0 2.0 3. 14.0 11.5 4. 2. 0.0 0. 1. + 1014. 1. 5. 27.0 2.5 0.0 4. 16.0 20.0 4. 2. 0.0 0. 1. + 1017. 1. 5. 37.0 13.0 2.0 2. 20.0 20.0 4. 5. 0.0 0. 1. + 1018. 1. 5. 27.0 13.0 2.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 1019. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 2. 5. 0.0 0. 1. + 1022. 1. 4. 22.0 6.0 1.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 1023. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 1025. 1. 3. 22.0 2.5 1.0 2. 12.0 6.5 2. 5. 0.0 0. 1. + 1027. 1. 5. 22.0 0.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 1031. 1. 5. 17.5 2.5 0.0 1. 14.0 6.5 3. 4. 0.0 0. 1. + 1032. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 1034. 1. 4. 22.0 0.5 0.0 3. 12.0 9.0 2. 5. 0.0 0. 1. + 1044. 1. 5. 27.0 2.5 0.0 1. 16.0 40.0 4. 5. 0.0 0. 1. + 1046. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 1053. 1. 4. 27.0 6.0 0.0 1. 12.0 20.0 3. 2. 0.0 0. 1. + 1065. 1. 5. 22.0 2.5 2.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 1070. 1. 2. 27.0 6.0 1.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 1079. 1. 5. 22.0 0.5 0.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 1082. 1. 5. 22.0 6.0 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 1085. 1. 5. 27.0 2.5 0.0 3. 12.0 11.5 4. 2. 0.0 0. 1. + 1086. 1. 3. 32.0 16.5 4.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 1090. 1. 5. 27.0 2.5 0.0 1. 20.0 9.0 4. 4. 0.0 0. 1. + 1098. 1. 4. 27.0 2.5 0.0 2. 16.0 40.0 5. 6. 0.0 0. 1. + 1103. 1. 5. 22.0 2.5 0.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 1107. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 1113. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 3. 2. 0.0 0. 1. + 1126. 1. 4. 37.0 16.5 3.0 2. 12.0 40.0 5. 4. 0.0 0. 1. + 1134. 1. 5. 27.0 6.0 2.0 4. 17.0 14.0 4. 5. 0.0 0. 1. + 1135. 1. 5. 22.0 2.5 1.0 2. 12.0 6.5 3. 2. 0.0 0. 1. + 1136. 1. 5. 32.0 16.5 4.0 3. 12.0 40.0 3. 3. 0.0 0. 1. + 1141. 1. 5. 22.0 0.5 0.0 4. 16.0 11.5 3. 2. 0.0 0. 1. + 1150. 1. 3. 27.0 9.0 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 1157. 1. 5. 37.0 23.0 3.0 4. 12.0 20.0 3. 2. 0.0 0. 1. + 1161. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 3. 5. 0.0 0. 1. + 1162. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 1163. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 1177. 1. 4. 32.0 13.0 1.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 1183. 1. 5. 32.0 2.5 1.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 1184. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 1185. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 1186. 1. 5. 17.5 2.5 1.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 1198. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 2. 4. 0.0 0. 1. + 1200. 1. 4. 27.0 0.5 0.0 3. 16.0 20.0 3. 6. 0.0 0. 1. + 1204. 1. 5. 22.0 2.5 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 1206. 1. 5. 22.0 2.5 0.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 1210. 1. 5. 32.0 2.5 0.0 3. 14.0 40.0 3. 4. 0.0 0. 1. + 1221. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 1225. 1. 4. 27.0 6.0 1.0 2. 12.0 6.5 3. 4. 0.0 0. 1. + 1227. 1. 3. 22.0 2.5 0.0 2. 14.0 20.0 2. 5. 0.0 0. 1. + 1231. 1. 5. 27.0 6.0 2.0 3. 12.0 11.5 4. 2. 0.0 0. 1. + 1237. 1. 4. 22.0 0.5 0.0 1. 12.0 11.5 2. 2. 0.0 0. 1. + 1239. 1. 5. 42.0 23.0 3.0 1. 20.0 40.0 4. 6. 0.0 0. 1. + 1245. 1. 3. 22.0 2.5 1.0 2. 12.0 6.5 3. 4. 0.0 0. 1. + 1257. 1. 5. 27.0 6.0 0.0 2. 16.0 40.0 5. 5. 0.0 0. 1. + 1258. 1. 4. 22.0 2.5 0.0 3. 12.0 6.5 2. 5. 0.0 0. 1. + 1264. 1. 5. 22.0 6.0 0.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 1270. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 5. 4. 0.0 0. 1. + 1272. 1. 5. 17.5 2.5 0.0 2. 12.0 9.0 2. 5. 0.0 0. 1. + 1276. 1. 4. 27.0 2.5 0.0 1. 17.0 9.0 2. 6. 0.0 0. 1. + 1287. 1. 3. 42.0 23.0 5.5 3. 14.0 20.0 3. 5. 0.0 0. 1. + 1299. 1. 4. 32.0 6.0 2.0 1. 16.0 14.0 4. 4. 0.0 0. 1. + 1303. 1. 5. 22.0 6.0 2.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 1305. 1. 5. 22.0 6.0 3.0 3. 12.0 6.5 3. 4. 0.0 0. 1. + 1310. 1. 5. 22.0 2.5 0.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 1312. 1. 4. 42.0 23.0 2.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 1322. 1. 4. 27.0 2.5 2.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 1324. 1. 4. 27.0 2.5 1.0 2. 14.0 9.0 3. 5. 0.0 0. 1. + 1326. 1. 4. 32.0 13.0 2.0 4. 14.0 11.5 4. 3. 0.0 0. 1. + 1327. 1. 5. 22.0 0.5 0.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 1335. 1. 3. 42.0 23.0 2.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 1340. 1. 5. 42.0 23.0 3.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 1343. 1. 5. 22.0 0.5 0.0 2. 20.0 14.0 4. 4. 0.0 0. 1. + 1344. 1. 5. 22.0 2.5 0.0 1. 14.0 14.0 3. 3. 0.0 0. 1. + 1347. 1. 4. 27.0 6.0 1.0 1. 20.0 20.0 4. 2. 0.0 0. 1. + 1348. 1. 5. 32.0 9.0 2.0 3. 14.0 11.5 4. 1. 0.0 0. 1. + 1357. 1. 4. 17.5 0.5 0.0 1. 12.0 14.0 3. 4. 0.0 0. 1. + 1366. 1. 5. 42.0 6.0 0.0 2. 17.0 40.0 4. 5. 0.0 0. 1. + 1371. 1. 5. 42.0 23.0 2.0 2. 12.0 40.0 3. 6. 0.0 0. 1. + 1373. 1. 4. 27.0 13.0 1.0 2. 12.0 14.0 5. 2. 0.0 0. 1. + 1375. 1. 4. 27.0 2.5 0.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 1376. 1. 3. 27.0 6.0 2.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 1377. 1. 5. 22.0 6.0 0.0 1. 14.0 40.0 5. 5. 0.0 0. 1. + 1380. 1. 4. 37.0 13.0 2.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 1382. 1. 4. 27.0 2.5 0.0 1. 16.0 14.0 4. 1. 0.0 0. 1. + 1385. 1. 5. 27.0 9.0 2.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 1386. 1. 4. 32.0 2.5 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 1390. 1. 4. 27.0 2.5 0.0 4. 14.0 20.0 3. 6. 0.0 0. 1. + 1397. 1. 5. 27.0 6.0 3.0 1. 16.0 20.0 3. 5. 0.0 0. 1. + 1401. 1. 5. 32.0 16.5 4.0 3. 14.0 11.5 5. 2. 0.0 0. 1. + 1405. 1. 5. 17.5 0.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 1409. 1. 4. 42.0 23.0 4.0 2. 12.0 11.5 2. 5. 0.0 0. 1. + 1417. 1. 5. 27.0 6.0 0.0 4. 16.0 20.0 5. 5. 0.0 0. 1. + 1418. 1. 4. 27.0 2.5 0.0 1. 16.0 14.0 4. 5. 0.0 0. 1. + 1423. 1. 5. 37.0 16.5 2.0 1. 16.0 40.0 4. 5. 0.0 0. 1. + 1429. 1. 5. 22.0 2.5 1.0 3. 17.0 11.5 4. 2. 0.0 0. 1. + 1430. 1. 4. 17.5 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 1437. 1. 3. 27.0 6.0 2.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 1440. 1. 3. 37.0 16.5 3.0 3. 12.0 20.0 4. 5. 0.0 0. 1. + 1451. 1. 4. 27.0 2.5 0.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 1454. 1. 4. 37.0 13.0 2.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 1456. 1. 4. 32.0 9.0 1.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 1457. 1. 5. 27.0 6.0 1.0 2. 16.0 11.5 2. 6. 0.0 0. 1. + 1461. 1. 4. 22.0 2.5 1.0 3. 12.0 9.0 2. 4. 0.0 0. 1. + 1468. 1. 2. 42.0 23.0 5.5 1. 12.0 20.0 5. 5. 0.0 0. 1. + 1472. 1. 5. 42.0 16.5 5.5 3. 17.0 40.0 4. 5. 0.0 0. 1. + 1474. 1. 5. 42.0 23.0 4.0 3. 12.0 40.0 5. 6. 0.0 0. 1. + 1475. 1. 5. 22.0 0.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 1479. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 5. 5. 0.0 0. 1. + 1481. 1. 3. 32.0 13.0 3.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 1485. 1. 3. 32.0 13.0 3.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 1490. 1. 5. 32.0 9.0 2.0 3. 16.0 40.0 4. 6. 0.0 0. 1. + 1493. 1. 5. 27.0 0.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 1497. 1. 5. 32.0 16.5 3.0 4. 14.0 20.0 2. 4. 0.0 0. 1. + 1500. 1. 3. 22.0 2.5 0.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 1502. 1. 5. 27.0 13.0 3.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 1507. 1. 4. 27.0 2.5 0.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 1511. 1. 4. 42.0 13.0 0.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 1524. 1. 5. 32.0 13.0 3.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 1525. 1. 5. 27.0 13.0 3.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 1528. 1. 4. 32.0 13.0 3.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 1533. 1. 4. 27.0 0.5 1.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 1541. 1. 5. 27.0 6.0 0.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 1542. 1. 3. 27.0 6.0 2.0 2. 14.0 20.0 4. 3. 0.0 0. 1. + 1544. 1. 3. 22.0 2.5 0.0 2. 16.0 20.0 5. 4. 0.0 0. 1. + 1546. 1. 3. 32.0 0.5 0.0 3. 20.0 40.0 6. 5. 0.0 0. 1. + 1547. 1. 5. 42.0 23.0 4.0 4. 20.0 40.0 4. 4. 0.0 0. 1. + 1550. 1. 3. 22.0 0.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 1557. 1. 5. 27.0 9.0 2.0 4. 16.0 20.0 2. 5. 0.0 0. 1. + 1566. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 1574. 1. 4. 42.0 16.5 2.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 1584. 1. 4. 42.0 16.5 3.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 1586. 1. 5. 42.0 23.0 4.0 2. 20.0 40.0 6. 5. 0.0 0. 1. + 1588. 1. 4. 32.0 16.5 3.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 1589. 1. 4. 32.0 6.0 1.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 1592. 1. 2. 32.0 16.5 2.0 4. 12.0 11.5 3. 2. 0.0 0. 1. + 1593. 1. 5. 32.0 9.0 2.0 4. 20.0 20.0 4. 6. 0.0 0. 1. + 1594. 1. 5. 22.0 2.5 0.0 2. 16.0 6.5 3. 2. 0.0 0. 1. + 1597. 1. 5. 27.0 2.5 1.0 1. 16.0 14.0 4. 4. 0.0 0. 1. + 1606. 1. 4. 27.0 9.0 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 1607. 1. 2. 32.0 16.5 3.0 4. 12.0 11.5 3. 5. 0.0 0. 1. + 1608. 1. 4. 32.0 13.0 2.0 1. 20.0 20.0 4. 6. 0.0 0. 1. + 1626. 1. 5. 27.0 2.5 0.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 1632. 1. 4. 37.0 13.0 2.0 4. 14.0 20.0 4. 5. 0.0 0. 1. + 1633. 1. 4. 22.0 0.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 1640. 1. 4. 27.0 9.0 2.0 2. 14.0 14.0 4. 4. 0.0 0. 1. + 1641. 1. 5. 27.0 6.0 0.0 1. 16.0 20.0 5. 5. 0.0 0. 1. + 1646. 1. 4. 32.0 13.0 2.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 1651. 1. 2. 42.0 23.0 2.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 1653. 1. 4. 22.0 0.5 0.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 1657. 1. 5. 42.0 23.0 2.0 3. 12.0 40.0 3. 5. 0.0 0. 1. + 1659. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 1664. 1. 5. 32.0 13.0 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 1665. 1. 5. 22.0 0.5 0.0 2. 16.0 9.0 4. 2. 0.0 0. 1. + 1669. 1. 4. 32.0 13.0 0.0 1. 12.0 40.0 5. 5. 0.0 0. 1. + 1670. 1. 4. 37.0 9.0 0.0 1. 16.0 20.0 3. 5. 0.0 0. 1. + 1671. 1. 5. 37.0 16.5 5.5 3. 14.0 20.0 4. 4. 0.0 0. 1. + 1687. 1. 4. 27.0 6.0 0.0 3. 14.0 40.0 5. 6. 0.0 0. 1. + 1691. 1. 5. 42.0 23.0 1.0 1. 17.0 20.0 3. 2. 0.0 0. 1. + 1692. 1. 4. 22.0 2.5 0.0 1. 17.0 20.0 1. 3. 0.0 0. 1. + 1693. 1. 4. 27.0 9.0 0.0 2. 12.0 40.0 3. 5. 0.0 0. 1. + 1696. 1. 4. 32.0 9.0 1.0 3. 14.0 11.5 3. 6. 0.0 0. 1. + 1697. 1. 1. 22.0 2.5 1.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 1698. 1. 4. 27.0 2.5 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 1699. 1. 4. 27.0 6.0 2.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 1700. 1. 2. 27.0 6.0 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 1702. 1. 2. 37.0 13.0 1.0 1. 12.0 9.0 2. 3. 0.0 0. 1. + 1705. 1. 5. 22.0 2.5 0.0 4. 14.0 20.0 5. 5. 0.0 0. 1. + 1706. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 4. 2. 0.0 0. 1. + 1715. 1. 4. 27.0 6.0 1.0 2. 14.0 9.0 4. 2. 0.0 0. 1. + 1716. 1. 4. 22.0 6.0 1.0 4. 14.0 9.0 3. 4. 0.0 0. 1. + 1719. 1. 4. 27.0 9.0 2.0 3. 12.0 11.5 4. 5. 0.0 0. 1. + 1728. 1. 4. 32.0 13.0 3.0 1. 16.0 40.0 4. 6. 0.0 0. 1. + 1733. 1. 5. 32.0 16.5 1.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 1738. 1. 4. 42.0 23.0 4.0 4. 14.0 11.5 5. 5. 0.0 0. 1. + 1748. 1. 5. 32.0 9.0 4.0 3. 14.0 14.0 4. 6. 0.0 0. 1. + 1751. 1. 3. 22.0 2.5 1.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 1752. 1. 5. 37.0 16.5 4.0 3. 17.0 40.0 5. 6. 0.0 0. 1. + 1754. 1. 5. 22.0 2.5 0.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 1758. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 1762. 1. 3. 42.0 16.5 3.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 1763. 1. 4. 37.0 13.0 3.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 1764. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 3. 6. 0.0 0. 1. + 1766. 1. 5. 42.0 23.0 5.5 4. 17.0 40.0 4. 6. 0.0 0. 1. + 1771. 1. 5. 22.0 0.5 2.0 1. 12.0 11.5 2. 4. 0.0 0. 1. + 1775. 1. 5. 37.0 16.5 3.0 1. 16.0 20.0 3. 4. 0.0 0. 1. + 1776. 1. 5. 32.0 9.0 3.0 3. 14.0 20.0 2. 5. 0.0 0. 1. + 1778. 1. 5. 27.0 6.0 1.0 3. 20.0 20.0 4. 6. 0.0 0. 1. + 1781. 1. 5. 27.0 6.0 2.0 3. 17.0 11.5 4. 1. 0.0 0. 1. + 1783. 1. 5. 32.0 6.0 1.0 4. 16.0 11.5 4. 6. 0.0 0. 1. + 1784. 1. 4. 27.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 1785. 1. 5. 22.0 2.5 0.0 1. 12.0 14.0 3. 3. 0.0 0. 1. + 1787. 1. 5. 22.0 2.5 0.0 1. 12.0 20.0 3. 3. 0.0 0. 1. + 1788. 1. 3. 42.0 23.0 4.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 1794. 1. 5. 27.0 6.0 1.0 1. 16.0 11.5 5. 2. 0.0 0. 1. + 1798. 1. 3. 27.0 6.0 0.0 2. 17.0 40.0 4. 6. 0.0 0. 1. + 1801. 1. 5. 27.0 6.0 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 1803. 1. 5. 27.0 6.0 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 1806. 1. 4. 27.0 2.5 0.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 1808. 1. 5. 32.0 9.0 2.0 1. 14.0 14.0 5. 5. 0.0 0. 1. + 1809. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 1810. 1. 4. 22.0 0.5 0.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 1814. 1. 5. 32.0 6.0 2.0 4. 12.0 14.0 3. 5. 0.0 0. 1. + 1816. 1. 5. 42.0 23.0 5.5 2. 12.0 20.0 2. 2. 0.0 0. 1. + 1817. 1. 5. 22.0 2.5 0.0 4. 16.0 6.5 4. 4. 0.0 0. 1. + 1818. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 5. 1. 0.0 0. 1. + 1824. 1. 5. 32.0 6.0 0.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 1825. 1. 4. 27.0 9.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 1828. 1. 4. 42.0 23.0 4.0 4. 16.0 14.0 4. 4. 0.0 0. 1. + 1833. 1. 4. 27.0 6.0 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 1835. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 1840. 1. 5. 27.0 0.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 1841. 1. 2. 27.0 2.5 0.0 3. 14.0 11.5 4. 1. 0.0 0. 1. + 1860. 1. 4. 27.0 6.0 0.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 1866. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 3. 3. 0.0 0. 1. + 1870. 1. 5. 32.0 13.0 2.0 2. 14.0 40.0 2. 4. 0.0 0. 1. + 1875. 1. 5. 22.0 2.5 0.0 4. 12.0 6.5 2. 4. 0.0 0. 1. + 1876. 1. 4. 42.0 16.5 2.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 1879. 1. 5. 27.0 13.0 2.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 1881. 1. 5. 22.0 2.5 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 1887. 1. 5. 37.0 16.5 4.0 3. 12.0 40.0 2. 6. 0.0 0. 1. + 1893. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 3. 4. 0.0 0. 1. + 1902. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 1903. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 2. 5. 0.0 0. 1. + 1905. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 2. 0.0 0. 1. + 1908. 1. 4. 27.0 2.5 0.0 2. 17.0 14.0 4. 4. 0.0 0. 1. + 1913. 1. 4. 42.0 23.0 2.0 4. 12.0 20.0 4. 2. 0.0 0. 1. + 1915. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 1919. 1. 4. 37.0 13.0 1.0 3. 12.0 40.0 2. 2. 0.0 0. 1. + 1927. 1. 4. 27.0 6.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 1929. 1. 5. 27.0 6.0 1.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 1932. 1. 3. 42.0 23.0 5.5 2. 14.0 40.0 4. 5. 0.0 0. 1. + 1943. 1. 5. 27.0 6.0 0.0 3. 20.0 40.0 4. 4. 0.0 0. 1. + 1944. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 1945. 1. 4. 27.0 2.5 0.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 1948. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 1949. 1. 2. 32.0 2.5 1.0 2. 12.0 14.0 5. 2. 0.0 0. 1. + 1955. 1. 4. 27.0 2.5 1.0 2. 14.0 14.0 4. 4. 0.0 0. 1. + 1956. 1. 4. 27.0 0.5 0.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 1959. 1. 4. 32.0 9.0 1.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 1962. 1. 4. 27.0 9.0 2.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 1963. 1. 5. 22.0 2.5 0.0 4. 14.0 6.5 4. 4. 0.0 0. 1. + 1985. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 1996. 1. 5. 27.0 6.0 2.0 2. 16.0 20.0 4. 1. 0.0 0. 1. + 1997. 1. 4. 27.0 6.0 0.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 1999. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2009. 1. 4. 37.0 16.5 2.0 1. 20.0 40.0 4. 6. 0.0 0. 1. + 2013. 1. 4. 42.0 23.0 3.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 2017. 1. 1. 42.0 23.0 5.5 3. 14.0 20.0 2. 5. 0.0 0. 1. + 2018. 1. 4. 27.0 2.5 0.0 1. 12.0 20.0 3. 2. 0.0 0. 1. + 2029. 1. 4. 27.0 6.0 1.0 3. 14.0 11.5 2. 5. 0.0 0. 1. + 2030. 1. 3. 42.0 16.5 5.5 2. 14.0 40.0 3. 6. 0.0 0. 1. + 2033. 1. 5. 22.0 2.5 0.0 2. 16.0 6.5 3. 1. 0.0 0. 1. + 2040. 1. 4. 27.0 2.5 1.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 2043. 1. 5. 37.0 16.5 4.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 2045. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 2049. 1. 4. 27.0 2.5 0.0 3. 14.0 11.5 3. 1. 0.0 0. 1. + 2057. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 2. 2. 0.0 0. 1. + 2059. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 2068. 1. 5. 22.0 0.5 0.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 2069. 1. 3. 42.0 23.0 2.0 1. 20.0 40.0 4. 4. 0.0 0. 1. + 2071. 1. 5. 32.0 16.5 1.0 3. 17.0 40.0 5. 4. 0.0 0. 1. + 2074. 1. 5. 27.0 9.0 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 2081. 1. 5. 27.0 2.5 1.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 2083. 1. 4. 27.0 6.0 0.0 2. 16.0 14.0 3. 3. 0.0 0. 1. + 2084. 1. 5. 22.0 0.5 0.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 2085. 1. 4. 32.0 9.0 0.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 2089. 1. 3. 37.0 16.5 3.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 2091. 1. 5. 27.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 2092. 1. 5. 22.0 2.5 0.0 4. 14.0 40.0 3. 2. 0.0 0. 1. + 2094. 1. 4. 32.0 13.0 3.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 2097. 1. 5. 42.0 23.0 5.5 4. 17.0 40.0 5. 5. 0.0 0. 1. + 2103. 1. 4. 27.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 2117. 1. 5. 42.0 16.5 4.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 2118. 1. 3. 27.0 2.5 0.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 2119. 1. 5. 27.0 6.0 2.0 4. 16.0 40.0 4. 6. 0.0 0. 1. + 2121. 1. 3. 22.0 0.5 0.0 3. 12.0 9.0 5. 4. 0.0 0. 1. + 2127. 1. 4. 42.0 23.0 3.0 2. 14.0 40.0 3. 4. 0.0 0. 1. + 2131. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 2148. 1. 5. 22.0 0.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 2151. 1. 5. 22.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 2154. 1. 5. 37.0 16.5 2.0 1. 12.0 40.0 3. 5. 0.0 0. 1. + 2162. 1. 3. 22.0 6.0 2.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 2171. 1. 2. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2172. 1. 4. 32.0 2.5 0.0 1. 17.0 40.0 5. 5. 0.0 0. 1. + 2175. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 3. 4. 0.0 0. 1. + 2181. 1. 4. 22.0 0.5 0.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 2184. 1. 5. 27.0 6.0 1.0 1. 14.0 14.0 4. 4. 0.0 0. 1. + 2186. 1. 4. 27.0 2.5 0.0 3. 16.0 40.0 4. 4. 0.0 0. 1. + 2188. 1. 5. 32.0 6.0 3.0 1. 16.0 20.0 3. 5. 0.0 0. 1. + 2190. 1. 5. 32.0 16.5 2.0 1. 12.0 20.0 2. 3. 0.0 0. 1. + 2193. 1. 4. 42.0 16.5 3.0 2. 14.0 40.0 3. 2. 0.0 0. 1. + 2194. 1. 5. 22.0 0.5 0.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 2197. 1. 5. 17.5 0.5 0.0 2. 12.0 4.0 2. 4. 0.0 0. 1. + 2198. 1. 5. 42.0 23.0 3.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 2200. 1. 2. 22.0 0.5 0.0 1. 14.0 20.0 3. 2. 0.0 0. 1. + 2201. 1. 5. 27.0 2.5 0.0 1. 16.0 40.0 4. 5. 0.0 0. 1. + 2204. 1. 5. 27.0 16.5 3.0 1. 12.0 11.5 3. 5. 0.0 0. 1. + 2207. 1. 5. 22.0 0.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2211. 1. 4. 32.0 9.0 2.0 3. 20.0 40.0 6. 5. 0.0 0. 1. + 2213. 1. 4. 22.0 0.5 0.0 2. 14.0 6.5 2. 1. 0.0 0. 1. + 2214. 1. 4. 27.0 6.0 2.0 4. 14.0 9.0 3. 5. 0.0 0. 1. + 2215. 1. 1. 27.0 9.0 4.0 1. 12.0 9.0 4. 2. 0.0 0. 1. + 2224. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2227. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 2233. 1. 5. 22.0 2.5 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 2237. 1. 5. 17.5 0.5 0.0 3. 12.0 11.5 5. 2. 0.0 0. 1. + 2239. 1. 4. 32.0 9.0 2.0 3. 14.0 14.0 2. 4. 0.0 0. 1. + 2245. 1. 5. 27.0 6.0 0.0 3. 17.0 20.0 5. 5. 0.0 0. 1. + 2246. 1. 5. 22.0 0.5 0.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 2250. 1. 5. 32.0 9.0 0.0 3. 12.0 40.0 3. 4. 0.0 0. 1. + 2252. 1. 3. 27.0 9.0 3.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 2254. 1. 5. 22.0 2.5 0.0 1. 12.0 4.0 3. 1. 0.0 0. 1. + 2261. 1. 5. 42.0 16.5 4.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2262. 1. 5. 27.0 2.5 1.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 2263. 1. 3. 22.0 2.5 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 2264. 1. 5. 22.0 2.5 1.0 1. 14.0 11.5 3. 5. 0.0 0. 1. + 2284. 1. 4. 27.0 16.5 3.0 1. 16.0 20.0 5. 5. 0.0 0. 1. + 2285. 1. 5. 27.0 2.5 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 2295. 1. 3. 27.0 2.5 1.0 1. 17.0 11.5 2. 5. 0.0 0. 1. + 2297. 1. 5. 22.0 2.5 0.0 3. 14.0 6.5 3. 4. 0.0 0. 1. + 2301. 1. 5. 37.0 16.5 2.0 3. 20.0 40.0 6. 6. 0.0 0. 1. + 2321. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 2322. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 2326. 1. 4. 22.0 2.5 0.0 3. 16.0 6.5 3. 1. 0.0 0. 1. + 2327. 1. 4. 27.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2332. 1. 1. 27.0 6.0 1.0 2. 20.0 40.0 4. 5. 0.0 0. 1. + 2335. 1. 5. 22.0 0.5 0.0 3. 14.0 14.0 2. 2. 0.0 0. 1. + 2345. 1. 5. 32.0 13.0 4.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 2347. 1. 5. 22.0 6.0 0.0 2. 12.0 40.0 3. 5. 0.0 0. 1. + 2351. 1. 5. 37.0 16.5 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 2353. 1. 3. 22.0 6.0 2.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 2356. 1. 4. 22.0 0.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 2361. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 2366. 1. 4. 22.0 2.5 0.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 2367. 1. 5. 22.0 2.5 0.0 1. 12.0 11.5 3. 2. 0.0 0. 1. + 2368. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2369. 1. 3. 27.0 0.5 0.0 3. 20.0 40.0 6. 6. 0.0 0. 1. + 2371. 1. 4. 32.0 13.0 2.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 2373. 1. 3. 22.0 2.5 0.0 2. 16.0 14.0 3. 6. 0.0 0. 1. + 2377. 1. 5. 32.0 2.5 0.0 2. 20.0 20.0 4. 4. 0.0 0. 1. + 2382. 1. 4. 22.0 2.5 0.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 2385. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 2387. 1. 3. 22.0 0.5 0.0 3. 16.0 20.0 3. 4. 0.0 0. 1. + 2389. 1. 5. 27.0 6.0 1.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 2394. 1. 5. 32.0 16.5 1.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 2397. 1. 3. 37.0 23.0 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 2399. 1. 5. 22.0 2.5 0.0 1. 20.0 20.0 4. 5. 0.0 0. 1. + 2401. 1. 5. 27.0 6.0 0.0 1. 12.0 14.0 3. 4. 0.0 0. 1. + 2405. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 2408. 1. 3. 37.0 23.0 5.5 1. 12.0 14.0 3. 4. 0.0 0. 1. + 2410. 1. 3. 42.0 16.5 2.0 2. 12.0 40.0 2. 6. 0.0 0. 1. + 2411. 1. 4. 27.0 6.0 2.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 2417. 1. 5. 22.0 2.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 2418. 1. 5. 22.0 0.5 0.0 3. 12.0 9.0 2. 5. 0.0 0. 1. + 2423. 1. 4. 42.0 23.0 2.0 3. 12.0 20.0 2. 5. 0.0 0. 1. + 2425. 1. 5. 37.0 16.5 2.0 1. 14.0 40.0 5. 6. 0.0 0. 1. + 2428. 1. 5. 42.0 23.0 4.0 4. 12.0 40.0 3. 5. 0.0 0. 1. + 2429. 1. 2. 22.0 2.5 0.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 2433. 1. 4. 27.0 6.0 2.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 2434. 1. 3. 22.0 0.5 0.0 2. 17.0 14.0 3. 5. 0.0 0. 1. + 2435. 1. 3. 27.0 6.0 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 2445. 1. 5. 32.0 13.0 3.0 2. 20.0 40.0 3. 6. 0.0 0. 1. + 2454. 1. 5. 42.0 23.0 4.0 4. 16.0 20.0 2. 5. 0.0 0. 1. + 2461. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 2470. 1. 5. 27.0 6.0 1.0 3. 20.0 40.0 4. 6. 0.0 0. 1. + 2471. 1. 2. 42.0 23.0 5.5 3. 12.0 20.0 2. 5. 0.0 0. 1. + 2472. 1. 5. 22.0 6.0 0.0 4. 14.0 6.5 3. 2. 0.0 0. 1. + 2478. 1. 5. 22.0 6.0 1.0 1. 12.0 11.5 3. 5. 0.0 0. 1. + 2480. 1. 5. 27.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 2492. 1. 5. 32.0 13.0 3.0 4. 16.0 14.0 4. 6. 0.0 0. 1. + 2493. 1. 5. 27.0 0.5 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 2501. 1. 4. 37.0 16.5 2.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 2505. 1. 4. 32.0 2.5 0.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 2506. 1. 5. 32.0 2.5 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 2513. 1. 4. 27.0 2.5 0.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 2519. 1. 5. 27.0 6.0 1.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 2520. 1. 4. 27.0 6.0 1.0 1. 20.0 20.0 4. 4. 0.0 0. 1. + 2522. 1. 5. 22.0 2.5 0.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 2524. 1. 5. 32.0 16.5 2.0 3. 17.0 11.5 3. 5. 0.0 0. 1. + 2535. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 5. 5. 0.0 0. 1. + 2537. 1. 5. 27.0 6.0 1.0 3. 20.0 20.0 6. 6. 0.0 0. 1. + 2542. 1. 3. 27.0 6.0 2.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 2544. 1. 5. 27.0 9.0 1.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 2545. 1. 3. 42.0 23.0 4.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 2549. 1. 5. 27.0 6.0 2.0 2. 20.0 14.0 4. 3. 0.0 0. 1. + 2555. 1. 4. 27.0 6.0 2.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 2558. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 5. 4. 0.0 0. 1. + 2563. 1. 4. 22.0 2.5 0.0 3. 16.0 14.0 3. 5. 0.0 0. 1. + 2569. 1. 5. 32.0 16.5 3.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 2573. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 1. 5. 0.0 0. 1. + 2574. 1. 5. 27.0 6.0 0.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 2576. 1. 5. 22.0 2.5 0.0 1. 12.0 9.0 2. 1. 0.0 0. 1. + 2580. 1. 4. 27.0 6.0 1.0 1. 14.0 20.0 4. 4. 0.0 0. 1. + 2581. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 2. 4. 0.0 0. 1. + 2582. 1. 4. 22.0 2.5 0.0 4. 12.0 20.0 3. 2. 0.0 0. 1. + 2586. 1. 5. 17.5 2.5 0.0 1. 12.0 9.0 2. 4. 0.0 0. 1. + 2592. 1. 4. 37.0 16.5 3.0 3. 12.0 11.5 4. 5. 0.0 0. 1. + 2593. 1. 4. 27.0 6.0 1.0 2. 12.0 11.5 4. 4. 0.0 0. 1. + 2595. 1. 3. 37.0 13.0 0.0 2. 14.0 20.0 5. 6. 0.0 0. 1. + 2597. 1. 4. 37.0 16.5 4.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 2598. 1. 4. 27.0 2.5 0.0 1. 14.0 40.0 5. 6. 0.0 0. 1. + 2599. 1. 5. 42.0 23.0 2.0 2. 12.0 40.0 5. 5. 0.0 0. 1. + 2600. 1. 5. 22.0 2.5 0.0 4. 14.0 11.5 2. 2. 0.0 0. 1. + 2601. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 3. 1. 0.0 0. 1. + 2610. 1. 5. 27.0 0.5 0.0 3. 20.0 40.0 4. 4. 0.0 0. 1. + 2616. 1. 5. 27.0 6.0 1.0 2. 20.0 14.0 4. 6. 0.0 0. 1. + 2619. 1. 4. 22.0 2.5 0.0 2. 16.0 9.0 5. 2. 0.0 0. 1. + 2622. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 2. 3. 0.0 0. 1. + 2623. 1. 5. 22.0 0.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 2631. 1. 4. 37.0 9.0 5.5 4. 12.0 20.0 4. 2. 0.0 0. 1. + 2646. 1. 3. 27.0 0.5 0.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 2671. 1. 5. 27.0 2.5 0.0 2. 20.0 20.0 4. 5. 0.0 0. 1. + 2674. 1. 3. 22.0 2.5 0.0 1. 14.0 14.0 3. 3. 0.0 0. 1. + 2680. 1. 3. 42.0 16.5 4.0 4. 16.0 6.5 3. 1. 0.0 0. 1. + 2684. 1. 5. 32.0 13.0 3.0 2. 12.0 40.0 2. 5. 0.0 0. 1. + 2688. 1. 2. 32.0 13.0 2.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 2696. 1. 5. 22.0 2.5 0.0 2. 14.0 6.5 3. 1. 0.0 0. 1. + 2697. 1. 3. 27.0 2.5 1.0 1. 14.0 11.5 5. 4. 0.0 0. 1. + 2702. 1. 4. 22.0 0.5 0.0 4. 12.0 14.0 3. 2. 0.0 0. 1. + 2713. 1. 4. 27.0 9.0 2.0 3. 12.0 11.5 5. 4. 0.0 0. 1. + 2715. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 2718. 1. 5. 27.0 6.0 2.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 2723. 1. 4. 22.0 2.5 0.0 1. 12.0 6.5 3. 2. 0.0 0. 1. + 2726. 1. 5. 22.0 0.5 0.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 2729. 1. 5. 42.0 23.0 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 2740. 1. 3. 22.0 2.5 1.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 2742. 1. 4. 27.0 16.5 2.0 3. 12.0 40.0 4. 4. 0.0 0. 1. + 2744. 1. 5. 17.5 0.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 2745. 1. 5. 27.0 2.5 0.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 2748. 1. 4. 27.0 9.0 2.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 2751. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 2754. 1. 5. 37.0 16.5 2.0 2. 12.0 20.0 3. 6. 0.0 0. 1. + 2755. 1. 5. 32.0 23.0 2.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 2758. 1. 5. 22.0 2.5 1.0 4. 14.0 4.0 4. 1. 0.0 0. 1. + 2760. 1. 4. 27.0 2.5 0.0 3. 17.0 14.0 4. 6. 0.0 0. 1. + 2761. 1. 5. 22.0 0.5 0.0 2. 12.0 11.5 4. 4. 0.0 0. 1. + 2764. 1. 4. 37.0 16.5 2.0 3. 20.0 20.0 4. 6. 0.0 0. 1. + 2765. 1. 4. 27.0 2.5 0.0 3. 14.0 14.0 4. 1. 0.0 0. 1. + 2766. 1. 4. 22.0 2.5 0.0 3. 16.0 14.0 4. 3. 0.0 0. 1. + 2769. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 2. 5. 0.0 0. 1. + 2774. 1. 5. 42.0 23.0 2.0 3. 14.0 40.0 3. 6. 0.0 0. 1. + 2775. 1. 5. 22.0 0.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 2783. 1. 5. 27.0 6.0 3.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 2784. 1. 4. 32.0 16.5 3.0 2. 16.0 40.0 2. 6. 0.0 0. 1. + 2789. 1. 4. 27.0 0.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 2793. 1. 2. 22.0 0.5 0.0 4. 12.0 20.0 3. 3. 0.0 0. 1. + 2797. 1. 4. 22.0 2.5 0.0 3. 17.0 11.5 4. 2. 0.0 0. 1. + 2798. 1. 5. 27.0 2.5 0.0 3. 16.0 14.0 4. 6. 0.0 0. 1. + 2812. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 2813. 1. 4. 27.0 2.5 3.0 2. 12.0 9.0 3. 6. 0.0 0. 1. + 2825. 1. 4. 32.0 6.0 1.0 4. 20.0 11.5 5. 5. 0.0 0. 1. + 2832. 1. 2. 27.0 2.5 0.0 3. 14.0 9.0 3. 3. 0.0 0. 1. + 2836. 1. 4. 42.0 23.0 4.0 2. 12.0 40.0 2. 6. 0.0 0. 1. + 2837. 1. 5. 42.0 16.5 1.0 3. 12.0 20.0 5. 3. 0.0 0. 1. + 2847. 1. 3. 27.0 9.0 2.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 2852. 1. 4. 42.0 23.0 2.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 2853. 1. 5. 42.0 23.0 2.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 2855. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 4. 4. 0.0 0. 1. + 2858. 1. 3. 42.0 23.0 3.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 2861. 1. 5. 22.0 2.5 0.0 4. 17.0 20.0 3. 2. 0.0 0. 1. + 2864. 1. 2. 22.0 2.5 0.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 2867. 1. 5. 27.0 6.0 1.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 2870. 1. 4. 37.0 16.5 5.5 2. 14.0 20.0 3. 4. 0.0 0. 1. + 2879. 1. 5. 32.0 13.0 3.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 2887. 1. 5. 27.0 6.0 2.0 3. 16.0 20.0 3. 4. 0.0 0. 1. + 2889. 1. 4. 27.0 6.0 1.0 1. 20.0 40.0 4. 4. 0.0 0. 1. + 2899. 1. 5. 22.0 2.5 0.0 1. 12.0 9.0 3. 2. 0.0 0. 1. + 2903. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 2904. 1. 5. 22.0 6.0 0.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 2905. 1. 4. 22.0 2.5 0.0 3. 12.0 9.0 5. 5. 0.0 0. 1. + 2906. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 4. 6. 0.0 0. 1. + 2908. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 2911. 1. 5. 27.0 6.0 0.0 2. 16.0 14.0 4. 6. 0.0 0. 1. + 2920. 1. 2. 37.0 16.5 3.0 4. 12.0 9.0 2. 5. 0.0 0. 1. + 2923. 1. 5. 22.0 6.0 2.0 2. 12.0 9.0 5. 2. 0.0 0. 1. + 2928. 1. 4. 27.0 2.5 1.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 2930. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 3. 2. 0.0 0. 1. + 2936. 1. 5. 42.0 23.0 3.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 2948. 1. 4. 22.0 2.5 0.0 3. 12.0 6.5 4. 1. 0.0 0. 1. + 2949. 1. 4. 32.0 13.0 2.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 2951. 1. 5. 27.0 2.5 0.0 3. 20.0 20.0 5. 6. 0.0 0. 1. + 2956. 1. 5. 22.0 0.5 0.0 3. 16.0 11.5 3. 2. 0.0 0. 1. + 2959. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 2960. 1. 4. 27.0 9.0 2.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 2966. 1. 4. 27.0 6.0 1.0 1. 20.0 20.0 4. 4. 0.0 0. 1. + 2969. 1. 5. 27.0 2.5 2.0 1. 12.0 9.0 2. 4. 0.0 0. 1. + 2974. 1. 4. 37.0 9.0 1.0 3. 20.0 20.0 4. 2. 0.0 0. 1. + 2976. 1. 4. 22.0 0.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 2979. 1. 5. 32.0 16.5 2.0 1. 14.0 40.0 5. 5. 0.0 0. 1. + 2983. 1. 3. 27.0 6.0 0.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 2985. 1. 4. 27.0 6.0 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 2988. 1. 5. 32.0 13.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 2993. 1. 3. 27.0 2.5 0.0 3. 12.0 6.5 3. 4. 0.0 0. 1. + 2997. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 2999. 1. 4. 32.0 6.0 1.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 3002. 1. 3. 27.0 2.5 0.0 1. 20.0 20.0 4. 4. 0.0 0. 1. + 3003. 1. 4. 42.0 23.0 2.0 4. 14.0 40.0 3. 5. 0.0 0. 1. + 3007. 1. 2. 27.0 2.5 1.0 2. 14.0 14.0 3. 2. 0.0 0. 1. + 3010. 1. 4. 42.0 23.0 3.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 3011. 1. 5. 27.0 6.0 2.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 3013. 1. 5. 22.0 0.5 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 3015. 1. 5. 27.0 6.0 2.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 3016. 1. 3. 22.0 2.5 0.0 1. 14.0 20.0 5. 4. 0.0 0. 1. + 3018. 1. 1. 42.0 23.0 3.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 3024. 1. 4. 42.0 16.5 3.0 2. 17.0 20.0 5. 5. 0.0 0. 1. + 3025. 1. 1. 27.0 2.5 0.0 1. 12.0 11.5 3. 1. 0.0 0. 1. + 3029. 1. 5. 22.0 0.5 0.0 1. 17.0 11.5 4. 4. 0.0 0. 1. + 3030. 1. 5. 37.0 16.5 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 3044. 1. 4. 27.0 6.0 2.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 3045. 1. 5. 22.0 2.5 0.0 4. 14.0 20.0 5. 5. 0.0 0. 1. + 3046. 1. 5. 22.0 2.5 0.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 3048. 1. 3. 27.0 6.0 2.0 3. 14.0 20.0 5. 2. 0.0 0. 1. + 3049. 1. 4. 27.0 2.5 0.0 3. 16.0 20.0 3. 6. 0.0 0. 1. + 3064. 1. 5. 27.0 2.5 0.0 1. 12.0 11.5 3. 5. 0.0 0. 1. + 3067. 1. 5. 17.5 2.5 2.0 1. 12.0 6.5 2. 4. 0.0 0. 1. + 3071. 1. 4. 32.0 16.5 2.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 3072. 1. 5. 27.0 2.5 0.0 1. 16.0 40.0 4. 5. 0.0 0. 1. + 3077. 1. 3. 42.0 23.0 2.0 3. 12.0 40.0 2. 5. 0.0 0. 1. + 3083. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 3084. 1. 3. 22.0 2.5 1.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 3086. 1. 3. 27.0 2.5 0.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 3090. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 3095. 1. 5. 32.0 13.0 2.0 4. 20.0 11.5 4. 6. 0.0 0. 1. + 3101. 1. 5. 22.0 2.5 0.0 1. 16.0 6.5 4. 6. 0.0 0. 1. + 3108. 1. 4. 32.0 9.0 2.0 3. 14.0 9.0 4. 2. 0.0 0. 1. + 3112. 1. 4. 42.0 23.0 5.5 3. 12.0 11.5 2. 4. 0.0 0. 1. + 3115. 1. 3. 27.0 0.5 0.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 3119. 1. 5. 42.0 23.0 2.0 2. 12.0 14.0 5. 2. 0.0 0. 1. + 3120. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 2. 4. 0.0 0. 1. + 3123. 1. 4. 22.0 2.5 2.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 3139. 1. 3. 27.0 6.0 2.0 2. 12.0 40.0 4. 5. 0.0 0. 1. + 3141. 1. 5. 27.0 2.5 2.0 3. 14.0 11.5 2. 4. 0.0 0. 1. + 3146. 1. 5. 22.0 0.5 0.0 2. 16.0 4.0 3. 4. 0.0 0. 1. + 3147. 1. 3. 32.0 6.0 2.0 2. 14.0 20.0 4. 6. 0.0 0. 1. + 3153. 1. 4. 27.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 3156. 1. 5. 37.0 23.0 5.5 2. 12.0 14.0 5. 2. 0.0 0. 1. + 3157. 1. 2. 27.0 6.0 0.0 1. 17.0 40.0 4. 4. 0.0 0. 1. + 3161. 1. 4. 32.0 16.5 4.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 3166. 1. 5. 22.0 2.5 2.0 2. 12.0 11.5 2. 5. 0.0 0. 1. + 3167. 1. 4. 22.0 2.5 0.0 1. 16.0 11.5 4. 4. 0.0 0. 1. + 3170. 1. 5. 27.0 2.5 0.0 3. 16.0 40.0 5. 5. 0.0 0. 1. + 3171. 1. 5. 22.0 2.5 0.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 3175. 1. 4. 22.0 2.5 1.0 4. 14.0 6.5 3. 5. 0.0 0. 1. + 3181. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 3183. 1. 5. 22.0 6.0 1.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 3184. 1. 3. 27.0 6.0 0.0 3. 14.0 20.0 5. 2. 0.0 0. 1. + 3193. 1. 5. 37.0 16.5 4.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 3198. 1. 4. 27.0 6.0 2.0 4. 14.0 14.0 4. 5. 0.0 0. 1. + 3200. 1. 4. 22.0 2.5 0.0 2. 17.0 14.0 5. 5. 0.0 0. 1. + 3201. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 4. 2. 0.0 0. 1. + 3206. 1. 3. 32.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 3208. 1. 5. 27.0 0.5 0.0 2. 16.0 40.0 4. 6. 0.0 0. 1. + 3210. 1. 5. 27.0 6.0 3.0 2. 14.0 11.5 2. 5. 0.0 0. 1. + 3211. 1. 5. 22.0 2.5 0.0 2. 16.0 14.0 2. 2. 0.0 0. 1. + 3214. 1. 4. 22.0 2.5 2.0 2. 16.0 20.0 5. 5. 0.0 0. 1. + 3215. 1. 4. 32.0 9.0 0.0 1. 20.0 40.0 4. 5. 0.0 0. 1. + 3229. 1. 3. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 3235. 1. 4. 37.0 9.0 1.0 3. 20.0 14.0 5. 4. 0.0 0. 1. + 3239. 1. 5. 27.0 2.5 0.0 3. 20.0 14.0 4. 4. 0.0 0. 1. + 3241. 1. 4. 32.0 13.0 2.0 4. 12.0 11.5 3. 3. 0.0 0. 1. + 3242. 1. 4. 27.0 2.5 1.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 3245. 1. 4. 22.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 3247. 1. 5. 27.0 6.0 2.0 4. 12.0 4.0 3. 2. 0.0 0. 1. + 3251. 1. 4. 32.0 13.0 1.0 3. 14.0 11.5 2. 4. 0.0 0. 1. + 3255. 1. 5. 22.0 0.5 0.0 1. 16.0 14.0 2. 3. 0.0 0. 1. + 3261. 1. 5. 22.0 2.5 0.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 3268. 1. 3. 42.0 23.0 5.5 2. 14.0 20.0 2. 5. 0.0 0. 1. + 3274. 1. 4. 27.0 6.0 2.0 1. 14.0 9.0 3. 3. 0.0 0. 1. + 3275. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 3276. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 3. 2. 0.0 0. 1. + 3278. 1. 2. 32.0 13.0 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 3286. 1. 5. 27.0 9.0 2.0 3. 12.0 11.5 2. 3. 0.0 0. 1. + 3291. 1. 4. 22.0 2.5 2.0 3. 14.0 14.0 4. 4. 0.0 0. 1. + 3292. 1. 5. 37.0 2.5 0.0 3. 14.0 20.0 3. 3. 0.0 0. 1. + 3293. 1. 5. 37.0 16.5 2.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 3294. 1. 5. 27.0 6.0 2.0 2. 14.0 11.5 4. 4. 0.0 0. 1. + 3297. 1. 4. 27.0 6.0 0.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 3298. 1. 5. 32.0 13.0 3.0 3. 12.0 14.0 4. 5. 0.0 0. 1. + 3299. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 3304. 1. 3. 22.0 2.5 0.0 2. 16.0 11.5 6. 3. 0.0 0. 1. + 3308. 1. 5. 32.0 9.0 3.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 3312. 1. 2. 27.0 6.0 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 3316. 1. 5. 22.0 2.5 0.0 1. 16.0 40.0 5. 5. 0.0 0. 1. + 3317. 1. 5. 22.0 0.5 0.0 2. 16.0 20.0 3. 4. 0.0 0. 1. + 3330. 1. 5. 27.0 2.5 0.0 4. 20.0 20.0 4. 5. 0.0 0. 1. + 3338. 1. 5. 22.0 0.5 0.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 3340. 1. 5. 22.0 2.5 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 3344. 1. 5. 27.0 6.0 0.0 2. 20.0 20.0 4. 6. 0.0 0. 1. + 3346. 1. 5. 17.5 0.5 0.0 3. 14.0 6.5 3. 4. 0.0 0. 1. + 3348. 1. 3. 32.0 16.5 3.0 2. 16.0 20.0 5. 4. 0.0 0. 1. + 3349. 1. 3. 37.0 16.5 4.0 2. 14.0 14.0 4. 3. 0.0 0. 1. + 3352. 1. 5. 27.0 6.0 1.0 3. 14.0 14.0 4. 2. 0.0 0. 1. + 3355. 1. 4. 32.0 16.5 4.0 4. 16.0 40.0 4. 4. 0.0 0. 1. + 3366. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 3367. 1. 4. 27.0 2.5 1.0 4. 14.0 11.5 3. 2. 0.0 0. 1. + 3369. 1. 3. 42.0 23.0 3.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 3372. 1. 4. 27.0 9.0 3.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 3374. 1. 4. 27.0 9.0 2.0 1. 20.0 20.0 4. 5. 0.0 0. 1. + 3379. 1. 4. 27.0 0.5 0.0 1. 14.0 20.0 4. 2. 0.0 0. 1. + 3388. 1. 5. 42.0 16.5 2.0 2. 12.0 11.5 3. 3. 0.0 0. 1. + 3393. 1. 4. 22.0 2.5 0.0 1. 16.0 11.5 4. 4. 0.0 0. 1. + 3395. 1. 4. 37.0 16.5 2.0 1. 17.0 40.0 4. 6. 0.0 0. 1. + 3396. 1. 5. 32.0 16.5 2.0 1. 12.0 40.0 3. 5. 0.0 0. 1. + 3400. 1. 5. 22.0 2.5 0.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 3419. 1. 5. 27.0 2.5 2.0 3. 20.0 11.5 2. 4. 0.0 0. 1. + 3424. 1. 5. 22.0 2.5 0.0 3. 14.0 6.5 3. 3. 0.0 0. 1. + 3425. 1. 4. 27.0 6.0 1.0 2. 20.0 20.0 4. 4. 0.0 0. 1. + 3427. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 3431. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 3. 0.0 0. 1. + 3433. 1. 4. 22.0 2.5 1.0 1. 14.0 40.0 3. 5. 0.0 0. 1. + 3437. 1. 5. 22.0 0.5 0.0 1. 12.0 14.0 3. 2. 0.0 0. 1. + 3438. 1. 4. 22.0 2.5 1.0 3. 12.0 9.0 4. 2. 0.0 0. 1. + 3439. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 4. 4. 0.0 0. 1. + 3444. 1. 4. 27.0 2.5 0.0 4. 16.0 40.0 5. 6. 0.0 0. 1. + 3448. 1. 5. 32.0 13.0 4.0 3. 16.0 14.0 4. 2. 0.0 0. 1. + 3462. 1. 5. 27.0 6.0 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 3466. 1. 4. 27.0 6.0 0.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 3470. 1. 4. 17.5 2.5 0.0 1. 14.0 9.0 3. 4. 0.0 0. 1. + 3473. 1. 5. 22.0 0.5 0.0 2. 16.0 20.0 3. 4. 0.0 0. 1. + 3474. 1. 5. 27.0 9.0 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 3477. 1. 5. 22.0 2.5 1.0 3. 12.0 9.0 3. 1. 0.0 0. 1. + 3478. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 3480. 1. 5. 42.0 16.5 2.0 3. 12.0 11.5 5. 4. 0.0 0. 1. + 3486. 1. 5. 17.5 2.5 0.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 3488. 1. 5. 22.0 2.5 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 3495. 1. 5. 32.0 9.0 3.0 4. 17.0 40.0 4. 6. 0.0 0. 1. + 3496. 1. 5. 22.0 2.5 2.0 3. 14.0 11.5 5. 4. 0.0 0. 1. + 3497. 1. 4. 37.0 23.0 5.5 2. 12.0 20.0 3. 2. 0.0 0. 1. + 3502. 1. 5. 27.0 2.5 0.0 4. 16.0 9.0 5. 3. 0.0 0. 1. + 3503. 1. 4. 22.0 2.5 0.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 3504. 1. 4. 22.0 2.5 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 3506. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 3514. 1. 5. 27.0 6.0 2.0 2. 14.0 14.0 5. 4. 0.0 0. 1. + 3523. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 3524. 1. 4. 32.0 2.5 0.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 3552. 1. 5. 32.0 6.0 2.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 3553. 1. 5. 27.0 13.0 3.0 1. 12.0 11.5 3. 4. 0.0 0. 1. + 3559. 1. 5. 32.0 16.5 3.0 3. 12.0 20.0 4. 2. 0.0 0. 1. + 3566. 1. 5. 17.5 0.5 0.0 1. 12.0 14.0 2. 4. 0.0 0. 1. + 3572. 1. 4. 27.0 2.5 0.0 1. 20.0 20.0 6. 6. 0.0 0. 1. + 3582. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 3585. 1. 4. 22.0 0.5 0.0 3. 12.0 20.0 5. 2. 0.0 0. 1. + 3586. 1. 5. 42.0 23.0 1.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 3594. 1. 3. 22.0 0.5 0.0 1. 12.0 20.0 3. 3. 0.0 0. 1. + 3597. 1. 5. 32.0 9.0 2.0 2. 20.0 14.0 4. 5. 0.0 0. 1. + 3599. 1. 4. 32.0 16.5 2.0 2. 14.0 11.5 5. 4. 0.0 0. 1. + 3610. 1. 5. 27.0 6.0 2.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 3612. 1. 5. 27.0 2.5 0.0 1. 16.0 20.0 3. 5. 0.0 0. 1. + 3621. 1. 5. 22.0 0.5 0.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 3623. 1. 4. 27.0 2.5 0.0 3. 17.0 14.0 4. 1. 0.0 0. 1. + 3625. 1. 5. 27.0 2.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 3630. 1. 5. 42.0 23.0 2.0 3. 9.0 6.5 2. 4. 0.0 0. 1. + 3631. 1. 5. 27.0 2.5 0.0 3. 14.0 40.0 3. 4. 0.0 0. 1. + 3637. 1. 5. 22.0 0.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 3644. 1. 5. 37.0 13.0 2.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 3646. 1. 4. 42.0 23.0 2.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 3648. 1. 4. 27.0 6.0 1.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 3651. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 3652. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 3654. 1. 5. 32.0 13.0 2.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 3661. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 3672. 1. 4. 32.0 9.0 2.0 1. 12.0 9.0 2. 2. 0.0 0. 1. + 3680. 1. 4. 22.0 2.5 0.0 1. 12.0 11.5 3. 2. 0.0 0. 1. + 3681. 1. 4. 22.0 6.0 2.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 3686. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 3692. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 3694. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 3697. 1. 5. 22.0 6.0 0.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 3699. 1. 3. 42.0 23.0 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 3702. 1. 5. 22.0 2.5 0.0 1. 12.0 9.0 2. 5. 0.0 0. 1. + 3706. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 3707. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 5. 5. 0.0 0. 1. + 3709. 1. 4. 17.5 2.5 0.0 2. 14.0 6.5 3. 3. 0.0 0. 1. + 3710. 1. 4. 37.0 13.0 0.0 3. 20.0 40.0 5. 5. 0.0 0. 1. + 3712. 1. 5. 27.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 3720. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 3722. 1. 4. 42.0 23.0 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 3723. 1. 5. 22.0 2.5 1.0 1. 12.0 11.5 2. 4. 0.0 0. 1. + 3726. 1. 4. 27.0 6.0 1.0 2. 16.0 20.0 3. 3. 0.0 0. 1. + 3730. 1. 4. 37.0 16.5 2.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 3736. 1. 4. 37.0 13.0 5.5 2. 14.0 40.0 2. 6. 0.0 0. 1. + 3745. 1. 5. 22.0 0.5 0.0 3. 16.0 9.0 3. 4. 0.0 0. 1. + 3756. 1. 4. 27.0 2.5 1.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 3760. 1. 4. 22.0 2.5 0.0 3. 14.0 40.0 3. 4. 0.0 0. 1. + 3761. 1. 5. 27.0 6.0 2.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 3763. 1. 5. 22.0 0.5 0.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 3766. 1. 5. 27.0 2.5 0.0 1. 12.0 11.5 2. 2. 0.0 0. 1. + 3767. 1. 4. 22.0 2.5 1.0 1. 12.0 14.0 3. 5. 0.0 0. 1. + 3773. 1. 4. 27.0 0.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 3790. 1. 4. 22.0 2.5 0.0 2. 16.0 11.5 4. 1. 0.0 0. 1. + 3797. 1. 3. 32.0 13.0 1.0 1. 12.0 20.0 3. 2. 0.0 0. 1. + 3799. 1. 5. 32.0 6.0 2.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 3801. 1. 5. 42.0 23.0 4.0 3. 14.0 14.0 2. 2. 0.0 0. 1. + 3803. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 3805. 1. 5. 32.0 2.5 1.0 1. 12.0 14.0 4. 5. 0.0 0. 1. + 3808. 1. 4. 32.0 13.0 2.0 1. 16.0 20.0 3. 6. 0.0 0. 1. + 3811. 1. 5. 27.0 6.0 2.0 2. 14.0 40.0 4. 5. 0.0 0. 1. + 3827. 1. 5. 32.0 16.5 4.0 4. 14.0 11.5 2. 3. 0.0 0. 1. + 3829. 1. 4. 22.0 0.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 3834. 1. 4. 22.0 2.5 1.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 3835. 1. 4. 32.0 9.0 2.0 3. 16.0 40.0 4. 4. 0.0 0. 1. + 3839. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 1. 1. 0.0 0. 1. + 3846. 1. 4. 27.0 2.5 2.0 3. 16.0 14.0 2. 4. 0.0 0. 1. + 3848. 1. 3. 27.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 3852. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 2. 0.0 0. 1. + 3856. 1. 3. 27.0 2.5 1.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 3867. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 3871. 1. 5. 42.0 23.0 5.5 3. 12.0 9.0 3. 2. 0.0 0. 1. + 3872. 1. 4. 37.0 13.0 2.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 3874. 1. 5. 32.0 2.5 0.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 3881. 1. 3. 37.0 23.0 3.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 3886. 1. 5. 22.0 0.5 0.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 3890. 1. 5. 32.0 16.5 3.0 4. 16.0 9.0 4. 2. 0.0 0. 1. + 3893. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 4. 4. 0.0 0. 1. + 3906. 1. 5. 37.0 16.5 2.0 4. 20.0 20.0 6. 4. 0.0 0. 1. + 3908. 1. 5. 27.0 6.0 1.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 3924. 1. 4. 37.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 3932. 1. 5. 42.0 23.0 3.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 3934. 1. 4. 37.0 16.5 3.0 2. 16.0 20.0 3. 4. 0.0 0. 1. + 3936. 1. 4. 37.0 13.0 2.0 3. 14.0 14.0 4. 2. 0.0 0. 1. + 3938. 1. 5. 22.0 2.5 0.0 1. 12.0 20.0 5. 4. 0.0 0. 1. + 3949. 1. 5. 22.0 0.5 0.0 4. 16.0 20.0 4. 6. 0.0 0. 1. + 3954. 1. 5. 22.0 6.0 1.0 1. 14.0 40.0 2. 4. 0.0 0. 1. + 3956. 1. 3. 22.0 2.5 1.0 2. 12.0 9.0 4. 4. 0.0 0. 1. + 3957. 1. 5. 27.0 2.5 0.0 2. 14.0 40.0 4. 6. 0.0 0. 1. + 3959. 1. 5. 22.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 3965. 1. 4. 42.0 23.0 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 3972. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 3987. 1. 5. 22.0 0.5 1.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 3998. 1. 3. 27.0 6.0 2.0 2. 14.0 11.5 2. 4. 0.0 0. 1. + 3999. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 4002. 1. 5. 22.0 0.5 0.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 4008. 1. 5. 42.0 23.0 3.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 4017. 1. 4. 27.0 2.5 0.0 1. 16.0 20.0 3. 3. 0.0 0. 1. + 4018. 1. 5. 27.0 2.5 0.0 2. 14.0 11.5 2. 2. 0.0 0. 1. + 4022. 1. 5. 27.0 9.0 2.0 4. 12.0 11.5 2. 4. 0.0 0. 1. + 4024. 1. 4. 22.0 2.5 0.0 4. 16.0 11.5 4. 5. 0.0 0. 1. + 4027. 1. 4. 27.0 6.0 2.0 1. 16.0 14.0 4. 5. 0.0 0. 1. + 4028. 1. 5. 27.0 6.0 1.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 4032. 1. 5. 32.0 16.5 3.0 3. 12.0 20.0 2. 3. 0.0 0. 1. + 4036. 1. 4. 17.5 2.5 0.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 4046. 1. 4. 32.0 2.5 0.0 3. 17.0 20.0 4. 2. 0.0 0. 1. + 4059. 1. 3. 32.0 16.5 3.0 3. 14.0 40.0 5. 6. 0.0 0. 1. + 4061. 1. 5. 22.0 2.5 1.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 4065. 1. 4. 32.0 23.0 4.0 4. 14.0 20.0 4. 2. 0.0 0. 1. + 4066. 1. 5. 22.0 2.5 0.0 1. 16.0 14.0 4. 5. 0.0 0. 1. + 4067. 1. 5. 22.0 0.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 4068. 1. 3. 22.0 2.5 0.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 4070. 1. 4. 37.0 6.0 0.0 3. 20.0 20.0 4. 3. 0.0 0. 1. + 4072. 1. 4. 22.0 0.5 0.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 4074. 1. 4. 32.0 9.0 0.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 4080. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 4082. 1. 4. 32.0 13.0 3.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 4086. 1. 4. 22.0 2.5 1.0 4. 14.0 11.5 3. 5. 0.0 0. 1. + 4093. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 4096. 1. 5. 17.5 2.5 0.0 3. 12.0 4.0 3. 2. 0.0 0. 1. + 4102. 1. 5. 27.0 2.5 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 4107. 1. 5. 22.0 2.5 1.0 1. 12.0 11.5 3. 4. 0.0 0. 1. + 4108. 1. 4. 27.0 6.0 1.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 4109. 1. 4. 42.0 23.0 2.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 4113. 1. 4. 37.0 16.5 3.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 4119. 1. 5. 42.0 23.0 5.5 4. 12.0 11.5 3. 5. 0.0 0. 1. + 4120. 1. 5. 27.0 9.0 2.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 4122. 1. 5. 27.0 6.0 0.0 2. 14.0 40.0 2. 3. 0.0 0. 1. + 4124. 1. 5. 22.0 0.5 0.0 3. 16.0 9.0 4. 2. 0.0 0. 1. + 4131. 1. 5. 42.0 23.0 5.5 2. 16.0 40.0 4. 6. 0.0 0. 1. + 4132. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 4143. 1. 5. 32.0 13.0 1.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 4148. 1. 5. 27.0 2.5 0.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 4149. 1. 5. 42.0 23.0 4.0 3. 14.0 40.0 4. 4. 0.0 0. 1. + 4150. 1. 5. 22.0 2.5 1.0 2. 12.0 14.0 2. 4. 0.0 0. 1. + 4151. 1. 3. 32.0 9.0 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 4162. 1. 5. 27.0 2.5 0.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 4163. 1. 4. 22.0 0.5 0.0 3. 14.0 9.0 4. 2. 0.0 0. 1. + 4164. 1. 2. 37.0 16.5 5.5 3. 14.0 20.0 3. 5. 0.0 0. 1. + 4167. 1. 5. 42.0 23.0 4.0 3. 12.0 20.0 5. 4. 0.0 0. 1. + 4173. 1. 3. 27.0 9.0 0.0 2. 12.0 20.0 3. 6. 0.0 0. 1. + 4174. 1. 5. 42.0 16.5 3.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 4175. 1. 4. 27.0 9.0 2.0 3. 14.0 14.0 2. 4. 0.0 0. 1. + 4180. 1. 4. 17.5 0.5 0.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 4185. 1. 4. 22.0 2.5 0.0 4. 12.0 11.5 2. 5. 0.0 0. 1. + 4187. 1. 4. 22.0 2.5 1.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 4189. 1. 5. 22.0 0.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 4193. 1. 5. 32.0 16.5 3.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 4197. 1. 4. 32.0 16.5 2.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 4202. 1. 5. 22.0 2.5 0.0 1. 17.0 14.0 4. 4. 0.0 0. 1. + 4204. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 5. 6. 0.0 0. 1. + 4207. 1. 5. 32.0 0.5 0.0 1. 12.0 40.0 4. 5. 0.0 0. 1. + 4208. 1. 3. 22.0 6.0 1.0 2. 9.0 11.5 2. 2. 0.0 0. 1. + 4216. 1. 4. 27.0 13.0 3.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 4222. 1. 5. 37.0 0.5 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 4224. 1. 5. 17.5 0.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 4228. 1. 4. 27.0 2.5 0.0 2. 16.0 20.0 4. 3. 0.0 0. 1. + 4229. 1. 4. 37.0 9.0 2.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 4236. 1. 4. 22.0 6.0 2.0 3. 12.0 6.5 3. 2. 0.0 0. 1. + 4240. 1. 4. 42.0 23.0 3.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 4244. 1. 5. 22.0 2.5 1.0 1. 14.0 14.0 3. 2. 0.0 0. 1. + 4247. 1. 3. 22.0 2.5 0.0 2. 16.0 4.0 3. 5. 0.0 0. 1. + 4248. 1. 5. 22.0 6.0 1.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 4251. 1. 4. 37.0 16.5 3.0 4. 16.0 14.0 4. 3. 0.0 0. 1. + 4253. 1. 3. 42.0 23.0 5.5 2. 14.0 20.0 3. 2. 0.0 0. 1. + 4254. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 4255. 1. 4. 27.0 2.5 1.0 4. 16.0 14.0 4. 2. 0.0 0. 1. + 4258. 1. 4. 32.0 9.0 3.0 3. 14.0 20.0 2. 2. 0.0 0. 1. + 4259. 1. 5. 37.0 16.5 3.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 4260. 1. 5. 22.0 6.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 4268. 1. 5. 22.0 2.5 1.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 4270. 1. 4. 27.0 9.0 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 4271. 1. 5. 22.0 2.5 0.0 4. 16.0 20.0 6. 6. 0.0 0. 1. + 4288. 1. 4. 32.0 2.5 0.0 3. 17.0 9.0 4. 3. 0.0 0. 1. + 4289. 1. 5. 27.0 9.0 0.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 4291. 1. 4. 22.0 6.0 0.0 1. 14.0 14.0 3. 5. 0.0 0. 1. + 4297. 1. 5. 42.0 23.0 4.0 4. 12.0 20.0 3. 2. 0.0 0. 1. + 4304. 1. 5. 32.0 16.5 4.0 3. 12.0 11.5 5. 4. 0.0 0. 1. + 4305. 1. 5. 32.0 16.5 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 4306. 1. 4. 27.0 6.0 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 4308. 1. 4. 32.0 2.5 0.0 3. 16.0 20.0 3. 4. 0.0 0. 1. + 4311. 1. 5. 27.0 6.0 1.0 2. 16.0 20.0 3. 3. 0.0 0. 1. + 4319. 1. 5. 22.0 0.5 0.0 1. 12.0 20.0 3. 2. 0.0 0. 1. + 4322. 1. 5. 42.0 23.0 4.0 4. 12.0 20.0 2. 4. 0.0 0. 1. + 4327. 1. 2. 32.0 6.0 2.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 4331. 1. 5. 22.0 6.0 2.0 3. 16.0 11.5 4. 2. 0.0 0. 1. + 4332. 1. 4. 22.0 2.5 1.0 2. 12.0 11.5 5. 4. 0.0 0. 1. + 4335. 1. 5. 42.0 23.0 5.5 3. 12.0 14.0 3. 2. 0.0 0. 1. + 4339. 1. 5. 32.0 6.0 2.0 2. 14.0 14.0 4. 4. 0.0 0. 1. + 4340. 1. 5. 42.0 23.0 2.0 2. 14.0 20.0 5. 3. 0.0 0. 1. + 4348. 1. 4. 27.0 6.0 0.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 4355. 1. 4. 37.0 16.5 3.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 4359. 1. 5. 42.0 16.5 3.0 2. 12.0 40.0 5. 2. 0.0 0. 1. + 4363. 1. 4. 32.0 16.5 3.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 4365. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 5. 1. 0.0 0. 1. + 4368. 1. 4. 27.0 9.0 2.0 3. 14.0 14.0 4. 3. 0.0 0. 1. + 4369. 1. 5. 22.0 6.0 1.0 2. 9.0 40.0 4. 2. 0.0 0. 1. + 4372. 1. 4. 22.0 2.5 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 4382. 1. 5. 27.0 9.0 1.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 4385. 1. 4. 27.0 6.0 2.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 4387. 1. 5. 22.0 2.5 0.0 4. 9.0 14.0 3. 5. 0.0 0. 1. + 4389. 1. 5. 22.0 2.5 0.0 3. 20.0 20.0 4. 6. 0.0 0. 1. + 4390. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 4394. 1. 5. 22.0 2.5 0.0 3. 17.0 14.0 4. 5. 0.0 0. 1. + 4395. 1. 5. 27.0 13.0 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 4397. 1. 4. 27.0 2.5 0.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 4407. 1. 4. 42.0 23.0 2.0 4. 12.0 9.0 4. 2. 0.0 0. 1. + 4414. 1. 5. 27.0 6.0 2.0 2. 17.0 6.5 4. 1. 0.0 0. 1. + 4415. 1. 3. 27.0 2.5 0.0 1. 16.0 14.0 4. 5. 0.0 0. 1. + 4427. 1. 4. 27.0 6.0 1.0 3. 12.0 11.5 4. 6. 0.0 0. 1. + 4428. 1. 5. 27.0 6.0 1.0 2. 16.0 14.0 4. 3. 0.0 0. 1. + 4431. 1. 5. 22.0 0.5 0.0 2. 12.0 6.5 2. 2. 0.0 0. 1. + 4436. 1. 2. 22.0 0.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 4438. 1. 4. 27.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 4447. 1. 5. 27.0 6.0 1.0 1. 14.0 20.0 4. 2. 0.0 0. 1. + 4448. 1. 4. 37.0 23.0 3.0 3. 14.0 20.0 2. 6. 0.0 0. 1. + 4451. 1. 3. 22.0 2.5 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 4455. 1. 4. 27.0 9.0 2.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 4456. 1. 4. 42.0 23.0 5.5 3. 12.0 14.0 3. 2. 0.0 0. 1. + 4458. 1. 4. 22.0 0.5 0.0 3. 16.0 11.5 3. 5. 0.0 0. 1. + 4460. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 3. 5. 0.0 0. 1. + 4464. 1. 5. 22.0 6.0 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 4465. 1. 4. 27.0 6.0 1.0 3. 16.0 11.5 4. 3. 0.0 0. 1. + 4467. 1. 4. 42.0 23.0 4.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 4472. 1. 5. 22.0 0.5 0.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 4477. 1. 4. 22.0 2.5 0.0 1. 16.0 11.5 2. 4. 0.0 0. 1. + 4486. 1. 5. 22.0 0.5 0.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 4488. 1. 5. 27.0 2.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 4492. 1. 5. 22.0 2.5 0.0 4. 14.0 9.0 3. 6. 0.0 0. 1. + 4495. 1. 4. 37.0 16.5 4.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 4497. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 4500. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 4502. 1. 4. 22.0 2.5 1.0 4. 16.0 11.5 3. 2. 0.0 0. 1. + 4504. 1. 5. 37.0 23.0 4.0 1. 14.0 20.0 3. 2. 0.0 0. 1. + 4506. 1. 5. 27.0 2.5 0.0 1. 16.0 40.0 3. 5. 0.0 0. 1. + 4509. 1. 3. 37.0 9.0 1.0 2. 17.0 20.0 5. 5. 0.0 0. 1. + 4511. 1. 5. 22.0 0.5 0.0 4. 16.0 20.0 4. 2. 0.0 0. 1. + 4513. 1. 5. 27.0 9.0 2.0 2. 14.0 14.0 4. 5. 0.0 0. 1. + 4515. 1. 5. 32.0 6.0 1.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 4524. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 4530. 1. 4. 27.0 6.0 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 4539. 1. 4. 17.5 0.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 4542. 1. 4. 27.0 6.0 1.0 1. 16.0 20.0 5. 4. 0.0 0. 1. + 4546. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 4549. 1. 4. 27.0 6.0 0.0 3. 14.0 40.0 4. 5. 0.0 0. 1. + 4565. 1. 4. 27.0 6.0 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 4567. 1. 4. 27.0 6.0 0.0 1. 20.0 20.0 4. 4. 0.0 0. 1. + 4574. 1. 5. 22.0 2.5 0.0 4. 14.0 20.0 5. 4. 0.0 0. 1. + 4589. 1. 5. 27.0 2.5 0.0 4. 20.0 20.0 6. 5. 0.0 0. 1. + 4593. 1. 5. 22.0 0.5 0.0 2. 17.0 14.0 4. 2. 0.0 0. 1. + 4595. 1. 5. 37.0 23.0 4.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 4601. 1. 5. 37.0 16.5 4.0 4. 12.0 20.0 4. 5. 0.0 0. 1. + 4603. 1. 5. 27.0 2.5 0.0 1. 14.0 14.0 5. 5. 0.0 0. 1. + 4604. 1. 5. 42.0 23.0 4.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 4607. 1. 5. 27.0 13.0 3.0 1. 14.0 14.0 2. 4. 0.0 0. 1. + 4609. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 4611. 1. 5. 32.0 16.5 4.0 4. 12.0 20.0 2. 4. 0.0 0. 1. + 4615. 1. 3. 37.0 16.5 2.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 4623. 1. 5. 22.0 2.5 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 4625. 1. 4. 27.0 2.5 1.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 4628. 1. 5. 27.0 2.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 4633. 1. 5. 32.0 13.0 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 4636. 1. 4. 27.0 2.5 1.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 4639. 1. 4. 22.0 0.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 4647. 1. 4. 27.0 2.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 4648. 1. 4. 27.0 2.5 0.0 2. 17.0 40.0 5. 6. 0.0 0. 1. + 4649. 1. 2. 22.0 2.5 0.0 1. 16.0 4.0 4. 1. 0.0 0. 1. + 4650. 1. 4. 32.0 9.0 2.0 3. 14.0 14.0 2. 4. 0.0 0. 1. + 4653. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 4655. 1. 3. 27.0 2.5 0.0 2. 14.0 40.0 4. 4. 0.0 0. 1. + 4657. 1. 5. 27.0 13.0 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 4664. 1. 4. 22.0 2.5 0.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 4666. 1. 4. 17.5 0.5 0.0 3. 17.0 4.0 2. 4. 0.0 0. 1. + 4667. 1. 4. 27.0 6.0 1.0 2. 12.0 11.5 3. 6. 0.0 0. 1. + 4668. 1. 5. 22.0 6.0 0.0 4. 14.0 6.5 4. 1. 0.0 0. 1. + 4669. 1. 3. 27.0 6.0 1.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 4670. 1. 5. 22.0 6.0 2.0 3. 12.0 20.0 4. 5. 0.0 0. 1. + 4672. 1. 5. 27.0 6.0 2.0 3. 16.0 14.0 4. 6. 0.0 0. 1. + 4673. 1. 5. 27.0 2.5 1.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 4674. 1. 4. 22.0 2.5 1.0 2. 14.0 14.0 1. 5. 0.0 0. 1. + 4675. 1. 4. 32.0 13.0 2.0 3. 12.0 20.0 2. 6. 0.0 0. 1. + 4683. 1. 4. 27.0 16.5 2.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 4694. 1. 4. 32.0 9.0 2.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 4698. 1. 4. 37.0 16.5 3.0 3. 14.0 11.5 2. 5. 0.0 0. 1. + 4703. 1. 5. 17.5 0.5 0.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 4708. 1. 4. 22.0 2.5 0.0 2. 16.0 9.0 4. 1. 0.0 0. 1. + 4711. 1. 4. 27.0 9.0 1.0 3. 14.0 9.0 3. 5. 0.0 0. 1. + 4720. 1. 5. 27.0 6.0 2.0 3. 14.0 14.0 4. 2. 0.0 0. 1. + 4722. 1. 1. 32.0 16.5 5.5 2. 12.0 14.0 2. 2. 0.0 0. 1. + 4737. 1. 3. 27.0 9.0 1.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 4739. 1. 3. 32.0 13.0 4.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 4740. 1. 5. 42.0 13.0 4.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 4741. 1. 3. 22.0 2.5 1.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 4747. 1. 5. 32.0 13.0 2.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 4751. 1. 5. 27.0 2.5 0.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 4754. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 4764. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 4766. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 2. 4. 0.0 0. 1. + 4767. 1. 3. 37.0 16.5 2.0 2. 14.0 9.0 2. 2. 0.0 0. 1. + 4772. 1. 5. 32.0 9.0 2.0 2. 20.0 20.0 4. 6. 0.0 0. 1. + 4777. 1. 5. 27.0 13.0 2.0 2. 12.0 14.0 5. 5. 0.0 0. 1. + 4780. 1. 3. 37.0 13.0 1.0 4. 12.0 11.5 2. 2. 0.0 0. 1. + 4781. 1. 5. 42.0 23.0 3.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 4782. 1. 4. 22.0 2.5 0.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 4792. 1. 4. 42.0 23.0 2.0 4. 14.0 40.0 3. 2. 0.0 0. 1. + 4797. 1. 3. 22.0 2.5 0.0 1. 14.0 14.0 3. 2. 0.0 0. 1. + 4798. 1. 4. 27.0 0.5 0.0 2. 14.0 14.0 3. 3. 0.0 0. 1. + 4803. 1. 4. 42.0 13.0 2.0 1. 20.0 40.0 4. 4. 0.0 0. 1. + 4805. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 4818. 1. 5. 27.0 6.0 0.0 4. 16.0 20.0 3. 5. 0.0 0. 1. + 4819. 1. 4. 22.0 0.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 4821. 1. 5. 32.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 4822. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 4825. 1. 4. 32.0 16.5 4.0 1. 12.0 20.0 2. 2. 0.0 0. 1. + 4828. 1. 3. 27.0 6.0 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 4832. 1. 5. 32.0 13.0 2.0 3. 16.0 11.5 2. 2. 0.0 0. 1. + 4836. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 4840. 1. 4. 32.0 16.5 2.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 4842. 1. 4. 17.5 0.5 0.0 2. 12.0 4.0 2. 2. 0.0 0. 1. + 4845. 1. 4. 37.0 23.0 3.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 4849. 1. 5. 27.0 13.0 2.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 4862. 1. 5. 32.0 16.5 3.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 4873. 1. 5. 27.0 6.0 2.0 2. 14.0 11.5 2. 5. 0.0 0. 1. + 4894. 1. 5. 22.0 2.5 0.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 4899. 1. 5. 27.0 2.5 1.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 4900. 1. 3. 17.5 2.5 1.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 4909. 1. 5. 22.0 2.5 0.0 2. 14.0 40.0 4. 2. 0.0 0. 1. + 4911. 1. 5. 22.0 0.5 0.0 4. 16.0 6.5 4. 2. 0.0 0. 1. + 4916. 1. 4. 27.0 2.5 0.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 4919. 1. 4. 27.0 6.0 2.0 1. 12.0 11.5 2. 2. 0.0 0. 1. + 4926. 1. 4. 22.0 6.0 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 4927. 1. 4. 27.0 2.5 0.0 3. 17.0 11.5 4. 1. 0.0 0. 1. + 4931. 1. 2. 32.0 16.5 3.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 4933. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 4938. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 3. 0.0 0. 1. + 4940. 1. 4. 27.0 2.5 0.0 3. 16.0 11.5 4. 2. 0.0 0. 1. + 4941. 1. 5. 27.0 6.0 2.0 4. 12.0 14.0 3. 2. 0.0 0. 1. + 4942. 1. 5. 32.0 16.5 2.0 3. 14.0 9.0 2. 2. 0.0 0. 1. + 4944. 1. 5. 17.5 2.5 0.0 2. 14.0 11.5 4. 4. 0.0 0. 1. + 4947. 1. 4. 42.0 16.5 5.5 3. 12.0 14.0 2. 5. 0.0 0. 1. + 4949. 1. 5. 27.0 2.5 1.0 2. 12.0 20.0 4. 4. 0.0 0. 1. + 4952. 1. 4. 32.0 2.5 0.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 4963. 1. 5. 22.0 6.0 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 4966. 1. 4. 27.0 6.0 1.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 4968. 1. 4. 37.0 16.5 2.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 4981. 1. 5. 17.5 0.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 4989. 1. 4. 37.0 16.5 3.0 3. 12.0 20.0 5. 2. 0.0 0. 1. + 4991. 1. 5. 27.0 2.5 0.0 2. 16.0 11.5 2. 2. 0.0 0. 1. + 4995. 1. 4. 27.0 6.0 0.0 2. 14.0 14.0 3. 1. 0.0 0. 1. + 5002. 1. 4. 27.0 9.0 2.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 5012. 1. 5. 32.0 16.5 2.0 4. 12.0 14.0 2. 5. 0.0 0. 1. + 5013. 1. 5. 27.0 2.5 2.0 3. 17.0 11.5 4. 5. 0.0 0. 1. + 5016. 1. 5. 37.0 16.5 2.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 5021. 1. 4. 42.0 23.0 3.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 5022. 1. 5. 32.0 16.5 2.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 5023. 1. 4. 22.0 0.5 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 5035. 1. 5. 27.0 6.0 1.0 1. 20.0 11.5 3. 5. 0.0 0. 1. + 5041. 1. 3. 27.0 2.5 0.0 3. 17.0 40.0 4. 3. 0.0 0. 1. + 5049. 1. 4. 32.0 13.0 2.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 5055. 1. 4. 22.0 2.5 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 5058. 1. 4. 27.0 2.5 0.0 1. 12.0 14.0 3. 4. 0.0 0. 1. + 5062. 1. 5. 22.0 2.5 0.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 5063. 1. 3. 42.0 23.0 3.0 3. 12.0 11.5 5. 2. 0.0 0. 1. + 5066. 1. 5. 27.0 6.0 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 5067. 1. 4. 37.0 16.5 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 5069. 1. 4. 27.0 6.0 0.0 4. 14.0 20.0 3. 3. 0.0 0. 1. + 5070. 1. 5. 22.0 6.0 1.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 5072. 1. 5. 32.0 6.0 1.0 2. 17.0 20.0 4. 3. 0.0 0. 1. + 5075. 1. 5. 22.0 0.5 0.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 5083. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 5100. 1. 4. 22.0 0.5 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 5101. 1. 3. 32.0 2.5 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 5102. 1. 2. 32.0 6.0 0.0 3. 17.0 20.0 4. 3. 0.0 0. 1. + 5115. 1. 5. 32.0 9.0 2.0 4. 17.0 20.0 4. 4. 0.0 0. 1. + 5116. 1. 4. 42.0 23.0 2.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 5121. 1. 5. 42.0 23.0 3.0 4. 17.0 20.0 4. 6. 0.0 0. 1. + 5128. 1. 5. 22.0 2.5 1.0 2. 12.0 6.5 2. 5. 0.0 0. 1. + 5135. 1. 5. 42.0 23.0 2.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 5136. 1. 4. 27.0 6.0 1.0 2. 12.0 20.0 2. 4. 0.0 0. 1. + 5141. 1. 4. 27.0 2.5 0.0 1. 14.0 20.0 3. 3. 0.0 0. 1. + 5142. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 2. 1. 0.0 0. 1. + 5163. 1. 4. 42.0 16.5 4.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 5164. 1. 5. 27.0 2.5 0.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 5165. 1. 3. 32.0 9.0 1.0 3. 14.0 20.0 2. 5. 0.0 0. 1. + 5168. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 4. 6. 0.0 0. 1. + 5170. 1. 4. 22.0 6.0 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 5173. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 5175. 1. 4. 22.0 0.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 5177. 1. 5. 22.0 0.5 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 5183. 1. 4. 32.0 9.0 0.0 2. 14.0 40.0 3. 2. 0.0 0. 1. + 5184. 1. 3. 27.0 2.5 1.0 3. 14.0 9.0 4. 4. 0.0 0. 1. + 5188. 1. 4. 27.0 6.0 0.0 2. 20.0 40.0 4. 6. 0.0 0. 1. + 5189. 1. 5. 22.0 2.5 0.0 1. 16.0 6.5 4. 2. 0.0 0. 1. + 5191. 1. 5. 22.0 2.5 2.0 3. 12.0 6.5 2. 4. 0.0 0. 1. + 5199. 1. 5. 22.0 6.0 3.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 5200. 1. 4. 27.0 9.0 2.0 3. 14.0 11.5 6. 4. 0.0 0. 1. + 5201. 1. 4. 32.0 16.5 5.5 3. 14.0 14.0 2. 2. 0.0 0. 1. + 5204. 1. 5. 32.0 6.0 2.0 3. 17.0 20.0 2. 6. 0.0 0. 1. + 5215. 1. 4. 22.0 0.5 0.0 3. 17.0 11.5 5. 5. 0.0 0. 1. + 5216. 1. 5. 27.0 6.0 2.0 4. 12.0 9.0 2. 2. 0.0 0. 1. + 5219. 1. 5. 42.0 23.0 4.0 4. 12.0 20.0 3. 5. 0.0 0. 1. + 5220. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 2. 5. 0.0 0. 1. + 5224. 1. 4. 42.0 23.0 3.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 5228. 1. 5. 32.0 9.0 2.0 3. 14.0 14.0 2. 2. 0.0 0. 1. + 5229. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 5232. 1. 4. 42.0 23.0 2.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 5235. 1. 5. 27.0 9.0 1.0 4. 16.0 14.0 3. 3. 0.0 0. 1. + 5244. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 2. 2. 0.0 0. 1. + 5257. 1. 3. 32.0 16.5 2.0 2. 9.0 20.0 2. 4. 0.0 0. 1. + 5259. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 5260. 1. 5. 32.0 9.0 1.0 4. 20.0 20.0 4. 5. 0.0 0. 1. + 5262. 1. 5. 27.0 6.0 2.0 4. 14.0 11.5 3. 2. 0.0 0. 1. + 5263. 1. 5. 42.0 23.0 2.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 5269. 1. 5. 32.0 16.5 2.0 1. 14.0 14.0 4. 5. 0.0 0. 1. + 5271. 1. 5. 27.0 9.0 3.0 1. 20.0 20.0 1. 6. 0.0 0. 1. + 5272. 1. 5. 32.0 13.0 2.0 4. 20.0 14.0 6. 6. 0.0 0. 1. + 5273. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 5. 4. 0.0 0. 1. + 5274. 1. 4. 27.0 6.0 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 5283. 1. 5. 27.0 2.5 0.0 4. 16.0 11.5 5. 5. 0.0 0. 1. + 5285. 1. 4. 17.5 2.5 1.0 2. 12.0 6.5 5. 6. 0.0 0. 1. + 5290. 1. 5. 22.0 0.5 0.0 4. 16.0 6.5 3. 2. 0.0 0. 1. + 5291. 1. 4. 22.0 2.5 0.0 4. 16.0 9.0 3. 1. 0.0 0. 1. + 5292. 1. 5. 37.0 23.0 5.5 3. 12.0 6.5 2. 2. 0.0 0. 1. + 5301. 1. 4. 22.0 0.5 0.0 1. 12.0 11.5 5. 2. 0.0 0. 1. + 5307. 1. 3. 32.0 9.0 3.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 5308. 1. 4. 22.0 2.5 0.0 1. 12.0 20.0 2. 4. 0.0 0. 1. + 5310. 1. 3. 27.0 6.0 4.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 5311. 1. 4. 22.0 2.5 1.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 5312. 1. 4. 32.0 6.0 0.0 1. 16.0 11.5 3. 2. 0.0 0. 1. + 5313. 1. 5. 32.0 16.5 3.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 5323. 1. 3. 22.0 2.5 1.0 2. 16.0 4.0 4. 4. 0.0 0. 1. + 5333. 1. 5. 27.0 6.0 0.0 3. 16.0 20.0 2. 1. 0.0 0. 1. + 5337. 1. 5. 32.0 6.0 0.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 5338. 1. 5. 27.0 6.0 2.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 5340. 1. 4. 22.0 2.5 0.0 3. 12.0 6.5 3. 3. 0.0 0. 1. + 5341. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 5. 5. 0.0 0. 1. + 5346. 1. 4. 22.0 2.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 5348. 1. 5. 27.0 6.0 0.0 2. 20.0 20.0 4. 1. 0.0 0. 1. + 5355. 1. 5. 32.0 9.0 3.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 5356. 1. 5. 42.0 23.0 4.0 1. 14.0 6.5 4. 4. 0.0 0. 1. + 5364. 1. 4. 27.0 6.0 1.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 5377. 1. 5. 22.0 2.5 0.0 1. 14.0 4.0 3. 1. 0.0 0. 1. + 5380. 1. 5. 27.0 6.0 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 5382. 1. 5. 27.0 2.5 1.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 5387. 1. 5. 37.0 13.0 1.0 2. 14.0 14.0 5. 5. 0.0 0. 1. + 5390. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 5391. 1. 5. 22.0 2.5 0.0 3. 12.0 6.5 4. 4. 0.0 0. 1. + 5395. 1. 3. 22.0 6.0 1.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 5396. 1. 5. 22.0 0.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 5397. 1. 4. 32.0 13.0 1.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 5399. 1. 4. 22.0 6.0 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 5401. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 3. 1. 0.0 0. 1. + 5404. 1. 3. 27.0 6.0 0.0 2. 14.0 6.5 3. 1. 0.0 0. 1. + 5406. 1. 3. 27.0 13.0 4.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 5410. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 5413. 1. 5. 27.0 6.0 2.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 5416. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 2. 5. 0.0 0. 1. + 5417. 1. 4. 17.5 2.5 0.0 2. 12.0 6.5 2. 2. 0.0 0. 1. + 5422. 1. 5. 42.0 16.5 3.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 5423. 1. 3. 27.0 6.0 2.0 2. 9.0 11.5 4. 2. 0.0 0. 1. + 5425. 1. 5. 27.0 2.5 0.0 1. 20.0 20.0 4. 6. 0.0 0. 1. + 5427. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 5. 4. 0.0 0. 1. + 5428. 1. 5. 32.0 16.5 4.0 3. 12.0 11.5 5. 5. 0.0 0. 1. + 5430. 1. 5. 27.0 0.5 0.0 3. 16.0 40.0 5. 5. 0.0 0. 1. + 5431. 1. 4. 22.0 2.5 0.0 4. 14.0 9.0 1. 6. 0.0 0. 1. + 5432. 1. 5. 32.0 13.0 3.0 3. 12.0 20.0 2. 2. 0.0 0. 1. + 5438. 1. 4. 22.0 2.5 0.0 3. 16.0 6.5 3. 1. 0.0 0. 1. + 5443. 1. 5. 27.0 2.5 0.0 1. 20.0 14.0 6. 1. 0.0 0. 1. + 5447. 1. 4. 27.0 2.5 0.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 5448. 1. 5. 22.0 2.5 0.0 4. 12.0 11.5 3. 4. 0.0 0. 1. + 5449. 1. 5. 17.5 0.5 0.0 4. 9.0 11.5 2. 2. 0.0 0. 1. + 5450. 1. 2. 27.0 9.0 1.0 1. 12.0 11.5 3. 5. 0.0 0. 1. + 5454. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 5457. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 5467. 1. 5. 42.0 23.0 3.0 1. 16.0 40.0 4. 6. 0.0 0. 1. + 5473. 1. 4. 22.0 2.5 1.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 5476. 1. 3. 27.0 6.0 1.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 5480. 1. 5. 27.0 0.5 0.0 4. 17.0 6.5 3. 2. 0.0 0. 1. + 5483. 1. 4. 42.0 23.0 1.0 3. 12.0 11.5 5. 5. 0.0 0. 1. + 5484. 1. 4. 32.0 16.5 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 5487. 1. 5. 22.0 6.0 0.0 2. 12.0 20.0 2. 4. 0.0 0. 1. + 5490. 1. 4. 22.0 2.5 0.0 2. 16.0 6.5 4. 4. 0.0 0. 1. + 5491. 1. 4. 22.0 2.5 0.0 3. 14.0 4.0 3. 1. 0.0 0. 1. + 5496. 1. 3. 27.0 9.0 2.0 1. 12.0 4.0 2. 2. 0.0 0. 1. + 5505. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 5506. 1. 5. 37.0 16.5 2.0 1. 12.0 40.0 3. 4. 0.0 0. 1. + 5523. 1. 4. 42.0 23.0 3.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 5531. 1. 5. 27.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 5532. 1. 4. 32.0 2.5 0.0 1. 14.0 20.0 3. 2. 0.0 0. 1. + 5536. 1. 3. 22.0 0.5 0.0 2. 16.0 4.0 3. 1. 0.0 0. 1. + 5537. 1. 5. 22.0 0.5 0.0 4. 16.0 9.0 3. 1. 0.0 0. 1. + 5540. 1. 5. 42.0 23.0 5.5 3. 12.0 20.0 2. 5. 0.0 0. 1. + 5543. 1. 4. 22.0 2.5 1.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 5547. 1. 4. 27.0 2.5 0.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 5558. 1. 2. 42.0 23.0 4.0 4. 12.0 9.0 3. 2. 0.0 0. 1. + 5560. 1. 4. 22.0 2.5 0.0 4. 17.0 6.5 5. 1. 0.0 0. 1. + 5568. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 2. 4. 0.0 0. 1. + 5575. 1. 5. 27.0 6.0 3.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 5576. 1. 5. 27.0 6.0 3.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 5583. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 5586. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 5587. 1. 4. 22.0 2.5 2.0 2. 14.0 11.5 2. 2. 0.0 0. 1. + 5591. 1. 3. 42.0 23.0 3.0 2. 12.0 40.0 3. 5. 0.0 0. 1. + 5592. 1. 5. 22.0 0.5 0.0 2. 17.0 14.0 4. 2. 0.0 0. 1. + 5597. 1. 5. 27.0 9.0 4.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 5601. 1. 5. 22.0 0.5 0.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 5602. 1. 4. 22.0 2.5 0.0 2. 16.0 14.0 4. 2. 0.0 0. 1. + 5604. 1. 5. 17.5 0.5 0.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 5625. 1. 5. 27.0 6.0 1.0 3. 12.0 14.0 3. 6. 0.0 0. 1. + 5630. 1. 2. 27.0 6.0 0.0 3. 17.0 20.0 2. 5. 0.0 0. 1. + 5634. 1. 5. 27.0 0.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 5636. 1. 5. 22.0 2.5 0.0 1. 12.0 20.0 5. 4. 0.0 0. 1. + 5637. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 5642. 1. 4. 37.0 16.5 2.0 2. 16.0 40.0 4. 3. 0.0 0. 1. + 5651. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 5659. 1. 5. 27.0 2.5 0.0 1. 16.0 20.0 4. 1. 0.0 0. 1. + 5661. 1. 5. 42.0 23.0 5.5 3. 14.0 20.0 3. 4. 0.0 0. 1. + 5664. 1. 5. 37.0 16.5 4.0 2. 14.0 40.0 2. 5. 0.0 0. 1. + 5668. 1. 4. 27.0 0.5 0.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 5672. 1. 5. 27.0 6.0 0.0 3. 20.0 14.0 6. 2. 0.0 0. 1. + 5681. 1. 4. 27.0 13.0 2.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 5693. 1. 3. 22.0 6.0 1.0 2. 12.0 14.0 4. 2. 0.0 0. 1. + 5701. 1. 5. 32.0 13.0 2.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 5703. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 3. 6. 0.0 0. 1. + 5706. 1. 5. 27.0 6.0 4.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 5707. 1. 4. 42.0 23.0 2.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 5709. 1. 4. 22.0 2.5 0.0 4. 17.0 20.0 4. 2. 0.0 0. 1. + 5712. 1. 5. 32.0 16.5 3.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 5721. 1. 5. 22.0 2.5 0.0 1. 16.0 14.0 3. 5. 0.0 0. 1. + 5723. 1. 5. 22.0 0.5 0.0 3. 12.0 9.0 5. 2. 0.0 0. 1. + 5727. 1. 4. 42.0 23.0 5.5 4. 12.0 20.0 3. 5. 0.0 0. 1. + 5729. 1. 5. 42.0 16.5 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 5730. 1. 4. 22.0 2.5 0.0 1. 12.0 14.0 3. 2. 0.0 0. 1. + 5731. 1. 2. 22.0 2.5 1.0 2. 14.0 6.5 3. 4. 0.0 0. 1. + 5732. 1. 3. 22.0 2.5 0.0 1. 12.0 11.5 3. 3. 0.0 0. 1. + 5734. 1. 4. 32.0 13.0 2.0 3. 17.0 40.0 4. 3. 0.0 0. 1. + 5742. 1. 5. 27.0 6.0 1.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 5750. 1. 4. 32.0 9.0 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 5755. 1. 5. 27.0 2.5 0.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 5757. 1. 2. 22.0 2.5 2.0 3. 14.0 20.0 4. 2. 0.0 0. 1. + 5764. 1. 5. 22.0 0.5 0.0 4. 16.0 11.5 4. 5. 0.0 0. 1. + 5765. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 5766. 1. 5. 27.0 6.0 1.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 5767. 1. 4. 27.0 6.0 2.0 4. 12.0 11.5 3. 2. 0.0 0. 1. + 5771. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 2. 0.0 0. 1. + 5772. 1. 4. 22.0 2.5 0.0 1. 12.0 20.0 4. 3. 0.0 0. 1. + 5781. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 5782. 1. 5. 22.0 2.5 2.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 5785. 1. 3. 32.0 6.0 2.0 3. 17.0 14.0 2. 4. 0.0 0. 1. + 5787. 1. 4. 27.0 6.0 3.0 3. 14.0 9.0 4. 4. 0.0 0. 1. + 5788. 1. 4. 42.0 23.0 3.0 3. 14.0 40.0 3. 4. 0.0 0. 1. + 5789. 1. 5. 22.0 0.5 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 5798. 1. 4. 42.0 13.0 4.0 3. 12.0 9.0 2. 5. 0.0 0. 1. + 5803. 1. 5. 22.0 6.0 0.0 4. 14.0 11.5 1. 5. 0.0 0. 1. + 5808. 1. 2. 32.0 13.0 1.0 3. 20.0 40.0 4. 3. 0.0 0. 1. + 5809. 1. 4. 22.0 2.5 0.0 1. 12.0 11.5 2. 4. 0.0 0. 1. + 5811. 1. 5. 22.0 2.5 0.0 2. 17.0 14.0 4. 5. 0.0 0. 1. + 5812. 1. 5. 42.0 23.0 5.5 2. 12.0 40.0 5. 5. 0.0 0. 1. + 5814. 1. 4. 17.5 2.5 1.0 2. 12.0 4.0 3. 2. 0.0 0. 1. + 5816. 1. 5. 27.0 13.0 1.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 5825. 1. 5. 22.0 0.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 5827. 1. 4. 32.0 2.5 0.0 1. 12.0 40.0 3. 4. 0.0 0. 1. + 5828. 1. 5. 17.5 0.5 0.0 4. 12.0 11.5 4. 5. 0.0 0. 1. + 5830. 1. 5. 22.0 0.5 2.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 5831. 1. 3. 17.5 2.5 1.0 2. 14.0 9.0 2. 1. 0.0 0. 1. + 5834. 1. 3. 27.0 6.0 0.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 5837. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 5839. 1. 5. 22.0 6.0 2.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 5841. 1. 4. 22.0 2.5 2.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 5845. 1. 4. 22.0 6.0 1.0 2. 12.0 6.5 3. 5. 0.0 0. 1. + 5860. 1. 4. 27.0 2.5 0.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 5861. 1. 5. 27.0 2.5 0.0 3. 17.0 20.0 3. 5. 0.0 0. 1. + 5866. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 5869. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 2. 2. 0.0 0. 1. + 5870. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 5873. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 2. 2. 0.0 0. 1. + 5875. 1. 5. 22.0 0.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 5877. 1. 4. 42.0 23.0 3.0 4. 17.0 20.0 3. 6. 0.0 0. 1. + 5881. 1. 5. 37.0 23.0 5.5 3. 12.0 20.0 5. 5. 0.0 0. 1. + 5882. 1. 4. 22.0 6.0 1.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 5885. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 5901. 1. 5. 32.0 2.5 0.0 1. 14.0 20.0 3. 3. 0.0 0. 1. + 5904. 1. 4. 17.5 2.5 0.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 5905. 1. 5. 37.0 23.0 5.5 3. 12.0 20.0 2. 3. 0.0 0. 1. + 5911. 1. 5. 22.0 2.5 1.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 5914. 1. 5. 42.0 23.0 5.5 4. 16.0 20.0 4. 5. 0.0 0. 1. + 5922. 1. 5. 42.0 23.0 4.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 6004. 1. 4. 27.0 6.0 0.0 2. 14.0 20.0 5. 3. 0.0 0. 1. + 6007. 1. 4. 32.0 13.0 2.0 3. 16.0 14.0 3. 3. 0.0 0. 1. + 6010. 1. 4. 27.0 6.0 2.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 6016. 1. 4. 32.0 13.0 3.0 4. 14.0 11.5 3. 5. 0.0 0. 1. + 6017. 1. 5. 32.0 13.0 3.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 6019. 1. 3. 42.0 23.0 5.5 2. 14.0 9.0 3. 2. 0.0 0. 1. + 6022. 1. 1. 37.0 13.0 3.0 4. 17.0 20.0 2. 4. 0.0 0. 1. + 6024. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 6028. 1. 4. 22.0 2.5 0.0 1. 12.0 11.5 5. 4. 0.0 0. 1. + 6033. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 6037. 1. 4. 22.0 6.0 3.0 2. 14.0 11.5 4. 2. 0.0 0. 1. + 6043. 1. 5. 27.0 2.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 6045. 1. 4. 22.0 0.5 0.0 2. 14.0 9.0 3. 5. 0.0 0. 1. + 6046. 1. 5. 22.0 0.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 6052. 1. 4. 27.0 9.0 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 6056. 1. 4. 27.0 0.5 0.0 3. 16.0 11.5 4. 6. 0.0 0. 1. + 6064. 1. 4. 27.0 6.0 2.0 3. 12.0 14.0 2. 6. 0.0 0. 1. + 6072. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 4. 4. 0.0 0. 1. + 6077. 1. 5. 22.0 6.0 0.0 3. 12.0 11.5 4. 6. 0.0 0. 1. + 6081. 1. 4. 22.0 0.5 0.0 2. 12.0 9.0 3. 5. 0.0 0. 1. + 6093. 1. 5. 17.5 0.5 0.0 2. 12.0 11.5 4. 2. 0.0 0. 1. + 6095. 1. 5. 27.0 2.5 1.0 1. 17.0 40.0 4. 5. 0.0 0. 1. + 6098. 1. 3. 27.0 9.0 2.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 6102. 1. 4. 27.0 0.5 2.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 6111. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 2. 5. 0.0 0. 1. + 6123. 1. 4. 27.0 2.5 0.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 6124. 1. 2. 27.0 6.0 2.0 2. 14.0 14.0 3. 2. 0.0 0. 1. + 6130. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 2. 4. 0.0 0. 1. + 6150. 1. 5. 42.0 9.0 0.0 4. 20.0 40.0 4. 4. 0.0 0. 1. + 6155. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 4. 3. 0.0 0. 1. + 6156. 1. 5. 37.0 13.0 5.5 4. 17.0 20.0 4. 5. 0.0 0. 1. + 6158. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 4. 3. 0.0 0. 1. + 6161. 1. 5. 32.0 16.5 3.0 4. 14.0 20.0 4. 3. 0.0 0. 1. + 6162. 1. 5. 37.0 16.5 1.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 6167. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 6177. 1. 5. 27.0 2.5 0.0 3. 20.0 20.0 6. 1. 0.0 0. 1. + 6189. 1. 4. 42.0 23.0 3.0 3. 14.0 40.0 4. 5. 0.0 0. 1. + 6194. 1. 4. 42.0 23.0 4.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 6197. 1. 3. 27.0 2.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 6200. 1. 5. 37.0 16.5 3.0 2. 16.0 20.0 4. 3. 0.0 0. 1. + 6202. 1. 5. 42.0 23.0 5.5 3. 14.0 14.0 4. 4. 0.0 0. 1. + 6206. 1. 4. 22.0 2.5 1.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 6208. 1. 5. 27.0 9.0 1.0 3. 12.0 20.0 2. 5. 0.0 0. 1. + 6211. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 6. 0.0 0. 1. + 6216. 1. 4. 22.0 2.5 1.0 2. 14.0 6.5 2. 2. 0.0 0. 1. + 6219. 1. 3. 42.0 23.0 3.0 4. 12.0 14.0 3. 4. 0.0 0. 1. + 6220. 1. 5. 42.0 23.0 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 6224. 1. 4. 32.0 13.0 2.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 6232. 1. 4. 37.0 16.5 5.5 3. 12.0 4.0 4. 5. 0.0 0. 1. + 6240. 1. 4. 27.0 6.0 1.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 6241. 1. 5. 42.0 23.0 5.5 3. 16.0 20.0 4. 5. 0.0 0. 1. + 6242. 1. 5. 32.0 6.0 2.0 2. 16.0 20.0 2. 5. 0.0 0. 1. + 6248. 1. 2. 32.0 9.0 2.0 4. 14.0 11.5 4. 5. 0.0 0. 1. + 6253. 1. 5. 27.0 13.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 6255. 1. 5. 42.0 23.0 5.5 4. 14.0 20.0 4. 2. 0.0 0. 1. + 6259. 1. 5. 42.0 23.0 3.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 6264. 1. 5. 22.0 0.5 0.0 2. 14.0 14.0 4. 3. 0.0 0. 1. + 6276. 1. 3. 37.0 16.5 2.0 3. 12.0 20.0 5. 2. 0.0 0. 1. + 6277. 1. 4. 27.0 6.0 2.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 6282. 1. 4. 37.0 16.5 2.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 6283. 1. 2. 32.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 6287. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 6290. 1. 5. 37.0 23.0 2.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 6296. 1. 5. 22.0 0.5 0.0 4. 14.0 6.5 4. 2. 0.0 0. 1. + 6297. 1. 5. 42.0 16.5 3.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 6319. 1. 4. 37.0 13.0 3.0 2. 12.0 9.0 2. 4. 0.0 0. 1. + 6321. 1. 5. 32.0 13.0 2.0 4. 12.0 14.0 2. 2. 0.0 0. 1. + 6330. 1. 4. 22.0 2.5 0.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 6336. 1. 5. 27.0 2.5 1.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 6342. 1. 5. 22.0 0.5 0.0 4. 16.0 9.0 4. 6. 0.0 0. 1. + 6347. 1. 5. 37.0 16.5 5.5 3. 12.0 20.0 2. 4. 0.0 0. 1. + 6348. 1. 4. 32.0 9.0 2.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 6351. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 6355. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 6356. 1. 4. 32.0 16.5 4.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 6357. 1. 5. 22.0 2.5 0.0 4. 14.0 14.0 3. 2. 0.0 0. 1. + 6359. 1. 5. 37.0 23.0 3.0 4. 14.0 14.0 2. 4. 0.0 0. 1. + 6374. 1. 5. 27.0 6.0 0.0 2. 16.0 11.5 4. 1. 0.0 0. 1. + 6376. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 6379. 1. 5. 32.0 6.0 0.0 4. 20.0 40.0 4. 4. 0.0 0. 1. + 6383. 1. 4. 32.0 16.5 2.0 2. 14.0 14.0 4. 2. 0.0 0. 1. + 6386. 1. 4. 22.0 0.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 6387. 1. 3. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 6393. 1. 4. 22.0 2.5 0.0 1. 14.0 20.0 5. 4. 0.0 0. 1. + 6395. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 6397. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 6398. 1. 2. 42.0 16.5 3.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 6399. 1. 3. 22.0 2.5 0.0 4. 14.0 20.0 3. 3. 0.0 0. 1. + 6401. 1. 5. 27.0 6.0 0.0 2. 20.0 20.0 4. 4. 0.0 0. 1. + 6402. 1. 5. 27.0 6.0 1.0 2. 12.0 14.0 4. 2. 0.0 0. 1. + 6412. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 6413. 1. 4. 37.0 16.5 3.0 1. 12.0 6.5 3. 2. 0.0 0. 1. + 6414. 1. 4. 32.0 16.5 3.0 2. 14.0 14.0 3. 2. 0.0 0. 1. + 6417. 1. 3. 27.0 6.0 1.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 6421. 1. 4. 27.0 6.0 1.0 3. 17.0 20.0 4. 3. 0.0 0. 1. + 6424. 1. 4. 42.0 23.0 2.0 3. 20.0 40.0 4. 4. 0.0 0. 1. + 6429. 1. 4. 27.0 6.0 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 6430. 1. 4. 32.0 9.0 2.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 6432. 1. 5. 42.0 23.0 2.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 6433. 1. 5. 32.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 6444. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 3. 4. 0.0 0. 1. + 6448. 1. 5. 27.0 6.0 2.0 3. 14.0 14.0 4. 3. 0.0 0. 1. + 6451. 1. 5. 27.0 2.5 1.0 2. 12.0 11.5 3. 3. 0.0 0. 1. + 6452. 1. 5. 27.0 6.0 1.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 6453. 1. 4. 32.0 6.0 1.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 6458. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 6468. 1. 5. 27.0 2.5 1.0 3. 16.0 11.5 3. 6. 0.0 0. 1. + 6469. 1. 3. 27.0 6.0 0.0 1. 17.0 20.0 4. 6. 0.0 0. 1. + 6479. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 6. 0.0 0. 1. + 6484. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 6490. 1. 4. 22.0 6.0 1.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 6494. 1. 3. 32.0 2.5 0.0 1. 20.0 14.0 6. 6. 0.0 0. 1. + 6507. 1. 2. 37.0 23.0 5.5 2. 14.0 20.0 3. 4. 0.0 0. 1. + 6510. 1. 3. 42.0 23.0 4.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 6517. 1. 4. 22.0 2.5 1.0 1. 12.0 20.0 3. 3. 0.0 0. 1. + 6519. 1. 5. 42.0 16.5 4.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 6523. 1. 5. 22.0 0.5 0.0 3. 14.0 6.5 3. 5. 0.0 0. 1. + 6524. 1. 4. 22.0 0.5 0.0 2. 12.0 6.5 2. 5. 0.0 0. 1. + 6527. 1. 4. 27.0 6.0 2.0 3. 12.0 20.0 4. 5. 0.0 0. 1. + 6529. 1. 5. 27.0 2.5 0.0 4. 16.0 6.5 3. 1. 0.0 0. 1. + 6537. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 5. 2. 0.0 0. 1. + 6539. 1. 3. 22.0 0.5 0.0 3. 14.0 9.0 3. 5. 0.0 0. 1. + 6540. 1. 5. 27.0 2.5 0.0 2. 16.0 40.0 3. 5. 0.0 0. 1. + 6542. 1. 5. 27.0 0.5 0.0 2. 20.0 20.0 4. 2. 0.0 0. 1. + 6543. 1. 5. 32.0 16.5 4.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 6546. 1. 4. 22.0 2.5 1.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 6552. 1. 3. 22.0 2.5 0.0 1. 16.0 9.0 3. 2. 0.0 0. 1. + 6559. 1. 4. 27.0 6.0 1.0 2. 12.0 20.0 4. 4. 0.0 0. 1. + 6562. 1. 4. 17.5 2.5 0.0 3. 14.0 6.5 2. 2. 0.0 0. 1. + 6570. 1. 5. 37.0 16.5 4.0 2. 17.0 20.0 4. 6. 0.0 0. 1. + 6571. 1. 4. 32.0 16.5 5.5 1. 14.0 11.5 2. 2. 0.0 0. 1. + 6574. 1. 5. 22.0 0.5 0.0 4. 16.0 14.0 4. 4. 0.0 0. 1. + 6576. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 6578. 1. 5. 17.5 0.5 0.0 2. 12.0 11.5 4. 4. 0.0 0. 1. + 6585. 1. 5. 22.0 2.5 1.0 4. 14.0 20.0 2. 2. 0.0 0. 1. + 6589. 1. 5. 42.0 9.0 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 6593. 1. 4. 27.0 6.0 1.0 2. 14.0 9.0 3. 2. 0.0 0. 1. + 6596. 1. 3. 32.0 13.0 2.0 2. 16.0 11.5 2. 2. 0.0 0. 1. + 6602. 1. 4. 32.0 13.0 2.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 6606. 1. 5. 22.0 2.5 0.0 3. 17.0 9.0 3. 4. 0.0 0. 1. + 6609. 1. 4. 27.0 9.0 2.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 6613. 1. 4. 37.0 23.0 2.0 4. 14.0 20.0 3. 6. 0.0 0. 1. + 6615. 1. 4. 42.0 23.0 3.0 2. 14.0 40.0 4. 6. 0.0 0. 1. + 6616. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 6620. 1. 5. 27.0 9.0 2.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 6623. 1. 2. 32.0 13.0 1.0 3. 14.0 20.0 5. 3. 0.0 0. 1. + 6638. 1. 1. 42.0 23.0 2.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 6639. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 6641. 1. 4. 27.0 6.0 1.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 6646. 1. 4. 42.0 23.0 4.0 3. 12.0 14.0 2. 5. 0.0 0. 1. + 6648. 1. 5. 32.0 16.5 3.0 1. 14.0 14.0 5. 5. 0.0 0. 1. + 6649. 1. 5. 27.0 2.5 0.0 4. 16.0 40.0 3. 6. 0.0 0. 1. + 6651. 1. 4. 27.0 9.0 0.0 2. 12.0 14.0 5. 2. 0.0 0. 1. + 6652. 1. 3. 22.0 2.5 0.0 1. 14.0 11.5 3. 5. 0.0 0. 1. + 6658. 1. 5. 27.0 2.5 0.0 2. 12.0 14.0 3. 6. 0.0 0. 1. + 6661. 1. 5. 32.0 9.0 3.0 2. 12.0 11.5 3. 3. 0.0 0. 1. + 6667. 1. 5. 22.0 0.5 0.0 3. 14.0 20.0 2. 4. 0.0 0. 1. + 6671. 1. 4. 27.0 2.5 1.0 1. 12.0 14.0 3. 3. 0.0 0. 1. + 6683. 1. 4. 37.0 16.5 3.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 6686. 1. 5. 22.0 2.5 0.0 3. 12.0 6.5 5. 4. 0.0 0. 1. + 6690. 1. 3. 22.0 2.5 0.0 2. 14.0 20.0 4. 2. 0.0 0. 1. + 6697. 1. 5. 32.0 13.0 2.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 6701. 1. 5. 32.0 9.0 2.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 6708. 1. 4. 37.0 16.5 3.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 6715. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 6718. 1. 2. 42.0 23.0 4.0 1. 17.0 40.0 3. 5. 0.0 0. 1. + 6719. 1. 4. 27.0 6.0 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 6725. 1. 4. 42.0 23.0 3.0 4. 14.0 20.0 4. 4. 0.0 0. 1. + 6733. 1. 5. 22.0 0.5 0.0 4. 14.0 9.0 3. 1. 0.0 0. 1. + 6737. 1. 5. 27.0 2.5 0.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 6741. 1. 4. 22.0 2.5 0.0 3. 16.0 9.0 4. 4. 0.0 0. 1. + 6742. 1. 3. 32.0 6.0 2.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 6749. 1. 5. 22.0 6.0 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 6750. 1. 4. 22.0 2.5 1.0 2. 12.0 9.0 2. 4. 0.0 0. 1. + 6756. 1. 5. 27.0 0.5 0.0 2. 14.0 11.5 4. 4. 0.0 0. 1. + 6767. 1. 3. 32.0 6.0 3.0 4. 16.0 40.0 5. 6. 0.0 0. 1. + 6769. 1. 4. 27.0 0.5 0.0 4. 14.0 11.5 3. 4. 0.0 0. 1. + 6776. 1. 5. 27.0 2.5 0.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 6778. 1. 4. 22.0 6.0 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 6781. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 6784. 1. 4. 22.0 2.5 0.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 6800. 1. 4. 27.0 6.0 2.0 4. 14.0 14.0 4. 5. 0.0 0. 1. + 6802. 1. 5. 22.0 2.5 0.0 1. 16.0 11.5 2. 5. 0.0 0. 1. + 6803. 1. 4. 27.0 6.0 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 6808. 1. 5. 22.0 0.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 6812. 1. 5. 32.0 13.0 3.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 6816. 1. 4. 32.0 6.0 0.0 3. 17.0 40.0 2. 2. 0.0 0. 1. + 6824. 1. 5. 32.0 13.0 2.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 6844. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 5. 2. 0.0 0. 1. + 6846. 1. 5. 27.0 13.0 2.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 6847. 1. 4. 27.0 6.0 1.0 4. 16.0 14.0 4. 4. 0.0 0. 1. + 6852. 1. 5. 32.0 16.5 5.5 4. 14.0 20.0 4. 6. 0.0 0. 1. + 6855. 1. 5. 37.0 16.5 3.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 6865. 1. 4. 22.0 2.5 0.0 4. 14.0 20.0 3. 2. 0.0 0. 1. + 6885. 1. 5. 37.0 16.5 4.0 2. 14.0 14.0 3. 2. 0.0 0. 1. + 6886. 1. 3. 32.0 16.5 3.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 6888. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 2. 2. 0.0 0. 1. + 6895. 1. 5. 22.0 2.5 2.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 6906. 1. 3. 37.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 6907. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 3. 6. 0.0 0. 1. + 6912. 1. 5. 22.0 0.5 0.0 3. 12.0 11.5 5. 4. 0.0 0. 1. + 6914. 1. 5. 42.0 23.0 3.0 4. 16.0 40.0 4. 5. 0.0 0. 1. + 6915. 1. 4. 22.0 6.0 2.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 6922. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 6. 0.0 0. 1. + 6927. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 6933. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 6934. 1. 4. 37.0 23.0 3.0 4. 14.0 14.0 4. 4. 0.0 0. 1. + 6938. 1. 3. 27.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 6941. 1. 5. 27.0 2.5 0.0 2. 14.0 9.0 4. 3. 0.0 0. 1. + 6946. 1. 5. 22.0 2.5 0.0 2. 14.0 40.0 3. 5. 0.0 0. 1. + 6951. 1. 4. 32.0 13.0 2.0 2. 14.0 20.0 2. 3. 0.0 0. 1. + 6955. 1. 4. 32.0 16.5 2.0 2. 17.0 40.0 4. 6. 0.0 0. 1. + 6957. 1. 4. 27.0 6.0 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 6959. 1. 4. 22.0 0.5 0.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 6964. 1. 3. 22.0 2.5 1.0 4. 14.0 11.5 2. 2. 0.0 0. 1. + 6968. 1. 3. 27.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 6969. 1. 3. 27.0 6.0 2.0 2. 17.0 20.0 6. 4. 0.0 0. 1. + 6970. 1. 5. 27.0 2.5 0.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 6979. 1. 5. 22.0 0.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 6980. 1. 2. 42.0 23.0 5.5 4. 12.0 20.0 3. 4. 0.0 0. 1. + 6984. 1. 4. 27.0 2.5 0.0 4. 17.0 20.0 5. 5. 0.0 0. 1. + 6988. 1. 5. 27.0 6.0 2.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 6994. 1. 4. 42.0 23.0 2.0 3. 12.0 4.0 3. 2. 0.0 0. 1. + 6996. 1. 5. 27.0 6.0 1.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 6999. 1. 5. 22.0 2.5 0.0 3. 14.0 6.5 4. 2. 0.0 0. 1. + 7000. 1. 3. 22.0 6.0 3.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 7005. 1. 5. 17.5 0.5 0.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 7006. 1. 4. 27.0 6.0 0.0 3. 14.0 6.5 3. 1. 0.0 0. 1. + 7009. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 7016. 1. 5. 27.0 0.5 0.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 7017. 1. 4. 42.0 23.0 5.5 4. 16.0 20.0 4. 5. 0.0 0. 1. + 7024. 1. 5. 37.0 16.5 3.0 2. 12.0 14.0 3. 3. 0.0 0. 1. + 7026. 1. 4. 42.0 23.0 3.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 7027. 1. 4. 27.0 2.5 0.0 3. 16.0 6.5 4. 4. 0.0 0. 1. + 7032. 1. 4. 22.0 2.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 7037. 1. 5. 22.0 0.5 0.0 2. 20.0 14.0 4. 5. 0.0 0. 1. + 7038. 1. 5. 22.0 2.5 1.0 2. 12.0 6.5 3. 4. 0.0 0. 1. + 7043. 1. 4. 22.0 6.0 3.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 7049. 1. 5. 42.0 23.0 5.5 2. 16.0 20.0 4. 4. 0.0 0. 1. + 7050. 1. 3. 32.0 6.0 0.0 1. 14.0 40.0 3. 6. 0.0 0. 1. + 7053. 1. 5. 37.0 13.0 0.0 2. 14.0 20.0 4. 6. 0.0 0. 1. + 7061. 1. 5. 27.0 2.5 0.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 7068. 1. 3. 32.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 7070. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 7072. 1. 5. 42.0 23.0 4.0 3. 14.0 20.0 2. 5. 0.0 0. 1. + 7077. 1. 5. 32.0 16.5 5.5 4. 12.0 20.0 5. 5. 0.0 0. 1. + 7078. 1. 4. 27.0 6.0 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 7085. 1. 3. 22.0 2.5 0.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 7086. 1. 2. 27.0 2.5 0.0 1. 20.0 9.0 4. 2. 0.0 0. 1. + 7093. 1. 5. 37.0 16.5 5.5 3. 9.0 20.0 2. 5. 0.0 0. 1. + 7096. 1. 3. 37.0 23.0 3.0 2. 12.0 20.0 2. 4. 0.0 0. 1. + 7099. 1. 5. 22.0 2.5 1.0 3. 12.0 6.5 2. 3. 0.0 0. 1. + 7104. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 7108. 1. 5. 22.0 2.5 0.0 4. 14.0 14.0 2. 2. 0.0 0. 1. + 7111. 1. 5. 27.0 2.5 0.0 4. 16.0 14.0 4. 4. 0.0 0. 1. + 7123. 1. 4. 22.0 2.5 0.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 7124. 1. 4. 32.0 6.0 2.0 3. 14.0 20.0 2. 2. 0.0 0. 1. + 7125. 1. 5. 17.5 2.5 0.0 1. 12.0 9.0 3. 2. 0.0 0. 1. + 7127. 1. 4. 27.0 9.0 2.0 1. 12.0 20.0 2. 2. 0.0 0. 1. + 7130. 1. 3. 32.0 16.5 1.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 7133. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 7135. 1. 5. 27.0 6.0 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 7142. 1. 5. 27.0 6.0 1.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 7143. 1. 4. 22.0 0.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 7144. 1. 5. 22.0 2.5 1.0 2. 12.0 20.0 4. 4. 0.0 0. 1. + 7145. 1. 4. 27.0 9.0 2.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 7146. 1. 4. 22.0 2.5 1.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 7149. 1. 4. 22.0 2.5 0.0 3. 16.0 6.5 4. 1. 0.0 0. 1. + 7152. 1. 5. 32.0 16.5 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 7161. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 7162. 1. 5. 22.0 2.5 1.0 3. 12.0 6.5 3. 4. 0.0 0. 1. + 7164. 1. 5. 27.0 13.0 1.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 7166. 1. 4. 27.0 6.0 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 7168. 1. 3. 42.0 23.0 4.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 7171. 1. 3. 37.0 16.5 2.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 7174. 1. 5. 27.0 6.0 1.0 3. 12.0 20.0 2. 2. 0.0 0. 1. + 7175. 1. 5. 22.0 0.5 0.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 7178. 1. 5. 22.0 2.5 0.0 4. 14.0 4.0 1. 1. 0.0 0. 1. + 7189. 1. 4. 27.0 6.0 1.0 4. 16.0 11.5 4. 4. 0.0 0. 1. + 7204. 1. 3. 42.0 23.0 2.0 4. 14.0 20.0 2. 5. 0.0 0. 1. + 7206. 1. 3. 27.0 6.0 1.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 7209. 1. 4. 22.0 2.5 0.0 3. 14.0 9.0 4. 4. 0.0 0. 1. + 7211. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 7213. 1. 3. 32.0 13.0 2.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 7214. 1. 4. 37.0 16.5 5.5 3. 14.0 20.0 1. 3. 0.0 0. 1. + 7217. 1. 4. 37.0 23.0 5.5 1. 14.0 14.0 3. 2. 0.0 0. 1. + 7218. 1. 5. 22.0 0.5 0.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 7219. 1. 5. 42.0 16.5 3.0 4. 17.0 40.0 4. 4. 0.0 0. 1. + 7221. 1. 4. 27.0 2.5 0.0 3. 17.0 11.5 4. 5. 0.0 0. 1. + 7232. 1. 4. 32.0 16.5 2.0 1. 12.0 14.0 5. 5. 0.0 0. 1. + 7234. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 7241. 1. 3. 22.0 6.0 2.0 2. 14.0 9.0 2. 4. 0.0 0. 1. + 7246. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 4. 6. 0.0 0. 1. + 7248. 1. 5. 37.0 13.0 0.0 1. 12.0 40.0 5. 5. 0.0 0. 1. + 7253. 1. 4. 42.0 23.0 5.5 2. 14.0 40.0 4. 3. 0.0 0. 1. + 7255. 1. 5. 37.0 16.5 3.0 2. 14.0 40.0 3. 6. 0.0 0. 1. + 7257. 1. 5. 27.0 6.0 0.0 3. 16.0 40.0 6. 5. 0.0 0. 1. + 7261. 1. 4. 22.0 9.0 3.0 3. 12.0 11.5 5. 5. 0.0 0. 1. + 7264. 1. 5. 17.5 2.5 0.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 7267. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 7269. 1. 5. 37.0 13.0 2.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 7273. 1. 4. 37.0 13.0 0.0 2. 14.0 40.0 5. 5. 0.0 0. 1. + 7276. 1. 2. 27.0 6.0 2.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 7279. 1. 5. 22.0 2.5 2.0 4. 12.0 11.5 3. 5. 0.0 0. 1. + 7281. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 7287. 1. 4. 27.0 6.0 1.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 7289. 1. 5. 42.0 23.0 4.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 7299. 1. 5. 27.0 2.5 0.0 4. 16.0 20.0 3. 3. 0.0 0. 1. + 7302. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 7306. 1. 5. 42.0 13.0 0.0 4. 14.0 40.0 5. 2. 0.0 0. 1. + 7308. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 7309. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 7311. 1. 5. 22.0 2.5 1.0 3. 17.0 11.5 4. 2. 0.0 0. 1. + 7316. 1. 5. 22.0 0.5 0.0 3. 17.0 11.5 4. 3. 0.0 0. 1. + 7324. 1. 4. 32.0 9.0 3.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 7325. 1. 4. 32.0 9.0 2.0 3. 14.0 11.5 2. 2. 0.0 0. 1. + 7328. 1. 4. 27.0 6.0 2.0 1. 14.0 6.5 4. 4. 0.0 0. 1. + 7330. 1. 5. 32.0 2.5 4.0 3. 16.0 20.0 5. 4. 0.0 0. 1. + 7331. 1. 5. 22.0 0.5 0.0 2. 14.0 14.0 2. 5. 0.0 0. 1. + 7332. 1. 5. 27.0 2.5 0.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 7337. 1. 4. 32.0 16.5 3.0 3. 9.0 20.0 4. 4. 0.0 0. 1. + 7340. 1. 5. 42.0 23.0 2.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 7358. 1. 3. 32.0 13.0 3.0 2. 16.0 11.5 4. 5. 0.0 0. 1. + 7362. 1. 4. 27.0 6.0 1.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 7366. 1. 5. 27.0 9.0 2.0 4. 12.0 11.5 2. 2. 0.0 0. 1. + 7372. 1. 4. 27.0 6.0 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 7373. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 1. 0.0 0. 1. + 7375. 1. 5. 17.5 0.5 0.0 1. 14.0 6.5 1. 1. 0.0 0. 1. + 7381. 1. 4. 32.0 16.5 3.0 3. 14.0 40.0 5. 5. 0.0 0. 1. + 7384. 1. 2. 22.0 6.0 1.0 2. 14.0 20.0 4. 2. 0.0 0. 1. + 7385. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 7388. 1. 4. 27.0 9.0 1.0 3. 12.0 11.5 4. 2. 0.0 0. 1. + 7391. 1. 5. 22.0 2.5 1.0 2. 12.0 6.5 4. 1. 0.0 0. 1. + 7392. 1. 5. 27.0 6.0 0.0 3. 12.0 20.0 4. 2. 0.0 0. 1. + 7394. 1. 3. 42.0 23.0 3.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 7403. 1. 5. 42.0 16.5 3.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 7405. 1. 5. 27.0 6.0 1.0 4. 14.0 11.5 2. 2. 0.0 0. 1. + 7406. 1. 5. 22.0 6.0 1.0 4. 14.0 11.5 5. 2. 0.0 0. 1. + 7408. 1. 4. 22.0 0.5 0.0 2. 16.0 20.0 3. 2. 0.0 0. 1. + 7409. 1. 4. 37.0 16.5 4.0 2. 14.0 11.5 2. 5. 0.0 0. 1. + 7417. 1. 5. 32.0 16.5 3.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 7425. 1. 5. 22.0 0.5 0.0 2. 14.0 9.0 3. 2. 0.0 0. 1. + 7427. 1. 5. 32.0 16.5 3.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 7429. 1. 5. 27.0 0.5 0.0 2. 20.0 20.0 4. 2. 0.0 0. 1. + 7438. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 7440. 1. 5. 27.0 9.0 2.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 7443. 1. 4. 22.0 2.5 1.0 2. 12.0 6.5 2. 3. 0.0 0. 1. + 7450. 1. 4. 27.0 6.0 3.0 3. 16.0 20.0 3. 4. 0.0 0. 1. + 7451. 1. 3. 42.0 16.5 3.0 4. 9.0 20.0 5. 4. 0.0 0. 1. + 7454. 1. 3. 32.0 13.0 1.0 3. 9.0 20.0 3. 5. 0.0 0. 1. + 7455. 1. 5. 32.0 16.5 3.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 7456. 1. 5. 27.0 6.0 1.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 7460. 1. 4. 32.0 16.5 2.0 2. 12.0 11.5 3. 3. 0.0 0. 1. + 7462. 1. 4. 32.0 13.0 3.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 7464. 1. 5. 22.0 2.5 0.0 3. 16.0 6.5 4. 1. 0.0 0. 1. + 7469. 1. 5. 22.0 2.5 0.0 2. 16.0 9.0 4. 4. 0.0 0. 1. + 7471. 1. 4. 27.0 13.0 2.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 7473. 1. 5. 17.5 0.5 0.0 3. 12.0 6.5 3. 1. 0.0 0. 1. + 7478. 1. 4. 27.0 9.0 2.0 3. 14.0 11.5 2. 1. 0.0 0. 1. + 7480. 1. 4. 32.0 9.0 2.0 3. 14.0 20.0 3. 3. 0.0 0. 1. + 7483. 1. 5. 32.0 16.5 3.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 7488. 1. 5. 27.0 6.0 0.0 4. 20.0 20.0 3. 4. 0.0 0. 1. + 7489. 1. 5. 32.0 16.5 2.0 4. 14.0 20.0 4. 4. 0.0 0. 1. + 7497. 1. 4. 37.0 16.5 5.5 1. 12.0 20.0 3. 4. 0.0 0. 1. + 7501. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 7507. 1. 5. 22.0 2.5 0.0 3. 14.0 6.5 3. 4. 0.0 0. 1. + 7511. 1. 4. 27.0 2.5 0.0 2. 16.0 40.0 3. 5. 0.0 0. 1. + 7512. 1. 5. 42.0 23.0 3.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 7513. 1. 5. 22.0 2.5 1.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 7514. 1. 5. 27.0 6.0 0.0 3. 16.0 9.0 3. 2. 0.0 0. 1. + 7516. 1. 4. 27.0 6.0 0.0 2. 14.0 9.0 2. 2. 0.0 0. 1. + 7518. 1. 4. 32.0 13.0 3.0 3. 14.0 14.0 4. 2. 0.0 0. 1. + 7519. 1. 5. 27.0 9.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 7520. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 7523. 1. 1. 42.0 23.0 4.0 4. 16.0 14.0 4. 2. 0.0 0. 1. + 7525. 1. 5. 22.0 6.0 0.0 1. 14.0 20.0 3. 2. 0.0 0. 1. + 7528. 1. 5. 32.0 13.0 3.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 7531. 1. 4. 42.0 23.0 4.0 4. 14.0 14.0 1. 5. 0.0 0. 1. + 7534. 1. 3. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 7541. 1. 5. 27.0 6.0 1.0 2. 17.0 40.0 4. 4. 0.0 0. 1. + 7547. 1. 3. 42.0 23.0 3.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 7558. 1. 4. 42.0 23.0 5.5 2. 12.0 11.5 3. 5. 0.0 0. 1. + 7560. 1. 4. 22.0 6.0 0.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 7562. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 2. 4. 0.0 0. 1. + 7570. 1. 5. 27.0 6.0 2.0 4. 12.0 11.5 2. 4. 0.0 0. 1. + 7571. 1. 2. 42.0 23.0 2.0 3. 14.0 11.5 2. 2. 0.0 0. 1. + 7573. 1. 5. 32.0 16.5 3.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 7576. 1. 4. 42.0 23.0 5.5 4. 20.0 20.0 5. 6. 0.0 0. 1. + 7586. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 2. 5. 0.0 0. 1. + 7593. 1. 5. 42.0 23.0 5.5 3. 12.0 20.0 3. 5. 0.0 0. 1. + 7595. 1. 5. 27.0 0.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 7597. 1. 5. 22.0 2.5 0.0 4. 16.0 20.0 3. 2. 0.0 0. 1. + 7600. 1. 3. 27.0 9.0 2.0 3. 12.0 14.0 2. 5. 0.0 0. 1. + 7603. 1. 5. 22.0 0.5 0.0 2. 16.0 6.5 4. 5. 0.0 0. 1. + 7604. 1. 5. 22.0 2.5 1.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 7612. 1. 4. 32.0 16.5 4.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 7618. 1. 4. 32.0 13.0 0.0 2. 17.0 20.0 4. 2. 0.0 0. 1. + 7622. 1. 4. 27.0 2.5 0.0 2. 17.0 20.0 4. 3. 0.0 0. 1. + 7626. 1. 5. 32.0 16.5 2.0 2. 14.0 14.0 3. 3. 0.0 0. 1. + 7628. 1. 4. 27.0 9.0 2.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 7629. 1. 4. 22.0 2.5 2.0 3. 12.0 6.5 2. 4. 0.0 0. 1. + 7631. 1. 5. 27.0 2.5 0.0 1. 16.0 14.0 4. 6. 0.0 0. 1. + 7633. 1. 2. 22.0 2.5 1.0 3. 16.0 11.5 2. 4. 0.0 0. 1. + 7634. 1. 5. 42.0 23.0 5.5 2. 16.0 40.0 5. 5. 0.0 0. 1. + 7635. 1. 5. 27.0 2.5 0.0 3. 20.0 11.5 4. 4. 0.0 0. 1. + 7640. 1. 5. 37.0 13.0 2.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 7649. 1. 5. 42.0 16.5 1.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 7655. 1. 4. 32.0 13.0 2.0 3. 20.0 11.5 4. 4. 0.0 0. 1. + 7661. 1. 5. 22.0 2.5 1.0 3. 12.0 9.0 3. 1. 0.0 0. 1. + 7665. 1. 4. 42.0 23.0 2.0 2. 20.0 20.0 4. 3. 0.0 0. 1. + 7667. 1. 4. 27.0 9.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 7668. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 2. 5. 0.0 0. 1. + 7683. 1. 5. 22.0 2.5 0.0 4. 12.0 6.5 2. 4. 0.0 0. 1. + 7686. 1. 5. 22.0 2.5 0.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 7687. 1. 5. 32.0 16.5 3.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 7688. 1. 3. 42.0 16.5 3.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 7692. 1. 5. 27.0 2.5 1.0 1. 16.0 11.5 4. 5. 0.0 0. 1. + 7693. 1. 4. 37.0 16.5 2.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 7694. 1. 5. 37.0 2.5 0.0 3. 20.0 14.0 4. 3. 0.0 0. 1. + 7701. 1. 5. 32.0 13.0 3.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 7709. 1. 3. 37.0 16.5 2.0 3. 14.0 20.0 2. 2. 0.0 0. 1. + 7718. 1. 4. 42.0 23.0 2.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 7736. 1. 5. 27.0 2.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 7739. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 4. 1. 0.0 0. 1. + 7752. 1. 5. 22.0 6.0 0.0 2. 14.0 20.0 2. 2. 0.0 0. 1. + 7755. 1. 4. 27.0 2.5 0.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 7761. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 4. 1. 0.0 0. 1. + 7762. 1. 3. 27.0 6.0 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 7764. 1. 5. 32.0 16.5 4.0 3. 12.0 14.0 5. 5. 0.0 0. 1. + 7765. 1. 5. 37.0 16.5 3.0 4. 17.0 11.5 4. 6. 0.0 0. 1. + 7772. 1. 4. 32.0 13.0 2.0 3. 12.0 20.0 4. 5. 0.0 0. 1. + 7774. 1. 3. 37.0 16.5 4.0 1. 12.0 11.5 5. 5. 0.0 0. 1. + 7778. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 2. 4. 0.0 0. 1. + 7781. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 2. 5. 0.0 0. 1. + 7782. 1. 4. 22.0 2.5 1.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 7785. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 7788. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 7794. 1. 4. 37.0 23.0 4.0 2. 9.0 6.5 2. 2. 0.0 0. 1. + 7795. 1. 5. 27.0 9.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 7797. 1. 5. 27.0 6.0 0.0 2. 16.0 4.0 4. 1. 0.0 0. 1. + 7807. 1. 4. 32.0 2.5 0.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 7811. 1. 4. 22.0 2.5 0.0 1. 14.0 6.5 2. 4. 0.0 0. 1. + 7812. 1. 3. 32.0 13.0 0.0 1. 14.0 14.0 3. 6. 0.0 0. 1. + 7822. 1. 5. 32.0 6.0 2.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 7824. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 3. 0.0 0. 1. + 7825. 1. 5. 27.0 6.0 2.0 2. 20.0 20.0 4. 6. 0.0 0. 1. + 7827. 1. 4. 22.0 2.5 0.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 7832. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 4. 1. 0.0 0. 1. + 7840. 1. 4. 42.0 23.0 4.0 2. 17.0 20.0 4. 6. 0.0 0. 1. + 7844. 1. 3. 27.0 6.0 1.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 7847. 1. 4. 27.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 7848. 1. 3. 42.0 23.0 2.0 3. 16.0 20.0 3. 4. 0.0 0. 1. + 7852. 1. 4. 42.0 23.0 3.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 7859. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 3. 0.0 0. 1. + 7862. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 7863. 1. 5. 27.0 0.5 0.0 1. 14.0 9.0 3. 2. 0.0 0. 1. + 7874. 1. 5. 37.0 16.5 3.0 3. 12.0 14.0 5. 5. 0.0 0. 1. + 7879. 1. 5. 32.0 6.0 0.0 2. 20.0 40.0 4. 5. 0.0 0. 1. + 7880. 1. 5. 22.0 6.0 0.0 1. 12.0 11.5 5. 5. 0.0 0. 1. + 7891. 1. 4. 32.0 16.5 4.0 1. 12.0 11.5 2. 2. 0.0 0. 1. + 7901. 1. 4. 22.0 2.5 1.0 1. 12.0 9.0 2. 2. 0.0 0. 1. + 7907. 1. 4. 27.0 2.5 2.0 3. 14.0 6.5 2. 4. 0.0 0. 1. + 7908. 1. 3. 27.0 2.5 0.0 2. 16.0 40.0 4. 2. 0.0 0. 1. + 7915. 1. 5. 42.0 23.0 4.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 7921. 1. 4. 27.0 2.5 1.0 4. 14.0 9.0 4. 4. 0.0 0. 1. + 7930. 1. 5. 27.0 6.0 1.0 3. 16.0 14.0 5. 2. 0.0 0. 1. + 7932. 1. 5. 27.0 6.0 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 7934. 1. 5. 42.0 23.0 4.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 7941. 1. 5. 22.0 2.5 1.0 3. 14.0 20.0 5. 2. 0.0 0. 1. + 7943. 1. 2. 27.0 6.0 2.0 4. 14.0 6.5 2. 2. 0.0 0. 1. + 7945. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 7947. 1. 5. 27.0 6.0 1.0 4. 14.0 20.0 5. 4. 0.0 0. 1. + 7953. 1. 4. 22.0 2.5 0.0 4. 16.0 11.5 4. 4. 0.0 0. 1. + 7955. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 7960. 1. 4. 27.0 9.0 2.0 2. 16.0 20.0 4. 3. 0.0 0. 1. + 7967. 1. 5. 37.0 16.5 1.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 7968. 1. 4. 22.0 2.5 1.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 7970. 1. 5. 27.0 13.0 2.0 4. 12.0 20.0 2. 4. 0.0 0. 1. + 7984. 1. 4. 27.0 6.0 0.0 2. 17.0 14.0 4. 5. 0.0 0. 1. + 7987. 1. 5. 22.0 2.5 1.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 7994. 1. 5. 17.5 0.5 0.0 1. 12.0 9.0 3. 3. 0.0 0. 1. + 7995. 1. 4. 27.0 2.5 0.0 1. 17.0 6.5 1. 4. 0.0 0. 1. + 7999. 1. 5. 27.0 6.0 1.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 8002. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 5. 5. 0.0 0. 1. + 8003. 1. 4. 37.0 16.5 3.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 8009. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 3. 3. 0.0 0. 1. + 8011. 1. 4. 32.0 9.0 2.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 8012. 1. 5. 22.0 2.5 1.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 8028. 1. 4. 27.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 8036. 1. 5. 27.0 6.0 2.0 2. 16.0 14.0 2. 4. 0.0 0. 1. + 8040. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 8041. 1. 3. 22.0 0.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 8050. 1. 5. 32.0 13.0 3.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 8051. 1. 5. 32.0 9.0 2.0 1. 16.0 14.0 2. 4. 0.0 0. 1. + 8053. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 8055. 1. 4. 32.0 13.0 0.0 3. 12.0 20.0 5. 4. 0.0 0. 1. + 8058. 1. 5. 27.0 2.5 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 8061. 1. 2. 22.0 2.5 0.0 3. 14.0 11.5 2. 2. 0.0 0. 1. + 8062. 1. 3. 32.0 9.0 1.0 3. 16.0 11.5 4. 3. 0.0 0. 1. + 8066. 1. 5. 22.0 0.5 0.0 3. 17.0 14.0 4. 2. 0.0 0. 1. + 8067. 1. 5. 27.0 6.0 0.0 3. 16.0 40.0 4. 6. 0.0 0. 1. + 8068. 1. 3. 42.0 23.0 3.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 8069. 1. 4. 32.0 9.0 2.0 1. 12.0 14.0 3. 3. 0.0 0. 1. + 8080. 1. 5. 32.0 13.0 2.0 4. 20.0 20.0 6. 6. 0.0 0. 1. + 8089. 1. 5. 27.0 2.5 1.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 8092. 1. 4. 32.0 9.0 2.0 3. 16.0 9.0 4. 2. 0.0 0. 1. + 8093. 1. 4. 37.0 16.5 3.0 4. 14.0 20.0 2. 4. 0.0 0. 1. + 8095. 1. 5. 42.0 23.0 1.0 4. 12.0 9.0 2. 2. 0.0 0. 1. + 8104. 1. 4. 27.0 2.5 0.0 1. 16.0 6.5 3. 3. 0.0 0. 1. + 8105. 1. 4. 27.0 6.0 1.0 2. 17.0 14.0 3. 3. 0.0 0. 1. + 8106. 1. 5. 32.0 13.0 1.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 8107. 1. 5. 27.0 6.0 1.0 4. 16.0 9.0 2. 2. 0.0 0. 1. + 8108. 1. 5. 32.0 16.5 3.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 8123. 1. 5. 42.0 23.0 2.0 4. 12.0 14.0 2. 2. 0.0 0. 1. + 8124. 1. 5. 37.0 6.0 1.0 3. 12.0 6.5 3. 2. 0.0 0. 1. + 8125. 1. 1. 22.0 2.5 1.0 2. 12.0 9.0 3. 5. 0.0 0. 1. + 8130. 1. 4. 22.0 2.5 1.0 3. 17.0 9.0 4. 4. 0.0 0. 1. + 8131. 1. 5. 17.5 0.5 1.0 2. 12.0 11.5 3. 3. 0.0 0. 1. + 8132. 1. 5. 42.0 23.0 5.5 3. 12.0 20.0 3. 4. 0.0 0. 1. + 8134. 1. 5. 42.0 6.0 0.0 4. 20.0 20.0 4. 2. 0.0 0. 1. + 8137. 1. 2. 17.5 2.5 1.0 2. 12.0 11.5 4. 4. 0.0 0. 1. + 8140. 1. 4. 37.0 16.5 3.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 8142. 1. 5. 32.0 16.5 3.0 2. 16.0 14.0 3. 5. 0.0 0. 1. + 8146. 1. 5. 22.0 2.5 0.0 3. 12.0 4.0 3. 1. 0.0 0. 1. + 8156. 1. 5. 22.0 6.0 2.0 4. 12.0 9.0 3. 3. 0.0 0. 1. + 8157. 1. 5. 22.0 2.5 1.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 8158. 1. 4. 22.0 6.0 0.0 1. 14.0 20.0 4. 6. 0.0 0. 1. + 8166. 1. 5. 32.0 13.0 1.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 8171. 1. 4. 32.0 6.0 3.0 2. 17.0 20.0 4. 6. 0.0 0. 1. + 8176. 1. 4. 27.0 6.0 2.0 3. 14.0 20.0 4. 2. 0.0 0. 1. + 8178. 1. 3. 22.0 6.0 1.0 3. 12.0 9.0 2. 4. 0.0 0. 1. + 8181. 1. 3. 37.0 23.0 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 8189. 1. 5. 22.0 2.5 1.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 8191. 1. 2. 27.0 9.0 1.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 8207. 1. 3. 22.0 2.5 1.0 2. 12.0 6.5 3. 2. 0.0 0. 1. + 8211. 1. 4. 32.0 13.0 2.0 2. 17.0 14.0 3. 2. 0.0 0. 1. + 8216. 1. 2. 22.0 2.5 1.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 8224. 1. 5. 37.0 13.0 0.0 2. 12.0 20.0 4. 2. 0.0 0. 1. + 8233. 1. 3. 37.0 16.5 4.0 4. 14.0 14.0 4. 2. 0.0 0. 1. + 8234. 1. 5. 42.0 23.0 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 8240. 1. 5. 22.0 2.5 0.0 4. 16.0 11.5 4. 4. 0.0 0. 1. + 8241. 1. 3. 27.0 2.5 0.0 3. 20.0 14.0 4. 4. 0.0 0. 1. + 8243. 1. 4. 27.0 2.5 2.0 3. 12.0 9.0 4. 5. 0.0 0. 1. + 8245. 1. 5. 22.0 2.5 0.0 4. 14.0 6.5 3. 1. 0.0 0. 1. + 8253. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 2. 2. 0.0 0. 1. + 8254. 1. 3. 32.0 13.0 2.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 8255. 1. 5. 27.0 6.0 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 8266. 1. 5. 27.0 9.0 3.0 4. 14.0 9.0 4. 2. 0.0 0. 1. + 8273. 1. 4. 22.0 6.0 2.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 8277. 1. 4. 32.0 9.0 3.0 2. 16.0 14.0 4. 2. 0.0 0. 1. + 8280. 1. 4. 42.0 23.0 4.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 8285. 1. 5. 42.0 23.0 5.5 4. 14.0 11.5 4. 4. 0.0 0. 1. + 8287. 1. 3. 22.0 2.5 2.0 1. 12.0 9.0 3. 2. 0.0 0. 1. + 8292. 1. 5. 32.0 13.0 3.0 3. 14.0 20.0 4. 3. 0.0 0. 1. + 8295. 1. 4. 32.0 16.5 5.5 3. 12.0 14.0 3. 4. 0.0 0. 1. + 8296. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 5. 5. 0.0 0. 1. + 8297. 1. 3. 22.0 2.5 1.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 8299. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 1. 4. 0.0 0. 1. + 8310. 1. 5. 32.0 9.0 0.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 8316. 1. 2. 22.0 2.5 1.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 8325. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 5. 1. 0.0 0. 1. + 8331. 1. 4. 27.0 6.0 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 8338. 1. 5. 27.0 0.5 0.0 3. 16.0 11.5 4. 1. 0.0 0. 1. + 8341. 1. 5. 27.0 6.0 2.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 8343. 1. 4. 27.0 2.5 1.0 3. 16.0 9.0 2. 3. 0.0 0. 1. + 8349. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 4. 2. 0.0 0. 1. + 8353. 1. 5. 32.0 16.5 4.0 3. 12.0 20.0 5. 2. 0.0 0. 1. + 8359. 1. 2. 22.0 2.5 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 8369. 1. 5. 27.0 0.5 0.0 1. 12.0 14.0 3. 2. 0.0 0. 1. + 8374. 1. 4. 42.0 23.0 1.0 1. 12.0 11.5 4. 5. 0.0 0. 1. + 8375. 1. 3. 27.0 9.0 0.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 8376. 1. 4. 22.0 2.5 0.0 2. 16.0 6.5 3. 1. 0.0 0. 1. + 8379. 1. 3. 42.0 23.0 3.0 3. 14.0 20.0 2. 2. 0.0 0. 1. + 8385. 1. 4. 22.0 0.5 0.0 3. 16.0 6.5 3. 4. 0.0 0. 1. + 8388. 1. 5. 32.0 9.0 2.0 1. 16.0 40.0 5. 5. 0.0 0. 1. + 8398. 1. 5. 37.0 0.5 0.0 2. 17.0 14.0 4. 2. 0.0 0. 1. + 8402. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 3. 5. 0.0 0. 1. + 8403. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 8405. 1. 5. 42.0 23.0 4.0 3. 12.0 9.0 2. 4. 0.0 0. 1. + 8406. 1. 5. 32.0 6.0 2.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 8409. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 8410. 1. 5. 22.0 2.5 1.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 8411. 1. 5. 27.0 13.0 1.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 8412. 1. 5. 27.0 6.0 2.0 2. 17.0 20.0 4. 3. 0.0 0. 1. + 8414. 1. 4. 22.0 2.5 0.0 3. 16.0 14.0 3. 2. 0.0 0. 1. + 8417. 1. 5. 27.0 6.0 0.0 1. 14.0 9.0 2. 1. 0.0 0. 1. + 8418. 1. 4. 42.0 23.0 5.5 3. 14.0 9.0 5. 4. 0.0 0. 1. + 8425. 1. 3. 17.5 2.5 1.0 2. 12.0 9.0 2. 4. 0.0 0. 1. + 8426. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 1. 1. 0.0 0. 1. + 8428. 1. 5. 22.0 0.5 0.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 8429. 1. 3. 27.0 2.5 1.0 1. 12.0 6.5 2. 2. 0.0 0. 1. + 8438. 1. 5. 17.5 2.5 0.0 3. 14.0 6.5 2. 3. 0.0 0. 1. + 8441. 1. 5. 37.0 16.5 3.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 8449. 1. 4. 27.0 6.0 2.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 8450. 1. 3. 42.0 23.0 3.0 2. 14.0 11.5 5. 4. 0.0 0. 1. + 8453. 1. 4. 22.0 2.5 0.0 3. 12.0 6.5 3. 2. 0.0 0. 1. + 8455. 1. 5. 22.0 0.5 0.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 8459. 1. 3. 27.0 9.0 3.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 8469. 1. 3. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 8470. 1. 4. 22.0 2.5 0.0 1. 17.0 6.5 4. 1. 0.0 0. 1. + 8471. 1. 3. 22.0 2.5 2.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 8481. 1. 3. 42.0 23.0 2.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 8486. 1. 4. 22.0 2.5 2.0 2. 14.0 6.5 2. 2. 0.0 0. 1. + 8488. 1. 5. 17.5 2.5 1.0 3. 12.0 6.5 5. 5. 0.0 0. 1. + 8499. 1. 5. 22.0 0.5 0.0 1. 16.0 14.0 4. 2. 0.0 0. 1. + 8503. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 3. 0.0 0. 1. + 8506. 1. 4. 27.0 6.0 1.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 8515. 1. 4. 27.0 2.5 0.0 1. 14.0 6.5 4. 1. 0.0 0. 1. + 8522. 1. 5. 22.0 2.5 0.0 3. 17.0 14.0 4. 2. 0.0 0. 1. + 8530. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 2. 5. 0.0 0. 1. + 8532. 1. 5. 22.0 2.5 0.0 1. 16.0 14.0 3. 2. 0.0 0. 1. + 8533. 1. 4. 32.0 13.0 2.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 8535. 1. 5. 22.0 0.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 8544. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 8553. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 2. 4. 0.0 0. 1. + 8566. 1. 5. 22.0 2.5 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 8572. 1. 5. 27.0 2.5 0.0 1. 12.0 14.0 3. 2. 0.0 0. 1. + 8578. 1. 3. 27.0 6.0 1.0 3. 12.0 14.0 4. 4. 0.0 0. 1. + 8581. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 8590. 1. 4. 32.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 8594. 1. 4. 27.0 6.0 0.0 1. 17.0 11.5 4. 5. 0.0 0. 1. + 8603. 1. 4. 22.0 2.5 0.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 8606. 1. 5. 27.0 6.0 0.0 2. 16.0 20.0 3. 4. 0.0 0. 1. + 8611. 1. 4. 27.0 6.0 0.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 8616. 1. 3. 32.0 16.5 2.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 8619. 1. 4. 22.0 2.5 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 8622. 1. 5. 27.0 6.0 2.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 8623. 1. 3. 27.0 9.0 1.0 3. 14.0 14.0 1. 4. 0.0 0. 1. + 8628. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 8630. 1. 5. 22.0 2.5 0.0 4. 16.0 20.0 3. 5. 0.0 0. 1. + 8632. 1. 5. 27.0 2.5 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 8638. 1. 1. 37.0 13.0 5.5 3. 12.0 4.0 2. 4. 0.0 0. 1. + 8640. 1. 4. 27.0 6.0 2.0 1. 12.0 11.5 3. 5. 0.0 0. 1. + 8644. 1. 3. 22.0 2.5 0.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 8649. 1. 4. 22.0 2.5 0.0 4. 16.0 11.5 3. 2. 0.0 0. 1. + 8651. 1. 4. 27.0 13.0 2.0 2. 12.0 11.5 4. 4. 0.0 0. 1. + 8654. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 4. 4. 0.0 0. 1. + 8655. 1. 4. 27.0 2.5 0.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 8668. 1. 2. 22.0 2.5 0.0 1. 12.0 11.5 3. 4. 0.0 0. 1. + 8672. 1. 5. 22.0 2.5 0.0 1. 16.0 11.5 3. 1. 0.0 0. 1. + 8678. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 8680. 1. 4. 27.0 2.5 0.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 8682. 1. 5. 22.0 0.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 8686. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 8689. 1. 3. 22.0 2.5 0.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 8693. 1. 5. 37.0 16.5 2.0 4. 14.0 40.0 4. 6. 0.0 0. 1. + 8694. 1. 5. 22.0 0.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 8696. 1. 5. 32.0 9.0 1.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 8705. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 3. 3. 0.0 0. 1. + 8708. 1. 5. 22.0 2.5 1.0 3. 14.0 14.0 4. 4. 0.0 0. 1. + 8710. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 5. 3. 0.0 0. 1. + 8713. 1. 4. 27.0 9.0 3.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 8715. 1. 2. 22.0 2.5 0.0 4. 16.0 14.0 4. 4. 0.0 0. 1. + 8718. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 4. 2. 0.0 0. 1. + 8720. 1. 5. 27.0 2.5 1.0 1. 16.0 40.0 4. 6. 0.0 0. 1. + 8721. 1. 4. 37.0 16.5 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 8723. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 8739. 1. 3. 22.0 2.5 0.0 1. 12.0 14.0 4. 4. 0.0 0. 1. + 8742. 1. 4. 32.0 9.0 3.0 2. 20.0 20.0 4. 6. 0.0 0. 1. + 8748. 1. 4. 42.0 23.0 3.0 4. 12.0 9.0 4. 2. 0.0 0. 1. + 8762. 1. 1. 32.0 2.5 1.0 1. 20.0 40.0 4. 4. 0.0 0. 1. + 8764. 1. 5. 22.0 6.0 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 8765. 1. 4. 27.0 6.0 1.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 8766. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 4. 2. 0.0 0. 1. + 8767. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 4. 4. 0.0 0. 1. + 8772. 1. 3. 32.0 13.0 2.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 8773. 1. 5. 37.0 23.0 3.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 8776. 1. 5. 22.0 9.0 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 8777. 1. 5. 27.0 6.0 0.0 3. 14.0 20.0 5. 2. 0.0 0. 1. + 8779. 1. 3. 37.0 16.5 3.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 8783. 1. 5. 27.0 6.0 0.0 3. 17.0 6.5 3. 1. 0.0 0. 1. + 8786. 1. 5. 17.5 0.5 0.0 4. 12.0 9.0 2. 2. 0.0 0. 1. + 8789. 1. 5. 27.0 2.5 0.0 4. 17.0 11.5 4. 2. 0.0 0. 1. + 8791. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 5. 4. 0.0 0. 1. + 8794. 1. 3. 22.0 2.5 0.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 8801. 1. 5. 22.0 2.5 1.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 8806. 1. 4. 27.0 2.5 0.0 2. 16.0 40.0 5. 4. 0.0 0. 1. + 8807. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 8810. 1. 5. 22.0 0.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 8818. 1. 4. 22.0 2.5 1.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 8819. 1. 4. 32.0 6.0 2.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 8820. 1. 4. 42.0 16.5 3.0 3. 20.0 20.0 6. 6. 0.0 0. 1. + 8821. 1. 3. 27.0 2.5 1.0 2. 17.0 14.0 4. 3. 0.0 0. 1. + 8828. 1. 2. 42.0 23.0 2.0 3. 14.0 40.0 3. 4. 0.0 0. 1. + 8830. 1. 5. 27.0 9.0 1.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 8831. 1. 5. 22.0 2.5 0.0 4. 17.0 6.5 4. 4. 0.0 0. 1. + 8838. 1. 4. 32.0 16.5 4.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 8843. 1. 4. 32.0 6.0 0.0 1. 14.0 20.0 4. 5. 0.0 0. 1. + 8844. 1. 5. 27.0 6.0 1.0 1. 20.0 20.0 6. 6. 0.0 0. 1. + 8846. 1. 4. 37.0 13.0 2.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 8854. 1. 4. 27.0 9.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 8855. 1. 5. 27.0 9.0 3.0 1. 12.0 9.0 2. 2. 0.0 0. 1. + 8858. 1. 4. 32.0 9.0 2.0 2. 12.0 20.0 5. 3. 0.0 0. 1. + 8862. 1. 5. 42.0 23.0 3.0 3. 12.0 20.0 5. 3. 0.0 0. 1. + 8864. 1. 3. 37.0 23.0 3.0 3. 14.0 40.0 4. 6. 0.0 0. 1. + 8868. 1. 4. 27.0 2.5 0.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 8871. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 5. 4. 0.0 0. 1. + 8874. 1. 4. 42.0 13.0 0.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 8875. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 8877. 1. 5. 22.0 2.5 0.0 4. 16.0 40.0 3. 1. 0.0 0. 1. + 8888. 1. 5. 37.0 16.5 1.0 3. 12.0 40.0 3. 5. 0.0 0. 1. + 8894. 1. 3. 32.0 13.0 3.0 2. 9.0 14.0 2. 5. 0.0 0. 1. + 8908. 1. 3. 27.0 6.0 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 8918. 1. 5. 27.0 2.5 1.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 8919. 1. 4. 37.0 16.5 3.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 8921. 1. 5. 22.0 2.5 0.0 4. 14.0 6.5 3. 2. 0.0 0. 1. + 8926. 1. 4. 37.0 16.5 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 8927. 1. 2. 32.0 6.0 0.0 3. 14.0 11.5 2. 2. 0.0 0. 1. + 8928. 1. 4. 27.0 9.0 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 8937. 1. 3. 32.0 9.0 1.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 8941. 1. 5. 22.0 6.0 2.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 8942. 1. 3. 27.0 13.0 3.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 8945. 1. 5. 22.0 2.5 0.0 1. 14.0 40.0 3. 4. 0.0 0. 1. + 8948. 1. 5. 37.0 16.5 3.0 3. 12.0 40.0 3. 5. 0.0 0. 1. + 8950. 1. 5. 27.0 2.5 1.0 3. 16.0 20.0 5. 3. 0.0 0. 1. + 8953. 1. 5. 32.0 13.0 3.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 8955. 1. 5. 37.0 23.0 3.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 8968. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 8977. 1. 3. 22.0 2.5 0.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 8982. 1. 4. 37.0 23.0 3.0 1. 9.0 14.0 3. 4. 0.0 0. 1. + 8986. 1. 4. 37.0 23.0 2.0 2. 14.0 11.5 5. 4. 0.0 0. 1. + 8989. 1. 3. 37.0 23.0 2.0 4. 14.0 20.0 3. 3. 0.0 0. 1. + 8991. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 8996. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 8997. 1. 5. 32.0 9.0 2.0 1. 17.0 11.5 4. 5. 0.0 0. 1. + 9000. 1. 5. 32.0 13.0 2.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 9002. 1. 3. 42.0 23.0 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 9014. 1. 2. 32.0 6.0 2.0 2. 16.0 11.5 4. 2. 0.0 0. 1. + 9018. 1. 5. 17.5 2.5 0.0 3. 12.0 6.5 4. 1. 0.0 0. 1. + 9020. 1. 5. 42.0 16.5 2.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 9021. 1. 5. 27.0 6.0 2.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 9023. 1. 5. 37.0 16.5 3.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 9026. 1. 5. 32.0 9.0 1.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 9029. 1. 4. 42.0 23.0 4.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 9030. 1. 4. 42.0 23.0 5.5 4. 20.0 20.0 4. 6. 0.0 0. 1. + 9031. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 9035. 1. 3. 27.0 9.0 1.0 3. 12.0 20.0 5. 4. 0.0 0. 1. + 9040. 1. 5. 22.0 0.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 9043. 1. 5. 37.0 13.0 1.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 9048. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 9049. 1. 2. 32.0 9.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 9055. 1. 4. 22.0 6.0 0.0 4. 14.0 9.0 3. 5. 0.0 0. 1. + 9062. 1. 4. 22.0 2.5 0.0 3. 14.0 6.5 4. 2. 0.0 0. 1. + 9069. 1. 5. 27.0 6.0 1.0 3. 16.0 14.0 3. 4. 0.0 0. 1. + 9071. 1. 4. 22.0 2.5 0.0 1. 17.0 20.0 4. 5. 0.0 0. 1. + 9072. 1. 4. 32.0 13.0 2.0 4. 17.0 20.0 5. 5. 0.0 0. 1. + 9086. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 9087. 1. 5. 37.0 23.0 3.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 9091. 1. 2. 37.0 16.5 2.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 9094. 1. 4. 27.0 6.0 2.0 3. 14.0 14.0 3. 3. 0.0 0. 1. + 9096. 1. 5. 27.0 2.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 9097. 1. 5. 42.0 23.0 2.0 4. 12.0 11.5 3. 2. 0.0 0. 1. + 9100. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 9101. 1. 5. 32.0 13.0 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 9107. 1. 5. 37.0 13.0 2.0 4. 20.0 40.0 4. 5. 0.0 0. 1. + 9112. 1. 3. 27.0 6.0 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 9114. 1. 3. 22.0 6.0 2.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 9115. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 2. 3. 0.0 0. 1. + 9116. 1. 5. 22.0 2.5 1.0 2. 14.0 9.0 2. 2. 0.0 0. 1. + 9118. 1. 2. 17.5 2.5 2.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 9120. 1. 5. 27.0 2.5 0.0 3. 14.0 40.0 3. 3. 0.0 0. 1. + 9121. 1. 5. 22.0 0.5 0.0 2. 16.0 11.5 4. 5. 0.0 0. 1. + 9122. 1. 5. 27.0 2.5 1.0 2. 12.0 6.5 2. 4. 0.0 0. 1. + 9126. 1. 2. 22.0 2.5 2.0 3. 12.0 9.0 2. 4. 0.0 0. 1. + 9127. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 9130. 1. 5. 42.0 16.5 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 9135. 1. 5. 32.0 6.0 0.0 1. 16.0 9.0 6. 1. 0.0 0. 1. + 9136. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 5. 2. 0.0 0. 1. + 9138. 1. 5. 37.0 16.5 2.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 9145. 1. 4. 27.0 6.0 1.0 4. 14.0 11.5 4. 4. 0.0 0. 1. + 9147. 1. 5. 27.0 6.0 1.0 2. 16.0 14.0 3. 5. 0.0 0. 1. + 9153. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 5. 6. 0.0 0. 1. + 9155. 1. 5. 42.0 23.0 1.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 9157. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 9159. 1. 4. 42.0 23.0 3.0 4. 12.0 20.0 5. 2. 0.0 0. 1. + 9165. 1. 5. 42.0 23.0 3.0 4. 12.0 11.5 3. 3. 0.0 0. 1. + 9168. 1. 5. 32.0 16.5 3.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 9170. 1. 4. 22.0 6.0 1.0 1. 12.0 9.0 3. 2. 0.0 0. 1. + 9171. 1. 5. 42.0 23.0 4.0 3. 20.0 40.0 6. 6. 0.0 0. 1. + 9173. 1. 5. 17.5 0.5 0.0 3. 14.0 6.5 3. 5. 0.0 0. 1. + 9174. 1. 5. 27.0 2.5 0.0 1. 14.0 40.0 2. 6. 0.0 0. 1. + 9181. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 9186. 1. 5. 32.0 6.0 1.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 9187. 1. 5. 22.0 0.5 0.0 3. 17.0 20.0 6. 2. 0.0 0. 1. + 9189. 1. 2. 37.0 16.5 2.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 9190. 1. 5. 27.0 9.0 2.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 9191. 1. 4. 27.0 2.5 0.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 9193. 1. 4. 27.0 13.0 1.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 9198. 1. 3. 42.0 23.0 3.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 9199. 1. 5. 27.0 6.0 1.0 1. 14.0 14.0 4. 5. 0.0 0. 1. + 9200. 1. 5. 27.0 6.0 0.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 9202. 1. 2. 22.0 6.0 1.0 1. 12.0 11.5 3. 2. 0.0 0. 1. + 9214. 1. 5. 37.0 16.5 4.0 3. 14.0 11.5 2. 3. 0.0 0. 1. + 9215. 1. 4. 27.0 9.0 2.0 3. 20.0 40.0 4. 5. 0.0 0. 1. + 9218. 1. 5. 17.5 0.5 0.0 4. 12.0 6.5 2. 4. 0.0 0. 1. + 9219. 1. 5. 42.0 23.0 3.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 9220. 1. 5. 37.0 16.5 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 9222. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 4. 4. 0.0 0. 1. + 9232. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 9245. 1. 3. 22.0 2.5 0.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 9254. 1. 3. 42.0 23.0 3.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 9255. 1. 4. 27.0 6.0 0.0 2. 16.0 20.0 5. 6. 0.0 0. 1. + 9256. 1. 5. 42.0 23.0 3.0 3. 16.0 20.0 2. 3. 0.0 0. 1. + 9258. 1. 5. 27.0 9.0 2.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 9265. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 3. 4. 0.0 0. 1. + 9274. 1. 2. 27.0 6.0 1.0 3. 16.0 14.0 4. 2. 0.0 0. 1. + 9275. 1. 5. 27.0 6.0 0.0 2. 17.0 20.0 4. 2. 0.0 0. 1. + 9278. 1. 3. 22.0 2.5 0.0 4. 17.0 20.0 4. 2. 0.0 0. 1. + 9279. 1. 4. 37.0 16.5 3.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 9286. 1. 3. 22.0 2.5 1.0 3. 16.0 20.0 4. 3. 0.0 0. 1. + 9288. 1. 4. 32.0 9.0 1.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 9293. 1. 5. 27.0 6.0 2.0 1. 12.0 14.0 3. 5. 0.0 0. 1. + 9304. 1. 5. 27.0 6.0 0.0 3. 16.0 20.0 5. 4. 0.0 0. 1. + 9308. 1. 5. 22.0 6.0 1.0 4. 14.0 14.0 3. 3. 0.0 0. 1. + 9314. 1. 4. 32.0 0.5 0.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 9316. 1. 5. 32.0 2.5 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 9317. 1. 4. 22.0 0.5 0.0 4. 14.0 6.5 3. 2. 0.0 0. 1. + 9319. 1. 4. 37.0 6.0 0.0 4. 12.0 11.5 3. 2. 0.0 0. 1. + 9320. 1. 2. 22.0 6.0 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 9323. 1. 5. 37.0 13.0 1.0 2. 12.0 14.0 5. 5. 0.0 0. 1. + 9331. 1. 4. 32.0 9.0 0.0 1. 12.0 40.0 3. 4. 0.0 0. 1. + 9333. 1. 5. 22.0 0.5 0.0 2. 14.0 14.0 3. 2. 0.0 0. 1. + 9336. 1. 5. 27.0 2.5 0.0 1. 16.0 20.0 5. 5. 0.0 0. 1. + 9342. 1. 5. 32.0 2.5 0.0 2. 16.0 40.0 5. 5. 0.0 0. 1. + 9344. 1. 4. 27.0 6.0 1.0 4. 14.0 11.5 4. 4. 0.0 0. 1. + 9345. 1. 5. 27.0 2.5 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 9350. 1. 4. 37.0 13.0 2.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 9351. 1. 4. 22.0 2.5 0.0 3. 17.0 20.0 5. 4. 0.0 0. 1. + 9353. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 9357. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 9360. 1. 4. 32.0 13.0 2.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 9361. 1. 4. 22.0 2.5 0.0 2. 16.0 9.0 4. 6. 0.0 0. 1. + 9362. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 2. 4. 0.0 0. 1. + 9363. 1. 3. 22.0 0.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 9365. 1. 5. 37.0 16.5 4.0 4. 12.0 20.0 3. 5. 0.0 0. 1. + 9372. 1. 4. 22.0 6.0 1.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 9376. 1. 5. 37.0 16.5 1.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 9377. 1. 4. 27.0 6.0 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 9378. 1. 5. 32.0 16.5 2.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 9379. 1. 5. 42.0 23.0 4.0 4. 20.0 40.0 4. 6. 0.0 0. 1. + 9382. 1. 5. 27.0 2.5 0.0 1. 20.0 20.0 5. 4. 0.0 0. 1. + 9385. 1. 5. 22.0 2.5 2.0 3. 16.0 6.5 3. 1. 0.0 0. 1. + 9387. 1. 4. 42.0 16.5 2.0 4. 20.0 20.0 4. 6. 0.0 0. 1. + 9394. 1. 4. 27.0 9.0 0.0 2. 12.0 20.0 5. 5. 0.0 0. 1. + 9398. 1. 4. 27.0 2.5 1.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 9403. 1. 4. 27.0 2.5 0.0 3. 17.0 20.0 5. 5. 0.0 0. 1. + 9408. 1. 5. 27.0 2.5 0.0 2. 16.0 11.5 3. 3. 0.0 0. 1. + 9411. 1. 4. 37.0 13.0 2.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 9413. 1. 5. 32.0 13.0 2.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 9415. 1. 4. 37.0 16.5 4.0 3. 16.0 20.0 4. 3. 0.0 0. 1. + 9417. 1. 4. 27.0 6.0 1.0 3. 20.0 20.0 4. 6. 0.0 0. 1. + 9418. 1. 3. 27.0 13.0 3.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 9425. 1. 4. 22.0 2.5 1.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 9427. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 9429. 1. 5. 37.0 16.5 1.0 3. 16.0 14.0 3. 4. 0.0 0. 1. + 9433. 1. 3. 42.0 23.0 3.0 2. 16.0 40.0 4. 2. 0.0 0. 1. + 9435. 1. 3. 22.0 2.5 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 9436. 1. 2. 27.0 2.5 1.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 9437. 1. 5. 27.0 6.0 3.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 9440. 1. 5. 27.0 0.5 0.0 2. 16.0 20.0 5. 6. 0.0 0. 1. + 9447. 1. 4. 32.0 2.5 0.0 3. 14.0 40.0 3. 6. 0.0 0. 1. + 9448. 1. 4. 27.0 6.0 0.0 3. 14.0 11.5 4. 5. 0.0 0. 1. + 9449. 1. 4. 37.0 13.0 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 9450. 1. 4. 42.0 23.0 3.0 3. 14.0 40.0 4. 6. 0.0 0. 1. + 9451. 1. 4. 27.0 9.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 9453. 1. 5. 37.0 2.5 0.0 2. 16.0 40.0 4. 3. 0.0 0. 1. + 9474. 1. 5. 27.0 6.0 1.0 2. 16.0 40.0 5. 6. 0.0 0. 1. + 9476. 1. 5. 32.0 2.5 1.0 3. 17.0 20.0 3. 5. 0.0 0. 1. + 9479. 1. 4. 42.0 16.5 2.0 2. 12.0 40.0 3. 5. 0.0 0. 1. + 9484. 1. 4. 22.0 2.5 0.0 3. 16.0 6.5 3. 4. 0.0 0. 1. + 9487. 1. 5. 32.0 13.0 1.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 9488. 1. 5. 27.0 2.5 0.0 2. 20.0 20.0 4. 5. 0.0 0. 1. + 9489. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 9492. 1. 5. 42.0 23.0 2.0 3. 16.0 40.0 4. 4. 0.0 0. 1. + 9495. 1. 4. 42.0 23.0 4.0 3. 20.0 40.0 4. 4. 0.0 0. 1. + 9501. 1. 5. 27.0 6.0 1.0 1. 16.0 14.0 1. 6. 0.0 0. 1. + 9504. 1. 5. 27.0 0.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 9507. 1. 5. 27.0 9.0 3.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 9509. 1. 4. 42.0 23.0 4.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 9512. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 3. 4. 0.0 0. 1. + 9514. 1. 5. 27.0 9.0 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 9529. 1. 4. 22.0 0.5 0.0 2. 16.0 20.0 5. 4. 0.0 0. 1. + 9530. 1. 4. 27.0 2.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 9534. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 9545. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 4. 4. 0.0 0. 1. + 9548. 1. 5. 22.0 2.5 0.0 1. 16.0 9.0 3. 5. 0.0 0. 1. + 9551. 1. 4. 42.0 23.0 3.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 9552. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 9562. 1. 4. 22.0 2.5 0.0 2. 17.0 6.5 3. 1. 0.0 0. 1. + 9563. 1. 5. 42.0 23.0 3.0 2. 12.0 40.0 3. 5. 0.0 0. 1. + 9567. 1. 5. 27.0 9.0 3.0 3. 14.0 11.5 2. 3. 0.0 0. 1. + 9570. 1. 3. 32.0 13.0 1.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 9573. 1. 5. 32.0 9.0 2.0 4. 20.0 20.0 5. 5. 0.0 0. 1. + 9575. 1. 3. 27.0 2.5 0.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 9582. 1. 4. 27.0 6.0 1.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 9585. 1. 4. 32.0 6.0 2.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 9588. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 4. 3. 0.0 0. 1. + 9589. 1. 5. 32.0 13.0 2.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 9594. 1. 4. 22.0 0.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 9599. 1. 3. 22.0 2.5 1.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 9600. 1. 2. 42.0 23.0 2.0 2. 20.0 40.0 4. 2. 0.0 0. 1. + 9611. 1. 4. 22.0 2.5 1.0 4. 12.0 9.0 3. 4. 0.0 0. 1. + 9615. 1. 4. 42.0 23.0 4.0 4. 16.0 40.0 4. 5. 0.0 0. 1. + 9616. 1. 3. 37.0 16.5 4.0 1. 12.0 40.0 3. 5. 0.0 0. 1. + 9624. 1. 4. 22.0 2.5 0.0 3. 14.0 6.5 5. 1. 0.0 0. 1. + 9633. 1. 1. 17.5 0.5 0.0 2. 9.0 6.5 2. 2. 0.0 0. 1. + 9642. 1. 4. 27.0 2.5 0.0 2. 20.0 20.0 6. 5. 0.0 0. 1. + 9647. 1. 4. 27.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 9654. 1. 3. 27.0 6.0 2.0 3. 12.0 9.0 3. 5. 0.0 0. 1. + 9662. 1. 5. 32.0 13.0 5.5 3. 14.0 20.0 4. 3. 0.0 0. 1. + 9672. 1. 5. 42.0 23.0 3.0 2. 12.0 20.0 5. 5. 0.0 0. 1. + 9681. 1. 4. 32.0 6.0 1.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 9682. 1. 4. 37.0 16.5 1.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 9685. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 9687. 1. 4. 37.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 9695. 1. 5. 22.0 2.5 0.0 3. 12.0 6.5 2. 3. 0.0 0. 1. + 9698. 1. 4. 22.0 0.5 0.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 9711. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 9716. 1. 5. 42.0 23.0 4.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 9717. 1. 2. 22.0 2.5 1.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 9718. 1. 4. 32.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 9720. 1. 1. 32.0 13.0 2.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 9729. 1. 5. 27.0 2.5 0.0 2. 14.0 14.0 4. 6. 0.0 0. 1. + 9738. 1. 4. 22.0 6.0 2.0 3. 12.0 6.5 5. 3. 0.0 0. 1. + 9739. 1. 4. 17.5 2.5 1.0 3. 9.0 9.0 2. 2. 0.0 0. 1. + 9740. 1. 4. 22.0 2.5 0.0 2. 17.0 11.5 4. 2. 0.0 0. 1. + 9741. 1. 5. 37.0 16.5 3.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 9744. 1. 4. 27.0 6.0 2.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 9746. 1. 4. 42.0 23.0 3.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 9748. 1. 3. 22.0 2.5 0.0 2. 16.0 40.0 4. 4. 0.0 0. 1. + 9751. 1. 2. 37.0 16.5 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 9752. 1. 4. 27.0 2.5 0.0 2. 16.0 20.0 5. 5. 0.0 0. 1. + 9753. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 4. 2. 0.0 0. 1. + 9755. 1. 5. 27.0 6.0 2.0 3. 16.0 11.5 3. 4. 0.0 0. 1. + 9761. 1. 5. 37.0 13.0 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 9763. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 2. 2. 0.0 0. 1. + 9764. 1. 4. 22.0 2.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 9765. 1. 3. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 9772. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 9775. 1. 3. 27.0 6.0 1.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 9778. 1. 4. 22.0 2.5 0.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 9786. 1. 3. 22.0 2.5 0.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 9789. 1. 5. 37.0 16.5 2.0 3. 17.0 20.0 3. 5. 0.0 0. 1. + 9792. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 9793. 1. 4. 37.0 13.0 2.0 4. 16.0 20.0 5. 5. 0.0 0. 1. + 9794. 1. 5. 32.0 13.0 3.0 3. 17.0 20.0 4. 3. 0.0 0. 1. + 9796. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 4. 5. 0.0 0. 1. + 9800. 1. 5. 22.0 0.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 9826. 1. 5. 22.0 2.5 0.0 4. 16.0 20.0 3. 5. 0.0 0. 1. + 9834. 1. 5. 17.5 2.5 0.0 3. 16.0 40.0 4. 2. 0.0 0. 1. + 9837. 1. 5. 22.0 6.0 1.0 4. 12.0 9.0 2. 4. 0.0 0. 1. + 9839. 1. 5. 27.0 6.0 2.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 9843. 1. 4. 37.0 16.5 2.0 4. 14.0 9.0 4. 6. 0.0 0. 1. + 9845. 1. 5. 22.0 6.0 1.0 3. 12.0 9.0 2. 5. 0.0 0. 1. + 9850. 1. 4. 17.5 0.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 9854. 1. 4. 22.0 2.5 0.0 4. 14.0 9.0 3. 4. 0.0 0. 1. + 9855. 1. 2. 22.0 2.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 9859. 1. 4. 27.0 6.0 1.0 4. 20.0 14.0 4. 5. 0.0 0. 1. + 9861. 1. 5. 22.0 0.5 0.0 3. 16.0 9.0 3. 1. 0.0 0. 1. + 9870. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 9880. 1. 4. 42.0 23.0 3.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 9881. 1. 4. 22.0 2.5 1.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 9882. 1. 5. 27.0 6.0 0.0 2. 17.0 11.5 4. 5. 0.0 0. 1. + 9886. 1. 5. 22.0 2.5 0.0 3. 17.0 11.5 5. 5. 0.0 0. 1. + 9887. 1. 4. 22.0 2.5 0.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 9892. 1. 5. 27.0 6.0 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 9895. 1. 5. 27.0 2.5 1.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 9899. 1. 5. 42.0 23.0 5.5 4. 14.0 11.5 4. 2. 0.0 0. 1. + 9907. 1. 5. 32.0 13.0 1.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 9908. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 9909. 1. 3. 22.0 2.5 0.0 4. 12.0 14.0 5. 5. 0.0 0. 1. + 9912. 1. 5. 22.0 2.5 1.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 9919. 1. 5. 32.0 16.5 3.0 4. 17.0 40.0 4. 6. 0.0 0. 1. + 9920. 1. 5. 42.0 23.0 4.0 3. 20.0 40.0 4. 6. 0.0 0. 1. + 9921. 1. 5. 22.0 2.5 0.0 4. 12.0 9.0 3. 5. 0.0 0. 1. + 9923. 1. 4. 42.0 23.0 3.0 4. 14.0 40.0 5. 2. 0.0 0. 1. + 9926. 1. 5. 27.0 6.0 0.0 2. 17.0 40.0 4. 6. 0.0 0. 1. + 9927. 1. 4. 27.0 2.5 1.0 3. 20.0 11.5 4. 4. 0.0 0. 1. + 9928. 1. 5. 32.0 13.0 3.0 4. 14.0 14.0 4. 3. 0.0 0. 1. + 9929. 1. 4. 22.0 2.5 1.0 4. 14.0 9.0 4. 4. 0.0 0. 1. + 9935. 1. 4. 32.0 13.0 2.0 3. 14.0 20.0 2. 5. 0.0 0. 1. + 9936. 1. 4. 17.5 2.5 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 9939. 1. 3. 22.0 2.5 0.0 3. 16.0 6.5 4. 1. 0.0 0. 1. + 9940. 1. 5. 27.0 6.0 1.0 3. 14.0 6.5 6. 4. 0.0 0. 1. + 9941. 1. 5. 27.0 9.0 2.0 4. 14.0 14.0 3. 3. 0.0 0. 1. + 9946. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 5. 5. 0.0 0. 1. + 9947. 1. 4. 27.0 9.0 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 9955. 1. 5. 32.0 9.0 2.0 2. 20.0 20.0 4. 3. 0.0 0. 1. + 9958. 1. 5. 42.0 23.0 5.5 4. 12.0 6.5 4. 2. 0.0 0. 1. + 9964. 1. 4. 27.0 6.0 1.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 9970. 1. 4. 27.0 6.0 1.0 3. 17.0 40.0 4. 6. 0.0 0. 1. + 9974. 1. 4. 27.0 6.0 0.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 9976. 1. 5. 27.0 2.5 0.0 4. 17.0 4.0 4. 1. 0.0 0. 1. + 9978. 1. 4. 42.0 13.0 0.0 3. 20.0 40.0 4. 5. 0.0 0. 1. + 9979. 1. 5. 22.0 2.5 1.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 9984. 1. 4. 17.5 2.5 0.0 3. 14.0 9.0 3. 3. 0.0 0. 1. + 9987. 1. 4. 22.0 6.0 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 9989. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 9992. 1. 5. 27.0 6.0 2.0 2. 14.0 11.5 3. 3. 0.0 0. 1. + 9993. 1. 3. 27.0 6.0 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 9996. 1. 5. 22.0 0.5 0.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 9997. 1. 5. 37.0 16.5 4.0 3. 12.0 40.0 2. 2. 0.0 0. 1. + 10004. 1. 4. 22.0 2.5 2.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 10011. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 10013. 1. 5. 27.0 2.5 0.0 1. 16.0 14.0 4. 5. 0.0 0. 1. + 10018. 1. 5. 27.0 6.0 0.0 2. 16.0 40.0 4. 3. 0.0 0. 1. + 10021. 1. 4. 27.0 2.5 0.0 2. 20.0 14.0 6. 4. 0.0 0. 1. + 10028. 1. 4. 22.0 6.0 2.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 10029. 1. 4. 22.0 2.5 0.0 1. 12.0 14.0 3. 5. 0.0 0. 1. + 10034. 1. 4. 17.5 2.5 0.0 2. 14.0 9.0 4. 4. 0.0 0. 1. + 10052. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 10053. 1. 5. 22.0 0.5 0.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 10061. 1. 3. 32.0 2.5 0.0 3. 17.0 20.0 4. 3. 0.0 0. 1. + 10072. 1. 5. 22.0 2.5 0.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 10075. 1. 4. 22.0 6.0 0.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 10076. 1. 3. 22.0 0.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 10094. 1. 4. 17.5 0.5 0.0 3. 12.0 9.0 2. 4. 0.0 0. 1. + 10108. 1. 3. 32.0 16.5 3.0 3. 12.0 20.0 4. 5. 0.0 0. 1. + 10109. 1. 5. 22.0 2.5 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 10112. 1. 5. 22.0 2.5 0.0 4. 12.0 11.5 3. 4. 0.0 0. 1. + 10113. 1. 5. 22.0 6.0 2.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 10120. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 5. 1. 0.0 0. 1. + 10131. 1. 5. 22.0 2.5 0.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 10132. 1. 5. 27.0 6.0 0.0 4. 12.0 11.5 3. 2. 0.0 0. 1. + 10135. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 3. 6. 0.0 0. 1. + 10136. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 10138. 1. 3. 37.0 16.5 1.0 3. 14.0 14.0 2. 5. 0.0 0. 1. + 10143. 1. 4. 32.0 13.0 2.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 10153. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 2. 5. 0.0 0. 1. + 10155. 1. 4. 27.0 9.0 1.0 1. 12.0 11.5 3. 2. 0.0 0. 1. + 10159. 1. 5. 42.0 23.0 2.0 3. 20.0 40.0 4. 6. 0.0 0. 1. + 10161. 1. 5. 22.0 2.5 1.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 10162. 1. 5. 42.0 23.0 4.0 3. 12.0 40.0 4. 5. 0.0 0. 1. + 10169. 1. 3. 27.0 9.0 2.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 10173. 1. 2. 32.0 13.0 4.0 3. 14.0 20.0 3. 3. 0.0 0. 1. + 10174. 1. 4. 22.0 6.0 0.0 2. 14.0 40.0 3. 5. 0.0 0. 1. + 10176. 1. 5. 22.0 2.5 0.0 1. 17.0 14.0 2. 5. 0.0 0. 1. + 10177. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 5. 2. 0.0 0. 1. + 10180. 1. 4. 22.0 2.5 1.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 10181. 1. 5. 27.0 6.0 1.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 10182. 1. 4. 27.0 6.0 1.0 1. 16.0 14.0 4. 4. 0.0 0. 1. + 10184. 1. 3. 22.0 2.5 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 10189. 1. 5. 32.0 6.0 0.0 3. 20.0 20.0 6. 6. 0.0 0. 1. + 10191. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 3. 2. 0.0 0. 1. + 10195. 1. 5. 17.5 0.5 0.0 3. 12.0 11.5 2. 5. 0.0 0. 1. + 10196. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 10200. 1. 4. 42.0 23.0 2.0 3. 20.0 20.0 4. 2. 0.0 0. 1. + 10205. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 10208. 1. 5. 22.0 6.0 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 10209. 1. 5. 22.0 0.5 0.0 3. 16.0 14.0 3. 4. 0.0 0. 1. + 10210. 1. 4. 22.0 0.5 0.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 10211. 1. 4. 22.0 2.5 0.0 4. 12.0 9.0 4. 4. 0.0 0. 1. + 10221. 1. 5. 27.0 2.5 1.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 10223. 1. 5. 22.0 6.0 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 10225. 1. 4. 22.0 2.5 0.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 10226. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 10227. 1. 5. 32.0 13.0 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 10231. 1. 4. 27.0 9.0 2.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 10234. 1. 4. 27.0 9.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 10240. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 6. 5. 0.0 0. 1. + 10243. 1. 4. 32.0 13.0 1.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 10247. 1. 3. 37.0 16.5 3.0 3. 14.0 40.0 4. 4. 0.0 0. 1. + 10248. 1. 3. 22.0 2.5 1.0 3. 16.0 11.5 6. 4. 0.0 0. 1. + 10255. 1. 5. 27.0 16.5 3.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 10258. 1. 5. 42.0 23.0 2.0 3. 12.0 11.5 5. 5. 0.0 0. 1. + 10262. 1. 5. 27.0 0.5 0.0 4. 12.0 20.0 3. 6. 0.0 0. 1. + 10263. 1. 5. 32.0 16.5 2.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 10270. 1. 5. 37.0 16.5 1.0 4. 12.0 20.0 3. 2. 0.0 0. 1. + 10274. 1. 5. 27.0 9.0 1.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 10275. 1. 5. 27.0 13.0 3.0 3. 14.0 14.0 3. 3. 0.0 0. 1. + 10276. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 10278. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 10279. 1. 5. 32.0 16.5 3.0 4. 12.0 20.0 3. 5. 0.0 0. 1. + 10280. 1. 5. 22.0 2.5 2.0 4. 12.0 9.0 2. 2. 0.0 0. 1. + 10283. 1. 5. 27.0 9.0 2.0 4. 14.0 11.5 3. 4. 0.0 0. 1. + 10287. 1. 5. 27.0 2.5 0.0 3. 16.0 6.5 4. 4. 0.0 0. 1. + 10299. 1. 4. 32.0 13.0 2.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 10302. 1. 5. 17.5 0.5 0.0 3. 12.0 9.0 2. 5. 0.0 0. 1. + 10305. 1. 5. 42.0 23.0 3.0 4. 14.0 20.0 3. 6. 0.0 0. 1. + 10308. 1. 5. 22.0 2.5 1.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 10313. 1. 5. 27.0 9.0 2.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 10319. 1. 4. 17.5 2.5 0.0 1. 14.0 9.0 3. 1. 0.0 0. 1. + 10321. 1. 2. 22.0 6.0 0.0 2. 14.0 11.5 5. 2. 0.0 0. 1. + 10325. 1. 5. 27.0 2.5 0.0 3. 16.0 14.0 3. 2. 0.0 0. 1. + 10328. 1. 4. 27.0 6.0 1.0 3. 16.0 9.0 4. 5. 0.0 0. 1. + 10332. 1. 4. 37.0 9.0 0.0 3. 20.0 14.0 4. 4. 0.0 0. 1. + 10336. 1. 4. 22.0 2.5 0.0 1. 16.0 14.0 3. 5. 0.0 0. 1. + 10338. 1. 4. 37.0 13.0 2.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 10339. 1. 5. 37.0 16.5 3.0 4. 17.0 20.0 4. 4. 0.0 0. 1. + 10340. 1. 4. 27.0 6.0 0.0 1. 20.0 20.0 6. 6. 0.0 0. 1. + 10342. 1. 4. 27.0 6.0 0.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 10346. 1. 5. 37.0 16.5 3.0 1. 17.0 20.0 4. 6. 0.0 0. 1. + 10348. 1. 5. 27.0 6.0 2.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 10349. 1. 5. 37.0 16.5 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 10363. 1. 5. 42.0 23.0 1.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 10365. 1. 5. 27.0 9.0 2.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 10366. 1. 5. 27.0 13.0 2.0 2. 14.0 14.0 2. 4. 0.0 0. 1. + 10375. 1. 5. 42.0 23.0 2.0 4. 14.0 14.0 5. 5. 0.0 0. 1. + 10376. 1. 5. 42.0 23.0 5.5 4. 14.0 11.5 5. 4. 0.0 0. 1. + 10382. 1. 4. 22.0 6.0 0.0 1. 17.0 20.0 4. 1. 0.0 0. 1. + 10395. 1. 4. 27.0 2.5 0.0 4. 16.0 11.5 3. 1. 0.0 0. 1. + 10398. 1. 4. 17.5 2.5 0.0 1. 12.0 11.5 5. 2. 0.0 0. 1. + 10399. 1. 3. 27.0 9.0 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 10401. 1. 5. 22.0 2.5 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 10412. 1. 4. 27.0 9.0 2.0 3. 12.0 40.0 3. 2. 0.0 0. 1. + 10416. 1. 4. 22.0 6.0 0.0 2. 16.0 20.0 5. 5. 0.0 0. 1. + 10419. 1. 4. 22.0 0.5 0.0 1. 14.0 6.5 1. 1. 0.0 0. 1. + 10421. 1. 5. 22.0 2.5 1.0 2. 12.0 6.5 3. 1. 0.0 0. 1. + 10422. 1. 5. 27.0 9.0 2.0 3. 12.0 9.0 5. 5. 0.0 0. 1. + 10423. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 10431. 1. 4. 22.0 2.5 0.0 3. 14.0 9.0 2. 2. 0.0 0. 1. + 10437. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 10439. 1. 5. 22.0 2.5 1.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 10464. 1. 3. 27.0 6.0 1.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 10471. 1. 5. 37.0 16.5 4.0 3. 20.0 40.0 4. 2. 0.0 0. 1. + 10476. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 10481. 1. 4. 32.0 13.0 2.0 3. 14.0 14.0 5. 5. 0.0 0. 1. + 10485. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 10487. 1. 5. 27.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 10495. 1. 4. 27.0 9.0 1.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 10496. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 10497. 1. 3. 37.0 13.0 1.0 3. 17.0 11.5 5. 3. 0.0 0. 1. + 10502. 1. 5. 42.0 23.0 3.0 4. 12.0 20.0 2. 2. 0.0 0. 1. + 10504. 1. 5. 27.0 6.0 0.0 4. 16.0 14.0 4. 5. 0.0 0. 1. + 10505. 1. 2. 27.0 6.0 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 10508. 1. 5. 32.0 13.0 2.0 4. 14.0 20.0 4. 5. 0.0 0. 1. + 10514. 1. 5. 22.0 2.5 0.0 1. 17.0 11.5 4. 4. 0.0 0. 1. + 10523. 1. 5. 27.0 9.0 2.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 10526. 1. 5. 27.0 6.0 0.0 2. 16.0 20.0 6. 6. 0.0 0. 1. + 10531. 1. 5. 27.0 6.0 1.0 3. 16.0 11.5 4. 2. 0.0 0. 1. + 10533. 1. 4. 22.0 9.0 1.0 1. 12.0 6.5 2. 2. 0.0 0. 1. + 10534. 1. 4. 32.0 13.0 3.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 10535. 1. 4. 22.0 2.5 0.0 1. 14.0 20.0 3. 2. 0.0 0. 1. + 10541. 1. 4. 27.0 6.0 2.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 10542. 1. 5. 42.0 23.0 4.0 2. 12.0 40.0 3. 6. 0.0 0. 1. + 10543. 1. 3. 32.0 13.0 3.0 4. 16.0 14.0 4. 2. 0.0 0. 1. + 10544. 1. 3. 22.0 0.5 0.0 3. 12.0 6.5 3. 1. 0.0 0. 1. + 10548. 1. 2. 22.0 2.5 0.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 10555. 1. 3. 37.0 23.0 4.0 2. 14.0 20.0 4. 2. 0.0 0. 1. + 10564. 1. 5. 42.0 23.0 5.5 4. 14.0 14.0 5. 2. 0.0 0. 1. + 10565. 1. 5. 37.0 23.0 3.0 3. 12.0 14.0 4. 5. 0.0 0. 1. + 10566. 1. 5. 32.0 9.0 2.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 10567. 1. 5. 32.0 23.0 2.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 10570. 1. 5. 37.0 13.0 3.0 4. 16.0 40.0 4. 2. 0.0 0. 1. + 10573. 1. 5. 32.0 16.5 5.5 2. 12.0 11.5 3. 2. 0.0 0. 1. + 10575. 1. 5. 27.0 9.0 3.0 1. 12.0 20.0 2. 5. 0.0 0. 1. + 10577. 1. 4. 17.5 2.5 0.0 2. 14.0 6.5 3. 3. 0.0 0. 1. + 10582. 1. 5. 22.0 0.5 0.0 1. 16.0 6.5 3. 1. 0.0 0. 1. + 10585. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 10586. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 5. 4. 0.0 0. 1. + 10588. 1. 5. 32.0 9.0 0.0 4. 20.0 40.0 6. 6. 0.0 0. 1. + 10593. 1. 3. 27.0 6.0 0.0 4. 16.0 11.5 4. 4. 0.0 0. 1. + 10595. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 10596. 1. 5. 22.0 0.5 0.0 2. 12.0 9.0 3. 1. 0.0 0. 1. + 10598. 1. 4. 27.0 13.0 2.0 4. 14.0 14.0 4. 4. 0.0 0. 1. + 10602. 1. 4. 42.0 23.0 4.0 2. 14.0 40.0 4. 5. 0.0 0. 1. + 10606. 1. 5. 22.0 2.5 0.0 3. 16.0 40.0 5. 3. 0.0 0. 1. + 10607. 1. 5. 42.0 23.0 3.0 3. 16.0 11.5 4. 2. 0.0 0. 1. + 10611. 1. 5. 22.0 2.5 0.0 1. 14.0 14.0 6. 6. 0.0 0. 1. + 10619. 1. 4. 17.5 2.5 0.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 10621. 1. 5. 27.0 2.5 2.0 1. 14.0 14.0 2. 3. 0.0 0. 1. + 10627. 1. 4. 27.0 9.0 1.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 10629. 1. 5. 22.0 0.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 10630. 1. 5. 32.0 16.5 4.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 10631. 1. 5. 32.0 13.0 2.0 4. 12.0 11.5 3. 3. 0.0 0. 1. + 10633. 1. 5. 27.0 2.5 1.0 3. 14.0 14.0 5. 5. 0.0 0. 1. + 10636. 1. 5. 42.0 23.0 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 10637. 1. 4. 42.0 23.0 4.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 10639. 1. 4. 22.0 0.5 0.0 2. 14.0 6.5 4. 4. 0.0 0. 1. + 10641. 1. 3. 27.0 6.0 2.0 3. 14.0 11.5 3. 6. 0.0 0. 1. + 10660. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 3. 5. 0.0 0. 1. + 10663. 1. 4. 37.0 23.0 5.5 2. 12.0 20.0 3. 2. 0.0 0. 1. + 10667. 1. 5. 37.0 16.5 3.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 10670. 1. 5. 27.0 9.0 3.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 10678. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 10681. 1. 3. 27.0 9.0 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 10685. 1. 3. 22.0 2.5 0.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 10690. 1. 5. 37.0 16.5 4.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 10695. 1. 4. 22.0 9.0 1.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 10697. 1. 2. 27.0 6.0 2.0 2. 12.0 11.5 5. 5. 0.0 0. 1. + 10698. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 5. 4. 0.0 0. 1. + 10705. 1. 5. 32.0 13.0 2.0 4. 14.0 20.0 5. 4. 0.0 0. 1. + 10710. 1. 4. 22.0 2.5 0.0 2. 16.0 11.5 3. 5. 0.0 0. 1. + 10716. 1. 5. 27.0 9.0 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 10724. 1. 5. 32.0 9.0 0.0 4. 20.0 40.0 4. 6. 0.0 0. 1. + 10725. 1. 5. 32.0 13.0 2.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 10726. 1. 5. 17.5 2.5 0.0 4. 14.0 11.5 3. 4. 0.0 0. 1. + 10728. 1. 5. 42.0 23.0 3.0 3. 12.0 6.5 3. 2. 0.0 0. 1. + 10743. 1. 5. 22.0 0.5 0.0 2. 14.0 9.0 4. 2. 0.0 0. 1. + 10753. 1. 5. 37.0 13.0 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 10762. 1. 4. 22.0 2.5 0.0 3. 14.0 6.5 3. 3. 0.0 0. 1. + 10771. 1. 5. 37.0 16.5 4.0 3. 14.0 20.0 4. 2. 0.0 0. 1. + 10791. 1. 4. 42.0 23.0 4.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 10793. 1. 5. 27.0 6.0 1.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 10794. 1. 5. 32.0 13.0 3.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 10804. 1. 5. 42.0 23.0 3.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 10805. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 10814. 1. 5. 42.0 13.0 0.0 4. 14.0 40.0 3. 5. 0.0 0. 1. + 10817. 1. 4. 27.0 2.5 0.0 1. 14.0 9.0 3. 2. 0.0 0. 1. + 10820. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 2. 2. 0.0 0. 1. + 10823. 1. 4. 22.0 6.0 0.0 2. 17.0 6.5 4. 1. 0.0 0. 1. + 10829. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 5. 5. 0.0 0. 1. + 10833. 1. 5. 32.0 16.5 3.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 10839. 1. 4. 27.0 2.5 0.0 2. 16.0 14.0 4. 6. 0.0 0. 1. + 10845. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 4. 3. 0.0 0. 1. + 10850. 1. 4. 32.0 16.5 2.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 10855. 1. 2. 22.0 2.5 0.0 2. 14.0 4.0 3. 4. 0.0 0. 1. + 10867. 1. 2. 42.0 23.0 3.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 10871. 1. 4. 42.0 23.0 4.0 3. 12.0 20.0 5. 2. 0.0 0. 1. + 10875. 1. 3. 32.0 16.5 3.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 10880. 1. 5. 37.0 16.5 2.0 4. 12.0 14.0 5. 5. 0.0 0. 1. + 10881. 1. 5. 32.0 13.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 10883. 1. 4. 22.0 2.5 0.0 2. 16.0 9.0 3. 2. 0.0 0. 1. + 10885. 1. 4. 27.0 2.5 0.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 10886. 1. 3. 42.0 23.0 4.0 4. 20.0 40.0 6. 6. 0.0 0. 1. + 10891. 1. 3. 32.0 16.5 2.0 2. 14.0 20.0 5. 2. 0.0 0. 1. + 10892. 1. 5. 22.0 0.5 1.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 10903. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 4. 1. 0.0 0. 1. + 10904. 1. 5. 27.0 6.0 0.0 3. 17.0 20.0 5. 6. 0.0 0. 1. + 10908. 1. 2. 37.0 13.0 4.0 4. 20.0 20.0 4. 6. 0.0 0. 1. + 10911. 1. 4. 27.0 2.5 0.0 3. 20.0 40.0 4. 3. 0.0 0. 1. + 10912. 1. 5. 32.0 2.5 1.0 1. 20.0 4.0 3. 1. 0.0 0. 1. + 10915. 1. 5. 37.0 16.5 3.0 3. 12.0 11.5 5. 5. 0.0 0. 1. + 10919. 1. 5. 27.0 9.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 10920. 1. 4. 32.0 13.0 2.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 10921. 1. 4. 37.0 16.5 4.0 4. 14.0 14.0 4. 5. 0.0 0. 1. + 10932. 1. 5. 17.5 0.5 0.0 2. 12.0 4.0 2. 2. 0.0 0. 1. + 10937. 1. 4. 32.0 13.0 1.0 3. 14.0 11.5 2. 5. 0.0 0. 1. + 10944. 1. 5. 37.0 23.0 5.5 4. 17.0 40.0 5. 6. 0.0 0. 1. + 10951. 1. 5. 22.0 2.5 0.0 2. 14.0 6.5 2. 4. 0.0 0. 1. + 10952. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 10953. 1. 4. 42.0 23.0 4.0 2. 12.0 20.0 4. 4. 0.0 0. 1. + 10955. 1. 5. 42.0 23.0 4.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 10958. 1. 4. 17.5 0.5 0.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 10963. 1. 5. 22.0 0.5 0.0 4. 20.0 11.5 4. 1. 0.0 0. 1. + 10967. 1. 4. 27.0 6.0 1.0 3. 16.0 14.0 4. 3. 0.0 0. 1. + 10981. 1. 4. 42.0 23.0 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 10982. 1. 4. 27.0 9.0 2.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 10985. 1. 4. 27.0 6.0 1.0 1. 12.0 11.5 4. 1. 0.0 0. 1. + 10987. 1. 5. 27.0 2.5 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 10990. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 2. 2. 0.0 0. 1. + 10992. 1. 5. 37.0 16.5 3.0 4. 14.0 40.0 4. 4. 0.0 0. 1. + 10998. 1. 5. 27.0 6.0 0.0 2. 14.0 6.5 2. 4. 0.0 0. 1. + 10999. 1. 5. 37.0 16.5 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 11002. 1. 2. 32.0 9.0 3.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 11015. 1. 5. 27.0 6.0 1.0 2. 16.0 11.5 3. 4. 0.0 0. 1. + 11018. 1. 4. 37.0 23.0 3.0 3. 20.0 14.0 4. 4. 0.0 0. 1. + 11025. 1. 5. 37.0 23.0 3.0 4. 12.0 20.0 3. 2. 0.0 0. 1. + 11029. 1. 4. 27.0 6.0 2.0 3. 14.0 9.0 3. 5. 0.0 0. 1. + 11033. 1. 5. 32.0 13.0 2.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 11035. 1. 4. 27.0 6.0 1.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 11040. 1. 3. 37.0 13.0 1.0 2. 14.0 40.0 4. 6. 0.0 0. 1. + 11044. 1. 5. 37.0 16.5 2.0 4. 14.0 20.0 3. 6. 0.0 0. 1. + 11046. 1. 4. 27.0 6.0 0.0 3. 16.0 9.0 3. 4. 0.0 0. 1. + 11052. 1. 4. 42.0 13.0 0.0 3. 14.0 9.0 5. 5. 0.0 0. 1. + 11057. 1. 4. 27.0 9.0 2.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 11058. 1. 4. 22.0 6.0 1.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 11063. 1. 5. 22.0 2.5 0.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 11066. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 2. 4. 0.0 0. 1. + 11074. 1. 4. 27.0 6.0 2.0 3. 16.0 11.5 4. 6. 0.0 0. 1. + 11083. 1. 4. 27.0 2.5 0.0 1. 12.0 20.0 3. 6. 0.0 0. 1. + 11100. 1. 5. 27.0 13.0 2.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 11103. 1. 4. 27.0 6.0 1.0 1. 16.0 11.5 2. 4. 0.0 0. 1. + 11110. 1. 5. 32.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 11112. 1. 5. 27.0 2.5 0.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 11121. 1. 4. 27.0 9.0 1.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 11124. 1. 5. 37.0 16.5 3.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 11129. 1. 5. 27.0 2.5 0.0 4. 20.0 14.0 4. 2. 0.0 0. 1. + 11133. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 11140. 1. 5. 27.0 6.0 1.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 11141. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 11149. 1. 5. 42.0 23.0 2.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 11154. 1. 5. 27.0 9.0 2.0 3. 20.0 40.0 4. 5. 0.0 0. 1. + 11155. 1. 3. 22.0 2.5 1.0 1. 12.0 11.5 3. 2. 0.0 0. 1. + 11158. 1. 5. 22.0 2.5 0.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 11159. 1. 5. 42.0 23.0 2.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 11167. 1. 5. 32.0 16.5 3.0 1. 14.0 20.0 4. 5. 0.0 0. 1. + 11171. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 3. 1. 0.0 0. 1. + 11173. 1. 5. 32.0 9.0 2.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 11187. 1. 5. 22.0 2.5 0.0 3. 16.0 40.0 4. 2. 0.0 0. 1. + 11203. 1. 4. 27.0 9.0 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 11209. 1. 4. 37.0 16.5 3.0 3. 12.0 20.0 3. 6. 0.0 0. 1. + 11212. 1. 3. 27.0 9.0 1.0 4. 14.0 20.0 6. 4. 0.0 0. 1. + 11213. 1. 5. 32.0 16.5 3.0 4. 12.0 11.5 4. 4. 0.0 0. 1. + 11221. 1. 4. 32.0 16.5 3.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 11228. 1. 5. 32.0 16.5 2.0 4. 12.0 20.0 4. 3. 0.0 0. 1. + 11236. 1. 3. 22.0 2.5 0.0 2. 16.0 20.0 2. 5. 0.0 0. 1. + 11238. 1. 5. 22.0 2.5 0.0 4. 14.0 6.5 3. 3. 0.0 0. 1. + 11241. 1. 4. 27.0 16.5 1.0 3. 14.0 14.0 4. 4. 0.0 0. 1. + 11258. 1. 5. 27.0 6.0 0.0 3. 16.0 20.0 3. 6. 0.0 0. 1. + 11261. 1. 5. 27.0 0.5 0.0 2. 17.0 14.0 4. 3. 0.0 0. 1. + 11263. 1. 5. 22.0 2.5 1.0 2. 14.0 11.5 4. 4. 0.0 0. 1. + 11268. 1. 4. 27.0 6.0 2.0 2. 17.0 20.0 4. 6. 0.0 0. 1. + 11276. 1. 3. 22.0 2.5 1.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 11280. 1. 5. 22.0 2.5 0.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 11289. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 11290. 1. 5. 42.0 23.0 4.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 11293. 1. 5. 22.0 0.5 0.0 2. 17.0 20.0 3. 4. 0.0 0. 1. + 11297. 1. 4. 27.0 9.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 11300. 1. 5. 22.0 2.5 0.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 11307. 1. 3. 27.0 6.0 2.0 4. 17.0 11.5 2. 4. 0.0 0. 1. + 11308. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 11312. 1. 5. 27.0 6.0 0.0 3. 14.0 40.0 3. 3. 0.0 0. 1. + 11316. 1. 3. 42.0 23.0 2.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 11320. 1. 5. 27.0 9.0 0.0 1. 14.0 14.0 3. 5. 0.0 0. 1. + 11321. 1. 3. 27.0 2.5 0.0 2. 20.0 20.0 6. 4. 0.0 0. 1. + 11323. 1. 4. 27.0 16.5 2.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 11324. 1. 4. 32.0 9.0 1.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 11329. 1. 4. 42.0 23.0 5.5 4. 14.0 20.0 5. 5. 0.0 0. 1. + 11341. 1. 4. 22.0 2.5 0.0 3. 12.0 4.0 2. 1. 0.0 0. 1. + 11343. 1. 5. 27.0 2.5 0.0 3. 20.0 20.0 4. 6. 0.0 0. 1. + 11349. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 11351. 1. 3. 22.0 2.5 2.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 11352. 1. 4. 42.0 23.0 3.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 11354. 1. 4. 22.0 2.5 0.0 2. 16.0 6.5 3. 1. 0.0 0. 1. + 11360. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 11370. 1. 5. 27.0 6.0 0.0 1. 17.0 40.0 4. 5. 0.0 0. 1. + 11371. 1. 5. 32.0 13.0 2.0 3. 14.0 14.0 2. 2. 0.0 0. 1. + 11379. 1. 5. 17.5 2.5 0.0 4. 12.0 4.0 3. 1. 0.0 0. 1. + 11381. 1. 5. 42.0 23.0 5.5 4. 14.0 40.0 4. 6. 0.0 0. 1. + 11388. 1. 5. 37.0 13.0 2.0 3. 16.0 40.0 4. 4. 0.0 0. 1. + 11401. 1. 4. 32.0 16.5 3.0 3. 14.0 40.0 2. 6. 0.0 0. 1. + 11403. 1. 2. 17.5 2.5 1.0 3. 14.0 6.5 3. 2. 0.0 0. 1. + 11405. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 11411. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 11412. 1. 3. 32.0 6.0 1.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 11415. 1. 4. 27.0 2.5 0.0 2. 16.0 11.5 4. 1. 0.0 0. 1. + 11417. 1. 3. 42.0 13.0 0.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 11420. 1. 5. 27.0 9.0 2.0 4. 14.0 11.5 5. 4. 0.0 0. 1. + 11423. 1. 3. 22.0 2.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 11424. 1. 5. 32.0 6.0 1.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 11425. 1. 5. 32.0 13.0 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 11435. 1. 3. 22.0 6.0 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 11437. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 6. 6. 0.0 0. 1. + 11444. 1. 5. 22.0 6.0 1.0 2. 14.0 14.0 4. 4. 0.0 0. 1. + 11448. 1. 5. 22.0 6.0 0.0 3. 12.0 11.5 5. 4. 0.0 0. 1. + 11460. 1. 4. 27.0 6.0 0.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 11464. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 11474. 1. 5. 22.0 2.5 2.0 3. 14.0 9.0 4. 4. 0.0 0. 1. + 11476. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 3. 0.0 0. 1. + 11477. 1. 5. 27.0 2.5 0.0 4. 16.0 20.0 5. 2. 0.0 0. 1. + 11480. 1. 4. 22.0 2.5 0.0 3. 14.0 6.5 3. 1. 0.0 0. 1. + 11485. 1. 4. 37.0 16.5 5.5 3. 14.0 9.0 2. 4. 0.0 0. 1. + 11487. 1. 5. 22.0 2.5 1.0 2. 12.0 6.5 5. 2. 0.0 0. 1. + 11490. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 5. 5. 0.0 0. 1. + 11491. 1. 5. 42.0 23.0 5.5 4. 17.0 14.0 4. 6. 0.0 0. 1. + 11493. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 3. 0.0 0. 1. + 11496. 1. 4. 32.0 13.0 1.0 3. 20.0 11.5 6. 5. 0.0 0. 1. + 11497. 1. 5. 22.0 2.5 0.0 2. 12.0 40.0 3. 4. 0.0 0. 1. + 11498. 1. 5. 27.0 9.0 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 11501. 1. 5. 32.0 16.5 2.0 4. 14.0 14.0 5. 4. 0.0 0. 1. + 11502. 1. 5. 27.0 9.0 3.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 11512. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 11514. 1. 4. 37.0 16.5 3.0 3. 14.0 20.0 5. 4. 0.0 0. 1. + 11519. 1. 4. 27.0 6.0 1.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 11523. 1. 4. 27.0 6.0 2.0 3. 16.0 9.0 4. 2. 0.0 0. 1. + 11527. 1. 4. 22.0 2.5 0.0 3. 14.0 6.5 3. 4. 0.0 0. 1. + 11537. 1. 4. 17.5 0.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 11544. 1. 5. 17.5 0.5 0.0 3. 12.0 6.5 3. 1. 0.0 0. 1. + 11548. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 3. 2. 0.0 0. 1. + 11561. 1. 5. 32.0 16.5 2.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 11564. 1. 5. 42.0 23.0 3.0 3. 17.0 40.0 4. 5. 0.0 0. 1. + 11565. 1. 5. 22.0 2.5 1.0 4. 12.0 11.5 5. 4. 0.0 0. 1. + 11568. 1. 4. 27.0 6.0 1.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 11569. 1. 3. 22.0 2.5 0.0 2. 12.0 4.0 3. 3. 0.0 0. 1. + 11574. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 2. 5. 0.0 0. 1. + 11579. 1. 5. 17.5 2.5 0.0 3. 12.0 4.0 2. 1. 0.0 0. 1. + 11580. 1. 4. 17.5 2.5 0.0 3. 12.0 6.5 2. 4. 0.0 0. 1. + 11582. 1. 5. 27.0 2.5 0.0 4. 12.0 20.0 3. 6. 0.0 0. 1. + 11594. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 11595. 1. 4. 42.0 23.0 3.0 1. 14.0 20.0 5. 4. 0.0 0. 1. + 11599. 1. 5. 42.0 23.0 2.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 11602. 1. 4. 22.0 6.0 2.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 11604. 1. 4. 32.0 13.0 2.0 3. 16.0 40.0 5. 2. 0.0 0. 1. + 11608. 1. 4. 37.0 16.5 3.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 11609. 1. 5. 32.0 16.5 5.5 4. 12.0 6.5 3. 4. 0.0 0. 1. + 11610. 1. 4. 32.0 9.0 1.0 2. 12.0 40.0 2. 3. 0.0 0. 1. + 11612. 1. 5. 22.0 2.5 0.0 4. 14.0 6.5 1. 2. 0.0 0. 1. + 11621. 1. 5. 17.5 2.5 0.0 3. 14.0 9.0 4. 1. 0.0 0. 1. + 11628. 1. 5. 22.0 2.5 0.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 11630. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 5. 5. 0.0 0. 1. + 11632. 1. 5. 27.0 6.0 1.0 4. 14.0 11.5 3. 3. 0.0 0. 1. + 11635. 1. 5. 32.0 13.0 2.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 11637. 1. 3. 37.0 16.5 5.5 3. 12.0 14.0 2. 4. 0.0 0. 1. + 11640. 1. 3. 32.0 9.0 3.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 11641. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 11647. 1. 5. 32.0 16.5 3.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 11654. 1. 5. 27.0 0.5 0.0 4. 17.0 20.0 4. 4. 0.0 0. 1. + 11664. 1. 4. 22.0 6.0 1.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 11667. 1. 4. 22.0 0.5 0.0 3. 14.0 6.5 3. 2. 0.0 0. 1. + 11671. 1. 5. 22.0 6.0 3.0 1. 12.0 11.5 4. 4. 0.0 0. 1. + 11679. 1. 4. 22.0 0.5 0.0 3. 14.0 11.5 2. 4. 0.0 0. 1. + 11683. 1. 5. 22.0 2.5 1.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 11684. 1. 3. 37.0 23.0 5.5 3. 16.0 40.0 4. 6. 0.0 0. 1. + 11692. 1. 2. 22.0 2.5 0.0 3. 14.0 6.5 3. 2. 0.0 0. 1. + 11695. 1. 5. 27.0 9.0 1.0 1. 14.0 9.0 4. 4. 0.0 0. 1. + 11696. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 2. 3. 0.0 0. 1. + 11697. 1. 3. 37.0 16.5 3.0 1. 16.0 20.0 3. 6. 0.0 0. 1. + 11698. 1. 3. 27.0 2.5 1.0 2. 14.0 20.0 2. 4. 0.0 0. 1. + 11704. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 11711. 1. 3. 27.0 2.5 2.0 2. 14.0 14.0 4. 4. 0.0 0. 1. + 11712. 1. 4. 22.0 2.5 0.0 1. 14.0 14.0 5. 4. 0.0 0. 1. + 11715. 1. 5. 22.0 0.5 0.0 3. 16.0 40.0 4. 2. 0.0 0. 1. + 11719. 1. 4. 27.0 6.0 2.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 11722. 1. 4. 22.0 6.0 1.0 2. 12.0 20.0 2. 5. 0.0 0. 1. + 11724. 1. 5. 32.0 13.0 3.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 11728. 1. 4. 32.0 16.5 1.0 3. 12.0 20.0 4. 2. 0.0 0. 1. + 11729. 1. 5. 27.0 2.5 0.0 4. 12.0 20.0 3. 5. 0.0 0. 1. + 11731. 1. 5. 17.5 2.5 1.0 1. 12.0 9.0 3. 4. 0.0 0. 1. + 11747. 1. 5. 22.0 2.5 1.0 3. 14.0 6.5 4. 1. 0.0 0. 1. + 11761. 1. 5. 32.0 9.0 0.0 4. 20.0 20.0 4. 5. 0.0 0. 1. + 11763. 1. 5. 22.0 0.5 0.0 1. 16.0 11.5 4. 5. 0.0 0. 1. + 11767. 1. 5. 32.0 9.0 0.0 1. 16.0 20.0 3. 5. 0.0 0. 1. + 11768. 1. 4. 42.0 23.0 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 11775. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 2. 2. 0.0 0. 1. + 11778. 1. 5. 32.0 13.0 1.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 11779. 1. 5. 22.0 6.0 1.0 1. 12.0 11.5 3. 4. 0.0 0. 1. + 11783. 1. 2. 42.0 23.0 4.0 2. 14.0 14.0 4. 5. 0.0 0. 1. + 11791. 1. 5. 22.0 2.5 0.0 4. 12.0 11.5 4. 4. 0.0 0. 1. + 11806. 1. 5. 32.0 13.0 2.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 11810. 1. 5. 22.0 0.5 0.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 11816. 1. 5. 22.0 2.5 0.0 1. 17.0 9.0 4. 1. 0.0 0. 1. + 11821. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 4. 1. 0.0 0. 1. + 11827. 1. 4. 42.0 23.0 5.5 3. 16.0 14.0 5. 5. 0.0 0. 1. + 11829. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 3. 5. 0.0 0. 1. + 11830. 1. 4. 37.0 13.0 1.0 4. 20.0 9.0 6. 4. 0.0 0. 1. + 11833. 1. 5. 27.0 2.5 0.0 2. 20.0 14.0 4. 4. 0.0 0. 1. + 11835. 1. 3. 22.0 0.5 1.0 4. 12.0 11.5 5. 4. 0.0 0. 1. + 11836. 1. 4. 27.0 2.5 1.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 11841. 1. 5. 22.0 2.5 0.0 1. 12.0 9.0 2. 4. 0.0 0. 1. + 11842. 1. 5. 22.0 6.0 2.0 2. 12.0 4.0 2. 4. 0.0 0. 1. + 11844. 1. 4. 27.0 6.0 2.0 1. 14.0 14.0 5. 5. 0.0 0. 1. + 11845. 1. 5. 22.0 0.5 0.0 2. 17.0 4.0 3. 1. 0.0 0. 1. + 11848. 1. 3. 27.0 9.0 1.0 2. 14.0 4.0 3. 4. 0.0 0. 1. + 11852. 1. 5. 42.0 23.0 4.0 3. 14.0 40.0 5. 5. 0.0 0. 1. + 11853. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 11854. 1. 4. 22.0 2.5 1.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 11856. 1. 5. 32.0 2.5 0.0 3. 16.0 40.0 4. 5. 0.0 0. 1. + 11875. 1. 4. 27.0 2.5 0.0 1. 20.0 9.0 4. 4. 0.0 0. 1. + 11877. 1. 4. 27.0 2.5 0.0 3. 17.0 11.5 4. 1. 0.0 0. 1. + 11880. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 3. 2. 0.0 0. 1. + 11882. 1. 4. 32.0 13.0 2.0 2. 17.0 40.0 4. 6. 0.0 0. 1. + 11885. 1. 5. 17.5 0.5 0.0 4. 12.0 11.5 4. 5. 0.0 0. 1. + 11889. 1. 3. 37.0 16.5 3.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 11893. 1. 4. 27.0 6.0 1.0 2. 14.0 9.0 3. 1. 0.0 0. 1. + 11894. 1. 4. 22.0 2.5 0.0 3. 14.0 6.5 3. 4. 0.0 0. 1. + 11907. 1. 4. 22.0 2.5 0.0 1. 14.0 14.0 3. 3. 0.0 0. 1. + 11910. 1. 3. 22.0 2.5 1.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 11921. 1. 4. 32.0 13.0 2.0 3. 12.0 11.5 5. 4. 0.0 0. 1. + 11926. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 2. 3. 0.0 0. 1. + 11930. 1. 5. 32.0 9.0 0.0 3. 16.0 14.0 5. 4. 0.0 0. 1. + 11931. 1. 5. 32.0 6.0 2.0 2. 17.0 20.0 6. 6. 0.0 0. 1. + 11941. 1. 5. 22.0 6.0 1.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 11947. 1. 3. 37.0 13.0 1.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 11951. 1. 3. 42.0 23.0 5.5 2. 14.0 20.0 3. 4. 0.0 0. 1. + 11953. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 11955. 1. 4. 22.0 0.5 0.0 3. 14.0 6.5 1. 1. 0.0 0. 1. + 11957. 1. 4. 22.0 0.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 11958. 1. 5. 27.0 2.5 0.0 3. 14.0 9.0 4. 1. 0.0 0. 1. + 11969. 1. 5. 27.0 0.5 0.0 1. 14.0 20.0 2. 6. 0.0 0. 1. + 11970. 1. 4. 37.0 23.0 5.5 4. 14.0 11.5 4. 4. 0.0 0. 1. + 11973. 1. 4. 22.0 2.5 0.0 1. 14.0 9.0 4. 2. 0.0 0. 1. + 11977. 1. 4. 27.0 2.5 3.0 1. 16.0 20.0 3. 4. 0.0 0. 1. + 11978. 1. 4. 22.0 0.5 0.0 2. 14.0 14.0 2. 2. 0.0 0. 1. + 11981. 1. 3. 37.0 9.0 2.0 3. 16.0 11.5 4. 5. 0.0 0. 1. + 11990. 1. 5. 37.0 16.5 3.0 4. 14.0 14.0 4. 2. 0.0 0. 1. + 11991. 1. 3. 27.0 6.0 0.0 1. 17.0 20.0 2. 6. 0.0 0. 1. + 11996. 1. 3. 27.0 9.0 3.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 11997. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 12020. 1. 5. 42.0 23.0 3.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 12021. 1. 5. 27.0 2.5 1.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 12030. 1. 5. 22.0 0.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 12037. 1. 5. 27.0 2.5 0.0 3. 16.0 6.5 3. 1. 0.0 0. 1. + 12046. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 5. 2. 0.0 0. 1. + 12049. 1. 4. 27.0 9.0 2.0 3. 14.0 14.0 5. 5. 0.0 0. 1. + 12052. 1. 5. 37.0 16.5 2.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 12054. 1. 4. 22.0 6.0 2.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 12057. 1. 4. 32.0 16.5 4.0 2. 16.0 20.0 5. 6. 0.0 0. 1. + 12058. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 12059. 1. 4. 32.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 12060. 1. 5. 37.0 23.0 5.5 4. 12.0 11.5 2. 5. 0.0 0. 1. + 12063. 1. 5. 22.0 0.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 12065. 1. 5. 27.0 6.0 1.0 1. 16.0 4.0 2. 1. 0.0 0. 1. + 12069. 1. 4. 22.0 2.5 2.0 2. 12.0 4.0 3. 2. 0.0 0. 1. + 12070. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 6. 4. 0.0 0. 1. + 12071. 1. 4. 32.0 13.0 2.0 4. 14.0 20.0 3. 6. 0.0 0. 1. + 12086. 1. 4. 27.0 9.0 2.0 2. 20.0 20.0 4. 5. 0.0 0. 1. + 12092. 1. 4. 22.0 2.5 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 12095. 1. 3. 22.0 2.5 1.0 2. 14.0 11.5 5. 5. 0.0 0. 1. + 12099. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 12100. 1. 3. 22.0 2.5 0.0 2. 16.0 14.0 3. 5. 0.0 0. 1. + 12106. 1. 5. 22.0 0.5 0.0 4. 14.0 11.5 5. 5. 0.0 0. 1. + 12109. 1. 5. 42.0 9.0 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 12115. 1. 4. 32.0 9.0 1.0 3. 17.0 20.0 5. 4. 0.0 0. 1. + 12116. 1. 5. 32.0 6.0 2.0 4. 17.0 40.0 2. 6. 0.0 0. 1. + 12125. 1. 5. 27.0 6.0 0.0 2. 20.0 20.0 4. 5. 0.0 0. 1. + 12126. 1. 5. 27.0 6.0 2.0 4. 16.0 9.0 4. 4. 0.0 0. 1. + 12127. 1. 5. 22.0 2.5 1.0 3. 12.0 9.0 4. 4. 0.0 0. 1. + 12134. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 12139. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 4. 6. 0.0 0. 1. + 12143. 1. 4. 22.0 2.5 1.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 12150. 1. 5. 42.0 23.0 2.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 12153. 1. 5. 32.0 13.0 0.0 2. 16.0 40.0 3. 5. 0.0 0. 1. + 12157. 1. 5. 22.0 2.5 0.0 1. 12.0 6.5 3. 1. 0.0 0. 1. + 12159. 1. 5. 22.0 9.0 3.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 12171. 1. 5. 27.0 0.5 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 12176. 1. 3. 32.0 6.0 0.0 2. 9.0 11.5 2. 2. 0.0 0. 1. + 12179. 1. 5. 22.0 2.5 0.0 1. 17.0 4.0 1. 1. 0.0 0. 1. + 12182. 1. 4. 32.0 16.5 5.5 2. 16.0 20.0 4. 4. 0.0 0. 1. + 12183. 1. 4. 37.0 6.0 1.0 3. 20.0 40.0 6. 6. 0.0 0. 1. + 12189. 1. 5. 42.0 23.0 2.0 2. 17.0 20.0 3. 5. 0.0 0. 1. + 12191. 1. 5. 27.0 2.5 0.0 3. 17.0 20.0 5. 5. 0.0 0. 1. + 12194. 1. 5. 42.0 23.0 2.0 3. 14.0 40.0 5. 5. 0.0 0. 1. + 12199. 1. 5. 27.0 6.0 2.0 1. 14.0 20.0 5. 5. 0.0 0. 1. + 12200. 1. 5. 32.0 13.0 2.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 12204. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 4. 5. 0.0 0. 1. + 12207. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 12215. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 12219. 1. 2. 32.0 13.0 4.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 12234. 1. 5. 37.0 16.5 4.0 4. 16.0 40.0 4. 2. 0.0 0. 1. + 12237. 1. 5. 37.0 16.5 5.5 4. 12.0 40.0 3. 6. 0.0 0. 1. + 12242. 1. 4. 22.0 6.0 2.0 1. 12.0 14.0 3. 4. 0.0 0. 1. + 12257. 1. 3. 37.0 9.0 0.0 4. 12.0 14.0 3. 3. 0.0 0. 1. + 12259. 1. 4. 27.0 6.0 1.0 1. 17.0 6.5 4. 4. 0.0 0. 1. + 12260. 1. 5. 22.0 2.5 1.0 2. 12.0 6.5 3. 3. 0.0 0. 1. + 12267. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 12277. 1. 5. 32.0 13.0 2.0 3. 12.0 11.5 3. 5. 0.0 0. 1. + 12281. 1. 5. 27.0 2.5 0.0 3. 17.0 11.5 4. 2. 0.0 0. 1. + 12287. 1. 4. 27.0 6.0 3.0 4. 14.0 40.0 4. 2. 0.0 0. 1. + 12292. 1. 3. 22.0 6.0 1.0 1. 12.0 20.0 3. 6. 0.0 0. 1. + 12293. 1. 4. 22.0 2.5 0.0 4. 17.0 20.0 4. 4. 0.0 0. 1. + 12302. 1. 5. 27.0 9.0 0.0 4. 20.0 40.0 4. 6. 0.0 0. 1. + 12305. 1. 3. 42.0 23.0 4.0 4. 14.0 20.0 5. 4. 0.0 0. 1. + 12306. 1. 4. 32.0 16.5 4.0 3. 14.0 14.0 3. 3. 0.0 0. 1. + 12310. 1. 5. 22.0 2.5 0.0 4. 16.0 14.0 3. 3. 0.0 0. 1. + 12311. 1. 5. 27.0 0.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 12313. 1. 5. 37.0 23.0 3.0 2. 14.0 40.0 4. 5. 0.0 0. 1. + 12314. 1. 5. 27.0 2.5 0.0 1. 12.0 14.0 3. 4. 0.0 0. 1. + 12320. 1. 5. 22.0 2.5 1.0 4. 12.0 6.5 3. 2. 0.0 0. 1. + 12323. 1. 5. 22.0 2.5 2.0 1. 16.0 9.0 3. 6. 0.0 0. 1. + 12333. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 12340. 1. 4. 27.0 6.0 1.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 12342. 1. 2. 27.0 2.5 1.0 3. 12.0 6.5 4. 5. 0.0 0. 1. + 12344. 1. 4. 37.0 16.5 3.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 12348. 1. 4. 32.0 16.5 2.0 3. 16.0 40.0 4. 4. 0.0 0. 1. + 12352. 1. 4. 27.0 6.0 0.0 1. 20.0 9.0 4. 1. 0.0 0. 1. + 12354. 1. 5. 27.0 9.0 3.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 12359. 1. 4. 27.0 2.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 12365. 1. 3. 22.0 6.0 1.0 2. 16.0 9.0 1. 3. 0.0 0. 1. + 12367. 1. 2. 27.0 9.0 2.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 12378. 1. 5. 27.0 9.0 3.0 3. 14.0 6.5 3. 4. 0.0 0. 1. + 12386. 1. 5. 22.0 0.5 0.0 3. 14.0 4.0 3. 1. 0.0 0. 1. + 12392. 1. 4. 27.0 9.0 2.0 3. 12.0 9.0 2. 4. 0.0 0. 1. + 12394. 1. 5. 32.0 13.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 12396. 1. 5. 27.0 0.5 0.0 2. 16.0 14.0 5. 4. 0.0 0. 1. + 12404. 1. 4. 42.0 23.0 5.5 3. 12.0 11.5 5. 4. 0.0 0. 1. + 12410. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 12416. 1. 5. 22.0 0.5 0.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 12420. 1. 4. 22.0 6.0 1.0 2. 14.0 40.0 4. 3. 0.0 0. 1. + 12425. 1. 3. 27.0 13.0 2.0 2. 12.0 4.0 2. 4. 0.0 0. 1. + 12430. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 5. 4. 0.0 0. 1. + 12431. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 3. 5. 0.0 0. 1. + 12434. 1. 5. 27.0 2.5 0.0 1. 16.0 11.5 2. 2. 0.0 0. 1. + 12441. 1. 3. 32.0 13.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 12445. 1. 5. 22.0 0.5 0.0 2. 16.0 14.0 3. 4. 0.0 0. 1. + 12446. 1. 3. 42.0 23.0 5.5 3. 17.0 11.5 5. 2. 0.0 0. 1. + 12447. 1. 2. 22.0 2.5 2.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 12448. 1. 4. 37.0 16.5 1.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 12449. 1. 4. 27.0 2.5 0.0 1. 20.0 40.0 6. 6. 0.0 0. 1. + 12459. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 2. 5. 0.0 0. 1. + 12464. 1. 4. 22.0 2.5 0.0 3. 14.0 4.0 3. 1. 0.0 0. 1. + 12465. 1. 5. 42.0 23.0 4.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 12467. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 4. 6. 0.0 0. 1. + 12470. 1. 5. 32.0 16.5 3.0 3. 12.0 11.5 2. 5. 0.0 0. 1. + 12472. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 4. 2. 0.0 0. 1. + 12476. 1. 5. 37.0 23.0 5.5 4. 12.0 14.0 5. 3. 0.0 0. 1. + 12480. 1. 5. 37.0 16.5 3.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 12495. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 2. 2. 0.0 0. 1. + 12500. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 12501. 1. 2. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 12503. 1. 3. 37.0 16.5 2.0 3. 14.0 14.0 5. 4. 0.0 0. 1. + 12505. 1. 3. 37.0 16.5 2.0 3. 14.0 6.5 3. 3. 0.0 0. 1. + 12510. 1. 3. 32.0 13.0 2.0 4. 16.0 14.0 3. 3. 0.0 0. 1. + 12517. 1. 5. 32.0 13.0 0.0 1. 14.0 14.0 4. 4. 0.0 0. 1. + 12522. 1. 4. 32.0 9.0 3.0 3. 14.0 9.0 1. 4. 0.0 0. 1. + 12527. 1. 5. 32.0 13.0 2.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 12528. 1. 4. 27.0 2.5 0.0 1. 14.0 11.5 2. 2. 0.0 0. 1. + 12531. 1. 3. 27.0 13.0 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 12533. 1. 2. 37.0 9.0 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 12537. 1. 4. 42.0 9.0 0.0 1. 14.0 9.0 3. 2. 0.0 0. 1. + 12543. 1. 5. 22.0 0.5 0.0 3. 14.0 6.5 4. 5. 0.0 0. 1. + 12547. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 3. 6. 0.0 0. 1. + 12550. 1. 5. 27.0 2.5 0.0 3. 16.0 40.0 5. 5. 0.0 0. 1. + 12552. 1. 5. 42.0 23.0 4.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 12554. 1. 3. 42.0 23.0 4.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 12555. 1. 4. 27.0 6.0 1.0 3. 14.0 14.0 3. 6. 0.0 0. 1. + 12556. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 12560. 1. 4. 22.0 0.5 0.0 4. 16.0 9.0 5. 1. 0.0 0. 1. + 12561. 1. 5. 27.0 6.0 1.0 3. 20.0 9.0 4. 4. 0.0 0. 1. + 12562. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 5. 1. 0.0 0. 1. + 12564. 1. 3. 27.0 9.0 2.0 3. 14.0 4.0 2. 1. 0.0 0. 1. + 12565. 1. 5. 27.0 6.0 0.0 4. 14.0 20.0 3. 3. 0.0 0. 1. + 12568. 1. 5. 32.0 6.0 1.0 3. 20.0 11.5 2. 5. 0.0 0. 1. + 12573. 1. 4. 22.0 2.5 1.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 12575. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 12576. 1. 4. 32.0 9.0 2.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 12578. 1. 5. 32.0 13.0 0.0 1. 16.0 40.0 4. 5. 0.0 0. 1. + 12584. 1. 4. 32.0 13.0 3.0 2. 12.0 20.0 2. 5. 0.0 0. 1. + 12585. 1. 3. 32.0 2.5 0.0 2. 14.0 20.0 5. 3. 0.0 0. 1. + 12589. 1. 5. 22.0 2.5 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 12592. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 12601. 1. 4. 27.0 6.0 0.0 2. 14.0 40.0 3. 3. 0.0 0. 1. + 12613. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 12614. 1. 3. 32.0 2.5 0.0 1. 17.0 20.0 5. 6. 0.0 0. 1. + 12616. 1. 5. 32.0 6.0 0.0 2. 17.0 40.0 4. 5. 0.0 0. 1. + 12622. 1. 4. 42.0 13.0 0.0 2. 14.0 11.5 2. 2. 0.0 0. 1. + 12624. 1. 4. 22.0 6.0 2.0 4. 12.0 9.0 4. 4. 0.0 0. 1. + 12625. 1. 3. 17.5 0.5 0.0 2. 14.0 9.0 3. 2. 0.0 0. 1. + 12626. 1. 3. 42.0 23.0 5.5 3. 14.0 14.0 2. 4. 0.0 0. 1. + 12628. 1. 5. 32.0 16.5 2.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 12631. 1. 5. 22.0 0.5 0.0 1. 12.0 6.5 2. 4. 0.0 0. 1. + 12634. 1. 5. 22.0 6.0 2.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 12642. 1. 5. 27.0 2.5 0.0 2. 20.0 11.5 4. 6. 0.0 0. 1. + 12644. 1. 4. 22.0 2.5 0.0 1. 16.0 14.0 5. 6. 0.0 0. 1. + 12645. 1. 4. 27.0 9.0 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 12648. 1. 4. 32.0 9.0 1.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 12650. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 3. 1. 0.0 0. 1. + 12652. 1. 4. 32.0 16.5 3.0 4. 16.0 20.0 4. 6. 0.0 0. 1. + 12658. 1. 4. 42.0 16.5 4.0 4. 14.0 14.0 3. 4. 0.0 0. 1. + 12659. 1. 4. 22.0 0.5 0.0 1. 12.0 14.0 2. 2. 0.0 0. 1. + 12664. 1. 5. 32.0 13.0 3.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 12674. 1. 5. 32.0 13.0 3.0 2. 14.0 11.5 2. 3. 0.0 0. 1. + 12676. 1. 3. 42.0 23.0 3.0 4. 12.0 14.0 3. 2. 0.0 0. 1. + 12678. 1. 5. 22.0 2.5 0.0 2. 14.0 6.5 3. 1. 0.0 0. 1. + 12687. 1. 5. 27.0 9.0 2.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 12692. 1. 5. 27.0 2.5 0.0 3. 20.0 6.5 4. 6. 0.0 0. 1. + 12693. 1. 5. 17.5 2.5 0.0 4. 14.0 9.0 2. 2. 0.0 0. 1. + 12695. 1. 5. 27.0 6.0 1.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 12697. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 2. 2. 0.0 0. 1. + 12703. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 1. 0.0 0. 1. + 12706. 1. 4. 37.0 16.5 3.0 3. 12.0 20.0 4. 4. 0.0 0. 1. + 12726. 1. 3. 42.0 23.0 5.5 4. 12.0 11.5 2. 4. 0.0 0. 1. + 12727. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 2. 2. 0.0 0. 1. + 12730. 1. 4. 32.0 2.5 0.0 2. 14.0 20.0 4. 3. 0.0 0. 1. + 12731. 1. 3. 32.0 13.0 1.0 1. 14.0 14.0 2. 2. 0.0 0. 1. + 12739. 1. 5. 27.0 6.0 1.0 1. 16.0 20.0 4. 2. 0.0 0. 1. + 12740. 1. 4. 27.0 6.0 2.0 3. 17.0 20.0 6. 5. 0.0 0. 1. + 12742. 1. 5. 37.0 13.0 2.0 3. 20.0 40.0 4. 6. 0.0 0. 1. + 12744. 1. 5. 22.0 0.5 0.0 3. 16.0 11.5 3. 6. 0.0 0. 1. + 12747. 1. 4. 22.0 2.5 0.0 2. 16.0 14.0 5. 4. 0.0 0. 1. + 12752. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 12763. 1. 5. 27.0 6.0 0.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 12771. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 12774. 1. 5. 27.0 6.0 2.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 12804. 1. 4. 42.0 23.0 4.0 1. 14.0 40.0 4. 4. 0.0 0. 1. + 12813. 1. 5. 27.0 6.0 0.0 1. 14.0 40.0 3. 5. 0.0 0. 1. + 12816. 1. 3. 37.0 16.5 5.5 3. 14.0 20.0 3. 2. 0.0 0. 1. + 12822. 1. 5. 32.0 16.5 2.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 12825. 1. 4. 22.0 0.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 12827. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 12828. 1. 4. 32.0 9.0 2.0 2. 16.0 40.0 4. 4. 0.0 0. 1. + 12830. 1. 4. 27.0 2.5 0.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 12832. 1. 5. 27.0 6.0 2.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 12833. 1. 3. 32.0 13.0 1.0 1. 14.0 11.5 3. 6. 0.0 0. 1. + 12834. 1. 5. 32.0 13.0 3.0 4. 14.0 20.0 5. 5. 0.0 0. 1. + 12840. 1. 5. 37.0 2.5 0.0 2. 12.0 9.0 2. 4. 0.0 0. 1. + 12846. 1. 5. 42.0 23.0 2.0 1. 12.0 40.0 5. 2. 0.0 0. 1. + 12862. 1. 4. 32.0 9.0 3.0 3. 14.0 11.5 5. 5. 0.0 0. 1. + 12867. 1. 5. 37.0 13.0 0.0 1. 16.0 20.0 3. 5. 0.0 0. 1. + 12869. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 12873. 1. 4. 32.0 2.5 0.0 3. 16.0 20.0 2. 5. 0.0 0. 1. + 12877. 1. 3. 42.0 23.0 3.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 12881. 1. 4. 37.0 16.5 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 12884. 1. 5. 37.0 16.5 1.0 4. 17.0 20.0 4. 4. 0.0 0. 1. + 12894. 1. 4. 27.0 2.5 0.0 1. 16.0 11.5 4. 5. 0.0 0. 1. + 12897. 1. 4. 37.0 16.5 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 12900. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 12910. 1. 3. 32.0 6.0 2.0 3. 20.0 14.0 4. 2. 0.0 0. 1. + 12914. 1. 5. 42.0 23.0 2.0 1. 12.0 20.0 3. 2. 0.0 0. 1. + 12918. 1. 5. 37.0 16.5 3.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 12920. 1. 3. 37.0 16.5 3.0 2. 12.0 14.0 2. 3. 0.0 0. 1. + 12924. 1. 5. 32.0 16.5 4.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 12925. 1. 4. 27.0 9.0 2.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 12927. 1. 5. 32.0 16.5 1.0 1. 14.0 14.0 2. 2. 0.0 0. 1. + 12931. 1. 4. 27.0 6.0 0.0 2. 16.0 40.0 5. 5. 0.0 0. 1. + 12934. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 4. 2. 0.0 0. 1. + 12940. 1. 3. 32.0 13.0 2.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 12942. 1. 5. 42.0 23.0 1.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 12943. 1. 5. 22.0 0.5 0.0 2. 14.0 14.0 2. 5. 0.0 0. 1. + 12955. 1. 5. 32.0 2.5 0.0 2. 14.0 14.0 5. 2. 0.0 0. 1. + 12960. 1. 5. 42.0 23.0 2.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 12965. 1. 3. 37.0 23.0 3.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 12983. 1. 5. 27.0 2.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 12988. 1. 5. 27.0 2.5 0.0 1. 17.0 20.0 4. 6. 0.0 0. 1. + 13001. 1. 5. 32.0 13.0 0.0 2. 20.0 40.0 5. 4. 0.0 0. 1. + 13005. 1. 3. 42.0 23.0 4.0 2. 14.0 20.0 6. 6. 0.0 0. 1. + 13009. 1. 3. 22.0 2.5 0.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 13013. 1. 5. 27.0 6.0 1.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 13019. 1. 4. 27.0 9.0 3.0 1. 12.0 11.5 2. 2. 0.0 0. 1. + 13021. 1. 5. 27.0 9.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 13022. 1. 5. 42.0 23.0 2.0 4. 12.0 20.0 2. 2. 0.0 0. 1. + 13026. 1. 5. 42.0 23.0 2.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 13033. 1. 4. 22.0 2.5 1.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 13037. 1. 3. 42.0 23.0 2.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 13039. 1. 4. 22.0 0.5 0.0 1. 14.0 20.0 3. 3. 0.0 0. 1. + 13042. 1. 5. 37.0 16.5 2.0 1. 16.0 40.0 4. 6. 0.0 0. 1. + 13044. 1. 5. 22.0 6.0 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 13046. 1. 5. 37.0 9.0 1.0 2. 14.0 40.0 3. 5. 0.0 0. 1. + 13052. 1. 3. 22.0 6.0 1.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 13056. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 13057. 1. 5. 27.0 6.0 2.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 13058. 1. 4. 17.5 2.5 1.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 13060. 1. 5. 42.0 23.0 3.0 3. 12.0 40.0 3. 5. 0.0 0. 1. + 13064. 1. 5. 27.0 2.5 1.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 13068. 1. 3. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 13076. 1. 5. 27.0 2.5 2.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 13079. 1. 4. 27.0 2.5 1.0 2. 16.0 40.0 4. 6. 0.0 0. 1. + 13080. 1. 5. 27.0 2.5 1.0 1. 14.0 11.5 2. 2. 0.0 0. 1. + 13090. 1. 5. 27.0 2.5 0.0 1. 16.0 40.0 4. 4. 0.0 0. 1. + 13092. 1. 5. 27.0 2.5 0.0 4. 14.0 20.0 5. 5. 0.0 0. 1. + 13097. 1. 5. 32.0 9.0 2.0 3. 16.0 14.0 4. 2. 0.0 0. 1. + 13099. 1. 5. 42.0 23.0 1.0 3. 14.0 20.0 2. 5. 0.0 0. 1. + 13100. 1. 4. 32.0 9.0 2.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 13103. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 1. 0.0 0. 1. + 13105. 1. 4. 27.0 6.0 1.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 13107. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 4. 2. 0.0 0. 1. + 13112. 1. 5. 22.0 2.5 0.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 13119. 1. 4. 27.0 2.5 1.0 2. 14.0 9.0 5. 5. 0.0 0. 1. + 13120. 1. 4. 22.0 2.5 0.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 13125. 1. 4. 27.0 6.0 0.0 3. 20.0 40.0 6. 6. 0.0 0. 1. + 13129. 1. 5. 27.0 2.5 0.0 2. 14.0 40.0 5. 4. 0.0 0. 1. + 13132. 1. 5. 32.0 16.5 2.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 13134. 1. 5. 32.0 13.0 0.0 1. 16.0 40.0 4. 6. 0.0 0. 1. + 13136. 1. 4. 27.0 9.0 0.0 4. 14.0 9.0 3. 4. 0.0 0. 1. + 13140. 1. 5. 37.0 16.5 2.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 13142. 1. 5. 32.0 16.5 4.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 13145. 1. 5. 27.0 6.0 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 13150. 1. 5. 27.0 6.0 2.0 1. 16.0 14.0 3. 5. 0.0 0. 1. + 13151. 1. 5. 22.0 2.5 1.0 4. 14.0 14.0 2. 4. 0.0 0. 1. + 13168. 1. 3. 32.0 2.5 1.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 13172. 1. 5. 22.0 6.0 0.0 2. 12.0 6.5 2. 2. 0.0 0. 1. + 13174. 1. 5. 42.0 23.0 2.0 2. 12.0 20.0 4. 4. 0.0 0. 1. + 13176. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 3. 2. 0.0 0. 1. + 13182. 1. 4. 37.0 9.0 2.0 3. 20.0 20.0 4. 2. 0.0 0. 1. + 13189. 1. 5. 32.0 13.0 2.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 13191. 1. 5. 42.0 23.0 1.0 4. 20.0 14.0 4. 4. 0.0 0. 1. + 13192. 1. 5. 27.0 6.0 0.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 13202. 1. 3. 42.0 23.0 2.0 2. 17.0 20.0 3. 4. 0.0 0. 1. + 13204. 1. 4. 22.0 2.5 1.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 13208. 1. 4. 37.0 16.5 3.0 2. 14.0 9.0 3. 3. 0.0 0. 1. + 13211. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 3. 0.0 0. 1. + 13216. 1. 3. 27.0 6.0 0.0 1. 16.0 40.0 5. 5. 0.0 0. 1. + 13217. 1. 4. 27.0 9.0 2.0 3. 17.0 40.0 6. 6. 0.0 0. 1. + 13219. 1. 4. 37.0 16.5 2.0 4. 14.0 40.0 5. 5. 0.0 0. 1. + 13221. 1. 5. 27.0 2.5 0.0 4. 16.0 14.0 4. 6. 0.0 0. 1. + 13222. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 2. 4. 0.0 0. 1. + 13224. 1. 4. 32.0 13.0 1.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 13226. 1. 5. 42.0 23.0 5.5 3. 12.0 20.0 3. 5. 0.0 0. 1. + 13227. 1. 5. 22.0 0.5 0.0 3. 16.0 14.0 3. 2. 0.0 0. 1. + 13229. 1. 5. 27.0 2.5 1.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 13232. 1. 3. 27.0 9.0 1.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 13233. 1. 5. 42.0 13.0 5.5 2. 12.0 14.0 3. 5. 0.0 0. 1. + 13238. 1. 4. 27.0 6.0 1.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 13244. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 3. 2. 0.0 0. 1. + 13250. 1. 4. 32.0 13.0 2.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 13255. 1. 4. 42.0 23.0 2.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 13261. 1. 4. 37.0 23.0 5.5 4. 12.0 20.0 3. 5. 0.0 0. 1. + 13268. 1. 3. 22.0 2.5 0.0 2. 14.0 6.5 4. 2. 0.0 0. 1. + 13269. 1. 5. 27.0 6.0 2.0 1. 20.0 20.0 5. 5. 0.0 0. 1. + 13285. 1. 4. 27.0 2.5 2.0 2. 16.0 40.0 4. 6. 0.0 0. 1. + 13292. 1. 4. 22.0 0.5 0.0 1. 16.0 20.0 4. 2. 0.0 0. 1. + 13302. 1. 2. 32.0 16.5 4.0 2. 14.0 14.0 4. 2. 0.0 0. 1. + 13303. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 13308. 1. 5. 22.0 2.5 0.0 4. 16.0 6.5 2. 4. 0.0 0. 1. + 13313. 1. 2. 27.0 2.5 2.0 4. 12.0 11.5 2. 4. 0.0 0. 1. + 13321. 1. 4. 27.0 2.5 1.0 2. 14.0 11.5 5. 2. 0.0 0. 1. + 13325. 1. 5. 22.0 2.5 0.0 3. 16.0 14.0 3. 4. 0.0 0. 1. + 13331. 1. 5. 27.0 16.5 3.0 2. 14.0 11.5 2. 4. 0.0 0. 1. + 13336. 1. 4. 22.0 2.5 0.0 4. 16.0 20.0 3. 3. 0.0 0. 1. + 13338. 1. 5. 42.0 23.0 5.5 4. 14.0 14.0 3. 5. 0.0 0. 1. + 13341. 1. 3. 27.0 6.0 3.0 3. 14.0 14.0 4. 2. 0.0 0. 1. + 13351. 1. 5. 27.0 2.5 2.0 1. 14.0 40.0 4. 6. 0.0 0. 1. + 13366. 1. 5. 27.0 6.0 1.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 13371. 1. 4. 27.0 16.5 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 13374. 1. 2. 27.0 2.5 1.0 2. 14.0 11.5 3. 3. 0.0 0. 1. + 13375. 1. 2. 32.0 13.0 2.0 1. 12.0 14.0 2. 2. 0.0 0. 1. + 13385. 1. 5. 37.0 16.5 5.5 2. 12.0 20.0 3. 5. 0.0 0. 1. + 13386. 1. 5. 42.0 23.0 3.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 13397. 1. 4. 42.0 23.0 2.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 13401. 1. 5. 22.0 2.5 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 13417. 1. 5. 27.0 13.0 2.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 13424. 1. 5. 32.0 6.0 2.0 4. 20.0 20.0 6. 6. 0.0 0. 1. + 13427. 1. 4. 42.0 23.0 4.0 4. 14.0 14.0 4. 4. 0.0 0. 1. + 13434. 1. 5. 37.0 16.5 2.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 13435. 1. 4. 22.0 2.5 0.0 1. 12.0 20.0 3. 3. 0.0 0. 1. + 13446. 1. 4. 22.0 2.5 0.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 13448. 1. 3. 22.0 6.0 1.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 13453. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 13454. 1. 4. 37.0 16.5 3.0 3. 14.0 11.5 4. 3. 0.0 0. 1. + 13458. 1. 2. 42.0 13.0 0.0 2. 12.0 6.5 3. 4. 0.0 0. 1. + 13460. 1. 5. 27.0 2.5 0.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 13468. 1. 4. 27.0 6.0 1.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 13474. 1. 4. 27.0 9.0 2.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 13475. 1. 5. 22.0 2.5 0.0 1. 16.0 11.5 6. 4. 0.0 0. 1. + 13479. 1. 4. 42.0 23.0 3.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 13488. 1. 4. 32.0 9.0 3.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 13489. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 13490. 1. 4. 27.0 6.0 2.0 4. 17.0 6.5 4. 2. 0.0 0. 1. + 13502. 1. 5. 27.0 2.5 0.0 3. 20.0 40.0 5. 6. 0.0 0. 1. + 13503. 1. 5. 27.0 6.0 0.0 4. 14.0 9.0 3. 4. 0.0 0. 1. + 13506. 1. 5. 37.0 16.5 2.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 13508. 1. 4. 37.0 16.5 2.0 2. 14.0 14.0 4. 4. 0.0 0. 1. + 13519. 1. 4. 27.0 2.5 0.0 1. 17.0 6.5 4. 1. 0.0 0. 1. + 13528. 1. 4. 27.0 13.0 2.0 2. 12.0 6.5 3. 4. 0.0 0. 1. + 13530. 1. 3. 22.0 2.5 0.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 13538. 1. 3. 37.0 16.5 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 13540. 1. 3. 22.0 2.5 0.0 1. 14.0 6.5 3. 1. 0.0 0. 1. + 13541. 1. 4. 27.0 2.5 1.0 1. 17.0 9.0 4. 4. 0.0 0. 1. + 13546. 1. 5. 32.0 13.0 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 13555. 1. 5. 42.0 13.0 0.0 3. 12.0 20.0 5. 2. 0.0 0. 1. + 13556. 1. 4. 42.0 23.0 2.0 2. 12.0 11.5 4. 4. 0.0 0. 1. + 13557. 1. 4. 27.0 9.0 2.0 2. 14.0 14.0 2. 3. 0.0 0. 1. + 13561. 1. 5. 22.0 2.5 0.0 1. 14.0 6.5 3. 1. 0.0 0. 1. + 13562. 1. 5. 27.0 6.0 2.0 3. 16.0 20.0 5. 4. 0.0 0. 1. + 13569. 1. 3. 22.0 2.5 1.0 4. 14.0 11.5 2. 2. 0.0 0. 1. + 13571. 1. 4. 32.0 16.5 3.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 13577. 1. 5. 27.0 2.5 1.0 3. 17.0 9.0 1. 6. 0.0 0. 1. + 13581. 1. 4. 27.0 6.0 0.0 2. 17.0 11.5 4. 4. 0.0 0. 1. + 13583. 1. 5. 42.0 23.0 3.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 13587. 1. 5. 27.0 2.5 0.0 1. 20.0 20.0 4. 5. 0.0 0. 1. + 13588. 1. 4. 37.0 16.5 4.0 2. 14.0 11.5 1. 4. 0.0 0. 1. + 13594. 1. 5. 17.5 0.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 13599. 1. 5. 42.0 23.0 3.0 1. 20.0 40.0 4. 6. 0.0 0. 1. + 13600. 1. 5. 32.0 13.0 2.0 4. 14.0 11.5 3. 5. 0.0 0. 1. + 13627. 1. 4. 37.0 16.5 4.0 2. 14.0 20.0 2. 4. 0.0 0. 1. + 13630. 1. 5. 32.0 16.5 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 13634. 1. 5. 32.0 9.0 2.0 2. 12.0 14.0 4. 2. 0.0 0. 1. + 13636. 1. 5. 42.0 23.0 5.5 3. 12.0 20.0 5. 4. 0.0 0. 1. + 13645. 1. 5. 42.0 23.0 5.5 1. 12.0 20.0 3. 5. 0.0 0. 1. + 13651. 1. 5. 27.0 6.0 0.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 13654. 1. 4. 27.0 6.0 0.0 2. 14.0 40.0 2. 2. 0.0 0. 1. + 13657. 1. 4. 22.0 6.0 2.0 2. 12.0 9.0 2. 4. 0.0 0. 1. + 13662. 1. 5. 22.0 0.5 0.0 3. 12.0 6.5 2. 2. 0.0 0. 1. + 13663. 1. 3. 32.0 6.0 0.0 1. 20.0 14.0 4. 2. 0.0 0. 1. + 13667. 1. 5. 37.0 16.5 3.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 13669. 1. 5. 42.0 23.0 1.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 13674. 1. 5. 27.0 0.5 0.0 3. 20.0 40.0 4. 4. 0.0 0. 1. + 13675. 1. 4. 27.0 9.0 2.0 1. 12.0 20.0 4. 5. 0.0 0. 1. + 13680. 1. 5. 42.0 23.0 5.5 2. 14.0 40.0 4. 4. 0.0 0. 1. + 13682. 1. 4. 42.0 23.0 3.0 2. 14.0 11.5 3. 3. 0.0 0. 1. + 13683. 1. 4. 37.0 16.5 4.0 3. 14.0 20.0 2. 4. 0.0 0. 1. + 13695. 1. 4. 27.0 9.0 1.0 4. 12.0 20.0 4. 5. 0.0 0. 1. + 13697. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 13698. 1. 5. 32.0 9.0 2.0 2. 16.0 6.5 3. 2. 0.0 0. 1. + 13705. 1. 4. 22.0 2.5 0.0 1. 14.0 40.0 2. 2. 0.0 0. 1. + 13707. 1. 4. 32.0 6.0 1.0 4. 17.0 20.0 4. 6. 0.0 0. 1. + 13708. 1. 5. 22.0 6.0 1.0 2. 12.0 20.0 2. 4. 0.0 0. 1. + 13712. 1. 5. 32.0 13.0 1.0 3. 16.0 20.0 5. 6. 0.0 0. 1. + 13717. 1. 5. 27.0 9.0 0.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 13718. 1. 5. 27.0 13.0 2.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 13729. 1. 4. 27.0 6.0 0.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 13734. 1. 4. 32.0 9.0 2.0 4. 16.0 40.0 4. 5. 0.0 0. 1. + 13736. 1. 4. 37.0 23.0 5.5 2. 14.0 20.0 4. 4. 0.0 0. 1. + 13749. 1. 2. 22.0 6.0 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 13750. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 4. 3. 0.0 0. 1. + 13757. 1. 3. 27.0 9.0 3.0 4. 14.0 20.0 2. 2. 0.0 0. 1. + 13761. 1. 5. 37.0 16.5 3.0 3. 14.0 20.0 3. 3. 0.0 0. 1. + 13763. 1. 3. 37.0 23.0 4.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 13764. 1. 1. 42.0 13.0 2.0 1. 14.0 20.0 5. 5. 0.0 0. 1. + 13766. 1. 5. 17.5 0.5 0.0 4. 12.0 11.5 1. 4. 0.0 0. 1. + 13768. 1. 4. 32.0 23.0 3.0 2. 9.0 40.0 2. 6. 0.0 0. 1. + 13769. 1. 5. 37.0 13.0 2.0 2. 16.0 11.5 5. 2. 0.0 0. 1. + 13770. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 5. 5. 0.0 0. 1. + 13772. 1. 5. 22.0 2.5 1.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 13773. 1. 4. 42.0 23.0 4.0 2. 14.0 20.0 6. 2. 0.0 0. 1. + 13774. 1. 2. 42.0 16.5 2.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 13776. 1. 5. 27.0 2.5 1.0 3. 16.0 11.5 4. 2. 0.0 0. 1. + 13780. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 13783. 1. 4. 27.0 2.5 1.0 2. 14.0 9.0 3. 3. 0.0 0. 1. + 13784. 1. 4. 42.0 23.0 2.0 3. 16.0 40.0 3. 6. 0.0 0. 1. + 13798. 1. 4. 37.0 23.0 3.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 13809. 1. 4. 32.0 9.0 3.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 13815. 1. 3. 27.0 6.0 0.0 2. 14.0 6.5 4. 2. 0.0 0. 1. + 13842. 1. 4. 27.0 2.5 0.0 1. 16.0 20.0 4. 2. 0.0 0. 1. + 13846. 1. 4. 27.0 9.0 2.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 13847. 1. 5. 22.0 2.5 0.0 2. 14.0 9.0 3. 1. 0.0 0. 1. + 13854. 1. 5. 27.0 6.0 2.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 13857. 1. 4. 27.0 6.0 0.0 4. 9.0 9.0 2. 2. 0.0 0. 1. + 13860. 1. 4. 32.0 13.0 3.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 13864. 1. 1. 42.0 23.0 3.0 3. 12.0 14.0 2. 3. 0.0 0. 1. + 13865. 1. 3. 22.0 2.5 1.0 3. 12.0 6.5 3. 2. 0.0 0. 1. + 13867. 1. 4. 27.0 16.5 2.0 1. 12.0 20.0 2. 4. 0.0 0. 1. + 13869. 1. 3. 22.0 2.5 0.0 3. 14.0 11.5 4. 5. 0.0 0. 1. + 13873. 1. 4. 22.0 2.5 1.0 1. 14.0 6.5 4. 4. 0.0 0. 1. + 13876. 1. 5. 27.0 6.0 2.0 2. 14.0 20.0 1. 2. 0.0 0. 1. + 13878. 1. 4. 27.0 9.0 4.0 3. 14.0 14.0 2. 5. 0.0 0. 1. + 13884. 1. 4. 22.0 0.5 0.0 3. 17.0 11.5 4. 1. 0.0 0. 1. + 13886. 1. 4. 27.0 2.5 1.0 3. 16.0 9.0 4. 2. 0.0 0. 1. + 13894. 1. 5. 22.0 2.5 1.0 2. 14.0 6.5 2. 2. 0.0 0. 1. + 13897. 1. 5. 22.0 0.5 0.0 3. 14.0 9.0 3. 5. 0.0 0. 1. + 13906. 1. 5. 32.0 16.5 4.0 2. 14.0 20.0 4. 6. 0.0 0. 1. + 13908. 1. 4. 22.0 2.5 0.0 1. 16.0 20.0 2. 5. 0.0 0. 1. + 13911. 1. 3. 27.0 9.0 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 13912. 1. 5. 22.0 0.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 13918. 1. 4. 42.0 13.0 2.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 13922. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 13927. 1. 4. 27.0 6.0 0.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 13933. 1. 5. 22.0 2.5 1.0 1. 16.0 9.0 3. 2. 0.0 0. 1. + 13938. 1. 5. 32.0 16.5 2.0 2. 14.0 40.0 5. 5. 0.0 0. 1. + 13944. 1. 5. 27.0 6.0 0.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 13952. 1. 5. 37.0 16.5 2.0 1. 14.0 11.5 5. 2. 0.0 0. 1. + 13957. 1. 3. 27.0 6.0 0.0 2. 16.0 11.5 5. 4. 0.0 0. 1. + 13958. 1. 5. 32.0 9.0 2.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 13968. 1. 4. 27.0 13.0 2.0 1. 14.0 20.0 4. 4. 0.0 0. 1. + 13970. 1. 5. 22.0 2.5 0.0 1. 12.0 9.0 2. 4. 0.0 0. 1. + 13971. 1. 5. 27.0 2.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 13976. 1. 2. 22.0 2.5 1.0 3. 16.0 9.0 3. 2. 0.0 0. 1. + 13977. 1. 5. 42.0 13.0 1.0 3. 12.0 40.0 2. 6. 0.0 0. 1. + 13983. 1. 3. 32.0 16.5 3.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 13985. 1. 4. 27.0 6.0 2.0 2. 14.0 20.0 2. 3. 0.0 0. 1. + 13988. 1. 5. 42.0 23.0 2.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 13989. 1. 4. 42.0 23.0 3.0 4. 16.0 20.0 3. 5. 0.0 0. 1. + 13990. 1. 4. 37.0 16.5 1.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 14009. 1. 4. 32.0 16.5 3.0 4. 12.0 11.5 2. 2. 0.0 0. 1. + 14013. 1. 5. 22.0 2.5 2.0 1. 14.0 40.0 3. 4. 0.0 0. 1. + 14014. 1. 3. 27.0 6.0 0.0 1. 14.0 14.0 3. 4. 0.0 0. 1. + 14018. 1. 5. 32.0 16.5 3.0 1. 12.0 11.5 2. 5. 0.0 0. 1. + 14019. 1. 5. 27.0 9.0 2.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 14024. 1. 5. 27.0 6.0 2.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 14026. 1. 4. 27.0 6.0 1.0 2. 14.0 14.0 4. 5. 0.0 0. 1. + 14059. 1. 5. 27.0 16.5 1.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 14061. 1. 5. 17.5 0.5 0.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 14064. 1. 4. 42.0 23.0 2.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 14068. 1. 4. 37.0 16.5 3.0 1. 12.0 20.0 4. 4. 0.0 0. 1. + 14070. 1. 5. 42.0 23.0 3.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 14072. 1. 5. 27.0 2.5 0.0 1. 16.0 14.0 3. 2. 0.0 0. 1. + 14076. 1. 4. 37.0 23.0 3.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 14087. 1. 5. 27.0 2.5 0.0 2. 14.0 14.0 5. 1. 0.0 0. 1. + 14088. 1. 3. 17.5 2.5 0.0 2. 12.0 11.5 1. 2. 0.0 0. 1. + 14093. 1. 4. 42.0 23.0 1.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 14095. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 14100. 1. 3. 22.0 2.5 1.0 3. 14.0 14.0 5. 4. 0.0 0. 1. + 14101. 1. 5. 17.5 0.5 0.0 1. 12.0 11.5 3. 2. 0.0 0. 1. + 14102. 1. 5. 32.0 6.0 1.0 1. 17.0 14.0 4. 6. 0.0 0. 1. + 14104. 1. 3. 27.0 2.5 0.0 1. 17.0 20.0 4. 2. 0.0 0. 1. + 14109. 1. 3. 37.0 16.5 3.0 4. 14.0 20.0 4. 6. 0.0 0. 1. + 14116. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 14123. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 14127. 1. 5. 32.0 16.5 3.0 4. 14.0 40.0 4. 5. 0.0 0. 1. + 14129. 1. 4. 27.0 6.0 1.0 1. 14.0 11.5 3. 5. 0.0 0. 1. + 14130. 1. 4. 22.0 0.5 0.0 3. 16.0 9.0 4. 1. 0.0 0. 1. + 14136. 1. 4. 22.0 2.5 0.0 4. 14.0 14.0 3. 5. 0.0 0. 1. + 14144. 1. 4. 32.0 16.5 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 14145. 1. 4. 22.0 2.5 0.0 1. 12.0 14.0 2. 4. 0.0 0. 1. + 14152. 1. 3. 27.0 2.5 0.0 2. 12.0 9.0 3. 1. 0.0 0. 1. + 14153. 1. 4. 22.0 2.5 0.0 1. 16.0 6.5 3. 4. 0.0 0. 1. + 14159. 1. 4. 27.0 6.0 1.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 14164. 1. 4. 32.0 16.5 4.0 4. 14.0 40.0 3. 5. 0.0 0. 1. + 14165. 1. 1. 27.0 6.0 0.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 14167. 1. 5. 27.0 6.0 2.0 4. 14.0 20.0 3. 2. 0.0 0. 1. + 14169. 1. 5. 32.0 16.5 3.0 1. 12.0 20.0 2. 5. 0.0 0. 1. + 14178. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 5. 4. 0.0 0. 1. + 14179. 1. 4. 27.0 0.5 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 14183. 1. 4. 17.5 2.5 1.0 1. 12.0 6.5 2. 4. 0.0 0. 1. + 14184. 1. 5. 42.0 23.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 14185. 1. 4. 37.0 9.0 1.0 3. 12.0 14.0 2. 5. 0.0 0. 1. + 14188. 1. 5. 42.0 23.0 3.0 3. 16.0 11.5 3. 3. 0.0 0. 1. + 14189. 1. 5. 22.0 2.5 0.0 2. 14.0 6.5 1. 4. 0.0 0. 1. + 14192. 1. 5. 42.0 23.0 3.0 3. 12.0 14.0 4. 5. 0.0 0. 1. + 14203. 1. 3. 22.0 2.5 0.0 4. 14.0 14.0 3. 5. 0.0 0. 1. + 14214. 1. 5. 27.0 9.0 2.0 2. 12.0 14.0 3. 3. 0.0 0. 1. + 14215. 1. 4. 37.0 16.5 2.0 4. 14.0 14.0 4. 4. 0.0 0. 1. + 14219. 1. 4. 42.0 23.0 3.0 1. 12.0 20.0 3. 5. 0.0 0. 1. + 14220. 1. 4. 27.0 16.5 2.0 3. 16.0 9.0 3. 4. 0.0 0. 1. + 14224. 1. 5. 32.0 2.5 0.0 4. 17.0 40.0 5. 4. 0.0 0. 1. + 14225. 1. 5. 27.0 9.0 1.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 14228. 1. 5. 27.0 6.0 0.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 14229. 1. 1. 37.0 13.0 2.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 14230. 1. 2. 17.5 0.5 0.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 14243. 1. 5. 27.0 6.0 2.0 2. 14.0 11.5 3. 3. 0.0 0. 1. + 14251. 1. 4. 42.0 23.0 3.0 2. 12.0 40.0 5. 6. 0.0 0. 1. + 14254. 1. 5. 32.0 23.0 3.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 14256. 1. 4. 32.0 13.0 3.0 2. 14.0 20.0 4. 6. 0.0 0. 1. + 14258. 1. 4. 17.5 0.5 0.0 2. 16.0 9.0 4. 4. 0.0 0. 1. + 14259. 1. 5. 27.0 0.5 0.0 3. 14.0 40.0 2. 2. 0.0 0. 1. + 14260. 1. 4. 27.0 6.0 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 14262. 1. 5. 32.0 13.0 3.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 14266. 1. 4. 22.0 2.5 0.0 1. 17.0 20.0 4. 5. 0.0 0. 1. + 14279. 1. 5. 32.0 2.5 0.0 1. 20.0 11.5 2. 1. 0.0 0. 1. + 14281. 1. 2. 32.0 16.5 3.0 4. 12.0 9.0 5. 5. 0.0 0. 1. + 14282. 1. 3. 32.0 9.0 0.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 14290. 1. 3. 22.0 0.5 0.0 2. 17.0 9.0 1. 5. 0.0 0. 1. + 14301. 1. 4. 27.0 9.0 2.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 14313. 1. 5. 42.0 23.0 3.0 3. 12.0 40.0 5. 4. 0.0 0. 1. + 14321. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 14333. 1. 5. 22.0 2.5 1.0 1. 14.0 11.5 2. 2. 0.0 0. 1. + 14341. 1. 5. 42.0 23.0 3.0 2. 12.0 40.0 5. 5. 0.0 0. 1. + 14352. 1. 5. 37.0 16.5 4.0 3. 20.0 40.0 4. 4. 0.0 0. 1. + 14355. 1. 4. 22.0 2.5 1.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 14369. 1. 3. 27.0 6.0 1.0 1. 17.0 40.0 5. 6. 0.0 0. 1. + 14377. 1. 2. 27.0 2.5 0.0 3. 12.0 40.0 3. 2. 0.0 0. 1. + 14379. 1. 4. 22.0 6.0 2.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 14380. 1. 5. 27.0 9.0 0.0 1. 17.0 40.0 4. 6. 0.0 0. 1. + 14384. 1. 4. 22.0 2.5 2.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 14390. 1. 4. 22.0 2.5 1.0 2. 12.0 11.5 3. 1. 0.0 0. 1. + 14403. 1. 4. 42.0 23.0 2.0 2. 12.0 20.0 2. 5. 0.0 0. 1. + 14406. 1. 3. 32.0 6.0 0.0 1. 16.0 14.0 4. 4. 0.0 0. 1. + 14413. 1. 5. 22.0 2.5 1.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 14418. 1. 5. 22.0 2.5 0.0 2. 12.0 6.5 4. 1. 0.0 0. 1. + 14427. 1. 4. 37.0 23.0 2.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 14431. 1. 3. 27.0 6.0 1.0 2. 12.0 11.5 4. 2. 0.0 0. 1. + 14438. 1. 5. 32.0 13.0 3.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 14446. 1. 4. 32.0 16.5 2.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 14447. 1. 5. 42.0 23.0 3.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 14448. 1. 4. 32.0 13.0 2.0 4. 14.0 20.0 2. 4. 0.0 0. 1. + 14452. 1. 4. 32.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 14468. 1. 4. 42.0 23.0 2.0 3. 14.0 40.0 5. 5. 0.0 0. 1. + 14471. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 14474. 1. 4. 27.0 6.0 0.0 1. 16.0 20.0 3. 2. 0.0 0. 1. + 14482. 1. 5. 27.0 2.5 0.0 4. 14.0 9.0 3. 6. 0.0 0. 1. + 14489. 1. 2. 22.0 2.5 0.0 3. 16.0 4.0 4. 5. 0.0 0. 1. + 14491. 1. 5. 27.0 6.0 1.0 2. 16.0 14.0 4. 6. 0.0 0. 1. + 14508. 1. 5. 27.0 6.0 0.0 2. 17.0 20.0 4. 6. 0.0 0. 1. + 14511. 1. 5. 27.0 6.0 1.0 2. 12.0 11.5 5. 5. 0.0 0. 1. + 14516. 1. 4. 22.0 2.5 0.0 2. 16.0 11.5 3. 4. 0.0 0. 1. + 14520. 1. 4. 27.0 9.0 1.0 1. 14.0 20.0 3. 4. 0.0 0. 1. + 14522. 1. 4. 32.0 6.0 2.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 14528. 1. 5. 22.0 0.5 0.0 2. 14.0 6.5 3. 1. 0.0 0. 1. + 14532. 1. 5. 22.0 2.5 2.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 14537. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 14539. 1. 4. 32.0 16.5 2.0 2. 9.0 11.5 3. 5. 0.0 0. 1. + 14541. 1. 5. 27.0 6.0 0.0 1. 14.0 40.0 3. 5. 0.0 0. 1. + 14542. 1. 5. 22.0 6.0 2.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 14546. 1. 5. 22.0 2.5 1.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 14565. 1. 4. 27.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 14569. 1. 5. 27.0 2.5 0.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 14570. 1. 5. 27.0 6.0 2.0 4. 12.0 20.0 2. 5. 0.0 0. 1. + 14572. 1. 5. 22.0 0.5 0.0 2. 14.0 11.5 2. 5. 0.0 0. 1. + 14578. 1. 5. 22.0 2.5 2.0 2. 12.0 6.5 2. 2. 0.0 0. 1. + 14580. 1. 5. 27.0 2.5 0.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 14585. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 3. 0.0 0. 1. + 14588. 1. 5. 17.5 0.5 0.0 4. 12.0 6.5 2. 4. 0.0 0. 1. + 14589. 1. 5. 32.0 13.0 2.0 2. 14.0 11.5 5. 4. 0.0 0. 1. + 14598. 1. 3. 27.0 6.0 0.0 2. 12.0 20.0 5. 5. 0.0 0. 1. + 14603. 1. 4. 37.0 16.5 3.0 3. 12.0 40.0 3. 5. 0.0 0. 1. + 14612. 1. 5. 32.0 13.0 2.0 2. 17.0 14.0 4. 3. 0.0 0. 1. + 14621. 1. 4. 22.0 2.5 1.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 14623. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 5. 5. 0.0 0. 1. + 14627. 1. 5. 32.0 9.0 2.0 4. 16.0 11.5 4. 5. 0.0 0. 1. + 14630. 1. 4. 27.0 6.0 1.0 2. 14.0 11.5 2. 2. 0.0 0. 1. + 14642. 1. 4. 27.0 6.0 1.0 2. 14.0 11.5 2. 3. 0.0 0. 1. + 14643. 1. 5. 32.0 2.5 0.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 14649. 1. 5. 22.0 0.5 0.0 1. 14.0 20.0 5. 6. 0.0 0. 1. + 14653. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 2. 2. 0.0 0. 1. + 14654. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 4. 1. 0.0 0. 1. + 14664. 1. 5. 42.0 16.5 3.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 14669. 1. 5. 42.0 16.5 2.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 14676. 1. 5. 22.0 0.5 0.0 3. 14.0 9.0 3. 3. 0.0 0. 1. + 14677. 1. 4. 22.0 2.5 1.0 1. 14.0 11.5 2. 5. 0.0 0. 1. + 14686. 1. 5. 42.0 23.0 5.5 2. 12.0 20.0 2. 2. 0.0 0. 1. + 14693. 1. 5. 27.0 2.5 0.0 2. 16.0 14.0 3. 6. 0.0 0. 1. + 14699. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 14700. 1. 4. 22.0 0.5 0.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 14701. 1. 5. 27.0 6.0 0.0 2. 14.0 11.5 4. 1. 0.0 0. 1. + 14706. 1. 5. 27.0 6.0 0.0 4. 17.0 20.0 4. 4. 0.0 0. 1. + 14713. 1. 5. 37.0 23.0 2.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 14715. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 14719. 1. 4. 22.0 2.5 0.0 1. 12.0 20.0 3. 3. 0.0 0. 1. + 14723. 1. 5. 37.0 13.0 2.0 2. 14.0 14.0 5. 2. 0.0 0. 1. + 14726. 1. 4. 17.5 0.5 0.0 4. 12.0 6.5 2. 5. 0.0 0. 1. + 14728. 1. 4. 22.0 2.5 1.0 1. 14.0 20.0 3. 2. 0.0 0. 1. + 14730. 1. 5. 27.0 2.5 0.0 1. 17.0 11.5 4. 5. 0.0 0. 1. + 14735. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 14737. 1. 4. 27.0 6.0 1.0 3. 16.0 11.5 3. 1. 0.0 0. 1. + 14743. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 3. 2. 0.0 0. 1. + 14757. 1. 1. 42.0 23.0 4.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 14760. 1. 4. 27.0 6.0 1.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 14767. 1. 5. 22.0 2.5 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 14774. 1. 4. 27.0 6.0 1.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 14779. 1. 4. 22.0 2.5 0.0 1. 12.0 9.0 3. 2. 0.0 0. 1. + 14784. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 4. 2. 0.0 0. 1. + 14791. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 14802. 1. 5. 17.5 0.5 0.0 1. 14.0 14.0 3. 5. 0.0 0. 1. + 14808. 1. 3. 37.0 16.5 3.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 14811. 1. 4. 32.0 2.5 1.0 3. 17.0 20.0 4. 3. 0.0 0. 1. + 14812. 1. 5. 32.0 16.5 3.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 14815. 1. 5. 22.0 6.0 2.0 2. 12.0 20.0 2. 5. 0.0 0. 1. + 14823. 1. 4. 27.0 6.0 0.0 2. 16.0 6.5 3. 6. 0.0 0. 1. + 14827. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 3. 4. 0.0 0. 1. + 14836. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 5. 2. 0.0 0. 1. + 14839. 1. 4. 22.0 6.0 3.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 14846. 1. 2. 42.0 16.5 2.0 3. 16.0 14.0 4. 2. 0.0 0. 1. + 14858. 1. 4. 27.0 6.0 1.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 14867. 1. 5. 32.0 13.0 2.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 14876. 1. 5. 27.0 6.0 1.0 2. 14.0 9.0 3. 1. 0.0 0. 1. + 14877. 1. 4. 22.0 0.5 0.0 3. 14.0 6.5 3. 1. 0.0 0. 1. + 14882. 1. 5. 32.0 16.5 3.0 4. 16.0 40.0 5. 6. 0.0 0. 1. + 14887. 1. 4. 27.0 6.0 0.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 14902. 1. 5. 27.0 6.0 1.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 14928. 1. 5. 32.0 13.0 3.0 2. 14.0 9.0 4. 6. 0.0 0. 1. + 14939. 1. 5. 22.0 2.5 0.0 1. 14.0 40.0 3. 5. 0.0 0. 1. + 14941. 1. 3. 27.0 2.5 2.0 2. 14.0 9.0 3. 1. 0.0 0. 1. + 14956. 1. 5. 27.0 6.0 0.0 2. 14.0 11.5 4. 6. 0.0 0. 1. + 14960. 1. 3. 22.0 0.5 0.0 1. 16.0 20.0 3. 3. 0.0 0. 1. + 14962. 1. 5. 27.0 6.0 1.0 2. 17.0 11.5 4. 4. 0.0 0. 1. + 14963. 1. 5. 27.0 2.5 0.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 14967. 1. 5. 32.0 16.5 4.0 4. 14.0 14.0 3. 3. 0.0 0. 1. + 14972. 1. 4. 42.0 23.0 4.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 14976. 1. 3. 27.0 9.0 2.0 1. 12.0 14.0 2. 4. 0.0 0. 1. + 14978. 1. 5. 32.0 16.5 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 14983. 1. 2. 42.0 23.0 2.0 1. 14.0 20.0 2. 2. 0.0 0. 1. + 14987. 1. 5. 37.0 16.5 2.0 1. 12.0 40.0 2. 5. 0.0 0. 1. + 14988. 1. 5. 27.0 6.0 1.0 4. 17.0 11.5 4. 6. 0.0 0. 1. + 14995. 1. 4. 37.0 2.5 0.0 3. 12.0 40.0 5. 5. 0.0 0. 1. + 15005. 1. 5. 27.0 2.5 1.0 2. 14.0 11.5 2. 2. 0.0 0. 1. + 15008. 1. 4. 27.0 2.5 0.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 15014. 1. 5. 27.0 2.5 0.0 4. 14.0 11.5 4. 4. 0.0 0. 1. + 15020. 1. 4. 27.0 9.0 0.0 1. 14.0 20.0 2. 4. 0.0 0. 1. + 15022. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 15023. 1. 4. 22.0 2.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 15047. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 15051. 1. 4. 17.5 0.5 0.0 1. 12.0 9.0 3. 1. 0.0 0. 1. + 15056. 1. 4. 27.0 2.5 0.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 15069. 1. 5. 17.5 0.5 0.0 1. 12.0 9.0 3. 4. 0.0 0. 1. + 15070. 1. 4. 32.0 13.0 2.0 1. 16.0 11.5 4. 4. 0.0 0. 1. + 15072. 1. 4. 27.0 2.5 0.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 15074. 1. 5. 27.0 9.0 2.0 3. 12.0 14.0 3. 2. 0.0 0. 1. + 15076. 1. 4. 32.0 6.0 1.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 15078. 1. 3. 27.0 2.5 0.0 2. 20.0 20.0 4. 4. 0.0 0. 1. + 15083. 1. 5. 22.0 0.5 0.0 2. 12.0 9.0 5. 1. 0.0 0. 1. + 15090. 1. 4. 42.0 23.0 2.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 15105. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 15107. 1. 5. 27.0 6.0 2.0 2. 14.0 11.5 4. 2. 0.0 0. 1. + 15111. 1. 5. 22.0 2.5 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 15112. 1. 5. 27.0 6.0 0.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 15123. 1. 4. 42.0 23.0 2.0 2. 17.0 20.0 2. 4. 0.0 0. 1. + 15130. 1. 5. 32.0 2.5 0.0 2. 14.0 20.0 2. 6. 0.0 0. 1. + 15135. 1. 5. 22.0 2.5 0.0 1. 14.0 14.0 4. 4. 0.0 0. 1. + 15140. 1. 4. 22.0 2.5 0.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 15141. 1. 5. 42.0 23.0 5.5 3. 20.0 40.0 4. 6. 0.0 0. 1. + 15150. 1. 5. 27.0 2.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 15153. 1. 4. 37.0 9.0 0.0 3. 14.0 14.0 4. 4. 0.0 0. 1. + 15168. 1. 3. 27.0 2.5 1.0 3. 17.0 14.0 4. 5. 0.0 0. 1. + 15171. 1. 5. 42.0 23.0 4.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 15176. 1. 4. 22.0 2.5 0.0 2. 14.0 6.5 3. 5. 0.0 0. 1. + 15180. 1. 5. 22.0 2.5 0.0 1. 14.0 14.0 3. 5. 0.0 0. 1. + 15182. 1. 5. 32.0 2.5 1.0 1. 14.0 20.0 4. 6. 0.0 0. 1. + 15185. 1. 3. 27.0 9.0 2.0 4. 12.0 11.5 3. 3. 0.0 0. 1. + 15188. 1. 4. 22.0 0.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 15190. 1. 2. 27.0 6.0 1.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 15194. 1. 5. 42.0 23.0 5.5 3. 14.0 11.5 5. 5. 0.0 0. 1. + 15200. 1. 5. 42.0 23.0 4.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 15209. 1. 4. 32.0 13.0 3.0 1. 12.0 14.0 3. 5. 0.0 0. 1. + 15212. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 15217. 1. 4. 37.0 16.5 2.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 15218. 1. 5. 37.0 16.5 4.0 2. 12.0 9.0 3. 5. 0.0 0. 1. + 15229. 1. 2. 27.0 6.0 1.0 3. 14.0 9.0 4. 4. 0.0 0. 1. + 15235. 1. 4. 27.0 6.0 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 15247. 1. 4. 22.0 6.0 0.0 3. 16.0 9.0 3. 2. 0.0 0. 1. + 15249. 1. 5. 27.0 6.0 1.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 15251. 1. 4. 22.0 2.5 0.0 2. 14.0 4.0 3. 4. 0.0 0. 1. + 15253. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 2. 5. 0.0 0. 1. + 15256. 1. 4. 22.0 2.5 1.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 15257. 1. 5. 27.0 6.0 0.0 4. 20.0 20.0 3. 5. 0.0 0. 1. + 15264. 1. 3. 42.0 23.0 3.0 2. 12.0 40.0 5. 5. 0.0 0. 1. + 15268. 1. 4. 22.0 6.0 2.0 3. 9.0 11.5 3. 4. 0.0 0. 1. + 15270. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 15275. 1. 5. 27.0 2.5 0.0 2. 16.0 20.0 4. 2. 0.0 0. 1. + 15276. 1. 5. 22.0 2.5 1.0 4. 14.0 11.5 4. 2. 0.0 0. 1. + 15278. 1. 4. 42.0 16.5 2.0 4. 17.0 40.0 4. 5. 0.0 0. 1. + 15281. 1. 4. 42.0 23.0 5.5 3. 14.0 20.0 5. 3. 0.0 0. 1. + 15286. 1. 4. 27.0 6.0 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 15289. 1. 4. 22.0 6.0 0.0 3. 17.0 14.0 4. 3. 0.0 0. 1. + 15292. 1. 4. 27.0 2.5 0.0 4. 16.0 9.0 3. 4. 0.0 0. 1. + 15294. 1. 4. 27.0 6.0 1.0 1. 17.0 14.0 4. 5. 0.0 0. 1. + 15295. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 15310. 1. 5. 27.0 6.0 2.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 15311. 1. 5. 32.0 13.0 2.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 15313. 1. 4. 22.0 2.5 0.0 3. 17.0 11.5 4. 1. 0.0 0. 1. + 15321. 1. 5. 27.0 13.0 2.0 4. 12.0 20.0 3. 5. 0.0 0. 1. + 15343. 1. 5. 22.0 2.5 3.0 3. 14.0 6.5 3. 5. 0.0 0. 1. + 15346. 1. 3. 42.0 23.0 3.0 3. 14.0 14.0 5. 3. 0.0 0. 1. + 15353. 1. 4. 27.0 6.0 1.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 15354. 1. 5. 22.0 2.5 0.0 2. 17.0 11.5 3. 1. 0.0 0. 1. + 15356. 1. 4. 32.0 16.5 3.0 3. 12.0 14.0 5. 5. 0.0 0. 1. + 15361. 1. 5. 17.5 0.5 0.0 2. 14.0 9.0 3. 6. 0.0 0. 1. + 15364. 1. 4. 22.0 2.5 0.0 4. 14.0 9.0 3. 4. 0.0 0. 1. + 15368. 1. 4. 42.0 16.5 3.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 15372. 1. 4. 27.0 9.0 1.0 1. 12.0 14.0 2. 4. 0.0 0. 1. + 15377. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 5. 1. 0.0 0. 1. + 15378. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 2. 0.0 0. 1. + 15387. 1. 5. 27.0 2.5 0.0 2. 14.0 20.0 2. 6. 0.0 0. 1. + 15390. 1. 4. 22.0 2.5 0.0 4. 20.0 20.0 2. 5. 0.0 0. 1. + 15397. 1. 3. 27.0 6.0 0.0 3. 14.0 40.0 3. 5. 0.0 0. 1. + 15402. 1. 5. 32.0 13.0 2.0 1. 17.0 40.0 5. 6. 0.0 0. 1. + 15404. 1. 5. 37.0 16.5 3.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 15414. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 2. 2. 0.0 0. 1. + 15419. 1. 5. 22.0 6.0 1.0 2. 14.0 9.0 4. 4. 0.0 0. 1. + 15420. 1. 3. 27.0 2.5 0.0 1. 16.0 11.5 3. 2. 0.0 0. 1. + 15426. 1. 4. 32.0 13.0 3.0 2. 16.0 40.0 4. 5. 0.0 0. 1. + 15432. 1. 5. 22.0 2.5 0.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 15435. 1. 5. 37.0 13.0 3.0 3. 16.0 20.0 3. 4. 0.0 0. 1. + 15436. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 4. 3. 0.0 0. 1. + 15438. 1. 5. 27.0 6.0 0.0 3. 14.0 14.0 4. 4. 0.0 0. 1. + 15439. 1. 4. 22.0 2.5 0.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 15445. 1. 4. 27.0 2.5 2.0 2. 14.0 11.5 3. 6. 0.0 0. 1. + 15446. 1. 4. 27.0 9.0 3.0 3. 14.0 6.5 3. 2. 0.0 0. 1. + 15452. 1. 4. 27.0 9.0 1.0 2. 14.0 14.0 2. 4. 0.0 0. 1. + 15455. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 3. 2. 0.0 0. 1. + 15459. 1. 5. 42.0 23.0 1.0 2. 20.0 40.0 6. 4. 0.0 0. 1. + 15461. 1. 4. 27.0 2.5 0.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 15463. 1. 5. 37.0 13.0 2.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 15465. 1. 5. 32.0 9.0 1.0 2. 14.0 11.5 5. 5. 0.0 0. 1. + 15469. 1. 4. 22.0 2.5 0.0 4. 12.0 11.5 3. 4. 0.0 0. 1. + 15470. 1. 4. 22.0 6.0 1.0 1. 12.0 9.0 3. 4. 0.0 0. 1. + 15471. 1. 5. 27.0 2.5 1.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 15473. 1. 5. 22.0 6.0 2.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 15474. 1. 4. 22.0 2.5 1.0 4. 12.0 9.0 3. 2. 0.0 0. 1. + 15478. 1. 4. 37.0 16.5 2.0 2. 20.0 40.0 4. 5. 0.0 0. 1. + 15479. 1. 5. 32.0 13.0 3.0 3. 14.0 14.0 2. 2. 0.0 0. 1. + 15486. 1. 4. 42.0 23.0 2.0 4. 16.0 20.0 4. 5. 0.0 0. 1. + 15490. 1. 5. 27.0 6.0 1.0 3. 16.0 9.0 4. 4. 0.0 0. 1. + 15499. 1. 4. 27.0 2.5 0.0 2. 12.0 11.5 2. 5. 0.0 0. 1. + 15500. 1. 3. 27.0 9.0 1.0 4. 12.0 14.0 3. 5. 0.0 0. 1. + 15501. 1. 5. 37.0 23.0 4.0 2. 14.0 40.0 3. 5. 0.0 0. 1. + 15513. 1. 3. 27.0 6.0 2.0 1. 14.0 20.0 4. 4. 0.0 0. 1. + 15516. 1. 5. 22.0 2.5 0.0 1. 12.0 14.0 2. 4. 0.0 0. 1. + 15521. 1. 5. 22.0 2.5 0.0 4. 14.0 9.0 4. 2. 0.0 0. 1. + 15530. 1. 4. 22.0 2.5 0.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 15532. 1. 3. 17.5 2.5 0.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 15535. 1. 5. 22.0 2.5 0.0 2. 16.0 14.0 3. 3. 0.0 0. 1. + 15546. 1. 5. 42.0 23.0 4.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 15558. 1. 4. 17.5 2.5 1.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 15568. 1. 4. 32.0 13.0 2.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 15569. 1. 5. 22.0 0.5 0.0 2. 12.0 6.5 3. 2. 0.0 0. 1. + 15577. 1. 3. 22.0 6.0 1.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 15578. 1. 3. 32.0 13.0 2.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 15579. 1. 5. 32.0 9.0 0.0 3. 17.0 40.0 6. 6. 0.0 0. 1. + 15589. 1. 4. 42.0 16.5 1.0 3. 14.0 40.0 3. 6. 0.0 0. 1. + 15595. 1. 3. 42.0 16.5 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 15601. 1. 4. 27.0 2.5 0.0 3. 16.0 40.0 3. 5. 0.0 0. 1. + 15604. 1. 4. 17.5 0.5 0.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 15609. 1. 5. 27.0 2.5 1.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 15612. 1. 5. 27.0 2.5 0.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 15615. 1. 5. 22.0 2.5 0.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 15616. 1. 4. 27.0 6.0 1.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 15619. 1. 5. 22.0 0.5 0.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 15622. 1. 4. 32.0 6.0 2.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 15626. 1. 3. 22.0 2.5 1.0 1. 12.0 9.0 3. 4. 0.0 0. 1. + 15627. 1. 2. 22.0 2.5 0.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 15629. 1. 5. 27.0 2.5 1.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 15633. 1. 5. 22.0 2.5 0.0 1. 17.0 14.0 4. 4. 0.0 0. 1. + 15634. 1. 4. 27.0 6.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 15637. 1. 5. 27.0 13.0 2.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 15640. 1. 5. 22.0 2.5 0.0 1. 14.0 4.0 1. 1. 0.0 0. 1. + 15645. 1. 4. 22.0 6.0 1.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 15647. 1. 5. 32.0 16.5 4.0 3. 14.0 40.0 4. 6. 0.0 0. 1. + 15649. 1. 5. 27.0 6.0 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 15650. 1. 4. 32.0 13.0 2.0 4. 14.0 14.0 5. 5. 0.0 0. 1. + 15654. 1. 4. 42.0 23.0 4.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 15658. 1. 4. 27.0 6.0 2.0 3. 16.0 40.0 3. 2. 0.0 0. 1. + 15659. 1. 5. 27.0 9.0 2.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 15671. 1. 3. 27.0 2.5 0.0 3. 16.0 20.0 5. 4. 0.0 0. 1. + 15674. 1. 3. 32.0 13.0 2.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 15675. 1. 4. 27.0 2.5 0.0 2. 16.0 14.0 5. 4. 0.0 0. 1. + 15681. 1. 5. 22.0 2.5 0.0 1. 12.0 14.0 3. 5. 0.0 0. 1. + 15689. 1. 4. 32.0 9.0 1.0 1. 16.0 14.0 4. 3. 0.0 0. 1. + 15691. 1. 5. 17.5 2.5 0.0 3. 12.0 6.5 4. 4. 0.0 0. 1. + 15699. 1. 4. 42.0 23.0 4.0 4. 16.0 40.0 4. 6. 0.0 0. 1. + 15704. 1. 5. 42.0 23.0 2.0 3. 17.0 20.0 4. 2. 0.0 0. 1. + 15710. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 1. 0.0 0. 1. + 15712. 1. 4. 32.0 9.0 2.0 2. 12.0 20.0 4. 6. 0.0 0. 1. + 15713. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 15715. 1. 5. 22.0 0.5 4.0 1. 12.0 40.0 5. 5. 0.0 0. 1. + 15719. 1. 5. 27.0 6.0 0.0 1. 20.0 20.0 4. 4. 0.0 0. 1. + 15721. 1. 5. 27.0 2.5 0.0 3. 20.0 40.0 4. 2. 0.0 0. 1. + 15723. 1. 5. 27.0 6.0 1.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 15726. 1. 4. 27.0 2.5 0.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 15728. 1. 5. 22.0 0.5 0.0 3. 16.0 6.5 4. 2. 0.0 0. 1. + 15730. 1. 5. 42.0 23.0 4.0 4. 14.0 9.0 4. 6. 0.0 0. 1. + 15737. 1. 3. 22.0 2.5 1.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 15738. 1. 4. 37.0 16.5 3.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 15751. 1. 4. 37.0 16.5 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 15753. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 15755. 1. 4. 22.0 6.0 0.0 2. 16.0 40.0 5. 5. 0.0 0. 1. + 15760. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 15762. 1. 4. 27.0 6.0 0.0 2. 12.0 14.0 2. 5. 0.0 0. 1. + 15775. 1. 2. 42.0 23.0 5.5 3. 16.0 20.0 4. 5. 0.0 0. 1. + 15777. 1. 5. 22.0 2.5 0.0 2. 14.0 6.5 3. 2. 0.0 0. 1. + 15781. 1. 5. 27.0 2.5 1.0 2. 12.0 6.5 2. 5. 0.0 0. 1. + 15784. 1. 5. 42.0 23.0 1.0 3. 12.0 20.0 4. 5. 0.0 0. 1. + 15785. 1. 5. 42.0 23.0 3.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 15789. 1. 5. 42.0 23.0 1.0 1. 12.0 40.0 3. 5. 0.0 0. 1. + 15790. 1. 4. 27.0 6.0 0.0 1. 16.0 14.0 4. 2. 0.0 0. 1. + 15792. 1. 3. 27.0 9.0 2.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 15796. 1. 5. 27.0 6.0 0.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 15800. 1. 4. 22.0 2.5 0.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 15803. 1. 5. 32.0 9.0 2.0 1. 16.0 20.0 4. 6. 0.0 0. 1. + 15822. 1. 5. 22.0 2.5 1.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 15830. 1. 5. 22.0 6.0 0.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 15833. 1. 5. 37.0 16.5 2.0 4. 20.0 20.0 4. 6. 0.0 0. 1. + 15857. 1. 4. 22.0 2.5 0.0 2. 12.0 6.5 5. 5. 0.0 0. 1. + 15860. 1. 4. 22.0 2.5 0.0 3. 14.0 9.0 3. 1. 0.0 0. 1. + 15865. 1. 5. 27.0 6.0 0.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 15869. 1. 5. 22.0 0.5 0.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 15884. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 15885. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 15887. 1. 4. 27.0 6.0 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 15903. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 15910. 1. 4. 22.0 0.5 0.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 15911. 1. 3. 42.0 23.0 1.0 1. 12.0 40.0 3. 6. 0.0 0. 1. + 15916. 1. 5. 22.0 2.5 1.0 3. 14.0 6.5 2. 2. 0.0 0. 1. + 15927. 1. 4. 27.0 6.0 1.0 2. 14.0 40.0 5. 2. 0.0 0. 1. + 15930. 1. 5. 22.0 2.5 0.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 15931. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 15934. 1. 5. 27.0 9.0 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 15951. 1. 5. 32.0 13.0 0.0 2. 12.0 40.0 5. 4. 0.0 0. 1. + 15952. 1. 3. 27.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 15958. 1. 3. 27.0 6.0 0.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 15965. 1. 5. 22.0 0.5 0.0 3. 16.0 14.0 5. 2. 0.0 0. 1. + 15969. 1. 5. 22.0 2.5 0.0 2. 16.0 6.5 4. 2. 0.0 0. 1. + 15971. 1. 5. 27.0 6.0 1.0 1. 16.0 14.0 4. 5. 0.0 0. 1. + 15972. 1. 5. 27.0 2.5 0.0 1. 12.0 14.0 3. 5. 0.0 0. 1. + 15973. 1. 5. 27.0 9.0 2.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 15974. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 4. 4. 0.0 0. 1. + 15979. 1. 5. 42.0 16.5 4.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 15984. 1. 3. 27.0 9.0 2.0 3. 12.0 6.5 5. 4. 0.0 0. 1. + 15985. 1. 4. 27.0 13.0 3.0 3. 14.0 14.0 5. 5. 0.0 0. 1. + 15989. 1. 4. 22.0 2.5 0.0 2. 17.0 20.0 4. 5. 0.0 0. 1. + 15993. 1. 5. 27.0 9.0 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 16002. 1. 2. 22.0 2.5 1.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 16006. 1. 5. 22.0 2.5 0.0 2. 12.0 6.5 5. 1. 0.0 0. 1. + 16008. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 4. 3. 0.0 0. 1. + 16010. 1. 5. 27.0 6.0 2.0 4. 17.0 20.0 4. 2. 0.0 0. 1. + 16018. 1. 4. 22.0 2.5 0.0 3. 17.0 14.0 4. 4. 0.0 0. 1. + 16020. 1. 5. 37.0 16.5 3.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 16021. 1. 2. 37.0 13.0 0.0 2. 17.0 14.0 3. 5. 0.0 0. 1. + 16029. 1. 5. 27.0 2.5 0.0 3. 16.0 9.0 2. 4. 0.0 0. 1. + 16035. 1. 3. 27.0 9.0 2.0 1. 12.0 11.5 3. 5. 0.0 0. 1. + 16038. 1. 5. 37.0 16.5 2.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 16040. 1. 4. 22.0 2.5 0.0 3. 16.0 20.0 5. 1. 0.0 0. 1. + 16046. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 16048. 1. 5. 17.5 0.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 16050. 1. 5. 37.0 13.0 3.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 16051. 1. 5. 32.0 9.0 3.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 16052. 1. 4. 27.0 0.5 0.0 2. 20.0 20.0 4. 5. 0.0 0. 1. + 16054. 1. 5. 37.0 16.5 2.0 4. 16.0 20.0 4. 6. 0.0 0. 1. + 16059. 1. 2. 27.0 2.5 1.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 16061. 1. 4. 22.0 2.5 0.0 3. 17.0 6.5 3. 6. 0.0 0. 1. + 16062. 1. 4. 32.0 6.0 1.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 16066. 1. 4. 22.0 2.5 1.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 16068. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 5. 0.0 0. 1. + 16071. 1. 4. 27.0 2.5 1.0 1. 16.0 20.0 4. 5. 0.0 0. 1. + 16077. 1. 5. 42.0 23.0 3.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 16081. 1. 4. 37.0 16.5 2.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 16085. 1. 4. 42.0 13.0 0.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 16086. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 5. 0.0 0. 1. + 16090. 1. 3. 22.0 0.5 0.0 2. 14.0 9.0 4. 4. 0.0 0. 1. + 16116. 1. 4. 32.0 6.0 1.0 1. 17.0 11.5 2. 4. 0.0 0. 1. + 16117. 1. 4. 27.0 2.5 0.0 2. 16.0 11.5 4. 2. 0.0 0. 1. + 16122. 1. 5. 22.0 2.5 0.0 2. 16.0 6.5 3. 1. 0.0 0. 1. + 16123. 1. 5. 37.0 16.5 5.5 3. 12.0 20.0 2. 6. 0.0 0. 1. + 16124. 1. 5. 22.0 2.5 0.0 2. 16.0 11.5 5. 2. 0.0 0. 1. + 16127. 1. 4. 27.0 0.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 16132. 1. 4. 22.0 2.5 0.0 2. 12.0 20.0 2. 2. 0.0 0. 1. + 16136. 1. 5. 32.0 6.0 2.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 16139. 1. 5. 42.0 23.0 2.0 3. 12.0 20.0 4. 4. 0.0 0. 1. + 16140. 1. 4. 32.0 6.0 2.0 3. 17.0 20.0 4. 2. 0.0 0. 1. + 16145. 1. 4. 27.0 2.5 0.0 2. 12.0 14.0 3. 2. 0.0 0. 1. + 16148. 1. 5. 32.0 13.0 1.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 16149. 1. 4. 37.0 16.5 2.0 2. 14.0 11.5 4. 2. 0.0 0. 1. + 16151. 1. 4. 27.0 0.5 0.0 1. 20.0 40.0 5. 5. 0.0 0. 1. + 16154. 1. 4. 17.5 0.5 0.0 2. 14.0 14.0 3. 3. 0.0 0. 1. + 16155. 1. 5. 32.0 16.5 3.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 16156. 1. 4. 37.0 16.5 3.0 2. 16.0 40.0 4. 6. 0.0 0. 1. + 16160. 1. 4. 22.0 2.5 0.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 16167. 1. 5. 32.0 13.0 2.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 16173. 1. 5. 27.0 6.0 2.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 16185. 1. 4. 22.0 2.5 0.0 2. 12.0 6.5 2. 4. 0.0 0. 1. + 16188. 1. 3. 22.0 2.5 0.0 2. 16.0 11.5 4. 1. 0.0 0. 1. + 16194. 1. 4. 27.0 9.0 1.0 1. 12.0 20.0 2. 5. 0.0 0. 1. + 16198. 1. 5. 22.0 2.5 0.0 3. 12.0 14.0 3. 4. 0.0 0. 1. + 16199. 1. 5. 32.0 13.0 3.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 16203. 1. 5. 22.0 0.5 0.0 2. 16.0 14.0 4. 4. 0.0 0. 1. + 16204. 1. 5. 32.0 13.0 2.0 4. 14.0 11.5 3. 4. 0.0 0. 1. + 16211. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 16218. 1. 5. 32.0 9.0 1.0 2. 17.0 14.0 2. 4. 0.0 0. 1. + 16223. 1. 5. 42.0 23.0 5.5 2. 12.0 20.0 3. 5. 0.0 0. 1. + 16227. 1. 2. 32.0 2.5 1.0 3. 20.0 20.0 6. 5. 0.0 0. 1. + 16228. 1. 5. 37.0 6.0 0.0 3. 20.0 40.0 4. 5. 0.0 0. 1. + 16229. 1. 4. 32.0 9.0 2.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 16233. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 16234. 1. 4. 22.0 2.5 0.0 1. 12.0 11.5 3. 2. 0.0 0. 1. + 16239. 1. 5. 27.0 2.5 0.0 2. 20.0 40.0 6. 6. 0.0 0. 1. + 16245. 1. 4. 32.0 13.0 2.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 16247. 1. 5. 17.5 2.5 1.0 3. 12.0 11.5 2. 1. 0.0 0. 1. + 16250. 1. 5. 32.0 16.5 3.0 3. 12.0 11.5 5. 5. 0.0 0. 1. + 16253. 1. 4. 27.0 6.0 0.0 3. 16.0 40.0 4. 4. 0.0 0. 1. + 16254. 1. 5. 37.0 16.5 2.0 2. 12.0 20.0 5. 5. 0.0 0. 1. + 16258. 1. 3. 27.0 2.5 1.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 16267. 1. 5. 27.0 6.0 0.0 1. 16.0 11.5 2. 4. 0.0 0. 1. + 16269. 1. 5. 37.0 23.0 3.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 16279. 1. 4. 27.0 2.5 1.0 3. 14.0 11.5 2. 2. 0.0 0. 1. + 16283. 1. 5. 22.0 2.5 0.0 2. 12.0 20.0 3. 6. 0.0 0. 1. + 16292. 1. 5. 22.0 2.5 0.0 1. 14.0 11.5 4. 4. 0.0 0. 1. + 16294. 1. 4. 22.0 6.0 2.0 1. 16.0 20.0 3. 4. 0.0 0. 1. + 16295. 1. 5. 22.0 0.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 16297. 1. 2. 22.0 2.5 1.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 16298. 1. 5. 22.0 0.5 0.0 2. 20.0 11.5 3. 4. 0.0 0. 1. + 16301. 1. 5. 32.0 2.5 0.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 16308. 1. 4. 27.0 2.5 1.0 2. 12.0 11.5 3. 1. 0.0 0. 1. + 16310. 1. 5. 22.0 2.5 0.0 3. 12.0 11.5 5. 2. 0.0 0. 1. + 16316. 1. 3. 42.0 13.0 0.0 4. 20.0 40.0 2. 2. 0.0 0. 1. + 16318. 1. 5. 27.0 2.5 1.0 1. 14.0 40.0 5. 4. 0.0 0. 1. + 16321. 1. 5. 27.0 13.0 2.0 4. 12.0 40.0 3. 6. 0.0 0. 1. + 16323. 1. 4. 27.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 16325. 1. 4. 32.0 13.0 2.0 3. 12.0 14.0 2. 4. 0.0 0. 1. + 16327. 1. 4. 27.0 6.0 0.0 2. 20.0 40.0 4. 6. 0.0 0. 1. + 16328. 1. 5. 32.0 6.0 0.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 16329. 1. 5. 22.0 0.5 0.0 2. 12.0 20.0 3. 2. 0.0 0. 1. + 16338. 1. 4. 27.0 9.0 1.0 1. 16.0 20.0 4. 4. 0.0 0. 1. + 16345. 1. 5. 27.0 0.5 0.0 2. 16.0 40.0 3. 5. 0.0 0. 1. + 16351. 1. 4. 22.0 0.5 0.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 16355. 1. 4. 22.0 6.0 1.0 2. 14.0 14.0 5. 5. 0.0 0. 1. + 16360. 1. 3. 22.0 2.5 2.0 1. 12.0 11.5 3. 4. 0.0 0. 1. + 16361. 1. 3. 42.0 13.0 2.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 16366. 1. 5. 27.0 6.0 3.0 2. 14.0 14.0 2. 5. 0.0 0. 1. + 16380. 1. 4. 27.0 6.0 2.0 1. 12.0 11.5 4. 2. 0.0 0. 1. + 16382. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 1. 4. 0.0 0. 1. + 16383. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 16385. 1. 5. 27.0 2.5 2.0 2. 17.0 40.0 4. 5. 0.0 0. 1. + 16388. 1. 3. 22.0 2.5 0.0 3. 14.0 11.5 4. 5. 0.0 0. 1. + 16400. 1. 4. 27.0 6.0 0.0 3. 12.0 6.5 3. 4. 0.0 0. 1. + 16401. 1. 2. 27.0 6.0 2.0 2. 16.0 20.0 2. 6. 0.0 0. 1. + 16402. 1. 4. 32.0 16.5 2.0 2. 17.0 14.0 4. 3. 0.0 0. 1. + 16403. 1. 4. 22.0 2.5 1.0 3. 17.0 20.0 4. 2. 0.0 0. 1. + 16407. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 16408. 1. 3. 22.0 2.5 1.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 16409. 1. 4. 22.0 2.5 0.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 16412. 1. 4. 22.0 0.5 0.0 3. 14.0 40.0 5. 4. 0.0 0. 1. + 16414. 1. 3. 32.0 13.0 2.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 16416. 1. 5. 17.5 2.5 0.0 1. 17.0 20.0 4. 4. 0.0 0. 1. + 16417. 1. 4. 22.0 2.5 0.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 16420. 1. 3. 27.0 2.5 0.0 1. 14.0 40.0 3. 2. 0.0 0. 1. + 16425. 1. 5. 42.0 13.0 0.0 4. 12.0 40.0 5. 5. 0.0 0. 1. + 16436. 1. 5. 32.0 16.5 3.0 4. 14.0 14.0 3. 2. 0.0 0. 1. + 16438. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 4. 5. 0.0 0. 1. + 16440. 1. 5. 22.0 0.5 0.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 16442. 1. 1. 32.0 16.5 4.0 3. 12.0 20.0 2. 5. 0.0 0. 1. + 16444. 1. 5. 32.0 16.5 1.0 1. 20.0 40.0 6. 6. 0.0 0. 1. + 16445. 1. 3. 27.0 9.0 0.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 16448. 1. 2. 27.0 0.5 0.0 2. 14.0 9.0 3. 4. 0.0 0. 1. + 16451. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 4. 6. 0.0 0. 1. + 16468. 1. 4. 37.0 13.0 2.0 3. 16.0 20.0 4. 3. 0.0 0. 1. + 16472. 1. 4. 42.0 16.5 2.0 4. 12.0 9.0 2. 4. 0.0 0. 1. + 16474. 1. 4. 42.0 23.0 4.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 16475. 1. 3. 17.5 0.5 1.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 16479. 1. 5. 27.0 2.5 1.0 3. 16.0 14.0 4. 4. 0.0 0. 1. + 16487. 1. 5. 32.0 16.5 2.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 16491. 1. 5. 42.0 23.0 5.5 4. 14.0 40.0 4. 4. 0.0 0. 1. + 16500. 1. 5. 37.0 16.5 3.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 16502. 1. 5. 22.0 2.5 1.0 1. 14.0 11.5 2. 5. 0.0 0. 1. + 16503. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 16533. 1. 5. 27.0 6.0 2.0 1. 14.0 11.5 2. 5. 0.0 0. 1. + 16535. 1. 5. 27.0 9.0 3.0 3. 12.0 11.5 2. 2. 0.0 0. 1. + 16540. 1. 5. 32.0 9.0 2.0 4. 20.0 14.0 2. 4. 0.0 0. 1. + 16550. 1. 3. 27.0 6.0 1.0 2. 14.0 14.0 1. 4. 0.0 0. 1. + 16551. 1. 4. 22.0 0.5 0.0 2. 12.0 14.0 2. 2. 0.0 0. 1. + 16553. 1. 4. 22.0 6.0 1.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 16558. 1. 4. 22.0 0.5 0.0 3. 14.0 6.5 3. 2. 0.0 0. 1. + 16561. 1. 5. 32.0 16.5 2.0 3. 14.0 40.0 3. 2. 0.0 0. 1. + 16562. 1. 5. 42.0 23.0 2.0 1. 20.0 40.0 4. 5. 0.0 0. 1. + 16563. 1. 5. 37.0 16.5 3.0 3. 17.0 40.0 4. 6. 0.0 0. 1. + 16565. 1. 4. 32.0 13.0 1.0 4. 17.0 6.5 4. 1. 0.0 0. 1. + 16567. 1. 5. 42.0 23.0 5.5 3. 12.0 40.0 5. 5. 0.0 0. 1. + 16568. 1. 5. 32.0 13.0 0.0 2. 14.0 20.0 5. 4. 0.0 0. 1. + 16569. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 4. 5. 0.0 0. 1. + 16572. 1. 1. 27.0 6.0 3.0 1. 14.0 20.0 2. 6. 0.0 0. 1. + 16573. 1. 4. 27.0 13.0 3.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 16574. 1. 4. 37.0 6.0 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 16575. 1. 5. 22.0 2.5 1.0 1. 14.0 9.0 2. 2. 0.0 0. 1. + 16578. 1. 5. 22.0 2.5 0.0 4. 12.0 14.0 3. 4. 0.0 0. 1. + 16583. 1. 5. 22.0 2.5 0.0 3. 14.0 6.5 4. 2. 0.0 0. 1. + 16585. 1. 5. 37.0 16.5 2.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 16586. 1. 5. 22.0 6.0 2.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 16587. 1. 5. 42.0 23.0 3.0 4. 16.0 20.0 4. 6. 0.0 0. 1. + 16597. 1. 4. 32.0 13.0 4.0 4. 12.0 14.0 3. 4. 0.0 0. 1. + 16602. 1. 5. 22.0 0.5 0.0 1. 14.0 20.0 3. 3. 0.0 0. 1. + 16606. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 16611. 1. 4. 27.0 6.0 0.0 1. 16.0 20.0 4. 6. 0.0 0. 1. + 16623. 1. 4. 32.0 13.0 3.0 2. 12.0 20.0 2. 6. 0.0 0. 1. + 16624. 1. 4. 22.0 2.5 1.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 16632. 1. 4. 22.0 0.5 0.0 1. 16.0 11.5 3. 5. 0.0 0. 1. + 16635. 1. 4. 32.0 13.0 2.0 2. 12.0 11.5 2. 5. 0.0 0. 1. + 16636. 1. 4. 17.5 2.5 1.0 1. 12.0 6.5 2. 4. 0.0 0. 1. + 16641. 1. 3. 27.0 6.0 0.0 1. 17.0 14.0 2. 6. 0.0 0. 1. + 16645. 1. 4. 32.0 16.5 1.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 16649. 1. 5. 27.0 0.5 0.0 2. 16.0 11.5 3. 2. 0.0 0. 1. + 16652. 1. 4. 27.0 9.0 2.0 4. 20.0 40.0 4. 4. 0.0 0. 1. + 16655. 1. 3. 42.0 23.0 2.0 3. 12.0 14.0 3. 5. 0.0 0. 1. + 16656. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 4. 2. 0.0 0. 1. + 16660. 1. 5. 32.0 13.0 3.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 16662. 1. 2. 32.0 6.0 2.0 2. 17.0 14.0 3. 4. 0.0 0. 1. + 16663. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 2. 2. 0.0 0. 1. + 16669. 1. 5. 27.0 9.0 3.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 16675. 1. 4. 27.0 2.5 1.0 4. 20.0 9.0 1. 1. 0.0 0. 1. + 16683. 1. 4. 27.0 6.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 16684. 1. 5. 22.0 2.5 0.0 3. 12.0 20.0 3. 6. 0.0 0. 1. + 16685. 1. 4. 32.0 16.5 5.5 3. 12.0 9.0 2. 2. 0.0 0. 1. + 16689. 1. 4. 32.0 13.0 2.0 4. 16.0 14.0 2. 4. 0.0 0. 1. + 16693. 1. 5. 32.0 13.0 5.5 3. 14.0 20.0 2. 2. 0.0 0. 1. + 16696. 1. 5. 27.0 9.0 3.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 16697. 1. 4. 27.0 2.5 0.0 2. 14.0 40.0 3. 2. 0.0 0. 1. + 16698. 1. 4. 42.0 23.0 4.0 1. 17.0 40.0 4. 4. 0.0 0. 1. + 16699. 1. 3. 27.0 9.0 2.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 16701. 1. 5. 27.0 6.0 1.0 3. 16.0 20.0 4. 3. 0.0 0. 1. + 16705. 1. 5. 27.0 2.5 0.0 1. 14.0 20.0 3. 5. 0.0 0. 1. + 16707. 1. 5. 42.0 23.0 4.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 16708. 1. 4. 22.0 2.5 1.0 2. 12.0 20.0 2. 4. 0.0 0. 1. + 16728. 1. 4. 37.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 16730. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 3. 6. 0.0 0. 1. + 16745. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 16747. 1. 5. 22.0 2.5 0.0 4. 17.0 20.0 4. 5. 0.0 0. 1. + 16749. 1. 5. 22.0 2.5 0.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 16751. 1. 3. 22.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 16753. 1. 4. 27.0 9.0 0.0 2. 14.0 40.0 5. 5. 0.0 0. 1. + 16755. 1. 4. 32.0 13.0 2.0 3. 14.0 20.0 3. 6. 0.0 0. 1. + 16757. 1. 5. 27.0 6.0 2.0 4. 20.0 6.5 6. 6. 0.0 0. 1. + 16758. 1. 5. 27.0 9.0 2.0 3. 16.0 20.0 4. 6. 0.0 0. 1. + 16764. 1. 5. 42.0 23.0 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 16772. 1. 4. 27.0 2.5 0.0 2. 12.0 14.0 3. 5. 0.0 0. 1. + 16776. 1. 5. 22.0 2.5 0.0 3. 14.0 9.0 3. 2. 0.0 0. 1. + 16787. 1. 4. 22.0 2.5 0.0 3. 12.0 9.0 2. 2. 0.0 0. 1. + 16796. 1. 4. 32.0 9.0 1.0 2. 12.0 20.0 2. 5. 0.0 0. 1. + 16806. 1. 4. 27.0 6.0 0.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 16807. 1. 5. 22.0 2.5 1.0 1. 12.0 6.5 3. 2. 0.0 0. 1. + 16808. 1. 5. 42.0 2.5 0.0 4. 12.0 20.0 5. 4. 0.0 0. 1. + 16813. 1. 5. 22.0 2.5 0.0 1. 14.0 14.0 4. 3. 0.0 0. 1. + 16816. 1. 4. 42.0 23.0 2.0 4. 20.0 20.0 2. 2. 0.0 0. 1. + 16822. 1. 4. 42.0 23.0 3.0 3. 12.0 20.0 4. 4. 0.0 0. 1. + 16825. 1. 5. 22.0 2.5 0.0 1. 16.0 20.0 4. 2. 0.0 0. 1. + 16831. 1. 5. 32.0 16.5 2.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 16833. 1. 5. 17.5 0.5 0.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 16840. 1. 4. 22.0 2.5 1.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 16841. 1. 5. 27.0 2.5 0.0 4. 17.0 20.0 4. 3. 0.0 0. 1. + 16842. 1. 4. 22.0 2.5 0.0 2. 14.0 14.0 3. 4. 0.0 0. 1. + 16854. 1. 5. 22.0 0.5 0.0 3. 16.0 20.0 2. 2. 0.0 0. 1. + 16856. 1. 5. 22.0 2.5 1.0 4. 14.0 4.0 3. 3. 0.0 0. 1. + 16857. 1. 5. 42.0 23.0 3.0 4. 14.0 20.0 3. 6. 0.0 0. 1. + 16859. 1. 5. 27.0 6.0 0.0 3. 12.0 14.0 2. 2. 0.0 0. 1. + 16863. 1. 4. 27.0 2.5 0.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 16865. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 2. 0.0 0. 1. + 16866. 1. 5. 42.0 23.0 3.0 3. 14.0 11.5 3. 3. 0.0 0. 1. + 16870. 1. 4. 42.0 16.5 3.0 3. 14.0 20.0 2. 2. 0.0 0. 1. + 16871. 1. 5. 32.0 13.0 2.0 2. 16.0 14.0 3. 4. 0.0 0. 1. + 16872. 1. 5. 22.0 2.5 0.0 3. 14.0 20.0 2. 2. 0.0 0. 1. + 16874. 1. 4. 22.0 6.0 2.0 3. 12.0 11.5 2. 4. 0.0 0. 1. + 16880. 1. 4. 27.0 6.0 0.0 3. 14.0 20.0 3. 3. 0.0 0. 1. + 16882. 1. 3. 32.0 6.0 1.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 16885. 1. 5. 37.0 16.5 3.0 4. 12.0 20.0 6. 5. 0.0 0. 1. + 16887. 1. 4. 27.0 9.0 2.0 2. 14.0 14.0 2. 2. 0.0 0. 1. + 16889. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 5. 0.0 0. 1. + 16890. 1. 5. 27.0 2.5 0.0 3. 20.0 40.0 4. 5. 0.0 0. 1. + 16892. 1. 4. 32.0 6.0 0.0 3. 12.0 14.0 5. 2. 0.0 0. 1. + 16893. 1. 4. 22.0 2.5 0.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 16896. 1. 5. 37.0 16.5 4.0 4. 14.0 11.5 3. 6. 0.0 0. 1. + 16897. 1. 3. 37.0 16.5 4.0 2. 12.0 11.5 2. 4. 0.0 0. 1. + 16905. 1. 2. 22.0 9.0 2.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 16908. 1. 4. 27.0 6.0 0.0 4. 16.0 11.5 5. 4. 0.0 0. 1. + 16912. 1. 5. 27.0 13.0 3.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 16921. 1. 5. 27.0 6.0 1.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 16929. 1. 5. 27.0 6.0 1.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 16932. 1. 5. 32.0 6.0 1.0 4. 20.0 14.0 6. 6. 0.0 0. 1. + 16938. 1. 5. 27.0 6.0 2.0 2. 14.0 11.5 4. 4. 0.0 0. 1. + 16946. 1. 5. 27.0 6.0 2.0 2. 14.0 11.5 4. 6. 0.0 0. 1. + 16948. 1. 3. 42.0 23.0 4.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 16949. 1. 4. 22.0 2.5 0.0 3. 14.0 9.0 3. 3. 0.0 0. 1. + 16961. 1. 3. 32.0 13.0 2.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 16962. 1. 4. 42.0 23.0 3.0 4. 12.0 20.0 2. 5. 0.0 0. 1. + 16964. 1. 5. 27.0 6.0 0.0 4. 14.0 11.5 5. 2. 0.0 0. 1. + 16965. 1. 4. 27.0 9.0 3.0 2. 14.0 11.5 3. 1. 0.0 0. 1. + 16967. 1. 5. 27.0 9.0 2.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 16969. 1. 5. 32.0 2.5 0.0 3. 12.0 20.0 5. 5. 0.0 0. 1. + 16975. 1. 5. 27.0 6.0 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 16977. 1. 4. 27.0 6.0 2.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 16978. 1. 5. 22.0 2.5 1.0 3. 14.0 20.0 3. 2. 0.0 0. 1. + 16979. 1. 5. 42.0 23.0 3.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 16982. 1. 5. 22.0 2.5 0.0 2. 17.0 11.5 4. 1. 0.0 0. 1. + 16984. 1. 4. 27.0 2.5 1.0 2. 14.0 14.0 3. 3. 0.0 0. 1. + 16989. 1. 4. 27.0 6.0 2.0 1. 14.0 20.0 5. 5. 0.0 0. 1. + 16992. 1. 5. 17.5 0.5 0.0 3. 12.0 9.0 3. 2. 0.0 0. 1. + 16994. 1. 4. 32.0 9.0 1.0 3. 12.0 20.0 3. 2. 0.0 0. 1. + 16997. 1. 5. 42.0 23.0 3.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 16998. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 2. 4. 0.0 0. 1. + 17003. 1. 5. 32.0 6.0 1.0 4. 17.0 14.0 2. 2. 0.0 0. 1. + 17006. 1. 4. 22.0 2.5 1.0 3. 14.0 14.0 3. 5. 0.0 0. 1. + 17007. 1. 5. 27.0 0.5 0.0 2. 14.0 9.0 6. 4. 0.0 0. 1. + 17009. 1. 3. 42.0 23.0 2.0 2. 14.0 20.0 3. 6. 0.0 0. 1. + 17010. 1. 5. 32.0 13.0 2.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 17015. 1. 4. 42.0 23.0 5.5 2. 12.0 11.5 2. 4. 0.0 0. 1. + 17016. 1. 4. 32.0 9.0 2.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 17024. 1. 5. 32.0 16.5 2.0 3. 12.0 40.0 2. 3. 0.0 0. 1. + 17028. 1. 5. 22.0 6.0 0.0 1. 14.0 11.5 5. 4. 0.0 0. 1. + 17033. 1. 5. 42.0 16.5 1.0 2. 12.0 20.0 5. 3. 0.0 0. 1. + 17041. 1. 4. 42.0 23.0 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 17044. 1. 2. 42.0 23.0 4.0 2. 14.0 40.0 5. 6. 0.0 0. 1. + 17045. 1. 4. 32.0 9.0 2.0 2. 14.0 20.0 3. 2. 0.0 0. 1. + 17046. 1. 5. 42.0 16.5 1.0 4. 12.0 14.0 4. 5. 0.0 0. 1. + 17051. 1. 4. 32.0 13.0 3.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 17052. 1. 4. 22.0 2.5 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 17053. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 4. 4. 0.0 0. 1. + 17054. 1. 5. 27.0 2.5 0.0 2. 20.0 6.5 1. 6. 0.0 0. 1. + 17062. 1. 5. 27.0 6.0 0.0 3. 16.0 14.0 4. 2. 0.0 0. 1. + 17069. 1. 4. 32.0 13.0 2.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 17075. 1. 4. 27.0 6.0 0.0 2. 16.0 20.0 4. 6. 0.0 0. 1. + 17080. 1. 5. 17.5 0.5 0.0 1. 14.0 4.0 3. 2. 0.0 0. 1. + 17087. 1. 5. 32.0 16.5 2.0 4. 12.0 9.0 3. 4. 0.0 0. 1. + 17094. 1. 5. 17.5 0.5 0.0 3. 12.0 9.0 6. 2. 0.0 0. 1. + 17101. 1. 4. 22.0 6.0 0.0 2. 14.0 14.0 3. 5. 0.0 0. 1. + 17106. 1. 5. 27.0 2.5 0.0 4. 20.0 20.0 4. 5. 0.0 0. 1. + 17107. 1. 5. 42.0 23.0 1.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 17108. 1. 3. 27.0 9.0 3.0 4. 12.0 11.5 2. 2. 0.0 0. 1. + 17112. 1. 5. 37.0 16.5 4.0 4. 14.0 20.0 3. 4. 0.0 0. 1. + 17116. 1. 4. 22.0 2.5 0.0 3. 14.0 14.0 5. 4. 0.0 0. 1. + 17122. 1. 5. 32.0 9.0 2.0 4. 12.0 11.5 3. 4. 0.0 0. 1. + 17137. 1. 5. 22.0 2.5 2.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 17144. 1. 5. 32.0 13.0 0.0 4. 12.0 20.0 3. 4. 0.0 0. 1. + 17145. 1. 3. 42.0 23.0 4.0 3. 12.0 20.0 3. 3. 0.0 0. 1. + 17146. 1. 4. 27.0 6.0 2.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 17148. 1. 4. 22.0 2.5 0.0 2. 16.0 20.0 5. 2. 0.0 0. 1. + 17151. 1. 4. 27.0 9.0 2.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 17156. 1. 5. 27.0 0.5 0.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 17159. 1. 5. 27.0 0.5 0.0 4. 17.0 14.0 4. 2. 0.0 0. 1. + 17160. 1. 5. 32.0 13.0 3.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 17161. 1. 5. 22.0 0.5 1.0 3. 14.0 20.0 4. 4. 0.0 0. 1. + 17167. 1. 5. 22.0 2.5 0.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 17171. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 2. 4. 0.0 0. 1. + 17172. 1. 4. 22.0 2.5 0.0 1. 12.0 6.5 3. 3. 0.0 0. 1. + 17174. 1. 4. 27.0 6.0 1.0 1. 14.0 11.5 3. 4. 0.0 0. 1. + 17186. 1. 5. 37.0 23.0 4.0 3. 16.0 20.0 5. 5. 0.0 0. 1. + 17187. 1. 5. 22.0 2.5 0.0 2. 16.0 20.0 4. 4. 0.0 0. 1. + 17190. 1. 3. 37.0 16.5 1.0 2. 20.0 40.0 4. 4. 0.0 0. 1. + 17207. 1. 4. 27.0 2.5 1.0 3. 14.0 9.0 4. 2. 0.0 0. 1. + 17211. 1. 5. 27.0 2.5 0.0 2. 17.0 20.0 4. 4. 0.0 0. 1. + 17220. 1. 5. 42.0 23.0 3.0 3. 17.0 20.0 4. 2. 0.0 0. 1. + 17221. 1. 5. 32.0 9.0 2.0 3. 14.0 14.0 4. 3. 0.0 0. 1. + 17225. 1. 5. 22.0 0.5 0.0 4. 14.0 20.0 3. 5. 0.0 0. 1. + 17227. 1. 3. 27.0 6.0 1.0 2. 12.0 11.5 5. 4. 0.0 0. 1. + 17230. 1. 3. 27.0 9.0 1.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 17232. 1. 5. 22.0 2.5 0.0 3. 16.0 11.5 5. 4. 0.0 0. 1. + 17241. 1. 4. 32.0 9.0 3.0 4. 16.0 20.0 4. 4. 0.0 0. 1. + 17243. 1. 2. 27.0 6.0 1.0 4. 20.0 20.0 5. 6. 0.0 0. 1. + 17248. 1. 5. 22.0 2.5 0.0 3. 14.0 11.5 4. 2. 0.0 0. 1. + 17249. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 4. 5. 0.0 0. 1. + 17251. 1. 4. 32.0 13.0 3.0 2. 12.0 11.5 2. 5. 0.0 0. 1. + 17256. 1. 4. 22.0 0.5 0.0 1. 14.0 14.0 3. 5. 0.0 0. 1. + 17257. 1. 5. 27.0 9.0 1.0 2. 12.0 20.0 3. 5. 0.0 0. 1. + 17258. 1. 5. 37.0 16.5 3.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 17264. 1. 5. 22.0 2.5 0.0 3. 16.0 14.0 4. 5. 0.0 0. 1. + 17266. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 17267. 1. 4. 42.0 23.0 1.0 2. 12.0 20.0 3. 3. 0.0 0. 1. + 17268. 1. 1. 27.0 6.0 1.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 17276. 1. 5. 27.0 6.0 1.0 3. 20.0 20.0 4. 5. 0.0 0. 1. + 17277. 1. 5. 27.0 2.5 0.0 4. 14.0 11.5 3. 4. 0.0 0. 1. + 17278. 1. 5. 27.0 2.5 0.0 3. 14.0 9.0 3. 4. 0.0 0. 1. + 17280. 1. 5. 32.0 9.0 0.0 2. 12.0 9.0 4. 5. 0.0 0. 1. + 17282. 1. 5. 22.0 2.5 0.0 3. 17.0 20.0 5. 5. 0.0 0. 1. + 17283. 1. 2. 37.0 16.5 3.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 17285. 1. 5. 27.0 6.0 0.0 3. 17.0 20.0 4. 6. 0.0 0. 1. + 17286. 1. 4. 27.0 6.0 0.0 1. 12.0 20.0 3. 3. 0.0 0. 1. + 17299. 1. 4. 27.0 9.0 1.0 3. 16.0 11.5 3. 2. 0.0 0. 1. + 17301. 1. 5. 22.0 2.5 1.0 3. 12.0 11.5 5. 5. 0.0 0. 1. + 17305. 1. 4. 17.5 2.5 0.0 3. 14.0 6.5 3. 1. 0.0 0. 1. + 17307. 1. 5. 27.0 2.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 17314. 1. 4. 22.0 2.5 0.0 2. 12.0 6.5 3. 2. 0.0 0. 1. + 17316. 1. 5. 27.0 9.0 2.0 3. 12.0 20.0 2. 2. 0.0 0. 1. + 17318. 1. 4. 32.0 9.0 1.0 3. 17.0 11.5 3. 6. 0.0 0. 1. + 17319. 1. 4. 37.0 16.5 4.0 2. 14.0 11.5 4. 3. 0.0 0. 1. + 17327. 1. 4. 27.0 9.0 0.0 3. 14.0 11.5 2. 5. 0.0 0. 1. + 17335. 1. 5. 37.0 13.0 3.0 3. 20.0 40.0 4. 6. 0.0 0. 1. + 17338. 1. 4. 27.0 2.5 1.0 3. 16.0 9.0 4. 2. 0.0 0. 1. + 17346. 1. 5. 27.0 2.5 0.0 2. 14.0 40.0 4. 6. 0.0 0. 1. + 17349. 1. 4. 22.0 2.5 0.0 2. 12.0 9.0 3. 2. 0.0 0. 1. + 17354. 1. 4. 27.0 6.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 17356. 1. 4. 27.0 13.0 3.0 2. 12.0 14.0 3. 4. 0.0 0. 1. + 17357. 1. 4. 27.0 6.0 1.0 3. 14.0 14.0 5. 5. 0.0 0. 1. + 17359. 1. 5. 27.0 6.0 1.0 4. 16.0 11.5 4. 4. 0.0 0. 1. + 17362. 1. 3. 27.0 9.0 0.0 2. 14.0 20.0 3. 5. 0.0 0. 1. + 17363. 1. 4. 42.0 23.0 3.0 4. 14.0 40.0 3. 3. 0.0 0. 1. + 17364. 1. 4. 32.0 13.0 2.0 2. 12.0 20.0 5. 5. 0.0 0. 1. + 17368. 1. 5. 27.0 6.0 0.0 4. 20.0 6.5 4. 1. 0.0 0. 1. + 17370. 1. 5. 37.0 23.0 4.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 17375. 1. 5. 22.0 2.5 0.0 2. 12.0 9.0 3. 4. 0.0 0. 1. + 17382. 1. 5. 22.0 2.5 1.0 4. 14.0 11.5 3. 4. 0.0 0. 1. + 17388. 1. 4. 22.0 2.5 0.0 3. 12.0 11.5 3. 4. 0.0 0. 1. + 17393. 1. 4. 17.5 2.5 0.0 2. 12.0 6.5 3. 4. 0.0 0. 1. + 17395. 1. 3. 22.0 2.5 1.0 3. 12.0 9.0 3. 4. 0.0 0. 1. + 17396. 1. 5. 17.5 0.5 0.0 4. 12.0 6.5 3. 2. 0.0 0. 1. + 17403. 1. 4. 37.0 23.0 3.0 4. 9.0 11.5 2. 2. 0.0 0. 1. + 17408. 1. 5. 42.0 23.0 4.0 2. 14.0 14.0 5. 4. 0.0 0. 1. + 17410. 1. 4. 32.0 16.5 2.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 17412. 1. 4. 22.0 2.5 2.0 3. 14.0 11.5 5. 4. 0.0 0. 1. + 17413. 1. 5. 17.5 0.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 17415. 1. 5. 37.0 16.5 3.0 4. 14.0 11.5 3. 4. 0.0 0. 1. + 17418. 1. 4. 27.0 9.0 1.0 3. 12.0 14.0 3. 3. 0.0 0. 1. + 17426. 1. 5. 37.0 16.5 3.0 2. 14.0 11.5 3. 3. 0.0 0. 1. + 17431. 1. 3. 42.0 13.0 2.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 17433. 1. 5. 37.0 23.0 4.0 4. 16.0 20.0 4. 6. 0.0 0. 1. + 17434. 1. 5. 37.0 23.0 1.0 3. 14.0 20.0 3. 5. 0.0 0. 1. + 17445. 1. 4. 42.0 23.0 3.0 3. 17.0 40.0 4. 2. 0.0 0. 1. + 17449. 1. 4. 27.0 6.0 1.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 17450. 1. 5. 32.0 9.0 0.0 4. 20.0 20.0 4. 6. 0.0 0. 1. + 17452. 1. 4. 27.0 2.5 0.0 4. 17.0 20.0 4. 4. 0.0 0. 1. + 17454. 1. 3. 17.5 2.5 0.0 3. 12.0 6.5 4. 4. 0.0 0. 1. + 17471. 1. 5. 22.0 2.5 0.0 3. 12.0 40.0 2. 2. 0.0 0. 1. + 17472. 1. 5. 37.0 13.0 3.0 1. 20.0 20.0 4. 5. 0.0 0. 1. + 17473. 1. 5. 27.0 16.5 2.0 3. 12.0 9.0 4. 4. 0.0 0. 1. + 17474. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 17506. 1. 4. 42.0 16.5 4.0 3. 9.0 11.5 2. 2. 0.0 0. 1. + 17508. 1. 4. 22.0 2.5 0.0 2. 14.0 9.0 3. 5. 0.0 0. 1. + 17509. 1. 4. 42.0 23.0 2.0 3. 14.0 20.0 4. 2. 0.0 0. 1. + 17517. 1. 5. 32.0 13.0 2.0 2. 14.0 20.0 2. 6. 0.0 0. 1. + 17520. 1. 4. 32.0 13.0 2.0 3. 17.0 20.0 4. 5. 0.0 0. 1. + 17523. 1. 5. 22.0 2.5 1.0 1. 12.0 9.0 5. 1. 0.0 0. 1. + 17533. 1. 5. 22.0 2.5 0.0 4. 16.0 20.0 4. 2. 0.0 0. 1. + 17544. 1. 5. 37.0 9.0 0.0 3. 20.0 40.0 4. 6. 0.0 0. 1. + 17547. 1. 5. 42.0 23.0 2.0 3. 14.0 9.0 3. 5. 0.0 0. 1. + 17551. 1. 5. 32.0 9.0 2.0 3. 16.0 11.5 4. 4. 0.0 0. 1. + 17553. 1. 5. 22.0 6.0 0.0 1. 12.0 14.0 3. 2. 0.0 0. 1. + 17558. 1. 4. 27.0 6.0 2.0 2. 12.0 9.0 2. 2. 0.0 0. 1. + 17564. 1. 4. 22.0 2.5 0.0 2. 12.0 11.5 3. 4. 0.0 0. 1. + 17569. 1. 5. 27.0 2.5 0.0 4. 16.0 6.5 4. 4. 0.0 0. 1. + 17573. 1. 5. 32.0 16.5 3.0 4. 14.0 20.0 2. 4. 0.0 0. 1. + 17574. 1. 4. 37.0 16.5 2.0 1. 12.0 20.0 3. 4. 0.0 0. 1. + 17575. 1. 5. 22.0 2.5 0.0 3. 12.0 9.0 3. 3. 0.0 0. 1. + 17578. 1. 4. 37.0 16.5 4.0 2. 12.0 11.5 2. 2. 0.0 0. 1. + 17580. 1. 3. 27.0 9.0 1.0 3. 17.0 14.0 4. 1. 0.0 0. 1. + 17585. 1. 5. 22.0 2.5 0.0 1. 17.0 9.0 2. 2. 0.0 0. 1. + 17596. 1. 5. 22.0 2.5 0.0 1. 14.0 9.0 3. 4. 0.0 0. 1. + 17598. 1. 5. 22.0 2.5 0.0 2. 16.0 14.0 4. 5. 0.0 0. 1. + 17602. 1. 5. 27.0 6.0 0.0 2. 16.0 20.0 3. 5. 0.0 0. 1. + 17608. 1. 4. 22.0 2.5 0.0 3. 14.0 11.5 5. 4. 0.0 0. 1. + 17616. 1. 5. 27.0 2.5 0.0 1. 17.0 11.5 4. 6. 0.0 0. 1. + 17620. 1. 5. 42.0 23.0 1.0 4. 20.0 40.0 4. 3. 0.0 0. 1. + 17625. 1. 4. 17.5 0.5 0.0 2. 14.0 4.0 3. 1. 0.0 0. 1. + 17627. 1. 5. 22.0 6.0 1.0 3. 12.0 11.5 2. 3. 0.0 0. 1. + 17636. 1. 4. 22.0 6.0 2.0 2. 9.0 6.5 2. 3. 0.0 0. 1. + 17643. 1. 5. 27.0 2.5 0.0 4. 16.0 20.0 5. 4. 0.0 0. 1. + 17646. 1. 4. 22.0 2.5 1.0 2. 12.0 6.5 3. 2. 0.0 0. 1. + 17651. 1. 3. 32.0 2.5 0.0 4. 17.0 14.0 6. 6. 0.0 0. 1. + 17661. 1. 5. 37.0 16.5 3.0 4. 14.0 20.0 4. 6. 0.0 0. 1. + 17668. 1. 5. 32.0 13.0 4.0 2. 12.0 11.5 5. 1. 0.0 0. 1. + 17669. 1. 3. 42.0 23.0 3.0 4. 16.0 14.0 3. 5. 0.0 0. 1. + 17673. 1. 5. 27.0 2.5 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 17674. 1. 5. 32.0 2.5 1.0 3. 20.0 20.0 4. 4. 0.0 0. 1. + 17676. 1. 5. 27.0 9.0 2.0 3. 12.0 9.0 2. 4. 0.0 0. 1. + 17690. 1. 3. 27.0 2.5 0.0 2. 14.0 14.0 3. 3. 0.0 0. 1. + 17691. 1. 5. 17.5 2.5 1.0 2. 12.0 6.5 5. 2. 0.0 0. 1. + 17696. 1. 4. 37.0 16.5 3.0 2. 17.0 40.0 4. 5. 0.0 0. 1. + 17700. 1. 4. 27.0 2.5 1.0 3. 16.0 40.0 4. 6. 0.0 0. 1. + 17705. 1. 5. 22.0 2.5 1.0 3. 14.0 11.5 3. 5. 0.0 0. 1. + 17706. 1. 4. 27.0 2.5 0.0 1. 20.0 40.0 5. 5. 0.0 0. 1. + 17707. 1. 5. 22.0 2.5 0.0 3. 14.0 14.0 5. 5. 0.0 0. 1. + 17716. 1. 5. 42.0 23.0 5.5 3. 14.0 14.0 4. 4. 0.0 0. 1. + 17718. 1. 5. 42.0 23.0 4.0 3. 14.0 14.0 3. 2. 0.0 0. 1. + 17721. 1. 5. 37.0 13.0 2.0 2. 20.0 40.0 6. 6. 0.0 0. 1. + 17723. 1. 5. 27.0 13.0 2.0 3. 14.0 20.0 4. 5. 0.0 0. 1. + 17726. 1. 4. 27.0 13.0 2.0 2. 12.0 6.5 2. 2. 0.0 0. 1. + 17742. 1. 5. 37.0 23.0 3.0 2. 12.0 14.0 4. 4. 0.0 0. 1. + 17748. 1. 5. 22.0 2.5 0.0 2. 17.0 11.5 5. 3. 0.0 0. 1. + 17750. 1. 5. 27.0 6.0 1.0 2. 12.0 14.0 2. 4. 0.0 0. 1. + 17752. 1. 5. 22.0 2.5 0.0 2. 14.0 11.5 3. 4. 0.0 0. 1. + 17758. 1. 5. 37.0 13.0 2.0 3. 16.0 20.0 4. 4. 0.0 0. 1. + 17780. 1. 5. 27.0 6.0 0.0 2. 17.0 20.0 5. 6. 0.0 0. 1. + 17786. 1. 5. 27.0 0.5 0.0 3. 12.0 40.0 3. 4. 0.0 0. 1. + 17796. 1. 2. 37.0 16.5 3.0 1. 14.0 14.0 3. 2. 0.0 0. 1. + 17797. 1. 5. 37.0 23.0 2.0 3. 20.0 40.0 4. 4. 0.0 0. 1. + 17802. 1. 2. 32.0 9.0 2.0 4. 14.0 14.0 3. 5. 0.0 0. 1. + 17803. 1. 5. 32.0 13.0 2.0 4. 20.0 20.0 4. 5. 0.0 0. 1. + 17805. 1. 5. 22.0 2.5 1.0 4. 16.0 11.5 4. 5. 0.0 0. 1. + 17812. 1. 5. 22.0 2.5 0.0 3. 20.0 11.5 4. 4. 0.0 0. 1. + 17813. 1. 3. 37.0 13.0 3.0 2. 16.0 11.5 4. 3. 0.0 0. 1. + 17818. 1. 3. 17.5 2.5 1.0 1. 9.0 6.5 3. 3. 0.0 0. 1. + 17820. 1. 4. 27.0 2.5 0.0 2. 14.0 11.5 3. 1. 0.0 0. 1. + 17821. 1. 1. 27.0 6.0 1.0 3. 14.0 14.0 3. 4. 0.0 0. 1. + 17824. 1. 4. 27.0 6.0 2.0 2. 14.0 40.0 4. 5. 0.0 0. 1. + 17829. 1. 2. 42.0 23.0 2.0 2. 14.0 20.0 3. 4. 0.0 0. 1. + 17832. 1. 5. 32.0 13.0 2.0 3. 14.0 20.0 4. 6. 0.0 0. 1. + 17841. 1. 4. 22.0 2.5 1.0 3. 14.0 11.5 3. 4. 0.0 0. 1. + 17866. 1. 4. 27.0 2.5 0.0 1. 14.0 9.0 2. 5. 0.0 0. 1. + 17872. 1. 4. 22.0 2.5 0.0 3. 20.0 40.0 6. 6. 0.0 0. 1. + 17873. 1. 3. 37.0 2.5 0.0 3. 12.0 11.5 3. 3. 0.0 0. 1. + 17876. 1. 5. 27.0 2.5 0.0 3. 17.0 20.0 4. 4. 0.0 0. 1. + 17878. 1. 5. 27.0 2.5 0.0 3. 16.0 20.0 3. 5. 0.0 0. 1. + 17879. 1. 4. 27.0 6.0 1.0 2. 20.0 20.0 4. 2. 0.0 0. 1. + 17880. 1. 4. 27.0 9.0 2.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 17892. 1. 4. 27.0 2.5 0.0 3. 17.0 11.5 4. 4. 0.0 0. 1. + 17895. 1. 5. 27.0 6.0 0.0 4. 16.0 14.0 4. 5. 0.0 0. 1. + 17901. 1. 5. 42.0 23.0 5.5 3. 12.0 14.0 3. 2. 0.0 0. 1. + 17905. 1. 5. 22.0 2.5 0.0 3. 16.0 9.0 4. 1. 0.0 0. 1. + 17914. 1. 5. 22.0 0.5 0.0 3. 14.0 9.0 2. 2. 0.0 0. 1. + 17916. 1. 4. 22.0 2.5 1.0 3. 14.0 9.0 2. 4. 0.0 0. 1. + 17925. 1. 5. 22.0 2.5 1.0 4. 12.0 6.5 3. 4. 0.0 0. 1. + 17928. 1. 5. 42.0 23.0 4.0 3. 14.0 14.0 5. 4. 0.0 0. 1. + 17929. 1. 5. 27.0 6.0 0.0 4. 14.0 6.5 4. 4. 0.0 0. 1. + 17934. 1. 5. 42.0 23.0 2.0 3. 12.0 40.0 2. 2. 0.0 0. 1. + 17939. 1. 4. 32.0 13.0 3.0 3. 16.0 20.0 4. 2. 0.0 0. 1. + 17940. 1. 5. 27.0 13.0 3.0 3. 16.0 14.0 4. 2. 0.0 0. 1. + 17943. 1. 5. 27.0 9.0 1.0 2. 14.0 20.0 4. 5. 0.0 0. 1. + 17946. 1. 4. 22.0 2.5 0.0 2. 16.0 6.5 4. 1. 0.0 0. 1. + 17947. 1. 5. 17.5 2.5 0.0 4. 12.0 14.0 3. 5. 0.0 0. 1. + 17952. 1. 4. 32.0 16.5 2.0 2. 12.0 20.0 3. 4. 0.0 0. 1. + 17953. 1. 5. 27.0 9.0 1.0 3. 12.0 40.0 3. 5. 0.0 0. 1. + 17960. 1. 4. 22.0 2.5 0.0 4. 14.0 11.5 4. 2. 0.0 0. 1. + 17961. 1. 5. 22.0 2.5 1.0 2. 12.0 11.5 3. 2. 0.0 0. 1. + 17962. 1. 5. 27.0 0.5 0.0 4. 20.0 20.0 4. 4. 0.0 0. 1. + 17963. 1. 5. 37.0 16.5 3.0 3. 14.0 20.0 5. 5. 0.0 0. 1. + 17967. 1. 5. 32.0 13.0 2.0 4. 14.0 20.0 3. 6. 0.0 0. 1. + 17971. 1. 4. 22.0 0.5 0.0 2. 16.0 9.0 3. 1. 0.0 0. 1. + 17973. 1. 5. 42.0 23.0 2.0 4. 12.0 20.0 3. 2. 0.0 0. 1. + 17975. 1. 5. 22.0 2.5 2.0 2. 14.0 6.5 3. 5. 0.0 0. 1. + 17978. 1. 5. 42.0 23.0 4.0 4. 12.0 20.0 3. 5. 0.0 0. 1. + 17981. 1. 4. 27.0 6.0 0.0 3. 12.0 20.0 3. 4. 0.0 0. 1. + 17982. 1. 5. 32.0 13.0 3.0 3. 12.0 20.0 3. 5. 0.0 0. 1. + 17990. 1. 5. 32.0 13.0 4.0 2. 14.0 20.0 4. 4. 0.0 0. 1. + 17997. 1. 3. 27.0 6.0 2.0 4. 14.0 6.5 3. 1. 0.0 0. 1. + 17998. 1. 4. 22.0 2.5 0.0 3. 16.0 11.5 5. 5. 0.0 0. 1. + 17999. 1. 5. 22.0 2.5 0.0 2. 14.0 20.0 3. 3. 0.0 0. 1. + 19006. 1. 5. 32.0 13.0 2.0 3. 17.0 40.0 4. 3. 0.0 0. 1. + 19009. 1. 4. 32.0 13.0 1.0 1. 16.0 40.0 5. 5. 0.0 0. 1. + 19013. 1. 5. 22.0 2.5 0.0 2. 14.0 6.5 3. 1. 0.0 0. 1. + 19015. 1. 5. 32.0 6.0 1.0 3. 14.0 20.0 3. 4. 0.0 0. 1. + 19020. 1. 4. 22.0 2.5 0.0 2. 16.0 4.0 2. 4. 0.0 0. 1. +END OF RB DATA diff --git a/shared/package-files/42/4222045f923c1994dc4e2ca52dd55101045fc2e4ebbf9d0658e4eb215c919477/blob b/shared/package-files/42/4222045f923c1994dc4e2ca52dd55101045fc2e4ebbf9d0658e4eb215c919477/blob new file mode 100644 index 0000000000000000000000000000000000000000..dfc371761ec06d4f5adef843ccf7cb05ae9d2d98 --- /dev/null +++ b/shared/package-files/42/4222045f923c1994dc4e2ca52dd55101045fc2e4ebbf9d0658e4eb215c919477/blob @@ -0,0 +1,192 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Generic + +from narwhals._compliant import LazyExprNamespace +from narwhals._compliant.any_namespace import StringNamespace +from narwhals._sql.typing import SQLExprT +from narwhals._utils import is_pyspark_pre_4 + +if TYPE_CHECKING: + from narwhals._compliant.expr import NativeExpr + + +class SQLExprStringNamespace( + LazyExprNamespace[SQLExprT], StringNamespace[SQLExprT], Generic[SQLExprT] +): + def _lit(self, value: Any) -> NativeExpr: + return self.compliant._lit(value) # type: ignore[no-any-return] + + def _function(self, name: str, *args: Any) -> NativeExpr: + return self.compliant._function(name, *args) # type: ignore[no-any-return] + + def _when( + self, condition: Any, value: Any, otherwise: Any | None = None + ) -> NativeExpr: + return self.compliant._when(condition, value, otherwise) # type: ignore[no-any-return] + + def contains(self, pattern: SQLExprT, *, literal: bool) -> SQLExprT: + + def func(expr: NativeExpr, pattern: NativeExpr) -> NativeExpr: + func_name = "contains" if literal else "regexp_matches" + return self._function(func_name, expr, pattern) + + compliant_pattern = ( + self.compliant.__narwhals_namespace__().lit(pattern, dtype=None) + if isinstance(pattern, str) + else pattern + ) + return self.compliant._with_elementwise( + func, expression_args={"pattern": compliant_pattern} + ) + + def ends_with(self, suffix: SQLExprT) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr, suffix: self._function("ends_with", expr, suffix), + expression_args={"suffix": suffix}, + ) + + def len_chars(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("length", expr) + ) + + def replace_all(self, value: SQLExprT, pattern: str, *, literal: bool) -> SQLExprT: + fname: str = "replace" if literal else "regexp_replace" + + options: list[Any] = [] + if not literal and self.compliant._implementation.is_duckdb(): + options = [self._lit("g")] + return self.compliant._with_elementwise( + lambda expr, value: self._function( + fname, expr, self._lit(pattern), value, *options + ), + expression_args={"value": value}, + ) + + def slice(self, offset: int, length: int | None) -> SQLExprT: + def func(expr: NativeExpr) -> NativeExpr: + str_length = self._function("length", expr) + count = self._lit(length) if length is not None else str_length + if offset >= 0: + return self._function("substr", expr, self._lit(offset + 1), count) + + # SQL engines disagree on a non-positive `substr` start, so clamp it to 1 + # and, like Polars, shorten `length` by however far `offset` overhangs. + start_index = self._function("add", str_length, self._lit(offset)) + start = self._function( + "greatest", self._lit(1), self._function("add", start_index, self._lit(1)) + ) + if length is not None: + overhang = self._function("least", self._lit(0), start_index) + count = self._function( + "greatest", self._lit(0), self._function("add", count, overhang) + ) + return self._function("substr", expr, start, count) + + return self.compliant._with_elementwise(func) + + def split(self, by: str) -> SQLExprT: + # PySpark < 4.0's `split` expects a raw Python string for `pattern`, + # not a Column literal. + _is_pyspark_pre_4 = is_pyspark_pre_4(self.compliant._implementation) + split_by = by if _is_pyspark_pre_4 else self._lit(by) + return self.compliant._with_elementwise( + lambda expr: self._function("str_split", expr, split_by) + ) + + def starts_with(self, prefix: SQLExprT) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr, prefix: self._function("starts_with", expr, prefix), + expression_args={"prefix": prefix}, + ) + + def strip_chars(self, characters: str | None) -> SQLExprT: + import string + + return self.compliant._with_elementwise( + lambda expr: self._function( + "trim", + expr, + self._lit(string.whitespace if characters is None else characters), + ) + ) + + def to_lowercase(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("lower", expr) + ) + + def to_uppercase(self) -> SQLExprT: + return self.compliant._with_elementwise( + lambda expr: self._function("upper", expr) + ) + + def zfill(self, width: int) -> SQLExprT: + # There is no built-in zfill function, so we need to implement it manually + # using string manipulation functions. + + # PySpark < 4.0's `lpad` expects raw Python values for `len` and `pad`, + # not Column literals. + _is_pyspark_pre_4 = is_pyspark_pre_4(self.compliant._implementation) + + def func(expr: NativeExpr) -> NativeExpr: + less_than_width = self._function("length", expr) < self._lit(width) + zero = "0" if _is_pyspark_pre_4 else self._lit("0") + width_after_sign = width - 1 if _is_pyspark_pre_4 else self._lit(width - 1) + full_width = width if _is_pyspark_pre_4 else self._lit(width) + hyphen, plus = self._lit("-"), self._lit("+") + + starts_with_minus = self._function("starts_with", expr, hyphen) + starts_with_plus = self._function("starts_with", expr, plus) + substring = self._function("substr", expr, self._lit(2)) + padded_substring = self._function("lpad", substring, width_after_sign, zero) + return self._when( + self._function("and", starts_with_minus, less_than_width), + self._function("concat", hyphen, padded_substring), + self._when( + self._function("and", starts_with_plus, less_than_width), + self._function("concat", plus, padded_substring), + self._when( + less_than_width, + self._function("lpad", expr, full_width, zero), + expr, + ), + ), + ) + + # can't use `_with_elementwise` due to `when` operator. + # TODO(unassigned): implement `window_func` like we do in `Expr.cast` + return self.compliant._with_callable(func) + + def pad_start(self, length: int, fill_char: str) -> SQLExprT: + # PySpark < 4.0's `lpad` expects raw Python values for `len` and `pad`, + # not Column literals. + _is_pyspark_pre_4 = is_pyspark_pre_4(self.compliant._implementation) + lpad_length = length if _is_pyspark_pre_4 else self._lit(length) + lpad_fill = fill_char if _is_pyspark_pre_4 else self._lit(fill_char) + + def _pad_start(expr: NativeExpr) -> NativeExpr: + return self._when( + self._function("length", expr) < self._lit(length), + self._function("lpad", expr, lpad_length, lpad_fill), + expr, + ) + + return self.compliant._with_callable(_pad_start) + + def pad_end(self, length: int, fill_char: str) -> SQLExprT: + # PySpark < 4.0's `rpad` expects raw Python values for `len` and `pad`, + # not Column literals. + _is_pyspark_pre_4 = is_pyspark_pre_4(self.compliant._implementation) + rpad_length = length if _is_pyspark_pre_4 else self._lit(length) + rpad_fill = fill_char if _is_pyspark_pre_4 else self._lit(fill_char) + + def _pad_end(expr: NativeExpr) -> NativeExpr: + return self._when( + self._function("length", expr) < self._lit(length), + self._function("rpad", expr, rpad_length, rpad_fill), + expr, + ) + + return self.compliant._with_callable(_pad_end) diff --git a/shared/package-files/42/4222e17be67d291bf54cc7dee5c6c22cef4d9b8be1a4db491173c285a3ffe0b8/blob b/shared/package-files/42/4222e17be67d291bf54cc7dee5c6c22cef4d9b8be1a4db491173c285a3ffe0b8/blob new file mode 100644 index 0000000000000000000000000000000000000000..6523f0b344e86bdcb1e520a61cbaed0a28e77e70 --- /dev/null +++ b/shared/package-files/42/4222e17be67d291bf54cc7dee5c6c22cef4d9b8be1a4db491173c285a3ffe0b8/blob @@ -0,0 +1,183 @@ +#!/usr/bin/env python +"""Tests for the linalg._isolve.gcrotmk module +""" + +import threading +from numpy.testing import (assert_, assert_allclose, assert_equal, + suppress_warnings) + +import numpy as np +from numpy import zeros, array, allclose +from scipy.linalg import norm +from scipy.sparse import csr_array, eye_array, random_array + +from scipy.sparse.linalg._interface import LinearOperator +from scipy.sparse.linalg import splu +from scipy.sparse.linalg._isolve import gcrotmk, gmres + + +Am = csr_array(array([[-2,1,0,0,0,9], + [1,-2,1,0,5,0], + [0,1,-2,1,0,0], + [0,0,1,-2,1,0], + [0,3,0,1,-2,1], + [1,0,0,0,1,-2]])) +b = array([1,2,3,4,5,6]) +count = threading.local() # [0] +niter = threading.local() # [0] + + +def matvec(v): + if not hasattr(count, 'c'): + count.c = [0] + count.c[0] += 1 + return Am@v + + +def cb(v): + if not hasattr(niter, 'n'): + niter.n = [0] + niter.n[0] += 1 + + +A = LinearOperator(matvec=matvec, shape=Am.shape, dtype=Am.dtype) + + +def do_solve(**kw): + if not hasattr(niter, 'n'): + niter.n = [0] + + if not hasattr(count, 'c'): + count.c = [0] + + count.c[0] = 0 + with suppress_warnings() as sup: + sup.filter(DeprecationWarning, ".*called without specifying.*") + x0, flag = gcrotmk(A, b, x0=zeros(A.shape[0]), rtol=1e-14, **kw) + count_0 = count.c[0] + assert_(allclose(A@x0, b, rtol=1e-12, atol=1e-12), norm(A@x0-b)) + return x0, count_0 + + +class TestGCROTMK: + def test_preconditioner(self): + # Check that preconditioning works + pc = splu(Am.tocsc()) + M = LinearOperator(matvec=pc.solve, shape=A.shape, dtype=A.dtype) + + x0, count_0 = do_solve() + niter.n[0] = 0 + x1, count_1 = do_solve(M=M, callback=cb) + + assert_equal(count_1, 3) + assert count_1 < count_0/2 + assert allclose(x1, x0, rtol=1e-14) + assert niter.n[0] < 3 + + def test_arnoldi(self): + rng = np.random.default_rng(1) + + A = eye_array(2000) + random_array((2000, 2000), density=5e-4, rng=rng) + b = rng.random(2000) + + # The inner arnoldi should be equivalent to gmres + with suppress_warnings() as sup: + sup.filter(DeprecationWarning, ".*called without specifying.*") + x0, flag0 = gcrotmk(A, b, x0=zeros(A.shape[0]), m=10, k=0, maxiter=1) + x1, flag1 = gmres(A, b, x0=zeros(A.shape[0]), restart=10, maxiter=1) + + assert_equal(flag0, 1) + assert_equal(flag1, 1) + assert np.linalg.norm(A.dot(x0) - b) > 1e-4 + + assert_allclose(x0, x1) + + def test_cornercase(self): + np.random.seed(1234) + + # Rounding error may prevent convergence with tol=0 --- ensure + # that the return values in this case are correct, and no + # exceptions are raised + + for n in [3, 5, 10, 100]: + A = 2*eye_array(n) + + with suppress_warnings() as sup: + sup.filter(DeprecationWarning, ".*called without specifying.*") + b = np.ones(n) + x, info = gcrotmk(A, b, maxiter=10) + assert_equal(info, 0) + assert_allclose(A.dot(x) - b, 0, atol=1e-14) + + x, info = gcrotmk(A, b, rtol=0, maxiter=10) + if info == 0: + assert_allclose(A.dot(x) - b, 0, atol=1e-14) + + b = np.random.rand(n) + x, info = gcrotmk(A, b, maxiter=10) + assert_equal(info, 0) + assert_allclose(A.dot(x) - b, 0, atol=1e-14) + + x, info = gcrotmk(A, b, rtol=0, maxiter=10) + if info == 0: + assert_allclose(A.dot(x) - b, 0, atol=1e-14) + + def test_nans(self): + A = eye_array(3, format='lil') + A[1,1] = np.nan + b = np.ones(3) + + with suppress_warnings() as sup: + sup.filter(DeprecationWarning, ".*called without specifying.*") + x, info = gcrotmk(A, b, rtol=0, maxiter=10) + assert_equal(info, 1) + + def test_truncate(self): + np.random.seed(1234) + A = np.random.rand(30, 30) + np.eye(30) + b = np.random.rand(30) + + for truncate in ['oldest', 'smallest']: + with suppress_warnings() as sup: + sup.filter(DeprecationWarning, ".*called without specifying.*") + x, info = gcrotmk(A, b, m=10, k=10, truncate=truncate, + rtol=1e-4, maxiter=200) + assert_equal(info, 0) + assert_allclose(A.dot(x) - b, 0, atol=1e-3) + + def test_CU(self): + for discard_C in (True, False): + # Check that C,U behave as expected + CU = [] + x0, count_0 = do_solve(CU=CU, discard_C=discard_C) + assert_(len(CU) > 0) + assert_(len(CU) <= 6) + + if discard_C: + for c, u in CU: + assert_(c is None) + + # should converge immediately + x1, count_1 = do_solve(CU=CU, discard_C=discard_C) + if discard_C: + assert_equal(count_1, 2 + len(CU)) + else: + assert_equal(count_1, 3) + assert_(count_1 <= count_0/2) + assert_allclose(x1, x0, atol=1e-14) + + def test_denormals(self): + # Check that no warnings are emitted if the matrix contains + # numbers for which 1/x has no float representation, and that + # the solver behaves properly. + A = np.array([[1, 2], [3, 4]], dtype=float) + A *= 100 * np.nextafter(0, 1) + + b = np.array([1, 1]) + + with suppress_warnings() as sup: + sup.filter(DeprecationWarning, ".*called without specifying.*") + xp, info = gcrotmk(A, b) + + if info == 0: + assert_allclose(A.dot(xp), b) diff --git a/shared/package-files/42/42241148c8c76ca081a635b227728f20980ad44ab4eea5d462350b6831e0b798/blob b/shared/package-files/42/42241148c8c76ca081a635b227728f20980ad44ab4eea5d462350b6831e0b798/blob new file mode 100644 index 0000000000000000000000000000000000000000..aef2e9044c6a3ee27b47ac17ce9c35a46d66970d --- /dev/null +++ b/shared/package-files/42/42241148c8c76ca081a635b227728f20980ad44ab4eea5d462350b6831e0b798/blob @@ -0,0 +1,1134 @@ +r""" +A module for dealing with the polylines used throughout Matplotlib. + +The primary class for polyline handling in Matplotlib is `Path`. Almost all +vector drawing makes use of `Path`\s somewhere in the drawing pipeline. + +Whilst a `Path` instance itself cannot be drawn, some `.Artist` subclasses, +such as `.PathPatch` and `.PathCollection`, can be used for convenient `Path` +visualisation. +""" + +import copy +from functools import lru_cache +from weakref import WeakValueDictionary + +import numpy as np + +import matplotlib as mpl +from . import _api, _path +from .cbook import _to_unmasked_float_array, simple_linear_interpolation +from .bezier import BezierSegment + + +class Path: + """ + A series of possibly disconnected, possibly closed, line and curve + segments. + + The underlying storage is made up of two parallel numpy arrays: + + - *vertices*: an (N, 2) float array of vertices + - *codes*: an N-length `numpy.uint8` array of path codes, or None + + These two arrays always have the same length in the first + dimension. For example, to represent a cubic curve, you must + provide three vertices and three `CURVE4` codes. + + The code types are: + + - `STOP` : 1 vertex (ignored) + A marker for the end of the entire path (currently not required and + ignored) + + - `MOVETO` : 1 vertex + Pick up the pen and move to the given vertex. + + - `LINETO` : 1 vertex + Draw a line from the current position to the given vertex. + + - `CURVE3` : 1 control point, 1 endpoint + Draw a quadratic Bézier curve from the current position, with the given + control point, to the given end point. + + - `CURVE4` : 2 control points, 1 endpoint + Draw a cubic Bézier curve from the current position, with the given + control points, to the given end point. + + - `CLOSEPOLY` : 1 vertex (ignored) + Draw a line segment to the start point of the current polyline. + + If *codes* is None, it is interpreted as a `MOVETO` followed by a series + of `LINETO`. + + Users of Path objects should not access the vertices and codes arrays + directly. Instead, they should use `iter_segments` or `cleaned` to get the + vertex/code pairs. This helps, in particular, to consistently handle the + case of *codes* being None. + + Some behavior of Path objects can be controlled by rcParams. See the + rcParams whose keys start with 'path.'. + + .. note:: + + The vertices and codes arrays should be treated as + immutable -- there are a number of optimizations and assumptions + made up front in the constructor that will not change when the + data changes. + """ + + code_type = np.uint8 + + # Path codes + STOP = code_type(0) # 1 vertex + MOVETO = code_type(1) # 1 vertex + LINETO = code_type(2) # 1 vertex + CURVE3 = code_type(3) # 2 vertices + CURVE4 = code_type(4) # 3 vertices + CLOSEPOLY = code_type(79) # 1 vertex + + #: A dictionary mapping Path codes to the number of vertices that the + #: code expects. + NUM_VERTICES_FOR_CODE = {STOP: 1, + MOVETO: 1, + LINETO: 1, + CURVE3: 2, + CURVE4: 3, + CLOSEPOLY: 1} + + def __init__(self, vertices, codes=None, _interpolation_steps=1, + closed=False, readonly=False): + """ + Create a new path with the given vertices and codes. + + Parameters + ---------- + vertices : (N, 2) array-like + The path vertices, as an array, masked array or sequence of pairs. + Masked values, if any, will be converted to NaNs, which are then + handled correctly by the Agg PathIterator and other consumers of + path data, such as :meth:`iter_segments`. + codes : array-like or None, optional + N-length array of integers representing the codes of the path. + If not None, codes must be the same length as vertices. + If None, *vertices* will be treated as a series of line segments. + _interpolation_steps : int, optional + Used as a hint to certain projections, such as Polar, that this + path should be linearly interpolated immediately before drawing. + This attribute is primarily an implementation detail and is not + intended for public use. + closed : bool, optional + If *codes* is None and closed is True, vertices will be treated as + line segments of a closed polygon. Note that the last vertex will + then be ignored (as the corresponding code will be set to + `CLOSEPOLY`). + readonly : bool, optional + Makes the path behave in an immutable way and sets the vertices + and codes as read-only arrays. + """ + vertices = _to_unmasked_float_array(vertices) + _api.check_shape((None, 2), vertices=vertices) + + if codes is not None and len(vertices): + codes = np.asarray(codes, self.code_type) + if codes.ndim != 1 or len(codes) != len(vertices): + raise ValueError("'codes' must be a 1D list or array with the " + "same length of 'vertices'. " + f"Your vertices have shape {vertices.shape} " + f"but your codes have shape {codes.shape}") + if len(codes) and codes[0] != self.MOVETO: + raise ValueError("The first element of 'code' must be equal " + f"to 'MOVETO' ({self.MOVETO}). " + f"Your first code is {codes[0]}") + elif closed and len(vertices): + codes = np.empty(len(vertices), dtype=self.code_type) + codes[0] = self.MOVETO + codes[1:-1] = self.LINETO + codes[-1] = self.CLOSEPOLY + + self._vertices = vertices + self._codes = codes + self._interpolation_steps = _interpolation_steps + self._update_values() + + if readonly: + self._vertices.flags.writeable = False + if self._codes is not None: + self._codes.flags.writeable = False + self._readonly = True + else: + self._readonly = False + + @classmethod + def _fast_from_codes_and_verts(cls, verts, codes, internals_from=None): + """ + Create a Path instance without the expense of calling the constructor. + + Parameters + ---------- + verts : array-like + codes : array + internals_from : Path or None + If not None, another `Path` from which the attributes + ``should_simplify``, ``simplify_threshold``, and + ``interpolation_steps`` will be copied. Note that ``readonly`` is + never copied, and always set to ``False`` by this constructor. + """ + pth = cls.__new__(cls) + pth._vertices = _to_unmasked_float_array(verts) + pth._codes = codes + pth._readonly = False + if internals_from is not None: + pth._should_simplify = internals_from._should_simplify + pth._simplify_threshold = internals_from._simplify_threshold + pth._interpolation_steps = internals_from._interpolation_steps + else: + pth._should_simplify = True + pth._simplify_threshold = mpl.rcParams['path.simplify_threshold'] + pth._interpolation_steps = 1 + return pth + + @classmethod + def _create_closed(cls, vertices): + """ + Create a closed polygonal path going through *vertices*. + + Unlike ``Path(..., closed=True)``, *vertices* should **not** end with + an entry for the CLOSEPATH; this entry is added by `._create_closed`. + """ + v = _to_unmasked_float_array(vertices) + return cls(np.concatenate([v, v[:1]]), closed=True) + + def _update_values(self): + self._simplify_threshold = mpl.rcParams['path.simplify_threshold'] + self._should_simplify = ( + self._simplify_threshold > 0 and + mpl.rcParams['path.simplify'] and + len(self._vertices) >= 128 and + (self._codes is None or np.all(self._codes <= Path.LINETO)) + ) + + @property + def vertices(self): + """The vertices of the `Path` as an (N, 2) array.""" + return self._vertices + + @vertices.setter + def vertices(self, vertices): + if self._readonly: + raise AttributeError("Can't set vertices on a readonly Path") + self._vertices = vertices + self._update_values() + + @property + def codes(self): + """ + The list of codes in the `Path` as a 1D array. + + Each code is one of `STOP`, `MOVETO`, `LINETO`, `CURVE3`, `CURVE4` or + `CLOSEPOLY`. For codes that correspond to more than one vertex + (`CURVE3` and `CURVE4`), that code will be repeated so that the length + of `vertices` and `codes` is always the same. + """ + return self._codes + + @codes.setter + def codes(self, codes): + if self._readonly: + raise AttributeError("Can't set codes on a readonly Path") + self._codes = codes + self._update_values() + + @property + def simplify_threshold(self): + """ + The fraction of a pixel difference below which vertices will + be simplified out. + """ + return self._simplify_threshold + + @simplify_threshold.setter + def simplify_threshold(self, threshold): + self._simplify_threshold = threshold + + @property + def should_simplify(self): + """ + `True` if the vertices array should be simplified. + """ + return self._should_simplify + + @should_simplify.setter + def should_simplify(self, should_simplify): + self._should_simplify = should_simplify + + @property + def readonly(self): + """ + `True` if the `Path` is read-only. + """ + return self._readonly + + def copy(self): + """ + Return a shallow copy of the `Path`, which will share the + vertices and codes with the source `Path`. + """ + return copy.copy(self) + + def __deepcopy__(self, memo): + """ + Return a deepcopy of the `Path`. The `Path` will not be + readonly, even if the source `Path` is. + """ + # Deepcopying arrays (vertices, codes) strips the writeable=False flag. + cls = type(self) + memo[id(self)] = p = cls.__new__(cls) + + for k, v in self.__dict__.items(): + setattr(p, k, copy.deepcopy(v, memo)) + + p._readonly = False + return p + + def deepcopy(self, memo=None): + """ + Return a deep copy of the `Path`. The `Path` will not be readonly, + even if the source `Path` is. + + Parameters + ---------- + memo : dict, optional + A dictionary to use for memoizing, passed to `copy.deepcopy`. + + Returns + ------- + Path + A deep copy of the `Path`, but not readonly. + """ + return copy.deepcopy(self, memo) + + @classmethod + def make_compound_path_from_polys(cls, XY): + """ + Make a compound `Path` object to draw a number of polygons with equal + numbers of sides. + + .. plot:: gallery/misc/histogram_path.py + + Parameters + ---------- + XY : (numpolys, numsides, 2) array + """ + # for each poly: 1 for the MOVETO, (numsides-1) for the LINETO, 1 for + # the CLOSEPOLY; the vert for the closepoly is ignored but we still + # need it to keep the codes aligned with the vertices + numpolys, numsides, two = XY.shape + if two != 2: + raise ValueError("The third dimension of 'XY' must be 2") + stride = numsides + 1 + nverts = numpolys * stride + verts = np.zeros((nverts, 2)) + codes = np.full(nverts, cls.LINETO, dtype=cls.code_type) + codes[0::stride] = cls.MOVETO + codes[numsides::stride] = cls.CLOSEPOLY + for i in range(numsides): + verts[i::stride] = XY[:, i] + return cls(verts, codes) + + @classmethod + def make_compound_path(cls, *args): + r""" + Concatenate a list of `Path`\s into a single `Path`, removing all `STOP`\s. + """ + if not args: + return Path(np.empty([0, 2], dtype=np.float32)) + vertices = np.concatenate([path.vertices for path in args]) + codes = np.empty(len(vertices), dtype=cls.code_type) + i = 0 + for path in args: + size = len(path.vertices) + if path.codes is None: + if size: + codes[i] = cls.MOVETO + codes[i+1:i+size] = cls.LINETO + else: + codes[i:i+size] = path.codes + i += size + not_stop_mask = codes != cls.STOP # Remove STOPs, as internal STOPs are a bug. + return cls(vertices[not_stop_mask], codes[not_stop_mask]) + + def __repr__(self): + return f"Path({self.vertices!r}, {self.codes!r})" + + def __len__(self): + return len(self.vertices) + + def iter_segments(self, transform=None, remove_nans=True, clip=None, + snap=False, stroke_width=1.0, simplify=None, + curves=True, sketch=None): + """ + Iterate over all curve segments in the path. + + Each iteration returns a pair ``(vertices, code)``, where ``vertices`` + is a sequence of 1-3 coordinate pairs, and ``code`` is a `Path` code. + + Additionally, this method can provide a number of standard cleanups and + conversions to the path. + + Parameters + ---------- + transform : None or :class:`~matplotlib.transforms.Transform` + If not None, the given affine transformation will be applied to the + path. + remove_nans : bool, optional + Whether to remove all NaNs from the path and skip over them using + MOVETO commands. + clip : None or (float, float, float, float), optional + If not None, must be a four-tuple (x1, y1, x2, y2) + defining a rectangle in which to clip the path. + snap : None or bool, optional + If True, snap all nodes to pixels; if False, don't snap them. + If None, snap if the path contains only segments + parallel to the x or y axes, and no more than 1024 of them. + stroke_width : float, optional + The width of the stroke being drawn (used for path snapping). + simplify : None or bool, optional + Whether to simplify the path by removing vertices + that do not affect its appearance. If None, use the + :attr:`should_simplify` attribute. See also :rc:`path.simplify` + and :rc:`path.simplify_threshold`. + curves : bool, optional + If True, curve segments will be returned as curve segments. + If False, all curves will be converted to line segments. + sketch : None or sequence, optional + If not None, must be a 3-tuple of the form + (scale, length, randomness), representing the sketch parameters. + """ + if not len(self): + return + + cleaned = self.cleaned(transform=transform, + remove_nans=remove_nans, clip=clip, + snap=snap, stroke_width=stroke_width, + simplify=simplify, curves=curves, + sketch=sketch) + + # Cache these object lookups for performance in the loop. + NUM_VERTICES_FOR_CODE = self.NUM_VERTICES_FOR_CODE + STOP = self.STOP + + vertices = iter(cleaned.vertices) + codes = iter(cleaned.codes) + for curr_vertices, code in zip(vertices, codes): + if code == STOP: + break + extra_vertices = NUM_VERTICES_FOR_CODE[code] - 1 + if extra_vertices: + for i in range(extra_vertices): + next(codes) + curr_vertices = np.append(curr_vertices, next(vertices)) + yield curr_vertices, code + + def iter_bezier(self, **kwargs): + """ + Iterate over each Bézier curve (lines included) in a `Path`. + + Parameters + ---------- + **kwargs + Forwarded to `.iter_segments`. + + Yields + ------ + B : `~matplotlib.bezier.BezierSegment` + The Bézier curves that make up the current path. Note in particular + that freestanding points are Bézier curves of order 0, and lines + are Bézier curves of order 1 (with two control points). + code : `~matplotlib.path.Path.code_type` + The code describing what kind of curve is being returned. + `MOVETO`, `LINETO`, `CURVE3`, and `CURVE4` correspond to + Bézier curves with 1, 2, 3, and 4 control points (respectively). + `CLOSEPOLY` is a `LINETO` with the control points correctly + chosen based on the start/end points of the current stroke. + """ + first_vert = None + prev_vert = None + for verts, code in self.iter_segments(**kwargs): + if first_vert is None: + if code != Path.MOVETO: + raise ValueError("Malformed path, must start with MOVETO.") + if code == Path.MOVETO: # a point is like "CURVE1" + first_vert = verts + yield BezierSegment(np.array([first_vert])), code + elif code == Path.LINETO: # "CURVE2" + yield BezierSegment(np.array([prev_vert, verts])), code + elif code == Path.CURVE3: + yield BezierSegment(np.array([prev_vert, verts[:2], + verts[2:]])), code + elif code == Path.CURVE4: + yield BezierSegment(np.array([prev_vert, verts[:2], + verts[2:4], verts[4:]])), code + elif code == Path.CLOSEPOLY: + yield BezierSegment(np.array([prev_vert, first_vert])), code + elif code == Path.STOP: + return + else: + raise ValueError(f"Invalid Path.code_type: {code}") + prev_vert = verts[-2:] + + def _iter_connected_components(self): + """Return subpaths split at MOVETOs.""" + if self.codes is None: + yield self + else: + idxs = np.append((self.codes == Path.MOVETO).nonzero()[0], len(self.codes)) + for sl in map(slice, idxs, idxs[1:]): + yield Path._fast_from_codes_and_verts( + self.vertices[sl], self.codes[sl], self) + + def cleaned(self, transform=None, remove_nans=False, clip=None, + *, simplify=False, curves=False, + stroke_width=1.0, snap=False, sketch=None): + """ + Return a new `Path` with vertices and codes cleaned according to the + parameters. + + See Also + -------- + Path.iter_segments : for details of the keyword arguments. + """ + vertices, codes = _path.cleanup_path( + self, transform, remove_nans, clip, snap, stroke_width, simplify, + curves, sketch) + pth = Path._fast_from_codes_and_verts(vertices, codes, self) + if not simplify: + pth._should_simplify = False + return pth + + def transformed(self, transform): + """ + Return a transformed copy of the path. + + See Also + -------- + matplotlib.transforms.TransformedPath + A specialized path class that will cache the transformed result and + automatically update when the transform changes. + """ + return Path(transform.transform(self.vertices), self.codes, + self._interpolation_steps) + + def contains_point(self, point, transform=None, radius=0.0): + """ + Return whether the area enclosed by the path contains the given point. + + The path is always treated as closed; i.e. if the last code is not + `CLOSEPOLY` an implicit segment connecting the last vertex to the first + vertex is assumed. + + Parameters + ---------- + point : (float, float) + The point (x, y) to check. + transform : `~matplotlib.transforms.Transform`, optional + If not ``None``, *point* will be compared to ``self`` transformed + by *transform*; i.e. for a correct check, *transform* should + transform the path into the coordinate system of *point*. + radius : float, default: 0 + Additional margin on the path in coordinates of *point*. + The path is extended tangentially by *radius/2*; i.e. if you would + draw the path with a linewidth of *radius*, all points on the line + would still be considered to be contained in the area. Conversely, + negative values shrink the area: Points on the imaginary line + will be considered outside the area. + + Returns + ------- + bool + + Notes + ----- + The current algorithm has some limitations: + + - The result is undefined for points exactly at the boundary + (i.e. at the path shifted by *radius/2*). + - The result is undefined if there is no enclosed area, i.e. all + vertices are on a straight line. + - If bounding lines start to cross each other due to *radius* shift, + the result is not guaranteed to be correct. + """ + if transform is not None: + transform = transform.frozen() + # `point_in_path` does not handle nonlinear transforms, so we + # transform the path ourselves. If *transform* is affine, letting + # `point_in_path` handle the transform avoids allocating an extra + # buffer. + if transform and not transform.is_affine: + self = transform.transform_path(self) + transform = None + return _path.point_in_path(point[0], point[1], radius, self, transform) + + def contains_points(self, points, transform=None, radius=0.0): + """ + Return whether the area enclosed by the path contains the given points. + + The path is always treated as closed; i.e. if the last code is not + `CLOSEPOLY` an implicit segment connecting the last vertex to the first + vertex is assumed. + + Parameters + ---------- + points : (N, 2) array + The points to check. Columns contain x and y values. + transform : `~matplotlib.transforms.Transform`, optional + If not ``None``, *points* will be compared to ``self`` transformed + by *transform*; i.e. for a correct check, *transform* should + transform the path into the coordinate system of *points*. + radius : float, default: 0 + Additional margin on the path in coordinates of *points*. + The path is extended tangentially by *radius/2*; i.e. if you would + draw the path with a linewidth of *radius*, all points on the line + would still be considered to be contained in the area. Conversely, + negative values shrink the area: Points on the imaginary line + will be considered outside the area. + + Returns + ------- + length-N bool array + + Notes + ----- + The current algorithm has some limitations: + + - The result is undefined for points exactly at the boundary + (i.e. at the path shifted by *radius/2*). + - The result is undefined if there is no enclosed area, i.e. all + vertices are on a straight line. + - If bounding lines start to cross each other due to *radius* shift, + the result is not guaranteed to be correct. + """ + if transform is not None: + transform = transform.frozen() + result = _path.points_in_path(points, radius, self, transform) + return result.astype('bool') + + def contains_path(self, path, transform=None): + """ + Return whether this (closed) path completely contains the given path. + + If *transform* is not ``None``, the path will be transformed before + checking for containment. + """ + if transform is not None: + transform = transform.frozen() + return _path.path_in_path(self, None, path, transform) + + def get_extents(self, transform=None, **kwargs): + """ + Get Bbox of the path. + + Parameters + ---------- + transform : `~matplotlib.transforms.Transform`, optional + Transform to apply to path before computing extents, if any. + **kwargs + Forwarded to `.iter_bezier`. + + Returns + ------- + matplotlib.transforms.Bbox + The extents of the path Bbox([[xmin, ymin], [xmax, ymax]]) + """ + from .transforms import Bbox + if transform is not None: + self = transform.transform_path(self) + if self.codes is None: + xys = self.vertices + elif len(np.intersect1d(self.codes, [Path.CURVE3, Path.CURVE4])) == 0: + # Optimization for the straight line case. + # Instead of iterating through each curve, consider + # each line segment's end-points + # (recall that STOP and CLOSEPOLY vertices are ignored) + xys = self.vertices[np.isin(self.codes, + [Path.MOVETO, Path.LINETO])] + else: + xys = [] + for curve, code in self.iter_bezier(**kwargs): + # places where the derivative is zero can be extrema + _, dzeros = curve.axis_aligned_extrema() + # as can the ends of the curve + xys.append(curve([0, *dzeros, 1])) + xys = np.concatenate(xys) + if len(xys): + return Bbox([xys.min(axis=0), xys.max(axis=0)]) + else: + return Bbox.null() + + def intersects_path(self, other, filled=True): + """ + Return whether if this path intersects another given path. + + If *filled* is True, then this also returns True if one path completely + encloses the other (i.e., the paths are treated as filled). + """ + return _path.path_intersects_path(self, other, filled) + + def intersects_bbox(self, bbox, filled=True): + """ + Return whether this path intersects a given `~.transforms.Bbox`. + + If *filled* is True, then this also returns True if the path completely + encloses the `.Bbox` (i.e., the path is treated as filled). + + The bounding box is always considered filled. + """ + return _path.path_intersects_rectangle( + self, bbox.x0, bbox.y0, bbox.x1, bbox.y1, filled) + + def interpolated(self, steps): + """ + Return a new path with each segment divided into *steps* parts. + + Codes other than `LINETO`, `MOVETO`, and `CLOSEPOLY` are not handled correctly. + + Parameters + ---------- + steps : int + The number of segments in the new path for each in the original. + + Returns + ------- + Path + The interpolated path. + """ + if steps == 1 or len(self) == 0: + return self + + if self.codes is not None and self.MOVETO in self.codes[1:]: + return self.make_compound_path( + *(p.interpolated(steps) for p in self._iter_connected_components())) + + if self.codes is not None and self.CLOSEPOLY in self.codes and not np.all( + self.vertices[self.codes == self.CLOSEPOLY] == self.vertices[0]): + vertices = self.vertices.copy() + vertices[self.codes == self.CLOSEPOLY] = vertices[0] + else: + vertices = self.vertices + + vertices = simple_linear_interpolation(vertices, steps) + codes = self.codes + if codes is not None: + new_codes = np.full((len(codes) - 1) * steps + 1, Path.LINETO, + dtype=self.code_type) + new_codes[0::steps] = codes + else: + new_codes = None + return Path(vertices, new_codes) + + def to_polygons(self, transform=None, width=0, height=0, closed_only=True): + """ + Convert this path to a list of polygons or polylines. Each + polygon/polyline is an (N, 2) array of vertices. In other words, + each polygon has no `MOVETO` instructions or curves. This + is useful for displaying in backends that do not support + compound paths or Bézier curves. + + If *width* and *height* are both non-zero then the lines will + be simplified so that vertices outside of (0, 0), (width, + height) will be clipped. + + The resulting polygons will be simplified if the + :attr:`Path.should_simplify` attribute of the path is `True`. + + If *closed_only* is `True` (default), only closed polygons, + with the last point being the same as the first point, will be + returned. Any unclosed polylines in the path will be + explicitly closed. If *closed_only* is `False`, any unclosed + polygons in the path will be returned as unclosed polygons, + and the closed polygons will be returned explicitly closed by + setting the last point to the same as the first point. + """ + if len(self.vertices) == 0: + return [] + + if transform is not None: + transform = transform.frozen() + + if self.codes is None and (width == 0 or height == 0): + vertices = self.vertices + if closed_only: + if len(vertices) < 3: + return [] + elif np.any(vertices[0] != vertices[-1]): + vertices = [*vertices, vertices[0]] + + if transform is None: + return [vertices] + else: + return [transform.transform(vertices)] + + # Deal with the case where there are curves and/or multiple + # subpaths (using extension code) + return _path.convert_path_to_polygons( + self, transform, width, height, closed_only) + + _unit_rectangle = None + + @classmethod + def unit_rectangle(cls): + """ + Return a `Path` instance of the unit rectangle from (0, 0) to (1, 1). + """ + if cls._unit_rectangle is None: + cls._unit_rectangle = cls([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]], + closed=True, readonly=True) + return cls._unit_rectangle + + _unit_regular_polygons = WeakValueDictionary() + + @classmethod + def unit_regular_polygon(cls, numVertices): + """ + Return a :class:`Path` instance for a unit regular polygon with the + given *numVertices* such that the circumscribing circle has radius 1.0, + centered at (0, 0). + """ + if numVertices <= 16: + path = cls._unit_regular_polygons.get(numVertices) + else: + path = None + if path is None: + theta = ((2 * np.pi / numVertices) * np.arange(numVertices + 1) + # This initial rotation is to make sure the polygon always + # "points-up". + + np.pi / 2) + verts = np.column_stack((np.cos(theta), np.sin(theta))) + path = cls(verts, closed=True, readonly=True) + if numVertices <= 16: + cls._unit_regular_polygons[numVertices] = path + return path + + _unit_regular_stars = WeakValueDictionary() + + @classmethod + def unit_regular_star(cls, numVertices, innerCircle=0.5): + """ + Return a :class:`Path` for a unit regular star with the given + numVertices and radius of 1.0, centered at (0, 0). + """ + if numVertices <= 16: + path = cls._unit_regular_stars.get((numVertices, innerCircle)) + else: + path = None + if path is None: + ns2 = numVertices * 2 + theta = (2*np.pi/ns2 * np.arange(ns2 + 1)) + # This initial rotation is to make sure the polygon always + # "points-up" + theta += np.pi / 2.0 + r = np.ones(ns2 + 1) + r[1::2] = innerCircle + verts = (r * np.vstack((np.cos(theta), np.sin(theta)))).T + path = cls(verts, closed=True, readonly=True) + if numVertices <= 16: + cls._unit_regular_stars[(numVertices, innerCircle)] = path + return path + + @classmethod + def unit_regular_asterisk(cls, numVertices): + """ + Return a :class:`Path` for a unit regular asterisk with the given + numVertices and radius of 1.0, centered at (0, 0). + """ + return cls.unit_regular_star(numVertices, 0.0) + + _unit_circle = None + + @classmethod + def unit_circle(cls): + """ + Return the readonly :class:`Path` of the unit circle. + + For most cases, :func:`Path.circle` will be what you want. + """ + if cls._unit_circle is None: + cls._unit_circle = cls.circle(center=(0, 0), radius=1, + readonly=True) + return cls._unit_circle + + @classmethod + def circle(cls, center=(0., 0.), radius=1., readonly=False): + """ + Return a `Path` representing a circle of a given radius and center. + + Parameters + ---------- + center : (float, float), default: (0, 0) + The center of the circle. + radius : float, default: 1 + The radius of the circle. + readonly : bool + Whether the created path should have the "readonly" argument + set when creating the Path instance. + + Notes + ----- + The circle is approximated using 8 cubic Bézier curves, as described in + + Lancaster, Don. `Approximating a Circle or an Ellipse Using Four + Bezier Cubic Splines `_. + """ + MAGIC = 0.2652031 + SQRTHALF = np.sqrt(0.5) + MAGIC45 = SQRTHALF * MAGIC + + vertices = np.array([[0.0, -1.0], + + [MAGIC, -1.0], + [SQRTHALF-MAGIC45, -SQRTHALF-MAGIC45], + [SQRTHALF, -SQRTHALF], + + [SQRTHALF+MAGIC45, -SQRTHALF+MAGIC45], + [1.0, -MAGIC], + [1.0, 0.0], + + [1.0, MAGIC], + [SQRTHALF+MAGIC45, SQRTHALF-MAGIC45], + [SQRTHALF, SQRTHALF], + + [SQRTHALF-MAGIC45, SQRTHALF+MAGIC45], + [MAGIC, 1.0], + [0.0, 1.0], + + [-MAGIC, 1.0], + [-SQRTHALF+MAGIC45, SQRTHALF+MAGIC45], + [-SQRTHALF, SQRTHALF], + + [-SQRTHALF-MAGIC45, SQRTHALF-MAGIC45], + [-1.0, MAGIC], + [-1.0, 0.0], + + [-1.0, -MAGIC], + [-SQRTHALF-MAGIC45, -SQRTHALF+MAGIC45], + [-SQRTHALF, -SQRTHALF], + + [-SQRTHALF+MAGIC45, -SQRTHALF-MAGIC45], + [-MAGIC, -1.0], + [0.0, -1.0], + + [0.0, -1.0]], + dtype=float) + + codes = [cls.CURVE4] * 26 + codes[0] = cls.MOVETO + codes[-1] = cls.CLOSEPOLY + return Path(vertices * radius + center, codes, readonly=readonly) + + _unit_circle_righthalf = None + + @classmethod + def unit_circle_righthalf(cls): + """ + Return a `Path` of the right half of a unit circle. + + See `Path.circle` for the reference on the approximation used. + """ + if cls._unit_circle_righthalf is None: + MAGIC = 0.2652031 + SQRTHALF = np.sqrt(0.5) + MAGIC45 = SQRTHALF * MAGIC + + vertices = np.array( + [[0.0, -1.0], + + [MAGIC, -1.0], + [SQRTHALF-MAGIC45, -SQRTHALF-MAGIC45], + [SQRTHALF, -SQRTHALF], + + [SQRTHALF+MAGIC45, -SQRTHALF+MAGIC45], + [1.0, -MAGIC], + [1.0, 0.0], + + [1.0, MAGIC], + [SQRTHALF+MAGIC45, SQRTHALF-MAGIC45], + [SQRTHALF, SQRTHALF], + + [SQRTHALF-MAGIC45, SQRTHALF+MAGIC45], + [MAGIC, 1.0], + [0.0, 1.0], + + [0.0, -1.0]], + + float) + + codes = np.full(14, cls.CURVE4, dtype=cls.code_type) + codes[0] = cls.MOVETO + codes[-1] = cls.CLOSEPOLY + + cls._unit_circle_righthalf = cls(vertices, codes, readonly=True) + return cls._unit_circle_righthalf + + @classmethod + def arc(cls, theta1, theta2, n=None, is_wedge=False): + """ + Return a `Path` for the unit circle arc from angles *theta1* to + *theta2* (in degrees). + + *theta2* is unwrapped to produce the shortest arc within 360 degrees. + That is, if *theta2* > *theta1* + 360, the arc will be from *theta1* to + *theta2* - 360 and not a full circle plus some extra overlap. + + If *n* is provided, it is the number of spline segments to make. + If *n* is not provided, the number of spline segments is + determined based on the delta between *theta1* and *theta2*. + + Masionobe, L. 2003. `Drawing an elliptical arc using + polylines, quadratic or cubic Bezier curves + `_. + """ + halfpi = np.pi * 0.5 + + eta1 = theta1 + eta2 = theta2 - 360 * np.floor((theta2 - theta1) / 360) + # Ensure 2pi range is not flattened to 0 due to floating-point errors, + # but don't try to expand existing 0 range. + if theta2 != theta1 and eta2 <= eta1: + eta2 += 360 + eta1, eta2 = np.deg2rad([eta1, eta2]) + + # number of curve segments to make + if n is None: + n = int(2 ** np.ceil((eta2 - eta1) / halfpi)) + if n < 1: + raise ValueError("n must be >= 1 or None") + + deta = (eta2 - eta1) / n + t = np.tan(0.5 * deta) + alpha = np.sin(deta) * (np.sqrt(4.0 + 3.0 * t * t) - 1) / 3.0 + + steps = np.linspace(eta1, eta2, n + 1, True) + cos_eta = np.cos(steps) + sin_eta = np.sin(steps) + + xA = cos_eta[:-1] + yA = sin_eta[:-1] + xA_dot = -yA + yA_dot = xA + + xB = cos_eta[1:] + yB = sin_eta[1:] + xB_dot = -yB + yB_dot = xB + + if is_wedge: + length = n * 3 + 4 + vertices = np.zeros((length, 2), float) + codes = np.full(length, cls.CURVE4, dtype=cls.code_type) + vertices[1] = [xA[0], yA[0]] + codes[0:2] = [cls.MOVETO, cls.LINETO] + codes[-2:] = [cls.LINETO, cls.CLOSEPOLY] + vertex_offset = 2 + end = length - 2 + else: + length = n * 3 + 1 + vertices = np.empty((length, 2), float) + codes = np.full(length, cls.CURVE4, dtype=cls.code_type) + vertices[0] = [xA[0], yA[0]] + codes[0] = cls.MOVETO + vertex_offset = 1 + end = length + + vertices[vertex_offset:end:3, 0] = xA + alpha * xA_dot + vertices[vertex_offset:end:3, 1] = yA + alpha * yA_dot + vertices[vertex_offset+1:end:3, 0] = xB - alpha * xB_dot + vertices[vertex_offset+1:end:3, 1] = yB - alpha * yB_dot + vertices[vertex_offset+2:end:3, 0] = xB + vertices[vertex_offset+2:end:3, 1] = yB + + return cls(vertices, codes, readonly=True) + + @classmethod + def wedge(cls, theta1, theta2, n=None): + """ + Return a `Path` for the unit circle wedge from angles *theta1* to + *theta2* (in degrees). + + *theta2* is unwrapped to produce the shortest wedge within 360 degrees. + That is, if *theta2* > *theta1* + 360, the wedge will be from *theta1* + to *theta2* - 360 and not a full circle plus some extra overlap. + + If *n* is provided, it is the number of spline segments to make. + If *n* is not provided, the number of spline segments is + determined based on the delta between *theta1* and *theta2*. + + See `Path.arc` for the reference on the approximation used. + """ + return cls.arc(theta1, theta2, n, True) + + @staticmethod + @lru_cache(8) + def hatch(hatchpattern, density=6): + """ + Given a hatch specifier, *hatchpattern*, generates a `Path` that + can be used in a repeated hatching pattern. *density* is the + number of lines per unit square. + """ + from matplotlib.hatch import get_path + return (get_path(hatchpattern, density) + if hatchpattern is not None else None) + + def clip_to_bbox(self, bbox, inside=True): + """ + Clip the path to the given bounding box. + + The path must be made up of one or more closed polygons. This + algorithm will not behave correctly for unclosed paths. + + If *inside* is `True`, clip to the inside of the box, otherwise + to the outside of the box. + """ + verts = _path.clip_path_to_rect(self, bbox, inside) + paths = [Path(poly) for poly in verts] + return self.make_compound_path(*paths) + + +def get_path_collection_extents( + master_transform, paths, transforms, offsets, offset_transform): + r""" + Get bounding box of a `.PathCollection`\s internal objects. + + That is, given a sequence of `Path`\s, `.Transform`\s objects, and offsets, as found + in a `.PathCollection`, return the bounding box that encapsulates all of them. + + Parameters + ---------- + master_transform : `~matplotlib.transforms.Transform` + Global transformation applied to all paths. + paths : list of `Path` + transforms : list of `~matplotlib.transforms.Affine2DBase` + If non-empty, this overrides *master_transform*. + offsets : (N, 2) array-like + offset_transform : `~matplotlib.transforms.Affine2DBase` + Transform applied to the offsets before offsetting the path. + + Notes + ----- + The way that *paths*, *transforms* and *offsets* are combined follows the same + method as for collections: each is iterated over independently, so if you have 3 + paths (A, B, C), 2 transforms (α, β) and 1 offset (O), their combinations are as + follows: + + - (A, α, O) + - (B, β, O) + - (C, α, O) + """ + from .transforms import Bbox + if len(paths) == 0: + raise ValueError("No paths provided") + if len(offsets) == 0: + raise ValueError("No offsets provided") + extents, minpos = _path.get_path_collection_extents( + master_transform, paths, np.atleast_3d(transforms), + offsets, offset_transform) + return Bbox.from_extents(*extents, minpos=minpos) diff --git a/shared/package-files/42/4224c872a950c066953ed1ec124fafb66264d70c70652be28e1a817bf6fd5422/blob b/shared/package-files/42/4224c872a950c066953ed1ec124fafb66264d70c70652be28e1a817bf6fd5422/blob new file mode 100644 index 0000000000000000000000000000000000000000..95d1b61203bfad44c8b31fb7bf215c4107d8a830 --- /dev/null +++ b/shared/package-files/42/4224c872a950c066953ed1ec124fafb66264d70c70652be28e1a817bf6fd5422/blob @@ -0,0 +1,3171 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/shared/package-files/42/4225d26bbba1be65014cbc94c01407ad891694e71e2a1e69e24543f7456708a3/blob b/shared/package-files/42/4225d26bbba1be65014cbc94c01407ad891694e71e2a1e69e24543f7456708a3/blob new file mode 100644 index 0000000000000000000000000000000000000000..2dabaef69b60d994799f71414699223f84e1809b --- /dev/null +++ b/shared/package-files/42/4225d26bbba1be65014cbc94c01407ad891694e71e2a1e69e24543f7456708a3/blob @@ -0,0 +1,116 @@ +""" Generic SymPy-Independent Strategies """ + + +def identity(x): + yield x + + +def exhaust(brule): + """ Apply a branching rule repeatedly until it has no effect """ + def exhaust_brl(expr): + seen = {expr} + for nexpr in brule(expr): + if nexpr not in seen: + seen.add(nexpr) + yield from exhaust_brl(nexpr) + if seen == {expr}: + yield expr + return exhaust_brl + + +def onaction(brule, fn): + def onaction_brl(expr): + for result in brule(expr): + if result != expr: + fn(brule, expr, result) + yield result + return onaction_brl + + +def debug(brule, file=None): + """ Print the input and output expressions at each rule application """ + if not file: + from sys import stdout + file = stdout + + def write(brl, expr, result): + file.write("Rule: %s\n" % brl.__name__) + file.write("In: %s\nOut: %s\n\n" % (expr, result)) + + return onaction(brule, write) + + +def multiplex(*brules): + """ Multiplex many branching rules into one """ + def multiplex_brl(expr): + seen = set() + for brl in brules: + for nexpr in brl(expr): + if nexpr not in seen: + seen.add(nexpr) + yield nexpr + return multiplex_brl + + +def condition(cond, brule): + """ Only apply branching rule if condition is true """ + def conditioned_brl(expr): + if cond(expr): + yield from brule(expr) + else: + pass + return conditioned_brl + + +def sfilter(pred, brule): + """ Yield only those results which satisfy the predicate """ + def filtered_brl(expr): + yield from filter(pred, brule(expr)) + return filtered_brl + + +def notempty(brule): + def notempty_brl(expr): + yielded = False + for nexpr in brule(expr): + yielded = True + yield nexpr + if not yielded: + yield expr + return notempty_brl + + +def do_one(*brules): + """ Execute one of the branching rules """ + def do_one_brl(expr): + yielded = False + for brl in brules: + for nexpr in brl(expr): + yielded = True + yield nexpr + if yielded: + return + return do_one_brl + + +def chain(*brules): + """ + Compose a sequence of brules so that they apply to the expr sequentially + """ + def chain_brl(expr): + if not brules: + yield expr + return + + head, tail = brules[0], brules[1:] + for nexpr in head(expr): + yield from chain(*tail)(nexpr) + + return chain_brl + + +def yieldify(rl): + """ Turn a rule into a branching rule """ + def brl(expr): + yield rl(expr) + return brl diff --git a/shared/package-files/42/422620e138cc7bb92d67e1870308093b13521d706dc599c6d4eeaaf307bf7c05/blob b/shared/package-files/42/422620e138cc7bb92d67e1870308093b13521d706dc599c6d4eeaaf307bf7c05/blob new file mode 100644 index 0000000000000000000000000000000000000000..2fe87d080232741a72696bfa2eb5432be4309826 --- /dev/null +++ b/shared/package-files/42/422620e138cc7bb92d67e1870308093b13521d706dc599c6d4eeaaf307bf7c05/blob @@ -0,0 +1,30 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_weight_norm(Tensor v, Tensor g, int dim=0) -> Tensor +inline at::Tensor _weight_norm(const at::Tensor & v, const at::Tensor & g, int64_t dim=0) { + return at::_ops::_weight_norm::call(v, g, dim); +} + +} diff --git a/shared/package-files/42/4226ea608db718f8ec6f2c5ac62368a806ca6b0cc799f60e971796d873c56d31/blob b/shared/package-files/42/4226ea608db718f8ec6f2c5ac62368a806ca6b0cc799f60e971796d873c56d31/blob new file mode 100644 index 0000000000000000000000000000000000000000..c3d525669d2c415ce0754a9c6ff1936061b4a3ce --- /dev/null +++ b/shared/package-files/42/4226ea608db718f8ec6f2c5ac62368a806ca6b0cc799f60e971796d873c56d31/blob @@ -0,0 +1,45 @@ +from __future__ import annotations + +from typing import Iterable + +from prompt_toolkit.document import Document + +from .base import CompleteEvent, Completer, Completion + +__all__ = ["DeduplicateCompleter"] + + +class DeduplicateCompleter(Completer): + """ + Wrapper around a completer that removes duplicates. Only the first unique + completions are kept. + + Completions are considered to be a duplicate if they result in the same + document text when they would be applied. + """ + + def __init__(self, completer: Completer) -> None: + self.completer = completer + + def get_completions( + self, document: Document, complete_event: CompleteEvent + ) -> Iterable[Completion]: + # Keep track of the document strings we'd get after applying any completion. + found_so_far: set[str] = set() + + for completion in self.completer.get_completions(document, complete_event): + text_if_applied = ( + document.text[: document.cursor_position + completion.start_position] + + completion.text + + document.text[document.cursor_position :] + ) + + if text_if_applied == document.text: + # Don't include completions that don't have any effect at all. + continue + + if text_if_applied in found_so_far: + continue + + found_so_far.add(text_if_applied) + yield completion diff --git a/shared/package-files/42/422809d13ba54e06bc80f8a76f0bf0b59814c22f71426394030bab790cec41e2/blob b/shared/package-files/42/422809d13ba54e06bc80f8a76f0bf0b59814c22f71426394030bab790cec41e2/blob new file mode 100644 index 0000000000000000000000000000000000000000..59bf0bdd2b650dfebc51c873f0e60cd56d654e93 --- /dev/null +++ b/shared/package-files/42/422809d13ba54e06bc80f8a76f0bf0b59814c22f71426394030bab790cec41e2/blob @@ -0,0 +1,132 @@ +#pragma once + +#include +#include +#include + +// NOTE [Tracing Mode Switches] +// +// Historically, tracing function was controlled by two switches: +// +// - `AutoDispatchBelowADInplaceOrView` guard +// +// Tracing function used to be script-generated inside `VariableType_*.cpp` +// kernels, sharing the same `Autograd` dispatch key with autograd function. +// Therefore, before tracing function was moved out of VariableType, +// `AutoDispatchBelowADInplaceOrView` guard can also disable tracing as a +// side effect of disabling `Autograd` dispatching. +// +// - `setTracingState()` API in `torch/csrc/jit/frontend/tracer.h` +// +// It stores tracing data in a `TracingState` object in TLS. If the +// `TracingState` object in TLS is `null`, then tracing is paused. +// +// The `TracingState` object is created in `tracer::trace()` - the main +// entrance of tracing function. It's temporarily set to `null` inside +// generated VariableType (now TraceType) to bypass tracing for intermediate +// ops (ops being called by other ops). After the intermediate op call +// finishes it's set back to the original `TracingState` object. +// +// The `TracingState` obect in TLS can also be read/written via its Python +// binding in `python_tracer.cpp`, and `get/setTracingState()` C++ APIs, +// which are also exposed as `TORCH_API`. +// +// Two new switches were introduced since tracing function was moved out of +// VariableType: +// +// - `tracer::impl::set_dispatch_enabled()` API +// +// Unlike the special `Autograd` dispatch key which is included in dispatch +// key set by default, `Tracer` dispatch key is off by default. The +// dispatching switch can be toggled via this new API. +// +// - `tracer::impl::NoTracerDispatchMode` guard +// +// It's used to cover the old semantics of `AutoDispatchBelowADInplaceOrView` +// after tracing was moved out of VariableType. +// +// Before tracing function was moved out of VariableType, tracing was enabled +// when the following conditions are satisfied: +// +// 1) `TracingState` object in TLS != null; +// - Either inside the execution scope of `tracer::trace()`, or +// - Eagerly called `setTracingState()` with non-null object. +// 2) Not inside `AutoDispatchBelowADInplaceOrView` scope; +// +// After: +// +// 1) `TracingState` object in TLS != null; +// 2) Has called `tracer::impl::set_dispatch_enabled(true)`; +// 3) Not inside `tracer::impl::NonDispatchGuard` scope; +// +// [TODOs] +// +// - `setTracingState()` v.s. `tracer::impl::set_dispatch_enabled()` +// +// Currently `set_dispatch_enabled()` is set/unset inside `setTracingState()` +// to keep the semantics exactly the same as before - it's confusing to keep +// both switches, though. We should consider simplifying/limiting the exposed +// `setTracingState()` Python/C++ APIs (and other APIs calling it) so that +// these two can be unified. +// +// - `AutoDispatchBelowADInplaceOrView` v.s. +// `tracer::impl::NoTracerDispatchMode` +// +// We don't need to always set both guards together to keep semantics +// unchanged. For the follow use cases of `AutoDispatchBelowADInplaceOrView` +// we don't need set the new tracer guard: +// +// * Script-generated VariableType kernels. The guard is not necessary as +// tracing is already disabled explicitly by `setTracingState(null)` in +// generated TraceType kernels - we could keep it as is or use the new guard +// instead. +// +// * Custom ops. Will be handled by fallback kernel for `Tracer`. +// +// * Functions that are not likely to be called in tracing context (no python +// binding / not an operator), e.g.: all mobile forward() wrappers, test +// binaries, and etc. +// +// * Where new threads are spawned, e.g.: ATen/native/ConvolutionMM2d.cpp. +// It's not necessary as tracing is off by default. +// +// For the rest of cases we might need have both: +// +// * Functions that might be reachable from eager mode python (especially +// factory methods), e.g.: +// `internal_new_from_data()` in `torch/csrc/utils/tensor_new.cpp`. +// Without the new guard it will add `aten::empty` to the traced graph. +// +// * Some manually maintained functions, e.g.: +// `torch/csrc/autograd/VariableTypeManual.cpp`. +// Set the new guard if it's not obvious whether `setTracingState(null)` +// has been called before it reaches the `AutoDispatchBelowADInplaceOrView` +// guard. +// +// We might need tweak the usage of the new guard to optimize/fix things. +// It should only affect the correctness of tracing function, because the +// guard is essentially no-op when the master `setTracingState()` switch is +// off. + +// TODO: move this from `at::` to `jit::torch::` after +// `aten/src/ATen/cpp_custom_type_hack.h` is removed. + +namespace at::tracer::impl { + +static inline bool is_dispatch_enabled() { + return c10::impl::tls_is_dispatch_key_included(at::DispatchKey::Tracer) && + !c10::impl::tls_is_dispatch_key_excluded(at::DispatchKey::Tracer); +} + +static inline void set_dispatch_enabled(bool enabled) { + TORCH_INTERNAL_ASSERT( + !c10::impl::tls_is_dispatch_key_excluded(at::DispatchKey::Tracer), + "Cannot enable tracing within the scope of NoTracerDispatchMode!"); + c10::impl::tls_set_dispatch_key_included(at::DispatchKey::Tracer, enabled); +} + +struct NoTracerDispatchMode { + c10::impl::ExcludeDispatchKeyGuard guard_{at::DispatchKey::Tracer}; +}; + +} // namespace at::tracer::impl diff --git a/shared/package-files/42/422886d00ac1185ec4358aef7203c6c2362051d9f75ba0a1fc613d5441760d62/blob b/shared/package-files/42/422886d00ac1185ec4358aef7203c6c2362051d9f75ba0a1fc613d5441760d62/blob new file mode 100644 index 0000000000000000000000000000000000000000..9118eb56f0ba4bbc5227b6c57450af891876acfa --- /dev/null +++ b/shared/package-files/42/422886d00ac1185ec4358aef7203c6c2362051d9f75ba0a1fc613d5441760d62/blob @@ -0,0 +1,274 @@ +import pickle + +import numpy as np +import pytest +from numpy.testing import assert_array_equal + +from sklearn.utils._encode import _check_unknown, _encode, _get_counts, _unique + + +@pytest.mark.parametrize( + "values, expected", + [ + (np.array([2, 1, 3, 1, 3], dtype="int64"), np.array([1, 2, 3], dtype="int64")), + ( + np.array([2, 1, np.nan, 1, np.nan], dtype="float32"), + np.array([1, 2, np.nan], dtype="float32"), + ), + ( + np.array(["b", "a", "c", "a", "c"], dtype=object), + np.array(["a", "b", "c"], dtype=object), + ), + ( + np.array(["b", "a", None, "a", None], dtype=object), + np.array(["a", "b", None], dtype=object), + ), + (np.array(["b", "a", "c", "a", "c"]), np.array(["a", "b", "c"])), + ], + ids=["int64", "float32-nan", "object", "object-None", "str"], +) +def test_encode_util(values, expected): + uniques = _unique(values) + assert_array_equal(uniques, expected) + + result, encoded = _unique(values, return_inverse=True) + assert_array_equal(result, expected) + assert_array_equal(encoded, np.array([1, 0, 2, 0, 2])) + + encoded = _encode(values, uniques=uniques) + assert_array_equal(encoded, np.array([1, 0, 2, 0, 2])) + + result, counts = _unique(values, return_counts=True) + assert_array_equal(result, expected) + assert_array_equal(counts, np.array([2, 1, 2])) + + result, encoded, counts = _unique(values, return_inverse=True, return_counts=True) + assert_array_equal(result, expected) + assert_array_equal(encoded, np.array([1, 0, 2, 0, 2])) + assert_array_equal(counts, np.array([2, 1, 2])) + + +def test_encode_with_check_unknown(): + # test for the check_unknown parameter of _encode() + uniques = np.array([1, 2, 3]) + values = np.array([1, 2, 3, 4]) + + # Default is True, raise error + with pytest.raises(ValueError, match="y contains previously unseen labels"): + _encode(values, uniques=uniques, check_unknown=True) + + # dont raise error if False + _encode(values, uniques=uniques, check_unknown=False) + + # parameter is ignored for object dtype + uniques = np.array(["a", "b", "c"], dtype=object) + values = np.array(["a", "b", "c", "d"], dtype=object) + with pytest.raises(ValueError, match="y contains previously unseen labels"): + _encode(values, uniques=uniques, check_unknown=False) + + +def _assert_check_unknown(values, uniques, expected_diff, expected_mask): + diff = _check_unknown(values, uniques) + assert_array_equal(diff, expected_diff) + + diff, valid_mask = _check_unknown(values, uniques, return_mask=True) + assert_array_equal(diff, expected_diff) + assert_array_equal(valid_mask, expected_mask) + + +@pytest.mark.parametrize( + "values, uniques, expected_diff, expected_mask", + [ + (np.array([1, 2, 3, 4]), np.array([1, 2, 3]), [4], [True, True, True, False]), + (np.array([2, 1, 4, 5]), np.array([2, 5, 1]), [4], [True, True, False, True]), + (np.array([2, 1, np.nan]), np.array([2, 5, 1]), [np.nan], [True, True, False]), + ( + np.array([2, 1, 4, np.nan]), + np.array([2, 5, 1, np.nan]), + [4], + [True, True, False, True], + ), + ( + np.array([2, 1, 4, np.nan]), + np.array([2, 5, 1]), + [4, np.nan], + [True, True, False, False], + ), + ( + np.array([2, 1, 4, 5]), + np.array([2, 5, 1, np.nan]), + [4], + [True, True, False, True], + ), + ( + np.array(["a", "b", "c", "d"], dtype=object), + np.array(["a", "b", "c"], dtype=object), + np.array(["d"], dtype=object), + [True, True, True, False], + ), + ( + np.array(["d", "c", "a", "b"], dtype=object), + np.array(["a", "c", "b"], dtype=object), + np.array(["d"], dtype=object), + [False, True, True, True], + ), + ( + np.array(["a", "b", "c", "d"]), + np.array(["a", "b", "c"]), + np.array(["d"]), + [True, True, True, False], + ), + ( + np.array(["d", "c", "a", "b"]), + np.array(["a", "c", "b"]), + np.array(["d"]), + [False, True, True, True], + ), + ], +) +def test_check_unknown(values, uniques, expected_diff, expected_mask): + _assert_check_unknown(values, uniques, expected_diff, expected_mask) + + +@pytest.mark.parametrize("missing_value", [None, np.nan, float("nan")]) +@pytest.mark.parametrize("pickle_uniques", [True, False]) +def test_check_unknown_missing_values(missing_value, pickle_uniques): + # check for check_unknown with missing values with object dtypes + values = np.array(["d", "c", "a", "b", missing_value], dtype=object) + uniques = np.array(["c", "a", "b", missing_value], dtype=object) + if pickle_uniques: + uniques = pickle.loads(pickle.dumps(uniques)) + + expected_diff = ["d"] + expected_mask = [False, True, True, True, True] + _assert_check_unknown(values, uniques, expected_diff, expected_mask) + + values = np.array(["d", "c", "a", "b", missing_value], dtype=object) + uniques = np.array(["c", "a", "b"], dtype=object) + if pickle_uniques: + uniques = pickle.loads(pickle.dumps(uniques)) + + expected_diff = ["d", missing_value] + + expected_mask = [False, True, True, True, False] + _assert_check_unknown(values, uniques, expected_diff, expected_mask) + + values = np.array(["a", missing_value], dtype=object) + uniques = np.array(["a", "b", "z"], dtype=object) + if pickle_uniques: + uniques = pickle.loads(pickle.dumps(uniques)) + + expected_diff = [missing_value] + expected_mask = [True, False] + _assert_check_unknown(values, uniques, expected_diff, expected_mask) + + +@pytest.mark.parametrize("missing_value", [np.nan, None, float("nan")]) +@pytest.mark.parametrize("pickle_uniques", [True, False]) +def test_unique_util_missing_values_objects(missing_value, pickle_uniques): + # check for _unique and _encode with missing values with object dtypes + values = np.array(["a", "c", "c", missing_value, "b"], dtype=object) + expected_uniques = np.array(["a", "b", "c", missing_value], dtype=object) + + uniques = _unique(values) + + if missing_value is None: + assert_array_equal(uniques, expected_uniques) + else: # missing_value == np.nan + assert_array_equal(uniques[:-1], expected_uniques[:-1]) + assert np.isnan(uniques[-1]) + + if pickle_uniques: + uniques = pickle.loads(pickle.dumps(uniques)) + + encoded = _encode(values, uniques=uniques) + assert_array_equal(encoded, np.array([0, 2, 2, 3, 1])) + + +def test_unique_util_missing_values_numeric(): + # Check missing values in numerical values + values = np.array([3, 1, np.nan, 5, 3, np.nan], dtype=float) + expected_uniques = np.array([1, 3, 5, np.nan], dtype=float) + expected_inverse = np.array([1, 0, 3, 2, 1, 3]) + + uniques = _unique(values) + assert_array_equal(uniques, expected_uniques) + + uniques, inverse = _unique(values, return_inverse=True) + assert_array_equal(uniques, expected_uniques) + assert_array_equal(inverse, expected_inverse) + + encoded = _encode(values, uniques=uniques) + assert_array_equal(encoded, expected_inverse) + + +def test_unique_util_with_all_missing_values(): + # test for all types of missing values for object dtype + values = np.array([np.nan, "a", "c", "c", None, float("nan"), None], dtype=object) + + uniques = _unique(values) + assert_array_equal(uniques[:-1], ["a", "c", None]) + # last value is nan + assert np.isnan(uniques[-1]) + + expected_inverse = [3, 0, 1, 1, 2, 3, 2] + _, inverse = _unique(values, return_inverse=True) + assert_array_equal(inverse, expected_inverse) + + +def test_check_unknown_with_both_missing_values(): + # test for both types of missing values for object dtype + values = np.array([np.nan, "a", "c", "c", None, np.nan, None], dtype=object) + + diff = _check_unknown(values, known_values=np.array(["a", "c"], dtype=object)) + assert diff[0] is None + assert np.isnan(diff[1]) + + diff, valid_mask = _check_unknown( + values, known_values=np.array(["a", "c"], dtype=object), return_mask=True + ) + + assert diff[0] is None + assert np.isnan(diff[1]) + assert_array_equal(valid_mask, [False, True, True, True, False, False, False]) + + +@pytest.mark.parametrize( + "values, uniques, expected_counts", + [ + (np.array([1] * 10 + [2] * 4 + [3] * 15), np.array([1, 2, 3]), [10, 4, 15]), + ( + np.array([1] * 10 + [2] * 4 + [3] * 15), + np.array([1, 2, 3, 5]), + [10, 4, 15, 0], + ), + ( + np.array([np.nan] * 10 + [2] * 4 + [3] * 15), + np.array([2, 3, np.nan]), + [4, 15, 10], + ), + ( + np.array(["b"] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object), + ["a", "b", "c"], + [16, 4, 20], + ), + ( + np.array(["b"] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object), + ["c", "b", "a"], + [20, 4, 16], + ), + ( + np.array([np.nan] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object), + ["c", np.nan, "a"], + [20, 4, 16], + ), + ( + np.array(["b"] * 4 + ["a"] * 16 + ["c"] * 20, dtype=object), + ["a", "b", "c", "e"], + [16, 4, 20, 0], + ), + ], +) +def test_get_counts(values, uniques, expected_counts): + counts = _get_counts(values, uniques) + assert_array_equal(counts, expected_counts) diff --git a/shared/package-files/42/42296b27cc13e2f2c62eb691c5aeed53f8fc7c7a856649485b6ff75696bdbbdf/blob b/shared/package-files/42/42296b27cc13e2f2c62eb691c5aeed53f8fc7c7a856649485b6ff75696bdbbdf/blob new file mode 100644 index 0000000000000000000000000000000000000000..73aa1ed5a954297106af6832677d047638b5b990 --- /dev/null +++ b/shared/package-files/42/42296b27cc13e2f2c62eb691c5aeed53f8fc7c7a856649485b6ff75696bdbbdf/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor & floor_divide_(at::Tensor & self, const at::Tensor & other); + +} // namespace meta +} // namespace at diff --git a/shared/package-files/42/4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5/blob b/shared/package-files/42/4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5/blob new file mode 100644 index 0000000000000000000000000000000000000000..ab8d53be7408626719c27aa29fdc2e143b7c380a --- /dev/null +++ b/shared/package-files/42/4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5/blob @@ -0,0 +1,29 @@ +from typing import Optional + +from pip._internal.distributions.base import AbstractDistribution +from pip._internal.index.package_finder import PackageFinder +from pip._internal.metadata import BaseDistribution + + +class InstalledDistribution(AbstractDistribution): + """Represents an installed package. + + This does not need any preparation as the required information has already + been computed. + """ + + @property + def build_tracker_id(self) -> Optional[str]: + return None + + def get_metadata_distribution(self) -> BaseDistribution: + assert self.req.satisfied_by is not None, "not actually installed" + return self.req.satisfied_by + + def prepare_distribution_metadata( + self, + finder: PackageFinder, + build_isolation: bool, + check_build_deps: bool, + ) -> None: + pass diff --git a/shared/package-files/42/4229f9c18e8e5336bd794ffb010538b3d56e2f422cb0f9ff058f756a5c2576af/blob b/shared/package-files/42/4229f9c18e8e5336bd794ffb010538b3d56e2f422cb0f9ff058f756a5c2576af/blob new file mode 100644 index 0000000000000000000000000000000000000000..97a02ee0b41b3058d27fefafe0d2365cd09e9228 --- /dev/null +++ b/shared/package-files/42/4229f9c18e8e5336bd794ffb010538b3d56e2f422cb0f9ff058f756a5c2576af/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor select(const at::Tensor & self, at::Dimname dim, int64_t index); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/42/422a781a47854e71baf61df028bc2d78a8a2fa8864f8357e84b61b96e5ccdb90/blob b/shared/package-files/42/422a781a47854e71baf61df028bc2d78a8a2fa8864f8357e84b61b96e5ccdb90/blob new file mode 100644 index 0000000000000000000000000000000000000000..5dd8422289e8197308409de4d24ec92918be38cb --- /dev/null +++ b/shared/package-files/42/422a781a47854e71baf61df028bc2d78a8a2fa8864f8357e84b61b96e5ccdb90/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams(Tensor self, Tensor scale, Tensor zero_point, Tensor fake_quant_enabled, int quant_min, int quant_max) -> (Tensor output, Tensor mask) +inline ::std::tuple _fake_quantize_per_tensor_affine_cachemask_tensor_qparams(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, const at::Tensor & fake_quant_enabled, int64_t quant_min, int64_t quant_max) { + return at::_ops::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams::call(self, scale, zero_point, fake_quant_enabled, quant_min, quant_max); +} + +// aten::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams.out(Tensor self, Tensor scale, Tensor zero_point, Tensor fake_quant_enabled, int quant_min, int quant_max, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) +inline ::std::tuple _fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, const at::Tensor & fake_quant_enabled, int64_t quant_min, int64_t quant_max) { + return at::_ops::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out::call(self, scale, zero_point, fake_quant_enabled, quant_min, quant_max, out0, out1); +} +// aten::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams.out(Tensor self, Tensor scale, Tensor zero_point, Tensor fake_quant_enabled, int quant_min, int quant_max, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) +inline ::std::tuple _fake_quantize_per_tensor_affine_cachemask_tensor_qparams_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, const at::Tensor & fake_quant_enabled, int64_t quant_min, int64_t quant_max, at::Tensor & out0, at::Tensor & out1) { + return at::_ops::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out::call(self, scale, zero_point, fake_quant_enabled, quant_min, quant_max, out0, out1); +} + +} diff --git a/shared/package-files/42/422b3ecb8ece9addfb1f06c0e918845271ccf0d6187b808db1973fc58b5fcf6d/blob b/shared/package-files/42/422b3ecb8ece9addfb1f06c0e918845271ccf0d6187b808db1973fc58b5fcf6d/blob new file mode 100644 index 0000000000000000000000000000000000000000..bb10fe4c4965c0355662e9177ea1a17b9e9ce3f2 --- /dev/null +++ b/shared/package-files/42/422b3ecb8ece9addfb1f06c0e918845271ccf0d6187b808db1973fc58b5fcf6d/blob @@ -0,0 +1,66 @@ +from typing import Iterator, List, Sequence, Union + + +from torch.utils.data.datapipes._decorator import functional_datapipe + +from torch.utils.data.datapipes.datapipe import IterDataPipe +from torch.utils.data.datapipes.iter import IterableWrapper +from torch.utils.data.datapipes.utils.common import get_file_pathnames_from_root + +__all__ = ["FileListerIterDataPipe", ] + + +@functional_datapipe("list_files") +class FileListerIterDataPipe(IterDataPipe[str]): + r""" + Given path(s) to the root directory, yields file pathname(s) (path + filename) of files within the root directory. + + Multiple root directories can be provided (functional name: ``list_files``). + + Args: + root: Root directory or a sequence of root directories + masks: Unix style filter string or string list for filtering file name(s) + recursive: Whether to return pathname from nested directories or not + abspath: Whether to return relative pathname or absolute pathname + non_deterministic: Whether to return pathname in sorted order or not. + If ``False``, the results yielded from each root directory will be sorted + length: Nominal length of the datapipe + + Example: + >>> # xdoctest: +SKIP + >>> from torchdata.datapipes.iter import FileLister + >>> dp = FileLister(root=".", recursive=True) + >>> list(dp) + ['example.py', './data/data.tar'] + """ + + def __init__( + self, + root: Union[str, Sequence[str], IterDataPipe] = '.', + masks: Union[str, List[str]] = '', + *, + recursive: bool = False, + abspath: bool = False, + non_deterministic: bool = False, + length: int = -1 + ) -> None: + super().__init__() + if isinstance(root, str): + root = [root, ] + if not isinstance(root, IterDataPipe): + root = IterableWrapper(root) + self.datapipe: IterDataPipe = root + self.masks: Union[str, List[str]] = masks + self.recursive: bool = recursive + self.abspath: bool = abspath + self.non_deterministic: bool = non_deterministic + self.length: int = length + + def __iter__(self) -> Iterator[str] : + for path in self.datapipe: + yield from get_file_pathnames_from_root(path, self.masks, self.recursive, self.abspath, self.non_deterministic) + + def __len__(self): + if self.length == -1: + raise TypeError(f"{type(self).__name__} instance doesn't have valid length") + return self.length diff --git a/shared/package-files/42/422c7cc77b3e9bc5137a2c3334f072fd942f0335ff69a8a1cff3f32df4e251a7/blob b/shared/package-files/42/422c7cc77b3e9bc5137a2c3334f072fd942f0335ff69a8a1cff3f32df4e251a7/blob new file mode 100644 index 0000000000000000000000000000000000000000..c65155402db6a465c05a8cd71ec7a0fc0f792762 Binary files /dev/null and b/shared/package-files/42/422c7cc77b3e9bc5137a2c3334f072fd942f0335ff69a8a1cff3f32df4e251a7/blob differ diff --git a/shared/package-files/42/422eb0810b066bd31089b611cb7397a9c0d0b30219674d1d2cea1250637eea8f/blob b/shared/package-files/42/422eb0810b066bd31089b611cb7397a9c0d0b30219674d1d2cea1250637eea8f/blob new file mode 100644 index 0000000000000000000000000000000000000000..2e50cd7b40ef18e7f7ee56c0f528bf0ef88b167a --- /dev/null +++ b/shared/package-files/42/422eb0810b066bd31089b611cb7397a9c0d0b30219674d1d2cea1250637eea8f/blob @@ -0,0 +1,94 @@ +# Copyright 2016 Étienne Bersac +# Copyright 2016 Julien Danjou +# Copyright 2016 Joshua Harlow +# Copyright 2013-2014 Ray Holder +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import functools +import sys +import typing as t +from asyncio import sleep + +from pip._vendor.tenacity import AttemptManager +from pip._vendor.tenacity import BaseRetrying +from pip._vendor.tenacity import DoAttempt +from pip._vendor.tenacity import DoSleep +from pip._vendor.tenacity import RetryCallState + +WrappedFnReturnT = t.TypeVar("WrappedFnReturnT") +WrappedFn = t.TypeVar("WrappedFn", bound=t.Callable[..., t.Awaitable[t.Any]]) + + +class AsyncRetrying(BaseRetrying): + sleep: t.Callable[[float], t.Awaitable[t.Any]] + + def __init__(self, sleep: t.Callable[[float], t.Awaitable[t.Any]] = sleep, **kwargs: t.Any) -> None: + super().__init__(**kwargs) + self.sleep = sleep + + async def __call__( # type: ignore[override] + self, fn: WrappedFn, *args: t.Any, **kwargs: t.Any + ) -> WrappedFnReturnT: + self.begin() + + retry_state = RetryCallState(retry_object=self, fn=fn, args=args, kwargs=kwargs) + while True: + do = self.iter(retry_state=retry_state) + if isinstance(do, DoAttempt): + try: + result = await fn(*args, **kwargs) + except BaseException: # noqa: B902 + retry_state.set_exception(sys.exc_info()) # type: ignore[arg-type] + else: + retry_state.set_result(result) + elif isinstance(do, DoSleep): + retry_state.prepare_for_next_attempt() + await self.sleep(do) + else: + return do # type: ignore[no-any-return] + + def __iter__(self) -> t.Generator[AttemptManager, None, None]: + raise TypeError("AsyncRetrying object is not iterable") + + def __aiter__(self) -> "AsyncRetrying": + self.begin() + self._retry_state = RetryCallState(self, fn=None, args=(), kwargs={}) + return self + + async def __anext__(self) -> AttemptManager: + while True: + do = self.iter(retry_state=self._retry_state) + if do is None: + raise StopAsyncIteration + elif isinstance(do, DoAttempt): + return AttemptManager(retry_state=self._retry_state) + elif isinstance(do, DoSleep): + self._retry_state.prepare_for_next_attempt() + await self.sleep(do) + else: + raise StopAsyncIteration + + def wraps(self, fn: WrappedFn) -> WrappedFn: + fn = super().wraps(fn) + # Ensure wrapper is recognized as a coroutine function. + + @functools.wraps(fn) + async def async_wrapped(*args: t.Any, **kwargs: t.Any) -> t.Any: + return await fn(*args, **kwargs) + + # Preserve attributes + async_wrapped.retry = fn.retry # type: ignore[attr-defined] + async_wrapped.retry_with = fn.retry_with # type: ignore[attr-defined] + + return async_wrapped # type: ignore[return-value] diff --git a/shared/package-files/42/422fbeb5f62848faceff131ba678f1093e2349676788b1555f7ae0352d5a9aef/blob b/shared/package-files/42/422fbeb5f62848faceff131ba678f1093e2349676788b1555f7ae0352d5a9aef/blob new file mode 100644 index 0000000000000000000000000000000000000000..5a6b8fa4624edbc8e6e511a2e0b949623b6b7478 Binary files /dev/null and b/shared/package-files/42/422fbeb5f62848faceff131ba678f1093e2349676788b1555f7ae0352d5a9aef/blob differ diff --git a/shared/package-files/42/423105f7db18103a9f63b50bcf5aa3413a3a7b494845409f9443818220d84550/blob b/shared/package-files/42/423105f7db18103a9f63b50bcf5aa3413a3a7b494845409f9443818220d84550/blob new file mode 100644 index 0000000000000000000000000000000000000000..362bb0397feb0ec63929920855c81279eca0bd6a --- /dev/null +++ b/shared/package-files/42/423105f7db18103a9f63b50bcf5aa3413a3a7b494845409f9443818220d84550/blob @@ -0,0 +1,177 @@ +from sympy.concrete.summations import Sum +from sympy.core.add import Add +from sympy.core.numbers import (I, Rational, oo, pi) +from sympy.core.singleton import S +from sympy.core.symbol import (Symbol, symbols) +from sympy.functions.combinatorial.factorials import (binomial, factorial, subfactorial) +from sympy.functions.combinatorial.numbers import (fibonacci, harmonic) +from sympy.functions.elementary.exponential import (exp, log) +from sympy.functions.elementary.miscellaneous import sqrt +from sympy.functions.elementary.trigonometric import (cos, sin) +from sympy.functions.special.gamma_functions import gamma +from sympy.series.limitseq import limit_seq +from sympy.series.limitseq import difference_delta as dd +from sympy.testing.pytest import raises, XFAIL +from sympy.calculus.accumulationbounds import AccumulationBounds + +n, m, k = symbols('n m k', integer=True) + + +def test_difference_delta(): + e = n*(n + 1) + e2 = e * k + + assert dd(e) == 2*n + 2 + assert dd(e2, n, 2) == k*(4*n + 6) + + raises(ValueError, lambda: dd(e2)) + raises(ValueError, lambda: dd(e2, n, oo)) + + +def test_difference_delta__Sum(): + e = Sum(1/k, (k, 1, n)) + assert dd(e, n) == 1/(n + 1) + assert dd(e, n, 5) == Add(*[1/(i + n + 1) for i in range(5)]) + + e = Sum(1/k, (k, 1, 3*n)) + assert dd(e, n) == Add(*[1/(i + 3*n + 1) for i in range(3)]) + + e = n * Sum(1/k, (k, 1, n)) + assert dd(e, n) == 1 + Sum(1/k, (k, 1, n)) + + e = Sum(1/k, (k, 1, n), (m, 1, n)) + assert dd(e, n) == harmonic(n) + + +def test_difference_delta__Add(): + e = n + n*(n + 1) + assert dd(e, n) == 2*n + 3 + assert dd(e, n, 2) == 4*n + 8 + + e = n + Sum(1/k, (k, 1, n)) + assert dd(e, n) == 1 + 1/(n + 1) + assert dd(e, n, 5) == 5 + Add(*[1/(i + n + 1) for i in range(5)]) + + +def test_difference_delta__Pow(): + e = 4**n + assert dd(e, n) == 3*4**n + assert dd(e, n, 2) == 15*4**n + + e = 4**(2*n) + assert dd(e, n) == 15*4**(2*n) + assert dd(e, n, 2) == 255*4**(2*n) + + e = n**4 + assert dd(e, n) == (n + 1)**4 - n**4 + + e = n**n + assert dd(e, n) == (n + 1)**(n + 1) - n**n + + +def test_limit_seq(): + e = binomial(2*n, n) / Sum(binomial(2*k, k), (k, 1, n)) + assert limit_seq(e) == S(3) / 4 + assert limit_seq(e, m) == e + + e = (5*n**3 + 3*n**2 + 4) / (3*n**3 + 4*n - 5) + assert limit_seq(e, n) == S(5) / 3 + + e = (harmonic(n) * Sum(harmonic(k), (k, 1, n))) / (n * harmonic(2*n)**2) + assert limit_seq(e, n) == 1 + + e = Sum(k**2 * Sum(2**m/m, (m, 1, k)), (k, 1, n)) / (2**n*n) + assert limit_seq(e, n) == 4 + + e = (Sum(binomial(3*k, k) * binomial(5*k, k), (k, 1, n)) / + (binomial(3*n, n) * binomial(5*n, n))) + assert limit_seq(e, n) == S(84375) / 83351 + + e = Sum(harmonic(k)**2/k, (k, 1, 2*n)) / harmonic(n)**3 + assert limit_seq(e, n) == S.One / 3 + + raises(ValueError, lambda: limit_seq(e * m)) + + +def test_alternating_sign(): + assert limit_seq((-1)**n/n**2, n) == 0 + assert limit_seq((-2)**(n+1)/(n + 3**n), n) == 0 + assert limit_seq((2*n + (-1)**n)/(n + 1), n) == 2 + assert limit_seq(sin(pi*n), n) == 0 + assert limit_seq(cos(2*pi*n), n) == 1 + assert limit_seq((S.NegativeOne/5)**n, n) == 0 + assert limit_seq((Rational(-1, 5))**n, n) == 0 + assert limit_seq((I/3)**n, n) == 0 + assert limit_seq(sqrt(n)*(I/2)**n, n) == 0 + assert limit_seq(n**7*(I/3)**n, n) == 0 + assert limit_seq(n/(n + 1) + (I/2)**n, n) == 1 + + +def test_accum_bounds(): + assert limit_seq((-1)**n, n) == AccumulationBounds(-1, 1) + assert limit_seq(cos(pi*n), n) == AccumulationBounds(-1, 1) + assert limit_seq(sin(pi*n/2)**2, n) == AccumulationBounds(0, 1) + assert limit_seq(2*(-3)**n/(n + 3**n), n) == AccumulationBounds(-2, 2) + assert limit_seq(3*n/(n + 1) + 2*(-1)**n, n) == AccumulationBounds(1, 5) + + +def test_limitseq_sum(): + from sympy.abc import x, y, z + assert limit_seq(Sum(1/x, (x, 1, y)) - log(y), y) == S.EulerGamma + assert limit_seq(Sum(1/x, (x, 1, y)) - 1/y, y) is S.Infinity + assert (limit_seq(binomial(2*x, x) / Sum(binomial(2*y, y), (y, 1, x)), x) == + S(3) / 4) + assert (limit_seq(Sum(y**2 * Sum(2**z/z, (z, 1, y)), (y, 1, x)) / + (2**x*x), x) == 4) + + +def test_issue_9308(): + assert limit_seq(subfactorial(n)/factorial(n), n) == exp(-1) + + +def test_issue_10382(): + n = Symbol('n', integer=True) + assert limit_seq(fibonacci(n+1)/fibonacci(n), n).together() == S.GoldenRatio + + +def test_issue_11672(): + assert limit_seq(Rational(-1, 2)**n, n) == 0 + + +def test_issue_14196(): + k, n = symbols('k, n', positive=True) + m = Symbol('m') + assert limit_seq(Sum(m**k, (m, 1, n)).doit()/(n**(k + 1)), n) == 1/(k + 1) + + +def test_issue_16735(): + assert limit_seq(5**n/factorial(n), n) == 0 + + +def test_issue_19868(): + assert limit_seq(1/gamma(n + S.One/2), n) == 0 + + +@XFAIL +def test_limit_seq_fail(): + # improve Summation algorithm or add ad-hoc criteria + e = (harmonic(n)**3 * Sum(1/harmonic(k), (k, 1, n)) / + (n * Sum(harmonic(k)/k, (k, 1, n)))) + assert limit_seq(e, n) == 2 + + # No unique dominant term + e = (Sum(2**k * binomial(2*k, k) / k**2, (k, 1, n)) / + (Sum(2**k/k*2, (k, 1, n)) * Sum(binomial(2*k, k), (k, 1, n)))) + assert limit_seq(e, n) == S(3) / 7 + + # Simplifications of summations needs to be improved. + e = n**3*Sum(2**k/k**2, (k, 1, n))**2 / (2**n * Sum(2**k/k, (k, 1, n))) + assert limit_seq(e, n) == 2 + + e = (harmonic(n) * Sum(2**k/k, (k, 1, n)) / + (n * Sum(2**k*harmonic(k)/k**2, (k, 1, n)))) + assert limit_seq(e, n) == 1 + + e = (Sum(2**k*factorial(k) / k**2, (k, 1, 2*n)) / + (Sum(4**k/k**2, (k, 1, n)) * Sum(factorial(k), (k, 1, 2*n)))) + assert limit_seq(e, n) == S(3) / 16 diff --git a/shared/package-files/42/42327dc30588463f52a72d0470a05c2cd2ce65458217e0800fc2da29b428ab0b/blob b/shared/package-files/42/42327dc30588463f52a72d0470a05c2cd2ce65458217e0800fc2da29b428ab0b/blob new file mode 100644 index 0000000000000000000000000000000000000000..023ec2ab3df69325aed529e87568ed4576a63492 --- /dev/null +++ b/shared/package-files/42/42327dc30588463f52a72d0470a05c2cd2ce65458217e0800fc2da29b428ab0b/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor vander(const at::Tensor & x, c10::optional N=c10::nullopt, bool increasing=false); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/42/423642958283c6051065cd56b933d40680e4f37b55180f8b8dc7e3ceb8dba519/blob b/shared/package-files/42/423642958283c6051065cd56b933d40680e4f37b55180f8b8dc7e3ceb8dba519/blob new file mode 100644 index 0000000000000000000000000000000000000000..a04023cd657db06b9b1d262c23ce6e2b7a2efc4d --- /dev/null +++ b/shared/package-files/42/423642958283c6051065cd56b933d40680e4f37b55180f8b8dc7e3ceb8dba519/blob @@ -0,0 +1,44 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::trunc(Tensor self) -> Tensor +inline at::Tensor trunc(const at::Tensor & self) { + return at::_ops::trunc::call(self); +} + +// aten::trunc_(Tensor(a!) self) -> Tensor(a!) +inline at::Tensor & trunc_(at::Tensor & self) { + return at::_ops::trunc_::call(self); +} + +// aten::trunc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & trunc_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::trunc_out::call(self, out); +} +// aten::trunc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & trunc_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::trunc_out::call(self, out); +} + +} diff --git a/shared/package-files/42/42376080be3ac7f7de39dc54e1a8a81e154cd3ea1ba3ebe2fcdf9206c811f92e/blob b/shared/package-files/42/42376080be3ac7f7de39dc54e1a8a81e154cd3ea1ba3ebe2fcdf9206c811f92e/blob new file mode 100644 index 0000000000000000000000000000000000000000..46cd6b87155505d0f6130b40217b4963cc5593cb --- /dev/null +++ b/shared/package-files/42/42376080be3ac7f7de39dc54e1a8a81e154cd3ea1ba3ebe2fcdf9206c811f92e/blob @@ -0,0 +1,32 @@ +import os +import typing +from datetime import tzinfo +from typing import Any, AnyStr, Iterable, Optional, Protocol, Sequence, Set, Type, Union + +_T = typing.TypeVar("_T", bound="ZoneInfo") + +class _IOBytes(Protocol): + def read(self, __size: int) -> bytes: ... + def seek(self, __size: int, __whence: int = ...) -> Any: ... + +class ZoneInfo(tzinfo): + @property + def key(self) -> str: ... + def __init__(self, key: str) -> None: ... + @classmethod + def no_cache(cls: Type[_T], key: str) -> _T: ... + @classmethod + def from_file(cls: Type[_T], __fobj: _IOBytes, key: Optional[str] = ...) -> _T: ... + @classmethod + def clear_cache(cls, *, only_keys: Iterable[str] = ...) -> None: ... + +# Note: Both here and in clear_cache, the types allow the use of `str` where +# a sequence of strings is required. This should be remedied if a solution +# to this typing bug is found: https://github.com/python/typing/issues/256 +def reset_tzpath(to: Optional[Sequence[Union[os.PathLike[AnyStr], str]]] = ...) -> None: ... +def available_timezones() -> Set[str]: ... + +TZPATH: Sequence[str] + +class ZoneInfoNotFoundError(KeyError): ... +class InvalidTZPathWarning(RuntimeWarning): ... diff --git a/shared/package-files/42/42378210605f4c16cc65df96a42398e62114cadf0eede2576b74432df302ef09/blob b/shared/package-files/42/42378210605f4c16cc65df96a42398e62114cadf0eede2576b74432df302ef09/blob new file mode 100644 index 0000000000000000000000000000000000000000..9ab8c47d4e6fa211522a5b3e85a8b06c0fa402e5 --- /dev/null +++ b/shared/package-files/42/42378210605f4c16cc65df96a42398e62114cadf0eede2576b74432df302ef09/blob @@ -0,0 +1,1348 @@ +"""Finitely Presented Groups and its algorithms. """ + +from sympy.core.singleton import S +from sympy.core.symbol import symbols +from sympy.combinatorics.free_groups import (FreeGroup, FreeGroupElement, + free_group) +from sympy.combinatorics.rewritingsystem import RewritingSystem +from sympy.combinatorics.coset_table import (CosetTable, + coset_enumeration_r, + coset_enumeration_c) +from sympy.combinatorics import PermutationGroup +from sympy.matrices.normalforms import invariant_factors +from sympy.matrices import Matrix +from sympy.polys.polytools import gcd +from sympy.printing.defaults import DefaultPrinting +from sympy.utilities import public +from sympy.utilities.magic import pollute + +from itertools import product + + +@public +def fp_group(fr_grp, relators=()): + _fp_group = FpGroup(fr_grp, relators) + return (_fp_group,) + tuple(_fp_group._generators) + +@public +def xfp_group(fr_grp, relators=()): + _fp_group = FpGroup(fr_grp, relators) + return (_fp_group, _fp_group._generators) + +# Does not work. Both symbols and pollute are undefined. Never tested. +@public +def vfp_group(fr_grpm, relators): + _fp_group = FpGroup(symbols, relators) + pollute([sym.name for sym in _fp_group.symbols], _fp_group.generators) + return _fp_group + + +def _parse_relators(rels): + """Parse the passed relators.""" + return rels + + +############################################################################### +# FINITELY PRESENTED GROUPS # +############################################################################### + + +class FpGroup(DefaultPrinting): + """ + The FpGroup would take a FreeGroup and a list/tuple of relators, the + relators would be specified in such a way that each of them be equal to the + identity of the provided free group. + + """ + is_group = True + is_FpGroup = True + is_PermutationGroup = False + + def __init__(self, fr_grp, relators): + relators = _parse_relators(relators) + self.free_group = fr_grp + self.relators = relators + self.generators = self._generators() + self.dtype = type("FpGroupElement", (FpGroupElement,), {"group": self}) + + # CosetTable instance on identity subgroup + self._coset_table = None + # returns whether coset table on identity subgroup + # has been standardized + self._is_standardized = False + + self._order = None + self._center = None + + self._rewriting_system = RewritingSystem(self) + self._perm_isomorphism = None + return + + def _generators(self): + return self.free_group.generators + + def make_confluent(self): + ''' + Try to make the group's rewriting system confluent + + ''' + self._rewriting_system.make_confluent() + return + + def reduce(self, word): + ''' + Return the reduced form of `word` in `self` according to the group's + rewriting system. If it's confluent, the reduced form is the unique normal + form of the word in the group. + + ''' + return self._rewriting_system.reduce(word) + + def equals(self, word1, word2): + ''' + Compare `word1` and `word2` for equality in the group + using the group's rewriting system. If the system is + confluent, the returned answer is necessarily correct. + (If it is not, `False` could be returned in some cases + where in fact `word1 == word2`) + + ''' + if self.reduce(word1*word2**-1) == self.identity: + return True + elif self._rewriting_system.is_confluent: + return False + return None + + @property + def identity(self): + return self.free_group.identity + + def __contains__(self, g): + return g in self.free_group + + def subgroup(self, gens, C=None, homomorphism=False): + ''' + Return the subgroup generated by `gens` using the + Reidemeister-Schreier algorithm + homomorphism -- When set to True, return a dictionary containing the images + of the presentation generators in the original group. + + Examples + ======== + + >>> from sympy.combinatorics.fp_groups import FpGroup + >>> from sympy.combinatorics import free_group + >>> F, x, y = free_group("x, y") + >>> f = FpGroup(F, [x**3, y**5, (x*y)**2]) + >>> H = [x*y, x**-1*y**-1*x*y*x] + >>> K, T = f.subgroup(H, homomorphism=True) + >>> T(K.generators) + [x*y, x**-1*y**2*x**-1] + + ''' + + if not all(isinstance(g, FreeGroupElement) for g in gens): + raise ValueError("Generators must be `FreeGroupElement`s") + if not all(g.group == self.free_group for g in gens): + raise ValueError("Given generators are not members of the group") + if homomorphism: + g, rels, _gens = reidemeister_presentation(self, gens, C=C, homomorphism=True) + else: + g, rels = reidemeister_presentation(self, gens, C=C) + if g: + g = FpGroup(g[0].group, rels) + else: + g = FpGroup(free_group('')[0], []) + if homomorphism: + from sympy.combinatorics.homomorphisms import homomorphism + return g, homomorphism(g, self, g.generators, _gens, check=False) + return g + + def coset_enumeration(self, H, strategy="relator_based", max_cosets=None, + draft=None, incomplete=False): + """ + Return an instance of ``coset table``, when Todd-Coxeter algorithm is + run over the ``self`` with ``H`` as subgroup, using ``strategy`` + argument as strategy. The returned coset table is compressed but not + standardized. + + An instance of `CosetTable` for `fp_grp` can be passed as the keyword + argument `draft` in which case the coset enumeration will start with + that instance and attempt to complete it. + + When `incomplete` is `True` and the function is unable to complete for + some reason, the partially complete table will be returned. + + """ + if not max_cosets: + max_cosets = CosetTable.coset_table_max_limit + if strategy == 'relator_based': + C = coset_enumeration_r(self, H, max_cosets=max_cosets, + draft=draft, incomplete=incomplete) + else: + C = coset_enumeration_c(self, H, max_cosets=max_cosets, + draft=draft, incomplete=incomplete) + if C.is_complete(): + C.compress() + return C + + def standardize_coset_table(self): + """ + Standardized the coset table ``self`` and makes the internal variable + ``_is_standardized`` equal to ``True``. + + """ + self._coset_table.standardize() + self._is_standardized = True + + def coset_table(self, H, strategy="relator_based", max_cosets=None, + draft=None, incomplete=False): + """ + Return the mathematical coset table of ``self`` in ``H``. + + """ + if not H: + if self._coset_table is not None: + if not self._is_standardized: + self.standardize_coset_table() + else: + C = self.coset_enumeration([], strategy, max_cosets=max_cosets, + draft=draft, incomplete=incomplete) + self._coset_table = C + self.standardize_coset_table() + return self._coset_table.table + else: + C = self.coset_enumeration(H, strategy, max_cosets=max_cosets, + draft=draft, incomplete=incomplete) + C.standardize() + return C.table + + def order(self, strategy="relator_based"): + """ + Returns the order of the finitely presented group ``self``. It uses + the coset enumeration with identity group as subgroup, i.e ``H=[]``. + + Examples + ======== + + >>> from sympy.combinatorics import free_group + >>> from sympy.combinatorics.fp_groups import FpGroup + >>> F, x, y = free_group("x, y") + >>> f = FpGroup(F, [x, y**2]) + >>> f.order(strategy="coset_table_based") + 2 + + """ + if self._order is not None: + return self._order + if self._coset_table is not None: + self._order = len(self._coset_table.table) + elif len(self.relators) == 0: + self._order = self.free_group.order() + elif len(self.generators) == 1: + self._order = abs(gcd([r.array_form[0][1] for r in self.relators])) + elif self._is_infinite(): + self._order = S.Infinity + else: + gens, C = self._finite_index_subgroup() + if C: + ind = len(C.table) + self._order = ind*self.subgroup(gens, C=C).order() + else: + self._order = self.index([]) + return self._order + + def _is_infinite(self): + ''' + Test if the group is infinite. Return `True` if the test succeeds + and `None` otherwise + + ''' + used_gens = set() + for r in self.relators: + used_gens.update(r.contains_generators()) + if not set(self.generators) <= used_gens: + return True + # Abelianisation test: check is the abelianisation is infinite + abelian_rels = [] + for rel in self.relators: + abelian_rels.append([rel.exponent_sum(g) for g in self.generators]) + m = Matrix(Matrix(abelian_rels)) + if 0 in invariant_factors(m): + return True + else: + return None + + + def _finite_index_subgroup(self, s=None): + ''' + Find the elements of `self` that generate a finite index subgroup + and, if found, return the list of elements and the coset table of `self` by + the subgroup, otherwise return `(None, None)` + + ''' + gen = self.most_frequent_generator() + rels = list(self.generators) + rels.extend(self.relators) + if not s: + if len(self.generators) == 2: + s = [gen] + [g for g in self.generators if g != gen] + else: + rand = self.free_group.identity + i = 0 + while ((rand in rels or rand**-1 in rels or rand.is_identity) + and i<10): + rand = self.random() + i += 1 + s = [gen, rand] + [g for g in self.generators if g != gen] + mid = (len(s)+1)//2 + half1 = s[:mid] + half2 = s[mid:] + draft1 = None + draft2 = None + m = 200 + C = None + while not C and (m/2 < CosetTable.coset_table_max_limit): + m = min(m, CosetTable.coset_table_max_limit) + draft1 = self.coset_enumeration(half1, max_cosets=m, + draft=draft1, incomplete=True) + if draft1.is_complete(): + C = draft1 + half = half1 + else: + draft2 = self.coset_enumeration(half2, max_cosets=m, + draft=draft2, incomplete=True) + if draft2.is_complete(): + C = draft2 + half = half2 + if not C: + m *= 2 + if not C: + return None, None + C.compress() + return half, C + + def most_frequent_generator(self): + gens = self.generators + rels = self.relators + freqs = [sum([r.generator_count(g) for r in rels]) for g in gens] + return gens[freqs.index(max(freqs))] + + def random(self): + import random + r = self.free_group.identity + for i in range(random.randint(2,3)): + r = r*random.choice(self.generators)**random.choice([1,-1]) + return r + + def index(self, H, strategy="relator_based"): + """ + Return the index of subgroup ``H`` in group ``self``. + + Examples + ======== + + >>> from sympy.combinatorics import free_group + >>> from sympy.combinatorics.fp_groups import FpGroup + >>> F, x, y = free_group("x, y") + >>> f = FpGroup(F, [x**5, y**4, y*x*y**3*x**3]) + >>> f.index([x]) + 4 + + """ + # TODO: use |G:H| = |G|/|H| (currently H can't be made into a group) + # when we know |G| and |H| + + if H == []: + return self.order() + else: + C = self.coset_enumeration(H, strategy) + return len(C.table) + + def __str__(self): + if self.free_group.rank > 30: + str_form = "" % self.free_group.rank + else: + str_form = "" % str(self.generators) + return str_form + + __repr__ = __str__ + +#============================================================================== +# PERMUTATION GROUP METHODS +#============================================================================== + + def _to_perm_group(self): + ''' + Return an isomorphic permutation group and the isomorphism. + The implementation is dependent on coset enumeration so + will only terminate for finite groups. + + ''' + from sympy.combinatorics import Permutation + from sympy.combinatorics.homomorphisms import homomorphism + if self.order() is S.Infinity: + raise NotImplementedError("Permutation presentation of infinite " + "groups is not implemented") + if self._perm_isomorphism: + T = self._perm_isomorphism + P = T.image() + else: + C = self.coset_table([]) + gens = self.generators + images = [[C[i][2*gens.index(g)] for i in range(len(C))] for g in gens] + images = [Permutation(i) for i in images] + P = PermutationGroup(images) + T = homomorphism(self, P, gens, images, check=False) + self._perm_isomorphism = T + return P, T + + def _perm_group_list(self, method_name, *args): + ''' + Given the name of a `PermutationGroup` method (returning a subgroup + or a list of subgroups) and (optionally) additional arguments it takes, + return a list or a list of lists containing the generators of this (or + these) subgroups in terms of the generators of `self`. + + ''' + P, T = self._to_perm_group() + perm_result = getattr(P, method_name)(*args) + single = False + if isinstance(perm_result, PermutationGroup): + perm_result, single = [perm_result], True + result = [] + for group in perm_result: + gens = group.generators + result.append(T.invert(gens)) + return result[0] if single else result + + def derived_series(self): + ''' + Return the list of lists containing the generators + of the subgroups in the derived series of `self`. + + ''' + return self._perm_group_list('derived_series') + + def lower_central_series(self): + ''' + Return the list of lists containing the generators + of the subgroups in the lower central series of `self`. + + ''' + return self._perm_group_list('lower_central_series') + + def center(self): + ''' + Return the list of generators of the center of `self`. + + ''' + return self._perm_group_list('center') + + + def derived_subgroup(self): + ''' + Return the list of generators of the derived subgroup of `self`. + + ''' + return self._perm_group_list('derived_subgroup') + + + def centralizer(self, other): + ''' + Return the list of generators of the centralizer of `other` + (a list of elements of `self`) in `self`. + + ''' + T = self._to_perm_group()[1] + other = T(other) + return self._perm_group_list('centralizer', other) + + def normal_closure(self, other): + ''' + Return the list of generators of the normal closure of `other` + (a list of elements of `self`) in `self`. + + ''' + T = self._to_perm_group()[1] + other = T(other) + return self._perm_group_list('normal_closure', other) + + def _perm_property(self, attr): + ''' + Given an attribute of a `PermutationGroup`, return + its value for a permutation group isomorphic to `self`. + + ''' + P = self._to_perm_group()[0] + return getattr(P, attr) + + @property + def is_abelian(self): + ''' + Check if `self` is abelian. + + ''' + return self._perm_property("is_abelian") + + @property + def is_nilpotent(self): + ''' + Check if `self` is nilpotent. + + ''' + return self._perm_property("is_nilpotent") + + @property + def is_solvable(self): + ''' + Check if `self` is solvable. + + ''' + return self._perm_property("is_solvable") + + @property + def elements(self): + ''' + List the elements of `self`. + + ''' + P, T = self._to_perm_group() + return T.invert(P._elements) + + @property + def is_cyclic(self): + """ + Return ``True`` if group is Cyclic. + + """ + if len(self.generators) <= 1: + return True + try: + P, T = self._to_perm_group() + except NotImplementedError: + raise NotImplementedError("Check for infinite Cyclic group " + "is not implemented") + return P.is_cyclic + + def abelian_invariants(self): + """ + Return Abelian Invariants of a group. + """ + try: + P, T = self._to_perm_group() + except NotImplementedError: + raise NotImplementedError("abelian invariants is not implemented" + "for infinite group") + return P.abelian_invariants() + + def composition_series(self): + """ + Return subnormal series of maximum length for a group. + """ + try: + P, T = self._to_perm_group() + except NotImplementedError: + raise NotImplementedError("composition series is not implemented" + "for infinite group") + return P.composition_series() + + +class FpSubgroup(DefaultPrinting): + ''' + The class implementing a subgroup of an FpGroup or a FreeGroup + (only finite index subgroups are supported at this point). This + is to be used if one wishes to check if an element of the original + group belongs to the subgroup + + ''' + def __init__(self, G, gens, normal=False): + super().__init__() + self.parent = G + self.generators = list({g for g in gens if g != G.identity}) + self._min_words = None #for use in __contains__ + self.C = None + self.normal = normal + + def __contains__(self, g): + + if isinstance(self.parent, FreeGroup): + if self._min_words is None: + # make _min_words - a list of subwords such that + # g is in the subgroup if and only if it can be + # partitioned into these subwords. Infinite families of + # subwords are presented by tuples, e.g. (r, w) + # stands for the family of subwords r*w**n*r**-1 + + def _process(w): + # this is to be used before adding new words + # into _min_words; if the word w is not cyclically + # reduced, it will generate an infinite family of + # subwords so should be written as a tuple; + # if it is, w**-1 should be added to the list + # as well + p, r = w.cyclic_reduction(removed=True) + if not r.is_identity: + return [(r, p)] + else: + return [w, w**-1] + + # make the initial list + gens = [] + for w in self.generators: + if self.normal: + w = w.cyclic_reduction() + gens.extend(_process(w)) + + for w1 in gens: + for w2 in gens: + # if w1 and w2 are equal or are inverses, continue + if w1 == w2 or (not isinstance(w1, tuple) + and w1**-1 == w2): + continue + + # if the start of one word is the inverse of the + # end of the other, their multiple should be added + # to _min_words because of cancellation + if isinstance(w1, tuple): + # start, end + s1, s2 = w1[0][0], w1[0][0]**-1 + else: + s1, s2 = w1[0], w1[len(w1)-1] + + if isinstance(w2, tuple): + # start, end + r1, r2 = w2[0][0], w2[0][0]**-1 + else: + r1, r2 = w2[0], w2[len(w1)-1] + + # p1 and p2 are w1 and w2 or, in case when + # w1 or w2 is an infinite family, a representative + p1, p2 = w1, w2 + if isinstance(w1, tuple): + p1 = w1[0]*w1[1]*w1[0]**-1 + if isinstance(w2, tuple): + p2 = w2[0]*w2[1]*w2[0]**-1 + + # add the product of the words to the list is necessary + if r1**-1 == s2 and not (p1*p2).is_identity: + new = _process(p1*p2) + if new not in gens: + gens.extend(new) + + if r2**-1 == s1 and not (p2*p1).is_identity: + new = _process(p2*p1) + if new not in gens: + gens.extend(new) + + self._min_words = gens + + min_words = self._min_words + + def _is_subword(w): + # check if w is a word in _min_words or one of + # the infinite families in it + w, r = w.cyclic_reduction(removed=True) + if r.is_identity or self.normal: + return w in min_words + else: + t = [s[1] for s in min_words if isinstance(s, tuple) + and s[0] == r] + return [s for s in t if w.power_of(s)] != [] + + # store the solution of words for which the result of + # _word_break (below) is known + known = {} + + def _word_break(w): + # check if w can be written as a product of words + # in min_words + if len(w) == 0: + return True + i = 0 + while i < len(w): + i += 1 + prefix = w.subword(0, i) + if not _is_subword(prefix): + continue + rest = w.subword(i, len(w)) + if rest not in known: + known[rest] = _word_break(rest) + if known[rest]: + return True + return False + + if self.normal: + g = g.cyclic_reduction() + return _word_break(g) + else: + if self.C is None: + C = self.parent.coset_enumeration(self.generators) + self.C = C + i = 0 + C = self.C + for j in range(len(g)): + i = C.table[i][C.A_dict[g[j]]] + return i == 0 + + def order(self): + if not self.generators: + return S.One + if isinstance(self.parent, FreeGroup): + return S.Infinity + if self.C is None: + C = self.parent.coset_enumeration(self.generators) + self.C = C + # This is valid because `len(self.C.table)` (the index of the subgroup) + # will always be finite - otherwise coset enumeration doesn't terminate + return self.parent.order()/len(self.C.table) + + def to_FpGroup(self): + if isinstance(self.parent, FreeGroup): + gen_syms = [('x_%d'%i) for i in range(len(self.generators))] + return free_group(', '.join(gen_syms))[0] + return self.parent.subgroup(C=self.C) + + def __str__(self): + if len(self.generators) > 30: + str_form = "" % len(self.generators) + else: + str_form = "" % str(self.generators) + return str_form + + __repr__ = __str__ + + +############################################################################### +# LOW INDEX SUBGROUPS # +############################################################################### + +def low_index_subgroups(G, N, Y=()): + """ + Implements the Low Index Subgroups algorithm, i.e find all subgroups of + ``G`` upto a given index ``N``. This implements the method described in + [Sim94]. This procedure involves a backtrack search over incomplete Coset + Tables, rather than over forced coincidences. + + Parameters + ========== + + G: An FpGroup < X|R > + N: positive integer, representing the maximum index value for subgroups + Y: (an optional argument) specifying a list of subgroup generators, such + that each of the resulting subgroup contains the subgroup generated by Y. + + Examples + ======== + + >>> from sympy.combinatorics import free_group + >>> from sympy.combinatorics.fp_groups import FpGroup, low_index_subgroups + >>> F, x, y = free_group("x, y") + >>> f = FpGroup(F, [x**2, y**3, (x*y)**4]) + >>> L = low_index_subgroups(f, 4) + >>> for coset_table in L: + ... print(coset_table.table) + [[0, 0, 0, 0]] + [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 3, 3]] + [[0, 0, 1, 2], [2, 2, 2, 0], [1, 1, 0, 1]] + [[1, 1, 0, 0], [0, 0, 1, 1]] + + References + ========== + + .. [1] Holt, D., Eick, B., O'Brien, E. + "Handbook of Computational Group Theory" + Section 5.4 + + .. [2] Marston Conder and Peter Dobcsanyi + "Applications and Adaptions of the Low Index Subgroups Procedure" + + """ + C = CosetTable(G, []) + R = G.relators + # length chosen for the length of the short relators + len_short_rel = 5 + # elements of R2 only checked at the last step for complete + # coset tables + R2 = {rel for rel in R if len(rel) > len_short_rel} + # elements of R1 are used in inner parts of the process to prune + # branches of the search tree, + R1 = {rel.identity_cyclic_reduction() for rel in set(R) - R2} + R1_c_list = C.conjugates(R1) + S = [] + descendant_subgroups(S, C, R1_c_list, C.A[0], R2, N, Y) + return S + + +def descendant_subgroups(S, C, R1_c_list, x, R2, N, Y): + A_dict = C.A_dict + A_dict_inv = C.A_dict_inv + if C.is_complete(): + # if C is complete then it only needs to test + # whether the relators in R2 are satisfied + for w, alpha in product(R2, C.omega): + if not C.scan_check(alpha, w): + return + # relators in R2 are satisfied, append the table to list + S.append(C) + else: + # find the first undefined entry in Coset Table + for alpha, x in product(range(len(C.table)), C.A): + if C.table[alpha][A_dict[x]] is None: + # this is "x" in pseudo-code (using "y" makes it clear) + undefined_coset, undefined_gen = alpha, x + break + # for filling up the undefine entry we try all possible values + # of beta in Omega or beta = n where beta^(undefined_gen^-1) is undefined + reach = C.omega + [C.n] + for beta in reach: + if beta < N: + if beta == C.n or C.table[beta][A_dict_inv[undefined_gen]] is None: + try_descendant(S, C, R1_c_list, R2, N, undefined_coset, \ + undefined_gen, beta, Y) + + +def try_descendant(S, C, R1_c_list, R2, N, alpha, x, beta, Y): + r""" + Solves the problem of trying out each individual possibility + for `\alpha^x. + + """ + D = C.copy() + if beta == D.n and beta < N: + D.table.append([None]*len(D.A)) + D.p.append(beta) + D.table[alpha][D.A_dict[x]] = beta + D.table[beta][D.A_dict_inv[x]] = alpha + D.deduction_stack.append((alpha, x)) + if not D.process_deductions_check(R1_c_list[D.A_dict[x]], \ + R1_c_list[D.A_dict_inv[x]]): + return + for w in Y: + if not D.scan_check(0, w): + return + if first_in_class(D, Y): + descendant_subgroups(S, D, R1_c_list, x, R2, N, Y) + + +def first_in_class(C, Y=()): + """ + Checks whether the subgroup ``H=G1`` corresponding to the Coset Table + could possibly be the canonical representative of its conjugacy class. + + Parameters + ========== + + C: CosetTable + + Returns + ======= + + bool: True/False + + If this returns False, then no descendant of C can have that property, and + so we can abandon C. If it returns True, then we need to process further + the node of the search tree corresponding to C, and so we call + ``descendant_subgroups`` recursively on C. + + Examples + ======== + + >>> from sympy.combinatorics import free_group + >>> from sympy.combinatorics.fp_groups import FpGroup, CosetTable, first_in_class + >>> F, x, y = free_group("x, y") + >>> f = FpGroup(F, [x**2, y**3, (x*y)**4]) + >>> C = CosetTable(f, []) + >>> C.table = [[0, 0, None, None]] + >>> first_in_class(C) + True + >>> C.table = [[1, 1, 1, None], [0, 0, None, 1]]; C.p = [0, 1] + >>> first_in_class(C) + True + >>> C.table = [[1, 1, 2, 1], [0, 0, 0, None], [None, None, None, 0]] + >>> C.p = [0, 1, 2] + >>> first_in_class(C) + False + >>> C.table = [[1, 1, 1, 2], [0, 0, 2, 0], [2, None, 0, 1]] + >>> first_in_class(C) + False + + # TODO:: Sims points out in [Sim94] that performance can be improved by + # remembering some of the information computed by ``first_in_class``. If + # the ``continue alpha`` statement is executed at line 14, then the same thing + # will happen for that value of alpha in any descendant of the table C, and so + # the values the values of alpha for which this occurs could profitably be + # stored and passed through to the descendants of C. Of course this would + # make the code more complicated. + + # The code below is taken directly from the function on page 208 of [Sim94] + # nu[alpha] + + """ + n = C.n + # lamda is the largest numbered point in Omega_c_alpha which is currently defined + lamda = -1 + # for alpha in Omega_c, nu[alpha] is the point in Omega_c_alpha corresponding to alpha + nu = [None]*n + # for alpha in Omega_c_alpha, mu[alpha] is the point in Omega_c corresponding to alpha + mu = [None]*n + # mutually nu and mu are the mutually-inverse equivalence maps between + # Omega_c_alpha and Omega_c + next_alpha = False + # For each 0!=alpha in [0 .. nc-1], we start by constructing the equivalent + # standardized coset table C_alpha corresponding to H_alpha + for alpha in range(1, n): + # reset nu to "None" after previous value of alpha + for beta in range(lamda+1): + nu[mu[beta]] = None + # we only want to reject our current table in favour of a preceding + # table in the ordering in which 1 is replaced by alpha, if the subgroup + # G_alpha corresponding to this preceding table definitely contains the + # given subgroup + for w in Y: + # TODO: this should support input of a list of general words + # not just the words which are in "A" (i.e gen and gen^-1) + if C.table[alpha][C.A_dict[w]] != alpha: + # continue with alpha + next_alpha = True + break + if next_alpha: + next_alpha = False + continue + # try alpha as the new point 0 in Omega_C_alpha + mu[0] = alpha + nu[alpha] = 0 + # compare corresponding entries in C and C_alpha + lamda = 0 + for beta in range(n): + for x in C.A: + gamma = C.table[beta][C.A_dict[x]] + delta = C.table[mu[beta]][C.A_dict[x]] + # if either of the entries is undefined, + # we move with next alpha + if gamma is None or delta is None: + # continue with alpha + next_alpha = True + break + if nu[delta] is None: + # delta becomes the next point in Omega_C_alpha + lamda += 1 + nu[delta] = lamda + mu[lamda] = delta + if nu[delta] < gamma: + return False + if nu[delta] > gamma: + # continue with alpha + next_alpha = True + break + if next_alpha: + next_alpha = False + break + return True + +#======================================================================== +# Simplifying Presentation +#======================================================================== + +def simplify_presentation(*args, change_gens=False): + ''' + For an instance of `FpGroup`, return a simplified isomorphic copy of + the group (e.g. remove redundant generators or relators). Alternatively, + a list of generators and relators can be passed in which case the + simplified lists will be returned. + + By default, the generators of the group are unchanged. If you would + like to remove redundant generators, set the keyword argument + `change_gens = True`. + + ''' + if len(args) == 1: + if not isinstance(args[0], FpGroup): + raise TypeError("The argument must be an instance of FpGroup") + G = args[0] + gens, rels = simplify_presentation(G.generators, G.relators, + change_gens=change_gens) + if gens: + return FpGroup(gens[0].group, rels) + return FpGroup(FreeGroup([]), []) + elif len(args) == 2: + gens, rels = args[0][:], args[1][:] + if not gens: + return gens, rels + identity = gens[0].group.identity + else: + if len(args) == 0: + m = "Not enough arguments" + else: + m = "Too many arguments" + raise RuntimeError(m) + + prev_gens = [] + prev_rels = [] + while not set(prev_rels) == set(rels): + prev_rels = rels + while change_gens and not set(prev_gens) == set(gens): + prev_gens = gens + gens, rels = elimination_technique_1(gens, rels, identity) + rels = _simplify_relators(rels, identity) + + if change_gens: + syms = [g.array_form[0][0] for g in gens] + F = free_group(syms)[0] + identity = F.identity + gens = F.generators + subs = dict(zip(syms, gens)) + for j, r in enumerate(rels): + a = r.array_form + rel = identity + for sym, p in a: + rel = rel*subs[sym]**p + rels[j] = rel + return gens, rels + +def _simplify_relators(rels, identity): + """Relies upon ``_simplification_technique_1`` for its functioning. """ + rels = rels[:] + + rels = list(set(_simplification_technique_1(rels))) + rels.sort() + rels = [r.identity_cyclic_reduction() for r in rels] + try: + rels.remove(identity) + except ValueError: + pass + return rels + +# Pg 350, section 2.5.1 from [2] +def elimination_technique_1(gens, rels, identity): + rels = rels[:] + # the shorter relators are examined first so that generators selected for + # elimination will have shorter strings as equivalent + rels.sort() + gens = gens[:] + redundant_gens = {} + redundant_rels = [] + used_gens = set() + # examine each relator in relator list for any generator occurring exactly + # once + for rel in rels: + # don't look for a redundant generator in a relator which + # depends on previously found ones + contained_gens = rel.contains_generators() + if any(g in contained_gens for g in redundant_gens): + continue + contained_gens = list(contained_gens) + contained_gens.sort(reverse = True) + for gen in contained_gens: + if rel.generator_count(gen) == 1 and gen not in used_gens: + k = rel.exponent_sum(gen) + gen_index = rel.index(gen**k) + bk = rel.subword(gen_index + 1, len(rel)) + fw = rel.subword(0, gen_index) + chi = bk*fw + redundant_gens[gen] = chi**(-1*k) + used_gens.update(chi.contains_generators()) + redundant_rels.append(rel) + break + rels = [r for r in rels if r not in redundant_rels] + # eliminate the redundant generators from remaining relators + rels = [r.eliminate_words(redundant_gens, _all = True).identity_cyclic_reduction() for r in rels] + rels = list(set(rels)) + try: + rels.remove(identity) + except ValueError: + pass + gens = [g for g in gens if g not in redundant_gens] + return gens, rels + +def _simplification_technique_1(rels): + """ + All relators are checked to see if they are of the form `gen^n`. If any + such relators are found then all other relators are processed for strings + in the `gen` known order. + + Examples + ======== + + >>> from sympy.combinatorics import free_group + >>> from sympy.combinatorics.fp_groups import _simplification_technique_1 + >>> F, x, y = free_group("x, y") + >>> w1 = [x**2*y**4, x**3] + >>> _simplification_technique_1(w1) + [x**-1*y**4, x**3] + + >>> w2 = [x**2*y**-4*x**5, x**3, x**2*y**8, y**5] + >>> _simplification_technique_1(w2) + [x**-1*y*x**-1, x**3, x**-1*y**-2, y**5] + + >>> w3 = [x**6*y**4, x**4] + >>> _simplification_technique_1(w3) + [x**2*y**4, x**4] + + """ + rels = rels[:] + # dictionary with "gen: n" where gen^n is one of the relators + exps = {} + for i in range(len(rels)): + rel = rels[i] + if rel.number_syllables() == 1: + g = rel[0] + exp = abs(rel.array_form[0][1]) + if rel.array_form[0][1] < 0: + rels[i] = rels[i]**-1 + g = g**-1 + if g in exps: + exp = gcd(exp, exps[g].array_form[0][1]) + exps[g] = g**exp + + one_syllables_words = exps.values() + # decrease some of the exponents in relators, making use of the single + # syllable relators + for i in range(len(rels)): + rel = rels[i] + if rel in one_syllables_words: + continue + rel = rel.eliminate_words(one_syllables_words, _all = True) + # if rels[i] contains g**n where abs(n) is greater than half of the power p + # of g in exps, g**n can be replaced by g**(n-p) (or g**(p-n) if n<0) + for g in rel.contains_generators(): + if g in exps: + exp = exps[g].array_form[0][1] + max_exp = (exp + 1)//2 + rel = rel.eliminate_word(g**(max_exp), g**(max_exp-exp), _all = True) + rel = rel.eliminate_word(g**(-max_exp), g**(-(max_exp-exp)), _all = True) + rels[i] = rel + rels = [r.identity_cyclic_reduction() for r in rels] + return rels + + +############################################################################### +# SUBGROUP PRESENTATIONS # +############################################################################### + +# Pg 175 [1] +def define_schreier_generators(C, homomorphism=False): + ''' + Parameters + ========== + + C -- Coset table. + homomorphism -- When set to True, return a dictionary containing the images + of the presentation generators in the original group. + ''' + y = [] + gamma = 1 + f = C.fp_group + X = f.generators + if homomorphism: + # `_gens` stores the elements of the parent group to + # to which the schreier generators correspond to. + _gens = {} + # compute the schreier Traversal + tau = {} + tau[0] = f.identity + C.P = [[None]*len(C.A) for i in range(C.n)] + for alpha, x in product(C.omega, C.A): + beta = C.table[alpha][C.A_dict[x]] + if beta == gamma: + C.P[alpha][C.A_dict[x]] = "" + C.P[beta][C.A_dict_inv[x]] = "" + gamma += 1 + if homomorphism: + tau[beta] = tau[alpha]*x + elif x in X and C.P[alpha][C.A_dict[x]] is None: + y_alpha_x = '%s_%s' % (x, alpha) + y.append(y_alpha_x) + C.P[alpha][C.A_dict[x]] = y_alpha_x + if homomorphism: + _gens[y_alpha_x] = tau[alpha]*x*tau[beta]**-1 + grp_gens = list(free_group(', '.join(y))) + C._schreier_free_group = grp_gens.pop(0) + C._schreier_generators = grp_gens + if homomorphism: + C._schreier_gen_elem = _gens + # replace all elements of P by, free group elements + for i, j in product(range(len(C.P)), range(len(C.A))): + # if equals "", replace by identity element + if C.P[i][j] == "": + C.P[i][j] = C._schreier_free_group.identity + elif isinstance(C.P[i][j], str): + r = C._schreier_generators[y.index(C.P[i][j])] + C.P[i][j] = r + beta = C.table[i][j] + C.P[beta][j + 1] = r**-1 + +def reidemeister_relators(C): + R = C.fp_group.relators + rels = [rewrite(C, coset, word) for word in R for coset in range(C.n)] + order_1_gens = {i for i in rels if len(i) == 1} + + # remove all the order 1 generators from relators + rels = list(filter(lambda rel: rel not in order_1_gens, rels)) + + # replace order 1 generators by identity element in reidemeister relators + for i in range(len(rels)): + w = rels[i] + w = w.eliminate_words(order_1_gens, _all=True) + rels[i] = w + + C._schreier_generators = [i for i in C._schreier_generators + if not (i in order_1_gens or i**-1 in order_1_gens)] + + # Tietze transformation 1 i.e TT_1 + # remove cyclic conjugate elements from relators + i = 0 + while i < len(rels): + w = rels[i] + j = i + 1 + while j < len(rels): + if w.is_cyclic_conjugate(rels[j]): + del rels[j] + else: + j += 1 + i += 1 + + C._reidemeister_relators = rels + + +def rewrite(C, alpha, w): + """ + Parameters + ========== + + C: CosetTable + alpha: A live coset + w: A word in `A*` + + Returns + ======= + + rho(tau(alpha), w) + + Examples + ======== + + >>> from sympy.combinatorics.fp_groups import FpGroup, CosetTable, define_schreier_generators, rewrite + >>> from sympy.combinatorics import free_group + >>> F, x, y = free_group("x, y") + >>> f = FpGroup(F, [x**2, y**3, (x*y)**6]) + >>> C = CosetTable(f, []) + >>> C.table = [[1, 1, 2, 3], [0, 0, 4, 5], [4, 4, 3, 0], [5, 5, 0, 2], [2, 2, 5, 1], [3, 3, 1, 4]] + >>> C.p = [0, 1, 2, 3, 4, 5] + >>> define_schreier_generators(C) + >>> rewrite(C, 0, (x*y)**6) + x_4*y_2*x_3*x_1*x_2*y_4*x_5 + + """ + v = C._schreier_free_group.identity + for i in range(len(w)): + x_i = w[i] + v = v*C.P[alpha][C.A_dict[x_i]] + alpha = C.table[alpha][C.A_dict[x_i]] + return v + +# Pg 350, section 2.5.2 from [2] +def elimination_technique_2(C): + """ + This technique eliminates one generator at a time. Heuristically this + seems superior in that we may select for elimination the generator with + shortest equivalent string at each stage. + + >>> from sympy.combinatorics import free_group + >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r, \ + reidemeister_relators, define_schreier_generators, elimination_technique_2 + >>> F, x, y = free_group("x, y") + >>> f = FpGroup(F, [x**3, y**5, (x*y)**2]); H = [x*y, x**-1*y**-1*x*y*x] + >>> C = coset_enumeration_r(f, H) + >>> C.compress(); C.standardize() + >>> define_schreier_generators(C) + >>> reidemeister_relators(C) + >>> elimination_technique_2(C) + ([y_1, y_2], [y_2**-3, y_2*y_1*y_2*y_1*y_2*y_1, y_1**2]) + + """ + rels = C._reidemeister_relators + rels.sort(reverse=True) + gens = C._schreier_generators + for i in range(len(gens) - 1, -1, -1): + rel = rels[i] + for j in range(len(gens) - 1, -1, -1): + gen = gens[j] + if rel.generator_count(gen) == 1: + k = rel.exponent_sum(gen) + gen_index = rel.index(gen**k) + bk = rel.subword(gen_index + 1, len(rel)) + fw = rel.subword(0, gen_index) + rep_by = (bk*fw)**(-1*k) + del rels[i]; del gens[j] + for l in range(len(rels)): + rels[l] = rels[l].eliminate_word(gen, rep_by) + break + C._reidemeister_relators = rels + C._schreier_generators = gens + return C._schreier_generators, C._reidemeister_relators + +def reidemeister_presentation(fp_grp, H, C=None, homomorphism=False): + """ + Parameters + ========== + + fp_group: A finitely presented group, an instance of FpGroup + H: A subgroup whose presentation is to be found, given as a list + of words in generators of `fp_grp` + homomorphism: When set to True, return a homomorphism from the subgroup + to the parent group + + Examples + ======== + + >>> from sympy.combinatorics import free_group + >>> from sympy.combinatorics.fp_groups import FpGroup, reidemeister_presentation + >>> F, x, y = free_group("x, y") + + Example 5.6 Pg. 177 from [1] + >>> f = FpGroup(F, [x**3, y**5, (x*y)**2]) + >>> H = [x*y, x**-1*y**-1*x*y*x] + >>> reidemeister_presentation(f, H) + ((y_1, y_2), (y_1**2, y_2**3, y_2*y_1*y_2*y_1*y_2*y_1)) + + Example 5.8 Pg. 183 from [1] + >>> f = FpGroup(F, [x**3, y**3, (x*y)**3]) + >>> H = [x*y, x*y**-1] + >>> reidemeister_presentation(f, H) + ((x_0, y_0), (x_0**3, y_0**3, x_0*y_0*x_0*y_0*x_0*y_0)) + + Exercises Q2. Pg 187 from [1] + >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3]) + >>> H = [x] + >>> reidemeister_presentation(f, H) + ((x_0,), (x_0**4,)) + + Example 5.9 Pg. 183 from [1] + >>> f = FpGroup(F, [x**3*y**-3, (x*y)**3, (x*y**-1)**2]) + >>> H = [x] + >>> reidemeister_presentation(f, H) + ((x_0,), (x_0**6,)) + + """ + if not C: + C = coset_enumeration_r(fp_grp, H) + C.compress(); C.standardize() + define_schreier_generators(C, homomorphism=homomorphism) + reidemeister_relators(C) + gens, rels = C._schreier_generators, C._reidemeister_relators + gens, rels = simplify_presentation(gens, rels, change_gens=True) + + C.schreier_generators = tuple(gens) + C.reidemeister_relators = tuple(rels) + + if homomorphism: + _gens = [] + for gen in gens: + _gens.append(C._schreier_gen_elem[str(gen)]) + return C.schreier_generators, C.reidemeister_relators, _gens + + return C.schreier_generators, C.reidemeister_relators + + +FpGroupElement = FreeGroupElement diff --git a/shared/package-files/42/4239de96773a37e2874fd38becafee81909702e58f06eb9c932a683d47a6946a/blob b/shared/package-files/42/4239de96773a37e2874fd38becafee81909702e58f06eb9c932a683d47a6946a/blob new file mode 100644 index 0000000000000000000000000000000000000000..ed1cb14b7c0cfcd4968d41389823625058705f48 --- /dev/null +++ b/shared/package-files/42/4239de96773a37e2874fd38becafee81909702e58f06eb9c932a683d47a6946a/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4239de96773a37e2874fd38becafee81909702e58f06eb9c932a683d47a6946a +size 354320 diff --git a/shared/package-files/42/423cd2cd3ac1a5a0a9244fb1318b403dd3d6f72b420eaf2eaf0ec4b5c690ec64/blob b/shared/package-files/42/423cd2cd3ac1a5a0a9244fb1318b403dd3d6f72b420eaf2eaf0ec4b5c690ec64/blob new file mode 100644 index 0000000000000000000000000000000000000000..4394c2a1ca9bf97ff39f3b94966339adc4769e4d --- /dev/null +++ b/shared/package-files/42/423cd2cd3ac1a5a0a9244fb1318b403dd3d6f72b420eaf2eaf0ec4b5c690ec64/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_special_zeta : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Tensor & other); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/42/423ee93db1e1dcbdb991db0fb75ca9c2f291ddd3f3b8eac5cf34133f731f8a58/blob b/shared/package-files/42/423ee93db1e1dcbdb991db0fb75ca9c2f291ddd3f3b8eac5cf34133f731f8a58/blob new file mode 100644 index 0000000000000000000000000000000000000000..62d1262a09cd293cf7b8eb42a3bf1cccfd533aa2 --- /dev/null +++ b/shared/package-files/42/423ee93db1e1dcbdb991db0fb75ca9c2f291ddd3f3b8eac5cf34133f731f8a58/blob @@ -0,0 +1,5 @@ +# Color cycle survey palette from Petroff (2021): +# https://arxiv.org/abs/2107.02270 +# https://github.com/mpetroff/accessible-color-cycles +axes.prop_cycle: cycler('color', ['3f90da', 'ffa90e', 'bd1f01', '94a4a2', '832db6', 'a96b59', 'e76300', 'b9ac70', '717581', '92dadd']) +patch.facecolor: 3f90da diff --git a/shared/package-files/42/4240298570b1b1522afc9d599ba55ee0008ef7b841fde430b14c092ec8160441/blob b/shared/package-files/42/4240298570b1b1522afc9d599ba55ee0008ef7b841fde430b14c092ec8160441/blob new file mode 100644 index 0000000000000000000000000000000000000000..3af90cc49765c8fcc31c9e8d79839f0d4bc4cd0d --- /dev/null +++ b/shared/package-files/42/4240298570b1b1522afc9d599ba55ee0008ef7b841fde430b14c092ec8160441/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API ::std::tuple unique_consecutive_out(const at::Tensor & self, bool return_inverse, bool return_counts, c10::optional dim, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); +TORCH_API ::std::tuple unique_consecutive_cpu(const at::Tensor & self, bool return_inverse=false, bool return_counts=false, c10::optional dim=c10::nullopt); +TORCH_API ::std::tuple unique_consecutive_cuda(const at::Tensor & self, bool return_inverse=false, bool return_counts=false, c10::optional dim=c10::nullopt); +} // namespace native +} // namespace at diff --git a/shared/package-files/42/42444a4411d59e501e080a8876abe6cb9d9d94c5df6f4f289b468679accdc07f/blob b/shared/package-files/42/42444a4411d59e501e080a8876abe6cb9d9d94c5df6f4f289b468679accdc07f/blob new file mode 100644 index 0000000000000000000000000000000000000000..64c44824157d1276a9c656ea5c8b236def1b995c --- /dev/null +++ b/shared/package-files/42/42444a4411d59e501e080a8876abe6cb9d9d94c5df6f4f289b468679accdc07f/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42444a4411d59e501e080a8876abe6cb9d9d94c5df6f4f289b468679accdc07f +size 735096 diff --git a/shared/package-files/42/42448a73bb53f861209b4494a0921f20565da7958715c00a0cb925683bf18edf/blob b/shared/package-files/42/42448a73bb53f861209b4494a0921f20565da7958715c00a0cb925683bf18edf/blob new file mode 100644 index 0000000000000000000000000000000000000000..38c0c985f50beb0cf130f519484077b8564cdbfa Binary files /dev/null and b/shared/package-files/42/42448a73bb53f861209b4494a0921f20565da7958715c00a0cb925683bf18edf/blob differ diff --git a/shared/package-files/42/42462ad82810e1a67ef767bff304a9bb168008120a8e4d9e238f8cfbac127995/blob b/shared/package-files/42/42462ad82810e1a67ef767bff304a9bb168008120a8e4d9e238f8cfbac127995/blob new file mode 100644 index 0000000000000000000000000000000000000000..7eb8dc0813868de9ca96c086f5506619719937f4 --- /dev/null +++ b/shared/package-files/42/42462ad82810e1a67ef767bff304a9bb168008120a8e4d9e238f8cfbac127995/blob @@ -0,0 +1,287 @@ +from datetime import ( + datetime, + time, + timedelta, +) +from typing import ( + Any, + Collection, + Literal, + TypeVar, + overload, +) + +import numpy as np + +from pandas._libs.tslibs.nattype import NaTType +from pandas._typing import ( + OffsetCalendar, + Self, + npt, +) + +from .timedeltas import Timedelta + +_BaseOffsetT = TypeVar("_BaseOffsetT", bound=BaseOffset) +_DatetimeT = TypeVar("_DatetimeT", bound=datetime) +_TimedeltaT = TypeVar("_TimedeltaT", bound=timedelta) + +_relativedelta_kwds: set[str] +prefix_mapping: dict[str, type] + +class ApplyTypeError(TypeError): ... + +class BaseOffset: + n: int + normalize: bool + def __init__(self, n: int = ..., normalize: bool = ...) -> None: ... + def __eq__(self, other) -> bool: ... + def __ne__(self, other) -> bool: ... + def __hash__(self) -> int: ... + @property + def kwds(self) -> dict: ... + @property + def base(self) -> BaseOffset: ... + @overload + def __add__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ... + @overload + def __add__(self, other: BaseOffset) -> Self: ... + @overload + def __add__(self, other: _DatetimeT) -> _DatetimeT: ... + @overload + def __add__(self, other: _TimedeltaT) -> _TimedeltaT: ... + @overload + def __radd__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ... + @overload + def __radd__(self, other: BaseOffset) -> Self: ... + @overload + def __radd__(self, other: _DatetimeT) -> _DatetimeT: ... + @overload + def __radd__(self, other: _TimedeltaT) -> _TimedeltaT: ... + @overload + def __radd__(self, other: NaTType) -> NaTType: ... + def __sub__(self, other: BaseOffset) -> Self: ... + @overload + def __rsub__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ... + @overload + def __rsub__(self, other: BaseOffset): ... + @overload + def __rsub__(self, other: _DatetimeT) -> _DatetimeT: ... + @overload + def __rsub__(self, other: _TimedeltaT) -> _TimedeltaT: ... + @overload + def __mul__(self, other: np.ndarray) -> np.ndarray: ... + @overload + def __mul__(self, other: int): ... + @overload + def __rmul__(self, other: np.ndarray) -> np.ndarray: ... + @overload + def __rmul__(self, other: int) -> Self: ... + def __neg__(self) -> Self: ... + def copy(self) -> Self: ... + @property + def name(self) -> str: ... + @property + def rule_code(self) -> str: ... + @property + def freqstr(self) -> str: ... + def _apply(self, other): ... + def _apply_array(self, dtarr: np.ndarray) -> np.ndarray: ... + def rollback(self, dt: datetime) -> datetime: ... + def rollforward(self, dt: datetime) -> datetime: ... + def is_on_offset(self, dt: datetime) -> bool: ... + def __setstate__(self, state) -> None: ... + def __getstate__(self): ... + @property + def nanos(self) -> int: ... + def is_anchored(self) -> bool: ... + +def _get_offset(name: str) -> BaseOffset: ... + +class SingleConstructorOffset(BaseOffset): + @classmethod + def _from_name(cls, suffix: None = ...): ... + def __reduce__(self): ... + +@overload +def to_offset(freq: None, is_period: bool = ...) -> None: ... +@overload +def to_offset(freq: _BaseOffsetT, is_period: bool = ...) -> _BaseOffsetT: ... +@overload +def to_offset(freq: timedelta | str, is_period: bool = ...) -> BaseOffset: ... + +class Tick(SingleConstructorOffset): + _creso: int + _prefix: str + def __init__(self, n: int = ..., normalize: bool = ...) -> None: ... + @property + def delta(self) -> Timedelta: ... + @property + def nanos(self) -> int: ... + +def delta_to_tick(delta: timedelta) -> Tick: ... + +class Day(Tick): ... +class Hour(Tick): ... +class Minute(Tick): ... +class Second(Tick): ... +class Milli(Tick): ... +class Micro(Tick): ... +class Nano(Tick): ... + +class RelativeDeltaOffset(BaseOffset): + def __init__(self, n: int = ..., normalize: bool = ..., **kwds: Any) -> None: ... + +class BusinessMixin(SingleConstructorOffset): + def __init__( + self, n: int = ..., normalize: bool = ..., offset: timedelta = ... + ) -> None: ... + +class BusinessDay(BusinessMixin): ... + +class BusinessHour(BusinessMixin): + def __init__( + self, + n: int = ..., + normalize: bool = ..., + start: str | time | Collection[str | time] = ..., + end: str | time | Collection[str | time] = ..., + offset: timedelta = ..., + ) -> None: ... + +class WeekOfMonthMixin(SingleConstructorOffset): + def __init__( + self, n: int = ..., normalize: bool = ..., weekday: int = ... + ) -> None: ... + +class YearOffset(SingleConstructorOffset): + def __init__( + self, n: int = ..., normalize: bool = ..., month: int | None = ... + ) -> None: ... + +class BYearEnd(YearOffset): ... +class BYearBegin(YearOffset): ... +class YearEnd(YearOffset): ... +class YearBegin(YearOffset): ... + +class QuarterOffset(SingleConstructorOffset): + def __init__( + self, n: int = ..., normalize: bool = ..., startingMonth: int | None = ... + ) -> None: ... + +class BQuarterEnd(QuarterOffset): ... +class BQuarterBegin(QuarterOffset): ... +class QuarterEnd(QuarterOffset): ... +class QuarterBegin(QuarterOffset): ... +class MonthOffset(SingleConstructorOffset): ... +class MonthEnd(MonthOffset): ... +class MonthBegin(MonthOffset): ... +class BusinessMonthEnd(MonthOffset): ... +class BusinessMonthBegin(MonthOffset): ... + +class SemiMonthOffset(SingleConstructorOffset): + def __init__( + self, n: int = ..., normalize: bool = ..., day_of_month: int | None = ... + ) -> None: ... + +class SemiMonthEnd(SemiMonthOffset): ... +class SemiMonthBegin(SemiMonthOffset): ... + +class Week(SingleConstructorOffset): + def __init__( + self, n: int = ..., normalize: bool = ..., weekday: int | None = ... + ) -> None: ... + +class WeekOfMonth(WeekOfMonthMixin): + def __init__( + self, n: int = ..., normalize: bool = ..., week: int = ..., weekday: int = ... + ) -> None: ... + +class LastWeekOfMonth(WeekOfMonthMixin): ... + +class FY5253Mixin(SingleConstructorOffset): + def __init__( + self, + n: int = ..., + normalize: bool = ..., + weekday: int = ..., + startingMonth: int = ..., + variation: Literal["nearest", "last"] = ..., + ) -> None: ... + +class FY5253(FY5253Mixin): ... + +class FY5253Quarter(FY5253Mixin): + def __init__( + self, + n: int = ..., + normalize: bool = ..., + weekday: int = ..., + startingMonth: int = ..., + qtr_with_extra_week: int = ..., + variation: Literal["nearest", "last"] = ..., + ) -> None: ... + +class Easter(SingleConstructorOffset): ... + +class _CustomBusinessMonth(BusinessMixin): + def __init__( + self, + n: int = ..., + normalize: bool = ..., + weekmask: str = ..., + holidays: list | None = ..., + calendar: OffsetCalendar | None = ..., + offset: timedelta = ..., + ) -> None: ... + +class CustomBusinessDay(BusinessDay): + def __init__( + self, + n: int = ..., + normalize: bool = ..., + weekmask: str = ..., + holidays: list | None = ..., + calendar: OffsetCalendar | None = ..., + offset: timedelta = ..., + ) -> None: ... + +class CustomBusinessHour(BusinessHour): + def __init__( + self, + n: int = ..., + normalize: bool = ..., + weekmask: str = ..., + holidays: list | None = ..., + calendar: OffsetCalendar | None = ..., + start: str | time | Collection[str | time] = ..., + end: str | time | Collection[str | time] = ..., + offset: timedelta = ..., + ) -> None: ... + +class CustomBusinessMonthEnd(_CustomBusinessMonth): ... +class CustomBusinessMonthBegin(_CustomBusinessMonth): ... +class OffsetMeta(type): ... +class DateOffset(RelativeDeltaOffset, metaclass=OffsetMeta): ... + +BDay = BusinessDay +BMonthEnd = BusinessMonthEnd +BMonthBegin = BusinessMonthBegin +CBMonthEnd = CustomBusinessMonthEnd +CBMonthBegin = CustomBusinessMonthBegin +CDay = CustomBusinessDay + +def roll_qtrday( + other: datetime, n: int, month: int, day_opt: str, modby: int +) -> int: ... + +INVALID_FREQ_ERR_MSG: Literal["Invalid frequency: {0}"] + +def shift_months( + dtindex: npt.NDArray[np.int64], + months: int, + day_opt: str | None = ..., + reso: int = ..., +) -> npt.NDArray[np.int64]: ... + +_offset_map: dict[str, BaseOffset] diff --git a/shared/package-files/42/4246b1a3a58b736dfde48ce65348cdf239217628fa030ba02746d832ab7780e4/blob b/shared/package-files/42/4246b1a3a58b736dfde48ce65348cdf239217628fa030ba02746d832ab7780e4/blob new file mode 100644 index 0000000000000000000000000000000000000000..842ce38d8dd56f569ff11ac5cb0baa40b96e337a --- /dev/null +++ b/shared/package-files/42/4246b1a3a58b736dfde48ce65348cdf239217628fa030ba02746d832ab7780e4/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _test_parallel_materialize { + using schema = at::Tensor (const at::Tensor &, int64_t, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_test_parallel_materialize") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_test_parallel_materialize(Tensor self, int num_parallel, bool skip_first=False) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t num_parallel, bool skip_first); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t num_parallel, bool skip_first); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/42/42476dec986c6aea8d13295eb656eceda53d44fc67a608724f0fd68a89d7582e/blob b/shared/package-files/42/42476dec986c6aea8d13295eb656eceda53d44fc67a608724f0fd68a89d7582e/blob new file mode 100644 index 0000000000000000000000000000000000000000..453cd5edc348bf1a0d957e011cd2fa85fee9b34a --- /dev/null +++ b/shared/package-files/42/42476dec986c6aea8d13295eb656eceda53d44fc67a608724f0fd68a89d7582e/blob @@ -0,0 +1,13 @@ +"""Semi-supervised learning algorithms. + +These algorithms utilize small amounts of labeled data and large amounts of unlabeled +data for classification tasks. +""" + +# Authors: The scikit-learn developers +# SPDX-License-Identifier: BSD-3-Clause + +from ._label_propagation import LabelPropagation, LabelSpreading +from ._self_training import SelfTrainingClassifier + +__all__ = ["LabelPropagation", "LabelSpreading", "SelfTrainingClassifier"] diff --git a/shared/package-files/42/4247b0bb8b4cca58157226a657058bf131680e89fc632ccdfbda68eaeb0de8c9/blob b/shared/package-files/42/4247b0bb8b4cca58157226a657058bf131680e89fc632ccdfbda68eaeb0de8c9/blob new file mode 100644 index 0000000000000000000000000000000000000000..d15b892b3eeaaed6762b6b9344ad9729a6ea3f0a --- /dev/null +++ b/shared/package-files/42/4247b0bb8b4cca58157226a657058bf131680e89fc632ccdfbda68eaeb0de8c9/blob @@ -0,0 +1,409 @@ +from io import BytesIO, StringIO +import gc +import multiprocessing +import os +from pathlib import Path +from PIL import Image +import shutil +import sys +import warnings + +import numpy as np +import pytest + +import matplotlib as mpl +from matplotlib.font_manager import ( + findfont, findSystemFonts, FontEntry, FontProperties, fontManager, + json_dump, json_load, get_font, is_opentype_cff_font, + MSUserFontDirectories, _get_fontconfig_fonts, ttfFontProperty) +from matplotlib import cbook, ft2font, pyplot as plt, rc_context, figure as mfigure +from matplotlib.testing import subprocess_run_helper, subprocess_run_for_testing + + +has_fclist = shutil.which('fc-list') is not None + + +def test_font_priority(): + with rc_context(rc={ + 'font.sans-serif': + ['cmmi10', 'Bitstream Vera Sans']}): + fontfile = findfont(FontProperties(family=["sans-serif"])) + assert Path(fontfile).name == 'cmmi10.ttf' + + # Smoketest get_charmap, which isn't used internally anymore + font = get_font(fontfile) + cmap = font.get_charmap() + assert len(cmap) == 131 + assert cmap[8729] == 30 + + +def test_score_weight(): + assert 0 == fontManager.score_weight("regular", "regular") + assert 0 == fontManager.score_weight("bold", "bold") + assert (0 < fontManager.score_weight(400, 400) < + fontManager.score_weight("normal", "bold")) + assert (0 < fontManager.score_weight("normal", "regular") < + fontManager.score_weight("normal", "bold")) + assert (fontManager.score_weight("normal", "regular") == + fontManager.score_weight(400, 400)) + + +def test_json_serialization(tmp_path): + # Can't open a NamedTemporaryFile twice on Windows, so use a temporary + # directory instead. + json_dump(fontManager, tmp_path / "fontlist.json") + copy = json_load(tmp_path / "fontlist.json") + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', 'findfont: Font family.*not found') + for prop in ({'family': 'STIXGeneral'}, + {'family': 'Bitstream Vera Sans', 'weight': 700}, + {'family': 'no such font family'}): + fp = FontProperties(**prop) + assert (fontManager.findfont(fp, rebuild_if_missing=False) == + copy.findfont(fp, rebuild_if_missing=False)) + + +def test_otf(): + fname = '/usr/share/fonts/opentype/freefont/FreeMono.otf' + if Path(fname).exists(): + assert is_opentype_cff_font(fname) + for f in fontManager.ttflist: + if 'otf' in f.fname: + with open(f.fname, 'rb') as fd: + res = fd.read(4) == b'OTTO' + assert res == is_opentype_cff_font(f.fname) + + +@pytest.mark.skipif(sys.platform == "win32" or not has_fclist, + reason='no fontconfig installed') +def test_get_fontconfig_fonts(): + assert len(_get_fontconfig_fonts()) > 1 + + +@pytest.mark.parametrize('factor', [2, 4, 6, 8]) +def test_hinting_factor(factor): + font = findfont(FontProperties(family=["sans-serif"])) + + font1 = get_font(font, hinting_factor=1) + font1.clear() + font1.set_size(12, 100) + font1.set_text('abc') + expected = font1.get_width_height() + + hinted_font = get_font(font, hinting_factor=factor) + hinted_font.clear() + hinted_font.set_size(12, 100) + hinted_font.set_text('abc') + # Check that hinting only changes text layout by a small (10%) amount. + np.testing.assert_allclose(hinted_font.get_width_height(), expected, + rtol=0.1) + + +def test_utf16m_sfnt(): + try: + # seguisbi = Microsoft Segoe UI Semibold + entry = next(entry for entry in fontManager.ttflist + if Path(entry.fname).name == "seguisbi.ttf") + except StopIteration: + pytest.skip("Couldn't find seguisbi.ttf font to test against.") + else: + # Check that we successfully read "semibold" from the font's sfnt table + # and set its weight accordingly. + assert entry.weight == 600 + + +def test_find_ttc(): + fp = FontProperties(family=["WenQuanYi Zen Hei"]) + if Path(findfont(fp)).name != "wqy-zenhei.ttc": + pytest.skip("Font wqy-zenhei.ttc may be missing") + fig, ax = plt.subplots() + ax.text(.5, .5, "\N{KANGXI RADICAL DRAGON}", fontproperties=fp) + for fmt in ["raw", "svg", "pdf", "ps"]: + fig.savefig(BytesIO(), format=fmt) + + +def test_find_noto(): + fp = FontProperties(family=["Noto Sans CJK SC", "Noto Sans CJK JP"]) + name = Path(findfont(fp)).name + if name not in ("NotoSansCJKsc-Regular.otf", "NotoSansCJK-Regular.ttc"): + pytest.skip(f"Noto Sans CJK SC font may be missing (found {name})") + + fig, ax = plt.subplots() + ax.text(0.5, 0.5, 'Hello, 你好', fontproperties=fp) + for fmt in ["raw", "svg", "pdf", "ps"]: + fig.savefig(BytesIO(), format=fmt) + + +def test_find_invalid(tmp_path): + + with pytest.raises(FileNotFoundError): + get_font(tmp_path / 'non-existent-font-name.ttf') + + with pytest.raises(FileNotFoundError): + get_font(str(tmp_path / 'non-existent-font-name.ttf')) + + with pytest.raises(FileNotFoundError): + get_font(bytes(tmp_path / 'non-existent-font-name.ttf')) + + # Not really public, but get_font doesn't expose non-filename constructor. + from matplotlib.ft2font import FT2Font + with pytest.raises(TypeError, match='font file or a binary-mode file'): + FT2Font(StringIO()) # type: ignore[arg-type] + + +@pytest.mark.skipif(sys.platform != 'linux' or not has_fclist, + reason='only Linux with fontconfig installed') +def test_user_fonts_linux(tmpdir, monkeypatch): + font_test_file = 'mpltest.ttf' + + # Precondition: the test font should not be available + fonts = findSystemFonts() + if any(font_test_file in font for font in fonts): + pytest.skip(f'{font_test_file} already exists in system fonts') + + # Prepare a temporary user font directory + user_fonts_dir = tmpdir.join('fonts') + user_fonts_dir.ensure(dir=True) + shutil.copyfile(Path(__file__).parent / font_test_file, + user_fonts_dir.join(font_test_file)) + + with monkeypatch.context() as m: + m.setenv('XDG_DATA_HOME', str(tmpdir)) + _get_fontconfig_fonts.cache_clear() + # Now, the font should be available + fonts = findSystemFonts() + assert any(font_test_file in font for font in fonts) + + # Make sure the temporary directory is no longer cached. + _get_fontconfig_fonts.cache_clear() + + +def test_addfont_as_path(): + """Smoke test that addfont() accepts pathlib.Path.""" + font_test_file = 'mpltest.ttf' + path = Path(__file__).parent / font_test_file + try: + fontManager.addfont(path) + added, = (font for font in fontManager.ttflist + if font.fname.endswith(font_test_file)) + fontManager.ttflist.remove(added) + finally: + to_remove = [font for font in fontManager.ttflist + if font.fname.endswith(font_test_file)] + for font in to_remove: + fontManager.ttflist.remove(font) + + +@pytest.mark.skipif(sys.platform != 'win32', reason='Windows only') +def test_user_fonts_win32(): + if not (os.environ.get('APPVEYOR') or os.environ.get('TF_BUILD')): + pytest.xfail("This test should only run on CI (appveyor or azure) " + "as the developer's font directory should remain " + "unchanged.") + pytest.xfail("We need to update the registry for this test to work") + font_test_file = 'mpltest.ttf' + + # Precondition: the test font should not be available + fonts = findSystemFonts() + if any(font_test_file in font for font in fonts): + pytest.skip(f'{font_test_file} already exists in system fonts') + + user_fonts_dir = MSUserFontDirectories[0] + + # Make sure that the user font directory exists (this is probably not the + # case on Windows versions < 1809) + os.makedirs(user_fonts_dir) + + # Copy the test font to the user font directory + shutil.copy(Path(__file__).parent / font_test_file, user_fonts_dir) + + # Now, the font should be available + fonts = findSystemFonts() + assert any(font_test_file in font for font in fonts) + + +def _model_handler(_): + fig, ax = plt.subplots() + fig.savefig(BytesIO(), format="pdf") + plt.close() + + +@pytest.mark.skipif(not hasattr(os, "register_at_fork"), + reason="Cannot register at_fork handlers") +def test_fork(): + _model_handler(0) # Make sure the font cache is filled. + ctx = multiprocessing.get_context("fork") + with ctx.Pool(processes=2) as pool: + pool.map(_model_handler, range(2)) + + +def test_missing_family(caplog): + plt.rcParams["font.sans-serif"] = ["this-font-does-not-exist"] + with caplog.at_level("WARNING"): + findfont("sans") + assert [rec.getMessage() for rec in caplog.records] == [ + "findfont: Font family ['sans'] not found. " + "Falling back to DejaVu Sans.", + "findfont: Generic family 'sans' not found because none of the " + "following families were found: this-font-does-not-exist", + ] + + +def _test_threading(): + import threading + from matplotlib.ft2font import LoadFlags + import matplotlib.font_manager as fm + + def loud_excepthook(args): + raise RuntimeError("error in thread!") + + threading.excepthook = loud_excepthook + + N = 10 + b = threading.Barrier(N) + + def bad_idea(n): + b.wait(timeout=5) + for j in range(100): + font = fm.get_font(fm.findfont("DejaVu Sans")) + font.set_text(str(n), 0.0, flags=LoadFlags.NO_HINTING) + + threads = [ + threading.Thread(target=bad_idea, name=f"bad_thread_{j}", args=(j,)) + for j in range(N) + ] + + for t in threads: + t.start() + + for t in threads: + t.join(timeout=9) + if t.is_alive(): + raise RuntimeError("thread failed to join") + + +def test_fontcache_thread_safe(): + pytest.importorskip('threading') + + subprocess_run_helper(_test_threading, timeout=10) + + +def test_lockfilefailure(tmp_path): + # The logic here: + # 1. get a temp directory from pytest + # 2. import matplotlib which makes sure it exists + # 3. get the cache dir (where we check it is writable) + # 4. make it not writable + # 5. try to write into it via font manager + proc = subprocess_run_for_testing( + [ + sys.executable, + "-c", + "import matplotlib;" + "import os;" + "p = matplotlib.get_cachedir();" + "os.chmod(p, 0o555);" + "import matplotlib.font_manager;" + ], + env={**os.environ, 'MPLCONFIGDIR': str(tmp_path)}, + check=True + ) + + +def test_fontentry_dataclass(): + fontent = FontEntry(name='font-name') + + png = fontent._repr_png_() + img = Image.open(BytesIO(png)) + assert img.width > 0 + assert img.height > 0 + + html = fontent._repr_html_() + assert html.startswith(" None: ... + def startElement(self, name, attrs, connection): ... + def endElement(self, name, value, connection): ... + def connect(self, **kw_params): ... diff --git a/shared/package-files/42/4248ada5d3d3089bd3ac37590466f5009e29037d2b7f355f696b2f316356c085/blob b/shared/package-files/42/4248ada5d3d3089bd3ac37590466f5009e29037d2b7f355f696b2f316356c085/blob new file mode 100644 index 0000000000000000000000000000000000000000..d002558113fc211a2cfeb9c9b7a744f8d50f6dcb --- /dev/null +++ b/shared/package-files/42/4248ada5d3d3089bd3ac37590466f5009e29037d2b7f355f696b2f316356c085/blob @@ -0,0 +1,1778 @@ +error(0.005859969820124944113) D0 D2 +error(0.002785180473373275855) D0 D2 ^ D8 +error(0.005000000000000000104) D0 D3 +error(0.04602149865715151472) D0 D5 +error(0.001668356733729803006) D0 D5 ^ D7 D8 +error(0.00357497063123127538) D0 D5 ^ D8 +error(0.002968225048212735136) D0 D9 +error(0.004107976363267442331) D0 D9 ^ D7 +error(0.0002194484671567856573) D0 D9 ^ D8 +error(0.006477511428027226542) D0 D10 +error(0.001004047896481121208) D0 D10 ^ D7 D8 +error(0.002779073657515943995) D0 D10 ^ D8 +error(0.01000000000000000021) D0 L0 +error(0.007112370957850999709) D1 D3 +error(0.03004234298198232844) D1 D9 +error(0.005000000000000000104) D1 L0 +error(0.007129882618785134824) D2 +error(0.002337146233243922021) D2 D5 +error(0.001981539105230504909) D2 D5 ^ D8 +error(0.0211830248537327355) D2 D6 +error(0.01155884922806079199) D2 D6 ^ D8 +error(0.002449624184169668737) D2 D10 +error(0.0004871431527278833403) D2 D10 ^ D8 +error(0.01741597086295970306) D3 +error(0.00242344694335577121) D3 D9 +error(0.0001183654020406494116) D3 D9 ^ D11 +error(0.02928984322464639467) D3 D10 +error(0.002219966368430509492) D3 D10 ^ D11 +error(0.006793755444368141522) D3 ^ D11 +error(0.0217727250182308367) D4 +error(0.01054213619241595179) D4 D7 +error(0.01415094072066073495) D4 D7 ^ D5 L0 +error(0.03112428738189396138) D4 D12 +error(0.007605025216541217749) D4 D12 ^ D13 L0 +error(0.006643555431332419207) D4 D15 +error(0.00548855459129347998) D4 D15 ^ D5 L0 +error(0.004567227145616721898) D4 D15 ^ D13 L0 +error(0.003742951627169742793) D4 D15 ^ D13 L0 ^ D5 L0 +error(0.003456310998655979291) D4 D16 +error(0.003000826243364488125) D4 D16 ^ D5 D13 +error(0.0005890454235397373081) D4 D16 ^ D5 L0 +error(0.001290843534788979879) D4 D16 ^ D13 L0 +error(0.00684477191321917252) D4 ^ D5 L0 +error(0.005707987121823666909) D5 D13 ^ D4 +error(0.005000000000000000104) D5 D6 +error(0.0004106803681311373003) D5 D6 ^ D4 +error(8.073949398501366153e-05) D5 D6 ^ D7 D8 +error(0.0005854115742089824282) D5 D6 ^ D7 D16 +error(0.01225441057855933095) D5 D6 ^ D8 +error(0.004397392613002783918) D5 D6 ^ D8 D16 +error(0.003022161545861388847) D5 D6 ^ D16 +error(0.0007976554828116148854) D5 D6 ^ D16 ^ D4 +error(0.01836924341345862535) D5 D10 +error(0.01367679462571064382) D5 D10 ^ D7 D8 +error(0.04826434730096164361) D5 D13 +error(0.003492226532555762694) D5 D13 ^ D15 D16 +error(0.004281833446095727712) D5 D13 ^ D16 +error(0.001853717777424029184) D5 D17 +error(0.002239735122648714612) D5 D17 ^ D7 D15 +error(0.0005612582963805286523) D5 D17 ^ D7 D16 +error(0.0004718732734019518349) D5 D17 ^ D15 D16 +error(0.0007341237423978296721) D5 D18 +error(0.002133173335255453534) D5 D18 ^ D7 D8 +error(0.0009726170139540637636) D5 D18 ^ D7 D15 +error(0.00206566717432974398) D5 D18 ^ D7 D16 +error(0.001068042459342767331) D5 D18 ^ D8 D16 +error(0.002694857058884877598) D5 D18 ^ D15 D16 +error(0.02452792260965630175) D5 L0 +error(0.008201930780325385542) D7 D15 ^ D5 L0 +error(0.005000000000000000104) D6 +error(0.006560379797122610837) D6 D13 +error(0.0007020324885268809526) D6 D13 ^ D4 +error(0.005393121636168434624) D6 D13 ^ D16 +error(0.0009863076048298488174) D6 D13 ^ D16 ^ D4 +error(0.02610789530202516778) D6 D14 +error(0.0110360761531631997) D6 D14 ^ D16 +error(0.002317202595067395943) D6 D18 +error(0.0003447409802485930266) D6 D18 ^ D7 D8 +error(0.0001709763741474679285) D6 D18 ^ D7 D16 +error(0.001306588848621806961) D6 D18 ^ D8 D16 +error(0.01455663173866768127) D6 ^ D8 +error(0.002806344194443891656) D6 ^ D16 ^ D8 +error(0.02704947590887026368) D7 +error(0.01020114792711506943) D7 D8 +error(0.0004492204672245427043) D7 D8 ^ D10 +error(0.001701853247078384795) D7 D8 ^ D10 D18 +error(0.02682470001186230621) D7 D15 +error(0.003351280911503579096) D7 D15 ^ D17 D18 +error(0.002838809172954709012) D7 D16 +error(0.0001572061157912999277) D7 D16 ^ D17 D18 +error(0.001393373771917199916) D7 D19 +error(0.0001884956742699187113) D7 D19 ^ D10 +error(0.001372135424766430601) D7 D19 ^ D10 D18 +error(0.0001330399799575002629) D7 D19 ^ D18 +error(0.003816837902020241494) D7 ^ D0 L0 +error(0.001660727215575634897) D7 ^ D5 L0 ^ D0 L0 +error(0.002001033354242249401) D7 ^ D8 ^ D0 L0 +error(0.0006664331841933626233) D7 ^ D8 ^ D5 L0 +error(0.009324080000931593559) D7 ^ D9 L0 +error(0.003935801536233380672) D9 D17 ^ D7 +error(0.04232002287197969559) D8 +error(0.02031638613454915532) D8 D11 +error(0.02117785516023332204) D8 D11 ^ D10 +error(0.0322765734706866661) D8 D16 +error(0.001935169617909809946) D8 D16 ^ D18 +error(0.009555400251384538537) D8 D19 +error(0.002204480404501199878) D8 D19 ^ D10 +error(0.005169913064080980045) D8 D19 ^ D18 +error(0.0006564952203538394456) D8 D19 ^ D18 ^ D10 +error(0.001783659775146166377) D8 ^ D0 L0 +error(0.001560532101789237954) D8 ^ D2 +error(0.004938872493708531923) D8 ^ D5 L0 +error(0.008581063227953886555) D9 D10 +error(0.01579786629787351473) D9 D10 ^ D7 +error(0.002848832426302692726) D9 D10 ^ D8 +error(0.0004900756591154590159) D9 D10 ^ D11 +error(0.02841728360156799832) D9 D17 +error(0.007450738501128452256) D9 L0 +error(0.02060826889280427746) D10 +error(0.002839966817347003205) D10 D17 +error(0.002452829707374155899) D10 D17 ^ D7 +error(5.017905351258029412e-05) D10 D17 ^ D19 +error(0.000247197448812605026) D10 D17 ^ D19 ^ D7 +error(0.03308377666233706244) D10 D18 +error(0.001240860359178470266) D10 D18 ^ D7 +error(0.001267847074638612246) D10 D18 ^ D19 +error(0.01826740958940055101) D10 ^ D11 +error(0.002030247209399251192) D10 ^ D19 +error(0.002716163382992085266) D11 D19 ^ D10 +error(0.03337790966511920004) D11 +error(0.02358145705777341117) D11 D19 +error(0.005000000000000000104) D12 +error(0.01617546677095215574) D12 D15 +error(0.01731851949100582724) D12 D15 ^ D13 L0 +error(0.03112428738189396138) D12 D20 +error(0.007605025216541217749) D12 D20 ^ D21 L0 +error(0.006643555431332419207) D12 D23 +error(0.00548855459129347998) D12 D23 ^ D13 L0 +error(0.004567227145616721898) D12 D23 ^ D21 L0 +error(0.003742951627169742793) D12 D23 ^ D21 L0 ^ D13 L0 +error(0.003456310998655979291) D12 D24 +error(0.003000826243364488125) D12 D24 ^ D13 D21 +error(0.0005890454235397373081) D12 D24 ^ D13 L0 +error(0.001290843534788979879) D12 D24 ^ D21 L0 +error(0.005000000000000000104) D12 ^ D13 L0 +error(0.005707987121823666909) D13 D21 ^ D12 +error(0.007117789145043611036) D13 D14 +error(0.0003981641069784467224) D13 D14 ^ D12 +error(0.0006749249515757715532) D13 D14 ^ D15 D16 +error(0.0005854115742089824282) D13 D14 ^ D15 D24 +error(0.01572940291487995648) D13 D14 ^ D16 +error(0.004397392613002783918) D13 D14 ^ D16 D24 +error(0.003022161545861388847) D13 D14 ^ D24 +error(0.0007976554828116148854) D13 D14 ^ D24 ^ D12 +error(0.01903773737510880068) D13 D18 +error(0.01301249434610882334) D13 D18 ^ D15 D16 +error(0.04826434730096164361) D13 D21 +error(0.003492226532555762694) D13 D21 ^ D23 D24 +error(0.004281833446095727712) D13 D21 ^ D24 +error(0.001853717777424029184) D13 D25 +error(0.002239735122648714612) D13 D25 ^ D15 D23 +error(0.0005612582963805286523) D13 D25 ^ D15 D24 +error(0.0004718732734019518349) D13 D25 ^ D23 D24 +error(0.0007341237423978296721) D13 D26 +error(0.002133173335255453534) D13 D26 ^ D15 D16 +error(0.0009726170139540637636) D13 D26 ^ D15 D23 +error(0.00206566717432974398) D13 D26 ^ D15 D24 +error(0.001068042459342767331) D13 D26 ^ D16 D24 +error(0.002694857058884877598) D13 D26 ^ D23 D24 +error(0.01000000000000000021) D13 L0 +error(0.008201930780325385542) D15 D23 ^ D13 L0 +error(0.005000000000000000104) D14 +error(0.006560379797122610837) D14 D21 +error(0.0007020324885268809526) D14 D21 ^ D12 +error(0.005393121636168434624) D14 D21 ^ D24 +error(0.0009863076048298488174) D14 D21 ^ D24 ^ D12 +error(0.02610789530202516778) D14 D22 +error(0.0110360761531631997) D14 D22 ^ D24 +error(0.002317202595067395943) D14 D26 +error(0.0003447409802485930266) D14 D26 ^ D15 D16 +error(0.0001709763741474679285) D14 D26 ^ D15 D24 +error(0.001306588848621806961) D14 D26 ^ D16 D24 +error(0.01507726810564594642) D14 ^ D16 +error(0.002806344194443891656) D14 ^ D24 ^ D16 +error(0.01000000000000000021) D15 +error(0.01068880118510151696) D15 D16 +error(0.0002438620789212667019) D15 D16 ^ D5 L0 +error(0.0004998182877393524907) D15 D16 ^ D17 D18 +error(0.001701853247078384795) D15 D16 ^ D18 D26 +error(0.02682470001186230621) D15 D23 +error(0.003351280911503579096) D15 D23 ^ D25 D26 +error(0.002838809172954709012) D15 D24 +error(0.0001572061157912999277) D15 D24 ^ D25 D26 +error(0.001393373771917199916) D15 D27 +error(0.0001884956742699187113) D15 D27 ^ D18 +error(0.001372135424766430601) D15 D27 ^ D18 D26 +error(0.0001330399799575002629) D15 D27 ^ D26 +error(0.009014877420392431936) D15 ^ D17 L0 +error(0.003935801536233380672) D17 D25 ^ D15 +error(0.01000000000000000021) D16 +error(0.02220618885390944833) D16 D19 +error(0.02105436195791260401) D16 D19 ^ D18 +error(0.0322765734706866661) D16 D24 +error(0.001935169617909809946) D16 D24 ^ D26 +error(0.009555400251384538537) D16 D27 +error(0.002204480404501199878) D16 D27 ^ D18 +error(0.005169913064080980045) D16 D27 ^ D26 +error(0.0006564952203538394456) D16 D27 ^ D26 ^ D18 +error(0.008126478579574632558) D17 D18 +error(0.003396220450673128732) D17 D18 ^ D7 +error(0.01234356543519746566) D17 D18 ^ D15 +error(0.0005596516236200856781) D17 D18 ^ D19 +error(0.0002482138172298047193) D17 D18 ^ D19 ^ D7 +error(0.02841728360156799832) D17 D25 +error(0.005000000000000000104) D17 L0 +error(0.0003172016853723943911) D17 L0 ^ D5 L0 ^ D7 +error(0.0001443879881180337103) D17 L0 ^ D5 L0 ^ D15 +error(0.0009522959210919978426) D17 L0 ^ D15 ^ D7 +error(0.01390683885060832979) D18 +error(0.002839966817347003205) D18 D25 +error(0.002452829707374155899) D18 D25 ^ D15 +error(5.017905351258029412e-05) D18 D25 ^ D27 +error(0.000247197448812605026) D18 D25 ^ D27 ^ D15 +error(0.03308377666233706244) D18 D26 +error(0.001240860359178470266) D18 D26 ^ D15 +error(0.001267847074638612246) D18 D26 ^ D27 +error(0.0007930654563626337965) D18 ^ D6 ^ D8 +error(0.0006216937696868836578) D18 ^ D6 ^ D16 +error(0.00105034782662940477) D18 ^ D16 +error(0.01387042499099926628) D18 ^ D19 +error(0.002030247209399251192) D18 ^ D27 +error(0.002716163382992085266) D19 D27 ^ D18 +error(0.007476592050288623746) D19 +error(0.02358145705777341117) D19 D27 +error(0.005000000000000000104) D20 +error(0.01617546677095215574) D20 D23 +error(0.01731851949100582724) D20 D23 ^ D21 L0 +error(0.03112428738189396138) D20 D28 +error(0.007605025216541217749) D20 D28 ^ D29 L0 +error(0.006643555431332419207) D20 D31 +error(0.00548855459129347998) D20 D31 ^ D21 L0 +error(0.004567227145616721898) D20 D31 ^ D29 L0 +error(0.003742951627169742793) D20 D31 ^ D29 L0 ^ D21 L0 +error(0.003456310998655979291) D20 D32 +error(0.003000826243364488125) D20 D32 ^ D21 D29 +error(0.0005890454235397373081) D20 D32 ^ D21 L0 +error(0.001290843534788979879) D20 D32 ^ D29 L0 +error(0.005000000000000000104) D20 ^ D21 L0 +error(0.005707987121823666909) D21 D29 ^ D20 +error(0.007117789145043611036) D21 D22 +error(0.0003981641069784467224) D21 D22 ^ D20 +error(0.0006749249515757715532) D21 D22 ^ D23 D24 +error(0.0005854115742089824282) D21 D22 ^ D23 D32 +error(0.01572940291487995648) D21 D22 ^ D24 +error(0.004397392613002783918) D21 D22 ^ D24 D32 +error(0.003022161545861388847) D21 D22 ^ D32 +error(0.0007976554828116148854) D21 D22 ^ D32 ^ D20 +error(0.01903773737510880068) D21 D26 +error(0.01301249434610882334) D21 D26 ^ D23 D24 +error(0.04826434730096164361) D21 D29 +error(0.003492226532555762694) D21 D29 ^ D31 D32 +error(0.004281833446095727712) D21 D29 ^ D32 +error(0.001853717777424029184) D21 D33 +error(0.002239735122648714612) D21 D33 ^ D23 D31 +error(0.0005612582963805286523) D21 D33 ^ D23 D32 +error(0.0004718732734019518349) D21 D33 ^ D31 D32 +error(0.0007341237423978296721) D21 D34 +error(0.002133173335255453534) D21 D34 ^ D23 D24 +error(0.0009726170139540637636) D21 D34 ^ D23 D31 +error(0.00206566717432974398) D21 D34 ^ D23 D32 +error(0.001068042459342767331) D21 D34 ^ D24 D32 +error(0.002694857058884877598) D21 D34 ^ D31 D32 +error(0.01000000000000000021) D21 L0 +error(0.008201930780325385542) D23 D31 ^ D21 L0 +error(0.005000000000000000104) D22 +error(0.006560379797122610837) D22 D29 +error(0.0007020324885268809526) D22 D29 ^ D20 +error(0.005393121636168434624) D22 D29 ^ D32 +error(0.0009863076048298488174) D22 D29 ^ D32 ^ D20 +error(0.02610789530202516778) D22 D30 +error(0.0110360761531631997) D22 D30 ^ D32 +error(0.002317202595067395943) D22 D34 +error(0.0003447409802485930266) D22 D34 ^ D23 D24 +error(0.0001709763741474679285) D22 D34 ^ D23 D32 +error(0.001306588848621806961) D22 D34 ^ D24 D32 +error(0.01507726810564594642) D22 ^ D24 +error(0.002806344194443891656) D22 ^ D32 ^ D24 +error(0.01000000000000000021) D23 +error(0.01068880118510151696) D23 D24 +error(0.0002438620789212667019) D23 D24 ^ D13 L0 +error(0.0004998182877393524907) D23 D24 ^ D25 D26 +error(0.001701853247078384795) D23 D24 ^ D26 D34 +error(0.02682470001186230621) D23 D31 +error(0.003351280911503579096) D23 D31 ^ D33 D34 +error(0.002838809172954709012) D23 D32 +error(0.0001572061157912999277) D23 D32 ^ D33 D34 +error(0.001393373771917199916) D23 D35 +error(0.0001884956742699187113) D23 D35 ^ D26 +error(0.001372135424766430601) D23 D35 ^ D26 D34 +error(0.0001330399799575002629) D23 D35 ^ D34 +error(0.009014877420392431936) D23 ^ D25 L0 +error(0.003935801536233380672) D25 D33 ^ D23 +error(0.01000000000000000021) D24 +error(0.02220618885390944833) D24 D27 +error(0.02105436195791260401) D24 D27 ^ D26 +error(0.0322765734706866661) D24 D32 +error(0.001935169617909809946) D24 D32 ^ D34 +error(0.009555400251384538537) D24 D35 +error(0.002204480404501199878) D24 D35 ^ D26 +error(0.005169913064080980045) D24 D35 ^ D34 +error(0.0006564952203538394456) D24 D35 ^ D34 ^ D26 +error(0.008126478579574632558) D25 D26 +error(0.003396220450673128732) D25 D26 ^ D15 +error(0.01234356543519746566) D25 D26 ^ D23 +error(0.0005596516236200856781) D25 D26 ^ D27 +error(0.0002482138172298047193) D25 D26 ^ D27 ^ D15 +error(0.02841728360156799832) D25 D33 +error(0.005000000000000000104) D25 L0 +error(0.0003172016853723943911) D25 L0 ^ D13 L0 ^ D15 +error(0.0001443879881180337103) D25 L0 ^ D13 L0 ^ D23 +error(0.0009522959210919978426) D25 L0 ^ D23 ^ D15 +error(0.01390683885060832979) D26 +error(0.002839966817347003205) D26 D33 +error(0.002452829707374155899) D26 D33 ^ D23 +error(5.017905351258029412e-05) D26 D33 ^ D35 +error(0.000247197448812605026) D26 D33 ^ D35 ^ D23 +error(0.03308377666233706244) D26 D34 +error(0.001240860359178470266) D26 D34 ^ D23 +error(0.001267847074638612246) D26 D34 ^ D35 +error(0.0007930654563626337965) D26 ^ D14 ^ D16 +error(0.0006216937696868836578) D26 ^ D14 ^ D24 +error(0.00105034782662940477) D26 ^ D24 +error(0.01387042499099926628) D26 ^ D27 +error(0.002030247209399251192) D26 ^ D35 +error(0.002716163382992085266) D27 D35 ^ D26 +error(0.007476592050288623746) D27 +error(0.02358145705777341117) D27 D35 +error(0.005000000000000000104) D28 +error(0.01617546677095215574) D28 D31 +error(0.01731851949100582724) D28 D31 ^ D29 L0 +error(0.03112428738189396138) D28 D36 +error(0.007605025216541217749) D28 D36 ^ D37 L0 +error(0.006643555431332419207) D28 D39 +error(0.00548855459129347998) D28 D39 ^ D29 L0 +error(0.004567227145616721898) D28 D39 ^ D37 L0 +error(0.003742951627169742793) D28 D39 ^ D37 L0 ^ D29 L0 +error(0.003456310998655979291) D28 D40 +error(0.003000826243364488125) D28 D40 ^ D29 D37 +error(0.0005890454235397373081) D28 D40 ^ D29 L0 +error(0.001290843534788979879) D28 D40 ^ D37 L0 +error(0.005000000000000000104) D28 ^ D29 L0 +error(0.005707987121823666909) D29 D37 ^ D28 +error(0.007117789145043611036) D29 D30 +error(0.0003981641069784467224) D29 D30 ^ D28 +error(0.0006749249515757715532) D29 D30 ^ D31 D32 +error(0.0005854115742089824282) D29 D30 ^ D31 D40 +error(0.01572940291487995648) D29 D30 ^ D32 +error(0.004397392613002783918) D29 D30 ^ D32 D40 +error(0.003022161545861388847) D29 D30 ^ D40 +error(0.0007976554828116148854) D29 D30 ^ D40 ^ D28 +error(0.01903773737510880068) D29 D34 +error(0.01301249434610882334) D29 D34 ^ D31 D32 +error(0.04826434730096164361) D29 D37 +error(0.003492226532555762694) D29 D37 ^ D39 D40 +error(0.004281833446095727712) D29 D37 ^ D40 +error(0.001853717777424029184) D29 D41 +error(0.002239735122648714612) D29 D41 ^ D31 D39 +error(0.0005612582963805286523) D29 D41 ^ D31 D40 +error(0.0004718732734019518349) D29 D41 ^ D39 D40 +error(0.0007341237423978296721) D29 D42 +error(0.002133173335255453534) D29 D42 ^ D31 D32 +error(0.0009726170139540637636) D29 D42 ^ D31 D39 +error(0.00206566717432974398) D29 D42 ^ D31 D40 +error(0.001068042459342767331) D29 D42 ^ D32 D40 +error(0.002694857058884877598) D29 D42 ^ D39 D40 +error(0.01000000000000000021) D29 L0 +error(0.008201930780325385542) D31 D39 ^ D29 L0 +error(0.005000000000000000104) D30 +error(0.006560379797122610837) D30 D37 +error(0.0007020324885268809526) D30 D37 ^ D28 +error(0.005393121636168434624) D30 D37 ^ D40 +error(0.0009863076048298488174) D30 D37 ^ D40 ^ D28 +error(0.02610789530202516778) D30 D38 +error(0.0110360761531631997) D30 D38 ^ D40 +error(0.002317202595067395943) D30 D42 +error(0.0003447409802485930266) D30 D42 ^ D31 D32 +error(0.0001709763741474679285) D30 D42 ^ D31 D40 +error(0.001306588848621806961) D30 D42 ^ D32 D40 +error(0.01507726810564594642) D30 ^ D32 +error(0.002806344194443891656) D30 ^ D40 ^ D32 +error(0.01000000000000000021) D31 +error(0.01068880118510151696) D31 D32 +error(0.0002438620789212667019) D31 D32 ^ D21 L0 +error(0.0004998182877393524907) D31 D32 ^ D33 D34 +error(0.001701853247078384795) D31 D32 ^ D34 D42 +error(0.02682470001186230621) D31 D39 +error(0.003351280911503579096) D31 D39 ^ D41 D42 +error(0.002838809172954709012) D31 D40 +error(0.0001572061157912999277) D31 D40 ^ D41 D42 +error(0.001393373771917199916) D31 D43 +error(0.0001884956742699187113) D31 D43 ^ D34 +error(0.001372135424766430601) D31 D43 ^ D34 D42 +error(0.0001330399799575002629) D31 D43 ^ D42 +error(0.009014877420392431936) D31 ^ D33 L0 +error(0.003935801536233380672) D33 D41 ^ D31 +error(0.01000000000000000021) D32 +error(0.02220618885390944833) D32 D35 +error(0.02105436195791260401) D32 D35 ^ D34 +error(0.0322765734706866661) D32 D40 +error(0.001935169617909809946) D32 D40 ^ D42 +error(0.009555400251384538537) D32 D43 +error(0.002204480404501199878) D32 D43 ^ D34 +error(0.005169913064080980045) D32 D43 ^ D42 +error(0.0006564952203538394456) D32 D43 ^ D42 ^ D34 +error(0.008126478579574632558) D33 D34 +error(0.003396220450673128732) D33 D34 ^ D23 +error(0.01234356543519746566) D33 D34 ^ D31 +error(0.0005596516236200856781) D33 D34 ^ D35 +error(0.0002482138172298047193) D33 D34 ^ D35 ^ D23 +error(0.02841728360156799832) D33 D41 +error(0.005000000000000000104) D33 L0 +error(0.0003172016853723943911) D33 L0 ^ D21 L0 ^ D23 +error(0.0001443879881180337103) D33 L0 ^ D21 L0 ^ D31 +error(0.0009522959210919978426) D33 L0 ^ D31 ^ D23 +error(0.01390683885060832979) D34 +error(0.002839966817347003205) D34 D41 +error(0.002452829707374155899) D34 D41 ^ D31 +error(5.017905351258029412e-05) D34 D41 ^ D43 +error(0.000247197448812605026) D34 D41 ^ D43 ^ D31 +error(0.03308377666233706244) D34 D42 +error(0.001240860359178470266) D34 D42 ^ D31 +error(0.001267847074638612246) D34 D42 ^ D43 +error(0.0007930654563626337965) D34 ^ D22 ^ D24 +error(0.0006216937696868836578) D34 ^ D22 ^ D32 +error(0.00105034782662940477) D34 ^ D32 +error(0.01387042499099926628) D34 ^ D35 +error(0.002030247209399251192) D34 ^ D43 +error(0.002716163382992085266) D35 D43 ^ D34 +error(0.007476592050288623746) D35 +error(0.02358145705777341117) D35 D43 +error(0.005000000000000000104) D36 +error(0.01617546677095215574) D36 D39 +error(0.01731851949100582724) D36 D39 ^ D37 L0 +error(0.03112428738189396138) D36 D44 +error(0.007605025216541217749) D36 D44 ^ D45 L0 +error(0.006643555431332419207) D36 D47 +error(0.00548855459129347998) D36 D47 ^ D37 L0 +error(0.004567227145616721898) D36 D47 ^ D45 L0 +error(0.003742951627169742793) D36 D47 ^ D45 L0 ^ D37 L0 +error(0.003456310998655979291) D36 D48 +error(0.003000826243364488125) D36 D48 ^ D37 D45 +error(0.0005890454235397373081) D36 D48 ^ D37 L0 +error(0.001290843534788979879) D36 D48 ^ D45 L0 +error(0.005000000000000000104) D36 ^ D37 L0 +error(0.005707987121823666909) D37 D45 ^ D36 +error(0.007117789145043611036) D37 D38 +error(0.0003981641069784467224) D37 D38 ^ D36 +error(0.0006749249515757715532) D37 D38 ^ D39 D40 +error(0.0005854115742089824282) D37 D38 ^ D39 D48 +error(0.01572940291487995648) D37 D38 ^ D40 +error(0.004397392613002783918) D37 D38 ^ D40 D48 +error(0.003022161545861388847) D37 D38 ^ D48 +error(0.0007976554828116148854) D37 D38 ^ D48 ^ D36 +error(0.01903773737510880068) D37 D42 +error(0.01301249434610882334) D37 D42 ^ D39 D40 +error(0.04826434730096164361) D37 D45 +error(0.003492226532555762694) D37 D45 ^ D47 D48 +error(0.004281833446095727712) D37 D45 ^ D48 +error(0.001853717777424029184) D37 D49 +error(0.002239735122648714612) D37 D49 ^ D39 D47 +error(0.0005612582963805286523) D37 D49 ^ D39 D48 +error(0.0004718732734019518349) D37 D49 ^ D47 D48 +error(0.0007341237423978296721) D37 D50 +error(0.002133173335255453534) D37 D50 ^ D39 D40 +error(0.0009726170139540637636) D37 D50 ^ D39 D47 +error(0.00206566717432974398) D37 D50 ^ D39 D48 +error(0.001068042459342767331) D37 D50 ^ D40 D48 +error(0.002694857058884877598) D37 D50 ^ D47 D48 +error(0.01000000000000000021) D37 L0 +error(0.008201930780325385542) D39 D47 ^ D37 L0 +error(0.005000000000000000104) D38 +error(0.006560379797122610837) D38 D45 +error(0.0007020324885268809526) D38 D45 ^ D36 +error(0.005393121636168434624) D38 D45 ^ D48 +error(0.0009863076048298488174) D38 D45 ^ D48 ^ D36 +error(0.02610789530202516778) D38 D46 +error(0.0110360761531631997) D38 D46 ^ D48 +error(0.002317202595067395943) D38 D50 +error(0.0003447409802485930266) D38 D50 ^ D39 D40 +error(0.0001709763741474679285) D38 D50 ^ D39 D48 +error(0.001306588848621806961) D38 D50 ^ D40 D48 +error(0.01507726810564594642) D38 ^ D40 +error(0.002806344194443891656) D38 ^ D48 ^ D40 +error(0.01000000000000000021) D39 +error(0.01068880118510151696) D39 D40 +error(0.0002438620789212667019) D39 D40 ^ D29 L0 +error(0.0004998182877393524907) D39 D40 ^ D41 D42 +error(0.001701853247078384795) D39 D40 ^ D42 D50 +error(0.02682470001186230621) D39 D47 +error(0.003351280911503579096) D39 D47 ^ D49 D50 +error(0.002838809172954709012) D39 D48 +error(0.0001572061157912999277) D39 D48 ^ D49 D50 +error(0.001393373771917199916) D39 D51 +error(0.0001884956742699187113) D39 D51 ^ D42 +error(0.001372135424766430601) D39 D51 ^ D42 D50 +error(0.0001330399799575002629) D39 D51 ^ D50 +error(0.009014877420392431936) D39 ^ D41 L0 +error(0.003935801536233380672) D41 D49 ^ D39 +error(0.01000000000000000021) D40 +error(0.02220618885390944833) D40 D43 +error(0.02105436195791260401) D40 D43 ^ D42 +error(0.0322765734706866661) D40 D48 +error(0.001935169617909809946) D40 D48 ^ D50 +error(0.009555400251384538537) D40 D51 +error(0.002204480404501199878) D40 D51 ^ D42 +error(0.005169913064080980045) D40 D51 ^ D50 +error(0.0006564952203538394456) D40 D51 ^ D50 ^ D42 +error(0.008126478579574632558) D41 D42 +error(0.003396220450673128732) D41 D42 ^ D31 +error(0.01234356543519746566) D41 D42 ^ D39 +error(0.0005596516236200856781) D41 D42 ^ D43 +error(0.0002482138172298047193) D41 D42 ^ D43 ^ D31 +error(0.02841728360156799832) D41 D49 +error(0.005000000000000000104) D41 L0 +error(0.0003172016853723943911) D41 L0 ^ D29 L0 ^ D31 +error(0.0001443879881180337103) D41 L0 ^ D29 L0 ^ D39 +error(0.0009522959210919978426) D41 L0 ^ D39 ^ D31 +error(0.01390683885060832979) D42 +error(0.002839966817347003205) D42 D49 +error(0.002452829707374155899) D42 D49 ^ D39 +error(5.017905351258029412e-05) D42 D49 ^ D51 +error(0.000247197448812605026) D42 D49 ^ D51 ^ D39 +error(0.03308377666233706244) D42 D50 +error(0.001240860359178470266) D42 D50 ^ D39 +error(0.001267847074638612246) D42 D50 ^ D51 +error(0.0007930654563626337965) D42 ^ D30 ^ D32 +error(0.0006216937696868836578) D42 ^ D30 ^ D40 +error(0.00105034782662940477) D42 ^ D40 +error(0.01387042499099926628) D42 ^ D43 +error(0.002030247209399251192) D42 ^ D51 +error(0.002716163382992085266) D43 D51 ^ D42 +error(0.007476592050288623746) D43 +error(0.02358145705777341117) D43 D51 +error(0.005000000000000000104) D44 +error(0.01617546677095215574) D44 D47 +error(0.01731851949100582724) D44 D47 ^ D45 L0 +error(0.03112428738189396138) D44 D52 +error(0.007605025216541217749) D44 D52 ^ D53 L0 +error(0.006643555431332419207) D44 D55 +error(0.00548855459129347998) D44 D55 ^ D45 L0 +error(0.004567227145616721898) D44 D55 ^ D53 L0 +error(0.003742951627169742793) D44 D55 ^ D53 L0 ^ D45 L0 +error(0.003456310998655979291) D44 D56 +error(0.003000826243364488125) D44 D56 ^ D45 D53 +error(0.0005890454235397373081) D44 D56 ^ D45 L0 +error(0.001290843534788979879) D44 D56 ^ D53 L0 +error(0.005000000000000000104) D44 ^ D45 L0 +error(0.005707987121823666909) D45 D53 ^ D44 +error(0.007117789145043611036) D45 D46 +error(0.0003981641069784467224) D45 D46 ^ D44 +error(0.0006749249515757715532) D45 D46 ^ D47 D48 +error(0.0005854115742089824282) D45 D46 ^ D47 D56 +error(0.01572940291487995648) D45 D46 ^ D48 +error(0.004397392613002783918) D45 D46 ^ D48 D56 +error(0.003022161545861388847) D45 D46 ^ D56 +error(0.0007976554828116148854) D45 D46 ^ D56 ^ D44 +error(0.01903773737510880068) D45 D50 +error(0.01301249434610882334) D45 D50 ^ D47 D48 +error(0.04826434730096164361) D45 D53 +error(0.003492226532555762694) D45 D53 ^ D55 D56 +error(0.004281833446095727712) D45 D53 ^ D56 +error(0.001853717777424029184) D45 D57 +error(0.002239735122648714612) D45 D57 ^ D47 D55 +error(0.0005612582963805286523) D45 D57 ^ D47 D56 +error(0.0004718732734019518349) D45 D57 ^ D55 D56 +error(0.0007341237423978296721) D45 D58 +error(0.002133173335255453534) D45 D58 ^ D47 D48 +error(0.0009726170139540637636) D45 D58 ^ D47 D55 +error(0.00206566717432974398) D45 D58 ^ D47 D56 +error(0.001068042459342767331) D45 D58 ^ D48 D56 +error(0.002694857058884877598) D45 D58 ^ D55 D56 +error(0.01000000000000000021) D45 L0 +error(0.008201930780325385542) D47 D55 ^ D45 L0 +error(0.005000000000000000104) D46 +error(0.006560379797122610837) D46 D53 +error(0.0007020324885268809526) D46 D53 ^ D44 +error(0.005393121636168434624) D46 D53 ^ D56 +error(0.0009863076048298488174) D46 D53 ^ D56 ^ D44 +error(0.02610789530202516778) D46 D54 +error(0.0110360761531631997) D46 D54 ^ D56 +error(0.002317202595067395943) D46 D58 +error(0.0003447409802485930266) D46 D58 ^ D47 D48 +error(0.0001709763741474679285) D46 D58 ^ D47 D56 +error(0.001306588848621806961) D46 D58 ^ D48 D56 +error(0.01507726810564594642) D46 ^ D48 +error(0.002806344194443891656) D46 ^ D56 ^ D48 +error(0.01000000000000000021) D47 +error(0.01068880118510151696) D47 D48 +error(0.0002438620789212667019) D47 D48 ^ D37 L0 +error(0.0004998182877393524907) D47 D48 ^ D49 D50 +error(0.001701853247078384795) D47 D48 ^ D50 D58 +error(0.02682470001186230621) D47 D55 +error(0.003351280911503579096) D47 D55 ^ D57 D58 +error(0.002838809172954709012) D47 D56 +error(0.0001572061157912999277) D47 D56 ^ D57 D58 +error(0.001393373771917199916) D47 D59 +error(0.0001884956742699187113) D47 D59 ^ D50 +error(0.001372135424766430601) D47 D59 ^ D50 D58 +error(0.0001330399799575002629) D47 D59 ^ D58 +error(0.009014877420392431936) D47 ^ D49 L0 +error(0.003935801536233380672) D49 D57 ^ D47 +error(0.01000000000000000021) D48 +error(0.02220618885390944833) D48 D51 +error(0.02105436195791260401) D48 D51 ^ D50 +error(0.0322765734706866661) D48 D56 +error(0.001935169617909809946) D48 D56 ^ D58 +error(0.009555400251384538537) D48 D59 +error(0.002204480404501199878) D48 D59 ^ D50 +error(0.005169913064080980045) D48 D59 ^ D58 +error(0.0006564952203538394456) D48 D59 ^ D58 ^ D50 +error(0.008126478579574632558) D49 D50 +error(0.003396220450673128732) D49 D50 ^ D39 +error(0.01234356543519746566) D49 D50 ^ D47 +error(0.0005596516236200856781) D49 D50 ^ D51 +error(0.0002482138172298047193) D49 D50 ^ D51 ^ D39 +error(0.02841728360156799832) D49 D57 +error(0.005000000000000000104) D49 L0 +error(0.0003172016853723943911) D49 L0 ^ D37 L0 ^ D39 +error(0.0001443879881180337103) D49 L0 ^ D37 L0 ^ D47 +error(0.0009522959210919978426) D49 L0 ^ D47 ^ D39 +error(0.01390683885060832979) D50 +error(0.002839966817347003205) D50 D57 +error(0.002452829707374155899) D50 D57 ^ D47 +error(5.017905351258029412e-05) D50 D57 ^ D59 +error(0.000247197448812605026) D50 D57 ^ D59 ^ D47 +error(0.03308377666233706244) D50 D58 +error(0.001240860359178470266) D50 D58 ^ D47 +error(0.001267847074638612246) D50 D58 ^ D59 +error(0.0007930654563626337965) D50 ^ D38 ^ D40 +error(0.0006216937696868836578) D50 ^ D38 ^ D48 +error(0.00105034782662940477) D50 ^ D48 +error(0.01387042499099926628) D50 ^ D51 +error(0.002030247209399251192) D50 ^ D59 +error(0.002716163382992085266) D51 D59 ^ D50 +error(0.007476592050288623746) D51 +error(0.02358145705777341117) D51 D59 +error(0.005000000000000000104) D52 +error(0.01617546677095215574) D52 D55 +error(0.01731851949100582724) D52 D55 ^ D53 L0 +error(0.03112428738189396138) D52 D60 +error(0.007605025216541217749) D52 D60 ^ D61 L0 +error(0.006643555431332419207) D52 D63 +error(0.00548855459129347998) D52 D63 ^ D53 L0 +error(0.004567227145616721898) D52 D63 ^ D61 L0 +error(0.003742951627169742793) D52 D63 ^ D61 L0 ^ D53 L0 +error(0.003456310998655979291) D52 D64 +error(0.003000826243364488125) D52 D64 ^ D53 D61 +error(0.0005890454235397373081) D52 D64 ^ D53 L0 +error(0.001290843534788979879) D52 D64 ^ D61 L0 +error(0.005000000000000000104) D52 ^ D53 L0 +error(0.005707987121823666909) D53 D61 ^ D52 +error(0.007117789145043611036) D53 D54 +error(0.0003981641069784467224) D53 D54 ^ D52 +error(0.0006749249515757715532) D53 D54 ^ D55 D56 +error(0.0005854115742089824282) D53 D54 ^ D55 D64 +error(0.01572940291487995648) D53 D54 ^ D56 +error(0.004397392613002783918) D53 D54 ^ D56 D64 +error(0.003022161545861388847) D53 D54 ^ D64 +error(0.0007976554828116148854) D53 D54 ^ D64 ^ D52 +error(0.01903773737510880068) D53 D58 +error(0.01301249434610882334) D53 D58 ^ D55 D56 +error(0.04826434730096164361) D53 D61 +error(0.003492226532555762694) D53 D61 ^ D63 D64 +error(0.004281833446095727712) D53 D61 ^ D64 +error(0.001853717777424029184) D53 D65 +error(0.002239735122648714612) D53 D65 ^ D55 D63 +error(0.0005612582963805286523) D53 D65 ^ D55 D64 +error(0.0004718732734019518349) D53 D65 ^ D63 D64 +error(0.0007341237423978296721) D53 D66 +error(0.002133173335255453534) D53 D66 ^ D55 D56 +error(0.0009726170139540637636) D53 D66 ^ D55 D63 +error(0.00206566717432974398) D53 D66 ^ D55 D64 +error(0.001068042459342767331) D53 D66 ^ D56 D64 +error(0.002694857058884877598) D53 D66 ^ D63 D64 +error(0.01000000000000000021) D53 L0 +error(0.008201930780325385542) D55 D63 ^ D53 L0 +error(0.005000000000000000104) D54 +error(0.006560379797122610837) D54 D61 +error(0.0007020324885268809526) D54 D61 ^ D52 +error(0.005393121636168434624) D54 D61 ^ D64 +error(0.0009863076048298488174) D54 D61 ^ D64 ^ D52 +error(0.02610789530202516778) D54 D62 +error(0.0110360761531631997) D54 D62 ^ D64 +error(0.002317202595067395943) D54 D66 +error(0.0003447409802485930266) D54 D66 ^ D55 D56 +error(0.0001709763741474679285) D54 D66 ^ D55 D64 +error(0.001306588848621806961) D54 D66 ^ D56 D64 +error(0.01507726810564594642) D54 ^ D56 +error(0.002806344194443891656) D54 ^ D64 ^ D56 +error(0.01000000000000000021) D55 +error(0.01068880118510151696) D55 D56 +error(0.0002438620789212667019) D55 D56 ^ D45 L0 +error(0.0004998182877393524907) D55 D56 ^ D57 D58 +error(0.001701853247078384795) D55 D56 ^ D58 D66 +error(0.02682470001186230621) D55 D63 +error(0.003351280911503579096) D55 D63 ^ D65 D66 +error(0.002838809172954709012) D55 D64 +error(0.0001572061157912999277) D55 D64 ^ D65 D66 +error(0.001393373771917199916) D55 D67 +error(0.0001884956742699187113) D55 D67 ^ D58 +error(0.001372135424766430601) D55 D67 ^ D58 D66 +error(0.0001330399799575002629) D55 D67 ^ D66 +error(0.009014877420392431936) D55 ^ D57 L0 +error(0.003935801536233380672) D57 D65 ^ D55 +error(0.01000000000000000021) D56 +error(0.02220618885390944833) D56 D59 +error(0.02105436195791260401) D56 D59 ^ D58 +error(0.0322765734706866661) D56 D64 +error(0.001935169617909809946) D56 D64 ^ D66 +error(0.009555400251384538537) D56 D67 +error(0.002204480404501199878) D56 D67 ^ D58 +error(0.005169913064080980045) D56 D67 ^ D66 +error(0.0006564952203538394456) D56 D67 ^ D66 ^ D58 +error(0.008126478579574632558) D57 D58 +error(0.003396220450673128732) D57 D58 ^ D47 +error(0.01234356543519746566) D57 D58 ^ D55 +error(0.0005596516236200856781) D57 D58 ^ D59 +error(0.0002482138172298047193) D57 D58 ^ D59 ^ D47 +error(0.02841728360156799832) D57 D65 +error(0.005000000000000000104) D57 L0 +error(0.0003172016853723943911) D57 L0 ^ D45 L0 ^ D47 +error(0.0001443879881180337103) D57 L0 ^ D45 L0 ^ D55 +error(0.0009522959210919978426) D57 L0 ^ D55 ^ D47 +error(0.01390683885060832979) D58 +error(0.002839966817347003205) D58 D65 +error(0.002452829707374155899) D58 D65 ^ D55 +error(5.017905351258029412e-05) D58 D65 ^ D67 +error(0.000247197448812605026) D58 D65 ^ D67 ^ D55 +error(0.03308377666233706244) D58 D66 +error(0.001240860359178470266) D58 D66 ^ D55 +error(0.001267847074638612246) D58 D66 ^ D67 +error(0.0007930654563626337965) D58 ^ D46 ^ D48 +error(0.0006216937696868836578) D58 ^ D46 ^ D56 +error(0.00105034782662940477) D58 ^ D56 +error(0.01387042499099926628) D58 ^ D59 +error(0.002030247209399251192) D58 ^ D67 +error(0.002716163382992085266) D59 D67 ^ D58 +error(0.007476592050288623746) D59 +error(0.02358145705777341117) D59 D67 +error(0.005000000000000000104) D60 +error(0.01617546677095215574) D60 D63 +error(0.01731851949100582724) D60 D63 ^ D61 L0 +error(0.03112428738189396138) D60 D68 +error(0.007605025216541217749) D60 D68 ^ D69 L0 +error(0.006643555431332419207) D60 D71 +error(0.00548855459129347998) D60 D71 ^ D61 L0 +error(0.004567227145616721898) D60 D71 ^ D69 L0 +error(0.003742951627169742793) D60 D71 ^ D69 L0 ^ D61 L0 +error(0.003456310998655979291) D60 D72 +error(0.003000826243364488125) D60 D72 ^ D61 D69 +error(0.0005890454235397373081) D60 D72 ^ D61 L0 +error(0.001290843534788979879) D60 D72 ^ D69 L0 +error(0.005000000000000000104) D60 ^ D61 L0 +error(0.005707987121823666909) D61 D69 ^ D60 +error(0.007117789145043611036) D61 D62 +error(0.0003981641069784467224) D61 D62 ^ D60 +error(0.0006749249515757715532) D61 D62 ^ D63 D64 +error(0.0005854115742089824282) D61 D62 ^ D63 D72 +error(0.01572940291487995648) D61 D62 ^ D64 +error(0.004397392613002783918) D61 D62 ^ D64 D72 +error(0.003022161545861388847) D61 D62 ^ D72 +error(0.0007976554828116148854) D61 D62 ^ D72 ^ D60 +error(0.01903773737510880068) D61 D66 +error(0.01301249434610882334) D61 D66 ^ D63 D64 +error(0.04826434730096164361) D61 D69 +error(0.003492226532555762694) D61 D69 ^ D71 D72 +error(0.004281833446095727712) D61 D69 ^ D72 +error(0.001853717777424029184) D61 D73 +error(0.002239735122648714612) D61 D73 ^ D63 D71 +error(0.0005612582963805286523) D61 D73 ^ D63 D72 +error(0.0004718732734019518349) D61 D73 ^ D71 D72 +error(0.0007341237423978296721) D61 D74 +error(0.002133173335255453534) D61 D74 ^ D63 D64 +error(0.0009726170139540637636) D61 D74 ^ D63 D71 +error(0.00206566717432974398) D61 D74 ^ D63 D72 +error(0.001068042459342767331) D61 D74 ^ D64 D72 +error(0.002694857058884877598) D61 D74 ^ D71 D72 +error(0.01000000000000000021) D61 L0 +error(0.008201930780325385542) D63 D71 ^ D61 L0 +error(0.005000000000000000104) D62 +error(0.006560379797122610837) D62 D69 +error(0.0007020324885268809526) D62 D69 ^ D60 +error(0.005393121636168434624) D62 D69 ^ D72 +error(0.0009863076048298488174) D62 D69 ^ D72 ^ D60 +error(0.02610789530202516778) D62 D70 +error(0.0110360761531631997) D62 D70 ^ D72 +error(0.002317202595067395943) D62 D74 +error(0.0003447409802485930266) D62 D74 ^ D63 D64 +error(0.0001709763741474679285) D62 D74 ^ D63 D72 +error(0.001306588848621806961) D62 D74 ^ D64 D72 +error(0.01507726810564594642) D62 ^ D64 +error(0.002806344194443891656) D62 ^ D72 ^ D64 +error(0.01000000000000000021) D63 +error(0.01068880118510151696) D63 D64 +error(0.0002438620789212667019) D63 D64 ^ D53 L0 +error(0.0004998182877393524907) D63 D64 ^ D65 D66 +error(0.001701853247078384795) D63 D64 ^ D66 D74 +error(0.02682470001186230621) D63 D71 +error(0.003351280911503579096) D63 D71 ^ D73 D74 +error(0.002838809172954709012) D63 D72 +error(0.0001572061157912999277) D63 D72 ^ D73 D74 +error(0.001393373771917199916) D63 D75 +error(0.0001884956742699187113) D63 D75 ^ D66 +error(0.001372135424766430601) D63 D75 ^ D66 D74 +error(0.0001330399799575002629) D63 D75 ^ D74 +error(0.009014877420392431936) D63 ^ D65 L0 +error(0.003935801536233380672) D65 D73 ^ D63 +error(0.01000000000000000021) D64 +error(0.02220618885390944833) D64 D67 +error(0.02105436195791260401) D64 D67 ^ D66 +error(0.0322765734706866661) D64 D72 +error(0.001935169617909809946) D64 D72 ^ D74 +error(0.009555400251384538537) D64 D75 +error(0.002204480404501199878) D64 D75 ^ D66 +error(0.005169913064080980045) D64 D75 ^ D74 +error(0.0006564952203538394456) D64 D75 ^ D74 ^ D66 +error(0.008126478579574632558) D65 D66 +error(0.003396220450673128732) D65 D66 ^ D55 +error(0.01234356543519746566) D65 D66 ^ D63 +error(0.0005596516236200856781) D65 D66 ^ D67 +error(0.0002482138172298047193) D65 D66 ^ D67 ^ D55 +error(0.02841728360156799832) D65 D73 +error(0.005000000000000000104) D65 L0 +error(0.0003172016853723943911) D65 L0 ^ D53 L0 ^ D55 +error(0.0001443879881180337103) D65 L0 ^ D53 L0 ^ D63 +error(0.0009522959210919978426) D65 L0 ^ D63 ^ D55 +error(0.01390683885060832979) D66 +error(0.002839966817347003205) D66 D73 +error(0.002452829707374155899) D66 D73 ^ D63 +error(5.017905351258029412e-05) D66 D73 ^ D75 +error(0.000247197448812605026) D66 D73 ^ D75 ^ D63 +error(0.03308377666233706244) D66 D74 +error(0.001240860359178470266) D66 D74 ^ D63 +error(0.001267847074638612246) D66 D74 ^ D75 +error(0.0007930654563626337965) D66 ^ D54 ^ D56 +error(0.0006216937696868836578) D66 ^ D54 ^ D64 +error(0.00105034782662940477) D66 ^ D64 +error(0.01387042499099926628) D66 ^ D67 +error(0.002030247209399251192) D66 ^ D75 +error(0.002716163382992085266) D67 D75 ^ D66 +error(0.007476592050288623746) D67 +error(0.02358145705777341117) D67 D75 +error(0.005000000000000000104) D68 +error(0.01617546677095215574) D68 D71 +error(0.01731851949100582724) D68 D71 ^ D69 L0 +error(0.03112428738189396138) D68 D76 +error(0.007605025216541217749) D68 D76 ^ D77 L0 +error(0.006643555431332419207) D68 D79 +error(0.00548855459129347998) D68 D79 ^ D69 L0 +error(0.004567227145616721898) D68 D79 ^ D77 L0 +error(0.003742951627169742793) D68 D79 ^ D77 L0 ^ D69 L0 +error(0.003456310998655979291) D68 D80 +error(0.003000826243364488125) D68 D80 ^ D69 D77 +error(0.0005890454235397373081) D68 D80 ^ D69 L0 +error(0.001290843534788979879) D68 D80 ^ D77 L0 +error(0.005000000000000000104) D68 ^ D69 L0 +error(0.005707987121823666909) D69 D77 ^ D68 +error(0.007117789145043611036) D69 D70 +error(0.0003981641069784467224) D69 D70 ^ D68 +error(0.0006749249515757715532) D69 D70 ^ D71 D72 +error(0.0005854115742089824282) D69 D70 ^ D71 D80 +error(0.01572940291487995648) D69 D70 ^ D72 +error(0.004397392613002783918) D69 D70 ^ D72 D80 +error(0.003022161545861388847) D69 D70 ^ D80 +error(0.0007976554828116148854) D69 D70 ^ D80 ^ D68 +error(0.01903773737510880068) D69 D74 +error(0.01301249434610882334) D69 D74 ^ D71 D72 +error(0.04826434730096164361) D69 D77 +error(0.003492226532555762694) D69 D77 ^ D79 D80 +error(0.004281833446095727712) D69 D77 ^ D80 +error(0.001853717777424029184) D69 D81 +error(0.002239735122648714612) D69 D81 ^ D71 D79 +error(0.0005612582963805286523) D69 D81 ^ D71 D80 +error(0.0004718732734019518349) D69 D81 ^ D79 D80 +error(0.0007341237423978296721) D69 D82 +error(0.002133173335255453534) D69 D82 ^ D71 D72 +error(0.0009726170139540637636) D69 D82 ^ D71 D79 +error(0.00206566717432974398) D69 D82 ^ D71 D80 +error(0.001068042459342767331) D69 D82 ^ D72 D80 +error(0.002694857058884877598) D69 D82 ^ D79 D80 +error(0.01000000000000000021) D69 L0 +error(0.008201930780325385542) D71 D79 ^ D69 L0 +error(0.005000000000000000104) D70 +error(0.006560379797122610837) D70 D77 +error(0.0007020324885268809526) D70 D77 ^ D68 +error(0.005393121636168434624) D70 D77 ^ D80 +error(0.0009863076048298488174) D70 D77 ^ D80 ^ D68 +error(0.02610789530202516778) D70 D78 +error(0.0110360761531631997) D70 D78 ^ D80 +error(0.002317202595067395943) D70 D82 +error(0.0003447409802485930266) D70 D82 ^ D71 D72 +error(0.0001709763741474679285) D70 D82 ^ D71 D80 +error(0.001306588848621806961) D70 D82 ^ D72 D80 +error(0.01507726810564594642) D70 ^ D72 +error(0.002806344194443891656) D70 ^ D80 ^ D72 +error(0.01000000000000000021) D71 +error(0.01068880118510151696) D71 D72 +error(0.0002438620789212667019) D71 D72 ^ D61 L0 +error(0.0004998182877393524907) D71 D72 ^ D73 D74 +error(0.001701853247078384795) D71 D72 ^ D74 D82 +error(0.02682470001186230621) D71 D79 +error(0.003351280911503579096) D71 D79 ^ D81 D82 +error(0.002838809172954709012) D71 D80 +error(0.0001572061157912999277) D71 D80 ^ D81 D82 +error(0.001393373771917199916) D71 D83 +error(0.0001884956742699187113) D71 D83 ^ D74 +error(0.001372135424766430601) D71 D83 ^ D74 D82 +error(0.0001330399799575002629) D71 D83 ^ D82 +error(0.009014877420392431936) D71 ^ D73 L0 +error(0.003935801536233380672) D73 D81 ^ D71 +error(0.01000000000000000021) D72 +error(0.02220618885390944833) D72 D75 +error(0.02105436195791260401) D72 D75 ^ D74 +error(0.0322765734706866661) D72 D80 +error(0.001935169617909809946) D72 D80 ^ D82 +error(0.009555400251384538537) D72 D83 +error(0.002204480404501199878) D72 D83 ^ D74 +error(0.005169913064080980045) D72 D83 ^ D82 +error(0.0006564952203538394456) D72 D83 ^ D82 ^ D74 +error(0.008126478579574632558) D73 D74 +error(0.003396220450673128732) D73 D74 ^ D63 +error(0.01234356543519746566) D73 D74 ^ D71 +error(0.0005596516236200856781) D73 D74 ^ D75 +error(0.0002482138172298047193) D73 D74 ^ D75 ^ D63 +error(0.02841728360156799832) D73 D81 +error(0.005000000000000000104) D73 L0 +error(0.0003172016853723943911) D73 L0 ^ D61 L0 ^ D63 +error(0.0001443879881180337103) D73 L0 ^ D61 L0 ^ D71 +error(0.0009522959210919978426) D73 L0 ^ D71 ^ D63 +error(0.01390683885060832979) D74 +error(0.002839966817347003205) D74 D81 +error(0.002452829707374155899) D74 D81 ^ D71 +error(5.017905351258029412e-05) D74 D81 ^ D83 +error(0.000247197448812605026) D74 D81 ^ D83 ^ D71 +error(0.03308377666233706244) D74 D82 +error(0.001240860359178470266) D74 D82 ^ D71 +error(0.001267847074638612246) D74 D82 ^ D83 +error(0.0007930654563626337965) D74 ^ D62 ^ D64 +error(0.0006216937696868836578) D74 ^ D62 ^ D72 +error(0.00105034782662940477) D74 ^ D72 +error(0.01387042499099926628) D74 ^ D75 +error(0.002030247209399251192) D74 ^ D83 +error(0.002716163382992085266) D75 D83 ^ D74 +error(0.007476592050288623746) D75 +error(0.02358145705777341117) D75 D83 +error(0.005000000000000000104) D76 +error(0.01617546677095215574) D76 D79 +error(0.01731851949100582724) D76 D79 ^ D77 L0 +error(0.03112428738189396138) D76 D84 +error(0.007605025216541217749) D76 D84 ^ D85 L0 +error(0.006643555431332419207) D76 D87 +error(0.00548855459129347998) D76 D87 ^ D77 L0 +error(0.004567227145616721898) D76 D87 ^ D85 L0 +error(0.003742951627169742793) D76 D87 ^ D85 L0 ^ D77 L0 +error(0.003456310998655979291) D76 D88 +error(0.003000826243364488125) D76 D88 ^ D77 D85 +error(0.0005890454235397373081) D76 D88 ^ D77 L0 +error(0.001290843534788979879) D76 D88 ^ D85 L0 +error(0.005000000000000000104) D76 ^ D77 L0 +error(0.005707987121823666909) D77 D85 ^ D76 +error(0.007117789145043611036) D77 D78 +error(0.0003981641069784467224) D77 D78 ^ D76 +error(0.0006749249515757715532) D77 D78 ^ D79 D80 +error(0.0005854115742089824282) D77 D78 ^ D79 D88 +error(0.01572940291487995648) D77 D78 ^ D80 +error(0.004397392613002783918) D77 D78 ^ D80 D88 +error(0.003022161545861388847) D77 D78 ^ D88 +error(0.0007976554828116148854) D77 D78 ^ D88 ^ D76 +error(0.01903773737510880068) D77 D82 +error(0.01301249434610882334) D77 D82 ^ D79 D80 +error(0.04826434730096164361) D77 D85 +error(0.003492226532555762694) D77 D85 ^ D87 D88 +error(0.004281833446095727712) D77 D85 ^ D88 +error(0.001853717777424029184) D77 D89 +error(0.002239735122648714612) D77 D89 ^ D79 D87 +error(0.0005612582963805286523) D77 D89 ^ D79 D88 +error(0.0004718732734019518349) D77 D89 ^ D87 D88 +error(0.0007341237423978296721) D77 D90 +error(0.002133173335255453534) D77 D90 ^ D79 D80 +error(0.0009726170139540637636) D77 D90 ^ D79 D87 +error(0.00206566717432974398) D77 D90 ^ D79 D88 +error(0.001068042459342767331) D77 D90 ^ D80 D88 +error(0.002694857058884877598) D77 D90 ^ D87 D88 +error(0.01000000000000000021) D77 L0 +error(0.008201930780325385542) D79 D87 ^ D77 L0 +error(0.005000000000000000104) D78 +error(0.006560379797122610837) D78 D85 +error(0.0007020324885268809526) D78 D85 ^ D76 +error(0.005393121636168434624) D78 D85 ^ D88 +error(0.0009863076048298488174) D78 D85 ^ D88 ^ D76 +error(0.02610789530202516778) D78 D86 +error(0.0110360761531631997) D78 D86 ^ D88 +error(0.002317202595067395943) D78 D90 +error(0.0003447409802485930266) D78 D90 ^ D79 D80 +error(0.0001709763741474679285) D78 D90 ^ D79 D88 +error(0.001306588848621806961) D78 D90 ^ D80 D88 +error(0.01507726810564594642) D78 ^ D80 +error(0.002806344194443891656) D78 ^ D88 ^ D80 +error(0.01000000000000000021) D79 +error(0.01068880118510151696) D79 D80 +error(0.0002438620789212667019) D79 D80 ^ D69 L0 +error(0.0004998182877393524907) D79 D80 ^ D81 D82 +error(0.001701853247078384795) D79 D80 ^ D82 D90 +error(0.02682470001186230621) D79 D87 +error(0.003351280911503579096) D79 D87 ^ D89 D90 +error(0.002838809172954709012) D79 D88 +error(0.0001572061157912999277) D79 D88 ^ D89 D90 +error(0.001393373771917199916) D79 D91 +error(0.0001884956742699187113) D79 D91 ^ D82 +error(0.001372135424766430601) D79 D91 ^ D82 D90 +error(0.0001330399799575002629) D79 D91 ^ D90 +error(0.009014877420392431936) D79 ^ D81 L0 +error(0.003935801536233380672) D81 D89 ^ D79 +error(0.01000000000000000021) D80 +error(0.02220618885390944833) D80 D83 +error(0.02105436195791260401) D80 D83 ^ D82 +error(0.0322765734706866661) D80 D88 +error(0.001935169617909809946) D80 D88 ^ D90 +error(0.009555400251384538537) D80 D91 +error(0.002204480404501199878) D80 D91 ^ D82 +error(0.005169913064080980045) D80 D91 ^ D90 +error(0.0006564952203538394456) D80 D91 ^ D90 ^ D82 +error(0.008126478579574632558) D81 D82 +error(0.003396220450673128732) D81 D82 ^ D71 +error(0.01234356543519746566) D81 D82 ^ D79 +error(0.0005596516236200856781) D81 D82 ^ D83 +error(0.0002482138172298047193) D81 D82 ^ D83 ^ D71 +error(0.02841728360156799832) D81 D89 +error(0.005000000000000000104) D81 L0 +error(0.0003172016853723943911) D81 L0 ^ D69 L0 ^ D71 +error(0.0001443879881180337103) D81 L0 ^ D69 L0 ^ D79 +error(0.0009522959210919978426) D81 L0 ^ D79 ^ D71 +error(0.01390683885060832979) D82 +error(0.002839966817347003205) D82 D89 +error(0.002452829707374155899) D82 D89 ^ D79 +error(5.017905351258029412e-05) D82 D89 ^ D91 +error(0.000247197448812605026) D82 D89 ^ D91 ^ D79 +error(0.03308377666233706244) D82 D90 +error(0.001240860359178470266) D82 D90 ^ D79 +error(0.001267847074638612246) D82 D90 ^ D91 +error(0.0007930654563626337965) D82 ^ D70 ^ D72 +error(0.0006216937696868836578) D82 ^ D70 ^ D80 +error(0.00105034782662940477) D82 ^ D80 +error(0.01387042499099926628) D82 ^ D83 +error(0.002030247209399251192) D82 ^ D91 +error(0.002716163382992085266) D83 D91 ^ D82 +error(0.007476592050288623746) D83 +error(0.02358145705777341117) D83 D91 +error(0.005000000000000000104) D84 +error(0.01617546677095215574) D84 D87 +error(0.01731851949100582724) D84 D87 ^ D85 L0 +error(0.03112428738189396138) D84 D92 +error(0.007605025216541217749) D84 D92 ^ D93 L0 +error(0.006643555431332419207) D84 D95 +error(0.00548855459129347998) D84 D95 ^ D85 L0 +error(0.004567227145616721898) D84 D95 ^ D93 L0 +error(0.003742951627169742793) D84 D95 ^ D93 L0 ^ D85 L0 +error(0.003456310998655979291) D84 D96 +error(0.003000826243364488125) D84 D96 ^ D85 D93 +error(0.0005890454235397373081) D84 D96 ^ D85 L0 +error(0.001290843534788979879) D84 D96 ^ D93 L0 +error(0.005000000000000000104) D84 ^ D85 L0 +error(0.005707987121823666909) D85 D93 ^ D84 +error(0.007117789145043611036) D85 D86 +error(0.0003981641069784467224) D85 D86 ^ D84 +error(0.0006749249515757715532) D85 D86 ^ D87 D88 +error(0.0005854115742089824282) D85 D86 ^ D87 D96 +error(0.01572940291487995648) D85 D86 ^ D88 +error(0.004397392613002783918) D85 D86 ^ D88 D96 +error(0.003022161545861388847) D85 D86 ^ D96 +error(0.0007976554828116148854) D85 D86 ^ D96 ^ D84 +error(0.01903773737510880068) D85 D90 +error(0.01301249434610882334) D85 D90 ^ D87 D88 +error(0.04826434730096164361) D85 D93 +error(0.003492226532555762694) D85 D93 ^ D95 D96 +error(0.004281833446095727712) D85 D93 ^ D96 +error(0.001853717777424029184) D85 D97 +error(0.002239735122648714612) D85 D97 ^ D87 D95 +error(0.0005612582963805286523) D85 D97 ^ D87 D96 +error(0.0004718732734019518349) D85 D97 ^ D95 D96 +error(0.0007341237423978296721) D85 D98 +error(0.002133173335255453534) D85 D98 ^ D87 D88 +error(0.0009726170139540637636) D85 D98 ^ D87 D95 +error(0.00206566717432974398) D85 D98 ^ D87 D96 +error(0.001068042459342767331) D85 D98 ^ D88 D96 +error(0.002694857058884877598) D85 D98 ^ D95 D96 +error(0.01000000000000000021) D85 L0 +error(0.008201930780325385542) D87 D95 ^ D85 L0 +error(0.005000000000000000104) D86 +error(0.006560379797122610837) D86 D93 +error(0.0007020324885268809526) D86 D93 ^ D84 +error(0.005393121636168434624) D86 D93 ^ D96 +error(0.0009863076048298488174) D86 D93 ^ D96 ^ D84 +error(0.02610789530202516778) D86 D94 +error(0.0110360761531631997) D86 D94 ^ D96 +error(0.002317202595067395943) D86 D98 +error(0.0003447409802485930266) D86 D98 ^ D87 D88 +error(0.0001709763741474679285) D86 D98 ^ D87 D96 +error(0.001306588848621806961) D86 D98 ^ D88 D96 +error(0.01507726810564594642) D86 ^ D88 +error(0.002806344194443891656) D86 ^ D96 ^ D88 +error(0.01000000000000000021) D87 +error(0.01068880118510151696) D87 D88 +error(0.0002438620789212667019) D87 D88 ^ D77 L0 +error(0.0004998182877393524907) D87 D88 ^ D89 D90 +error(0.001701853247078384795) D87 D88 ^ D90 D98 +error(0.02682470001186230621) D87 D95 +error(0.003351280911503579096) D87 D95 ^ D97 D98 +error(0.002838809172954709012) D87 D96 +error(0.0001572061157912999277) D87 D96 ^ D97 D98 +error(0.001393373771917199916) D87 D99 +error(0.0001884956742699187113) D87 D99 ^ D90 +error(0.001372135424766430601) D87 D99 ^ D90 D98 +error(0.0001330399799575002629) D87 D99 ^ D98 +error(0.009014877420392431936) D87 ^ D89 L0 +error(0.003935801536233380672) D89 D97 ^ D87 +error(0.01000000000000000021) D88 +error(0.02220618885390944833) D88 D91 +error(0.02105436195791260401) D88 D91 ^ D90 +error(0.0322765734706866661) D88 D96 +error(0.001935169617909809946) D88 D96 ^ D98 +error(0.009555400251384538537) D88 D99 +error(0.002204480404501199878) D88 D99 ^ D90 +error(0.005169913064080980045) D88 D99 ^ D98 +error(0.0006564952203538394456) D88 D99 ^ D98 ^ D90 +error(0.008126478579574632558) D89 D90 +error(0.003396220450673128732) D89 D90 ^ D79 +error(0.01234356543519746566) D89 D90 ^ D87 +error(0.0005596516236200856781) D89 D90 ^ D91 +error(0.0002482138172298047193) D89 D90 ^ D91 ^ D79 +error(0.02841728360156799832) D89 D97 +error(0.005000000000000000104) D89 L0 +error(0.0003172016853723943911) D89 L0 ^ D77 L0 ^ D79 +error(0.0001443879881180337103) D89 L0 ^ D77 L0 ^ D87 +error(0.0009522959210919978426) D89 L0 ^ D87 ^ D79 +error(0.01390683885060832979) D90 +error(0.002839966817347003205) D90 D97 +error(0.002452829707374155899) D90 D97 ^ D87 +error(5.017905351258029412e-05) D90 D97 ^ D99 +error(0.000247197448812605026) D90 D97 ^ D99 ^ D87 +error(0.03308377666233706244) D90 D98 +error(0.001240860359178470266) D90 D98 ^ D87 +error(0.001267847074638612246) D90 D98 ^ D99 +error(0.0007930654563626337965) D90 ^ D78 ^ D80 +error(0.0006216937696868836578) D90 ^ D78 ^ D88 +error(0.00105034782662940477) D90 ^ D88 +error(0.01387042499099926628) D90 ^ D91 +error(0.002030247209399251192) D90 ^ D99 +error(0.002716163382992085266) D91 D99 ^ D90 +error(0.007476592050288623746) D91 +error(0.02358145705777341117) D91 D99 +error(0.005000000000000000104) D92 +error(0.01617546677095215574) D92 D95 +error(0.01731851949100582724) D92 D95 ^ D93 L0 +error(0.03112428738189396138) D92 D100 +error(0.007605025216541217749) D92 D100 ^ D101 L0 +error(0.006643555431332419207) D92 D103 +error(0.00548855459129347998) D92 D103 ^ D93 L0 +error(0.004567227145616721898) D92 D103 ^ D101 L0 +error(0.003742951627169742793) D92 D103 ^ D101 L0 ^ D93 L0 +error(0.003456310998655979291) D92 D104 +error(0.003000826243364488125) D92 D104 ^ D93 D101 +error(0.0005890454235397373081) D92 D104 ^ D93 L0 +error(0.001290843534788979879) D92 D104 ^ D101 L0 +error(0.005000000000000000104) D92 ^ D93 L0 +error(0.005707987121823666909) D93 D101 ^ D92 +error(0.007117789145043611036) D93 D94 +error(0.0003981641069784467224) D93 D94 ^ D92 +error(0.0006749249515757715532) D93 D94 ^ D95 D96 +error(0.0005854115742089824282) D93 D94 ^ D95 D104 +error(0.01572940291487995648) D93 D94 ^ D96 +error(0.004397392613002783918) D93 D94 ^ D96 D104 +error(0.003022161545861388847) D93 D94 ^ D104 +error(0.0007976554828116148854) D93 D94 ^ D104 ^ D92 +error(0.01903773737510880068) D93 D98 +error(0.01301249434610882334) D93 D98 ^ D95 D96 +error(0.04826434730096164361) D93 D101 +error(0.003492226532555762694) D93 D101 ^ D103 D104 +error(0.004281833446095727712) D93 D101 ^ D104 +error(0.001853717777424029184) D93 D105 +error(0.002239735122648714612) D93 D105 ^ D95 D103 +error(0.0005612582963805286523) D93 D105 ^ D95 D104 +error(0.0004718732734019518349) D93 D105 ^ D103 D104 +error(0.0007341237423978296721) D93 D106 +error(0.002133173335255453534) D93 D106 ^ D95 D96 +error(0.0009726170139540637636) D93 D106 ^ D95 D103 +error(0.00206566717432974398) D93 D106 ^ D95 D104 +error(0.001068042459342767331) D93 D106 ^ D96 D104 +error(0.002694857058884877598) D93 D106 ^ D103 D104 +error(0.01000000000000000021) D93 L0 +error(0.008201930780325385542) D95 D103 ^ D93 L0 +error(0.005000000000000000104) D94 +error(0.006560379797122610837) D94 D101 +error(0.0007020324885268809526) D94 D101 ^ D92 +error(0.005393121636168434624) D94 D101 ^ D104 +error(0.0009863076048298488174) D94 D101 ^ D104 ^ D92 +error(0.02610789530202516778) D94 D102 +error(0.0110360761531631997) D94 D102 ^ D104 +error(0.002317202595067395943) D94 D106 +error(0.0003447409802485930266) D94 D106 ^ D95 D96 +error(0.0001709763741474679285) D94 D106 ^ D95 D104 +error(0.001306588848621806961) D94 D106 ^ D96 D104 +error(0.01507726810564594642) D94 ^ D96 +error(0.002806344194443891656) D94 ^ D104 ^ D96 +error(0.01000000000000000021) D95 +error(0.01068880118510151696) D95 D96 +error(0.0002438620789212667019) D95 D96 ^ D85 L0 +error(0.0004998182877393524907) D95 D96 ^ D97 D98 +error(0.001701853247078384795) D95 D96 ^ D98 D106 +error(0.02682470001186230621) D95 D103 +error(0.003351280911503579096) D95 D103 ^ D105 D106 +error(0.002838809172954709012) D95 D104 +error(0.0001572061157912999277) D95 D104 ^ D105 D106 +error(0.001393373771917199916) D95 D107 +error(0.0001884956742699187113) D95 D107 ^ D98 +error(0.001372135424766430601) D95 D107 ^ D98 D106 +error(0.0001330399799575002629) D95 D107 ^ D106 +error(0.009014877420392431936) D95 ^ D97 L0 +error(0.003935801536233380672) D97 D105 ^ D95 +error(0.01000000000000000021) D96 +error(0.02220618885390944833) D96 D99 +error(0.02105436195791260401) D96 D99 ^ D98 +error(0.0322765734706866661) D96 D104 +error(0.001935169617909809946) D96 D104 ^ D106 +error(0.009555400251384538537) D96 D107 +error(0.002204480404501199878) D96 D107 ^ D98 +error(0.005169913064080980045) D96 D107 ^ D106 +error(0.0006564952203538394456) D96 D107 ^ D106 ^ D98 +error(0.008126478579574632558) D97 D98 +error(0.003396220450673128732) D97 D98 ^ D87 +error(0.01234356543519746566) D97 D98 ^ D95 +error(0.0005596516236200856781) D97 D98 ^ D99 +error(0.0002482138172298047193) D97 D98 ^ D99 ^ D87 +error(0.02841728360156799832) D97 D105 +error(0.005000000000000000104) D97 L0 +error(0.0003172016853723943911) D97 L0 ^ D85 L0 ^ D87 +error(0.0001443879881180337103) D97 L0 ^ D85 L0 ^ D95 +error(0.0009522959210919978426) D97 L0 ^ D95 ^ D87 +error(0.01390683885060832979) D98 +error(0.002839966817347003205) D98 D105 +error(0.002452829707374155899) D98 D105 ^ D95 +error(5.017905351258029412e-05) D98 D105 ^ D107 +error(0.000247197448812605026) D98 D105 ^ D107 ^ D95 +error(0.03308377666233706244) D98 D106 +error(0.001240860359178470266) D98 D106 ^ D95 +error(0.001267847074638612246) D98 D106 ^ D107 +error(0.0007930654563626337965) D98 ^ D86 ^ D88 +error(0.0006216937696868836578) D98 ^ D86 ^ D96 +error(0.00105034782662940477) D98 ^ D96 +error(0.01387042499099926628) D98 ^ D99 +error(0.002030247209399251192) D98 ^ D107 +error(0.002716163382992085266) D99 D107 ^ D98 +error(0.007476592050288623746) D99 +error(0.02358145705777341117) D99 D107 +error(0.005000000000000000104) D100 +error(0.01617546677095215574) D100 D103 +error(0.01731851949100582724) D100 D103 ^ D101 L0 +error(0.03112428738189396138) D100 D108 +error(0.007605025216541217749) D100 D108 ^ D109 L0 +error(0.006643555431332419207) D100 D111 +error(0.00548855459129347998) D100 D111 ^ D101 L0 +error(0.004567227145616721898) D100 D111 ^ D109 L0 +error(0.003742951627169742793) D100 D111 ^ D109 L0 ^ D101 L0 +error(0.003456310998655979291) D100 D112 +error(0.003000826243364488125) D100 D112 ^ D101 D109 +error(0.0005890454235397373081) D100 D112 ^ D101 L0 +error(0.001290843534788979879) D100 D112 ^ D109 L0 +error(0.005000000000000000104) D100 ^ D101 L0 +error(0.005707987121823666909) D101 D109 ^ D100 +error(0.007117789145043611036) D101 D102 +error(0.0003981641069784467224) D101 D102 ^ D100 +error(0.0006749249515757715532) D101 D102 ^ D103 D104 +error(0.0005854115742089824282) D101 D102 ^ D103 D112 +error(0.01572940291487995648) D101 D102 ^ D104 +error(0.004397392613002783918) D101 D102 ^ D104 D112 +error(0.003022161545861388847) D101 D102 ^ D112 +error(0.0007976554828116148854) D101 D102 ^ D112 ^ D100 +error(0.01903773737510880068) D101 D106 +error(0.01301249434610882334) D101 D106 ^ D103 D104 +error(0.04826434730096164361) D101 D109 +error(0.003492226532555762694) D101 D109 ^ D111 D112 +error(0.004281833446095727712) D101 D109 ^ D112 +error(0.001853717777424029184) D101 D113 +error(0.002239735122648714612) D101 D113 ^ D103 D111 +error(0.0005612582963805286523) D101 D113 ^ D103 D112 +error(0.0004718732734019518349) D101 D113 ^ D111 D112 +error(0.0007341237423978296721) D101 D114 +error(0.002133173335255453534) D101 D114 ^ D103 D104 +error(0.0009726170139540637636) D101 D114 ^ D103 D111 +error(0.00206566717432974398) D101 D114 ^ D103 D112 +error(0.001068042459342767331) D101 D114 ^ D104 D112 +error(0.002694857058884877598) D101 D114 ^ D111 D112 +error(0.01000000000000000021) D101 L0 +error(0.008201930780325385542) D103 D111 ^ D101 L0 +error(0.005000000000000000104) D102 +error(0.006560379797122610837) D102 D109 +error(0.0007020324885268809526) D102 D109 ^ D100 +error(0.005393121636168434624) D102 D109 ^ D112 +error(0.0009863076048298488174) D102 D109 ^ D112 ^ D100 +error(0.02610789530202516778) D102 D110 +error(0.0110360761531631997) D102 D110 ^ D112 +error(0.002317202595067395943) D102 D114 +error(0.0003447409802485930266) D102 D114 ^ D103 D104 +error(0.0001709763741474679285) D102 D114 ^ D103 D112 +error(0.001306588848621806961) D102 D114 ^ D104 D112 +error(0.01507726810564594642) D102 ^ D104 +error(0.002806344194443891656) D102 ^ D112 ^ D104 +error(0.01000000000000000021) D103 +error(0.01068880118510151696) D103 D104 +error(0.0002438620789212667019) D103 D104 ^ D93 L0 +error(0.0004998182877393524907) D103 D104 ^ D105 D106 +error(0.001701853247078384795) D103 D104 ^ D106 D114 +error(0.02682470001186230621) D103 D111 +error(0.003351280911503579096) D103 D111 ^ D113 D114 +error(0.002838809172954709012) D103 D112 +error(0.0001572061157912999277) D103 D112 ^ D113 D114 +error(0.001393373771917199916) D103 D115 +error(0.0001884956742699187113) D103 D115 ^ D106 +error(0.001372135424766430601) D103 D115 ^ D106 D114 +error(0.0001330399799575002629) D103 D115 ^ D114 +error(0.009014877420392431936) D103 ^ D105 L0 +error(0.003935801536233380672) D105 D113 ^ D103 +error(0.01000000000000000021) D104 +error(0.02220618885390944833) D104 D107 +error(0.02105436195791260401) D104 D107 ^ D106 +error(0.0322765734706866661) D104 D112 +error(0.001935169617909809946) D104 D112 ^ D114 +error(0.009555400251384538537) D104 D115 +error(0.002204480404501199878) D104 D115 ^ D106 +error(0.005169913064080980045) D104 D115 ^ D114 +error(0.0006564952203538394456) D104 D115 ^ D114 ^ D106 +error(0.008126478579574632558) D105 D106 +error(0.003396220450673128732) D105 D106 ^ D95 +error(0.01234356543519746566) D105 D106 ^ D103 +error(0.0005596516236200856781) D105 D106 ^ D107 +error(0.0002482138172298047193) D105 D106 ^ D107 ^ D95 +error(0.02841728360156799832) D105 D113 +error(0.005000000000000000104) D105 L0 +error(0.0003172016853723943911) D105 L0 ^ D93 L0 ^ D95 +error(0.0001443879881180337103) D105 L0 ^ D93 L0 ^ D103 +error(0.0009522959210919978426) D105 L0 ^ D103 ^ D95 +error(0.01390683885060832979) D106 +error(0.002839966817347003205) D106 D113 +error(0.002452829707374155899) D106 D113 ^ D103 +error(5.017905351258029412e-05) D106 D113 ^ D115 +error(0.000247197448812605026) D106 D113 ^ D115 ^ D103 +error(0.03308377666233706244) D106 D114 +error(0.001240860359178470266) D106 D114 ^ D103 +error(0.001267847074638612246) D106 D114 ^ D115 +error(0.0007930654563626337965) D106 ^ D94 ^ D96 +error(0.0006216937696868836578) D106 ^ D94 ^ D104 +error(0.00105034782662940477) D106 ^ D104 +error(0.01387042499099926628) D106 ^ D107 +error(0.002030247209399251192) D106 ^ D115 +error(0.002716163382992085266) D107 D115 ^ D106 +error(0.007476592050288623746) D107 +error(0.02358145705777341117) D107 D115 +error(0.005000000000000000104) D108 +error(0.01617546677095215574) D108 D111 +error(0.01731851949100582724) D108 D111 ^ D109 L0 +error(0.03112428738189396138) D108 D116 +error(0.007605025216541217749) D108 D116 ^ D117 L0 +error(0.006643555431332419207) D108 D119 +error(0.00548855459129347998) D108 D119 ^ D109 L0 +error(0.004567227145616721898) D108 D119 ^ D117 L0 +error(0.003742951627169742793) D108 D119 ^ D117 L0 ^ D109 L0 +error(0.003456310998655979291) D108 D120 +error(0.003000826243364488125) D108 D120 ^ D109 D117 +error(0.0005890454235397373081) D108 D120 ^ D109 L0 +error(0.001290843534788979879) D108 D120 ^ D117 L0 +error(0.005000000000000000104) D108 ^ D109 L0 +error(0.005707987121823666909) D109 D117 ^ D108 +error(0.007117789145043611036) D109 D110 +error(0.0003981641069784467224) D109 D110 ^ D108 +error(0.0006749249515757715532) D109 D110 ^ D111 D112 +error(0.0005854115742089824282) D109 D110 ^ D111 D120 +error(0.01572940291487995648) D109 D110 ^ D112 +error(0.004397392613002783918) D109 D110 ^ D112 D120 +error(0.003022161545861388847) D109 D110 ^ D120 +error(0.0007976554828116148854) D109 D110 ^ D120 ^ D108 +error(0.01903773737510880068) D109 D114 +error(0.01301249434610882334) D109 D114 ^ D111 D112 +error(0.04826434730096164361) D109 D117 +error(0.003492226532555762694) D109 D117 ^ D119 D120 +error(0.004281833446095727712) D109 D117 ^ D120 +error(0.001853717777424029184) D109 D121 +error(0.002239735122648714612) D109 D121 ^ D111 D119 +error(0.0005612582963805286523) D109 D121 ^ D111 D120 +error(0.0004718732734019518349) D109 D121 ^ D119 D120 +error(0.0007341237423978296721) D109 D122 +error(0.002133173335255453534) D109 D122 ^ D111 D112 +error(0.0009726170139540637636) D109 D122 ^ D111 D119 +error(0.00206566717432974398) D109 D122 ^ D111 D120 +error(0.001068042459342767331) D109 D122 ^ D112 D120 +error(0.002694857058884877598) D109 D122 ^ D119 D120 +error(0.01000000000000000021) D109 L0 +error(0.008201930780325385542) D111 D119 ^ D109 L0 +error(0.005000000000000000104) D110 +error(0.006560379797122610837) D110 D117 +error(0.0007020324885268809526) D110 D117 ^ D108 +error(0.005393121636168434624) D110 D117 ^ D120 +error(0.0009863076048298488174) D110 D117 ^ D120 ^ D108 +error(0.02610789530202516778) D110 D118 +error(0.0110360761531631997) D110 D118 ^ D120 +error(0.002317202595067395943) D110 D122 +error(0.0003447409802485930266) D110 D122 ^ D111 D112 +error(0.0001709763741474679285) D110 D122 ^ D111 D120 +error(0.001306588848621806961) D110 D122 ^ D112 D120 +error(0.01507726810564594642) D110 ^ D112 +error(0.002806344194443891656) D110 ^ D120 ^ D112 +error(0.01000000000000000021) D111 +error(0.01068880118510151696) D111 D112 +error(0.0002438620789212667019) D111 D112 ^ D101 L0 +error(0.0004998182877393524907) D111 D112 ^ D113 D114 +error(0.001701853247078384795) D111 D112 ^ D114 D122 +error(0.02682470001186230621) D111 D119 +error(0.003351280911503579096) D111 D119 ^ D121 D122 +error(0.002838809172954709012) D111 D120 +error(0.0001572061157912999277) D111 D120 ^ D121 D122 +error(0.001393373771917199916) D111 D123 +error(0.0001884956742699187113) D111 D123 ^ D114 +error(0.001372135424766430601) D111 D123 ^ D114 D122 +error(0.0001330399799575002629) D111 D123 ^ D122 +error(0.009014877420392431936) D111 ^ D113 L0 +error(0.003935801536233380672) D113 D121 ^ D111 +error(0.01000000000000000021) D112 +error(0.02220618885390944833) D112 D115 +error(0.02105436195791260401) D112 D115 ^ D114 +error(0.0322765734706866661) D112 D120 +error(0.001935169617909809946) D112 D120 ^ D122 +error(0.009555400251384538537) D112 D123 +error(0.002204480404501199878) D112 D123 ^ D114 +error(0.005169913064080980045) D112 D123 ^ D122 +error(0.0006564952203538394456) D112 D123 ^ D122 ^ D114 +error(0.008126478579574632558) D113 D114 +error(0.003396220450673128732) D113 D114 ^ D103 +error(0.01234356543519746566) D113 D114 ^ D111 +error(0.0005596516236200856781) D113 D114 ^ D115 +error(0.0002482138172298047193) D113 D114 ^ D115 ^ D103 +error(0.02841728360156799832) D113 D121 +error(0.005000000000000000104) D113 L0 +error(0.0003172016853723943911) D113 L0 ^ D101 L0 ^ D103 +error(0.0001443879881180337103) D113 L0 ^ D101 L0 ^ D111 +error(0.0009522959210919978426) D113 L0 ^ D111 ^ D103 +error(0.01390683885060832979) D114 +error(0.002839966817347003205) D114 D121 +error(0.002452829707374155899) D114 D121 ^ D111 +error(5.017905351258029412e-05) D114 D121 ^ D123 +error(0.000247197448812605026) D114 D121 ^ D123 ^ D111 +error(0.03308377666233706244) D114 D122 +error(0.001240860359178470266) D114 D122 ^ D111 +error(0.001267847074638612246) D114 D122 ^ D123 +error(0.0007930654563626337965) D114 ^ D102 ^ D104 +error(0.0006216937696868836578) D114 ^ D102 ^ D112 +error(0.00105034782662940477) D114 ^ D112 +error(0.01387042499099926628) D114 ^ D115 +error(0.002030247209399251192) D114 ^ D123 +error(0.002716163382992085266) D115 D123 ^ D114 +error(0.007476592050288623746) D115 +error(0.02358145705777341117) D115 D123 +error(0.005000000000000000104) D116 +error(0.01617546677095215574) D116 D119 +error(0.01731851949100582724) D116 D119 ^ D117 L0 +error(0.03112428738189396138) D116 D124 +error(0.007605025216541217749) D116 D124 ^ D125 L0 +error(0.006643555431332419207) D116 D127 +error(0.00548855459129347998) D116 D127 ^ D117 L0 +error(0.004567227145616721898) D116 D127 ^ D125 L0 +error(0.003742951627169742793) D116 D127 ^ D125 L0 ^ D117 L0 +error(0.003456310998655979291) D116 D128 +error(0.003000826243364488125) D116 D128 ^ D117 D125 +error(0.0005890454235397373081) D116 D128 ^ D117 L0 +error(0.001290843534788979879) D116 D128 ^ D125 L0 +error(0.005000000000000000104) D116 ^ D117 L0 +error(0.005707987121823666909) D117 D125 ^ D116 +error(0.007117789145043611036) D117 D118 +error(0.0003981641069784467224) D117 D118 ^ D116 +error(0.0006749249515757715532) D117 D118 ^ D119 D120 +error(0.0005854115742089824282) D117 D118 ^ D119 D128 +error(0.01572940291487995648) D117 D118 ^ D120 +error(0.004397392613002783918) D117 D118 ^ D120 D128 +error(0.003022161545861388847) D117 D118 ^ D128 +error(0.0007976554828116148854) D117 D118 ^ D128 ^ D116 +error(0.01903773737510880068) D117 D122 +error(0.01301249434610882334) D117 D122 ^ D119 D120 +error(0.04826434730096164361) D117 D125 +error(0.003492226532555762694) D117 D125 ^ D127 D128 +error(0.004281833446095727712) D117 D125 ^ D128 +error(0.001853717777424029184) D117 D129 +error(0.002239735122648714612) D117 D129 ^ D119 D127 +error(0.0005612582963805286523) D117 D129 ^ D119 D128 +error(0.0004718732734019518349) D117 D129 ^ D127 D128 +error(0.0007341237423978296721) D117 D130 +error(0.002133173335255453534) D117 D130 ^ D119 D120 +error(0.0009726170139540637636) D117 D130 ^ D119 D127 +error(0.00206566717432974398) D117 D130 ^ D119 D128 +error(0.001068042459342767331) D117 D130 ^ D120 D128 +error(0.002694857058884877598) D117 D130 ^ D127 D128 +error(0.01000000000000000021) D117 L0 +error(0.008201930780325385542) D119 D127 ^ D117 L0 +error(0.005000000000000000104) D118 +error(0.006560379797122610837) D118 D125 +error(0.0007020324885268809526) D118 D125 ^ D116 +error(0.005393121636168434624) D118 D125 ^ D128 +error(0.0009863076048298488174) D118 D125 ^ D128 ^ D116 +error(0.02610789530202516778) D118 D126 +error(0.0110360761531631997) D118 D126 ^ D128 +error(0.002317202595067395943) D118 D130 +error(0.0003447409802485930266) D118 D130 ^ D119 D120 +error(0.0001709763741474679285) D118 D130 ^ D119 D128 +error(0.001306588848621806961) D118 D130 ^ D120 D128 +error(0.01507726810564594642) D118 ^ D120 +error(0.002806344194443891656) D118 ^ D128 ^ D120 +error(0.01000000000000000021) D119 +error(0.01068880118510151696) D119 D120 +error(0.0002438620789212667019) D119 D120 ^ D109 L0 +error(0.0004998182877393524907) D119 D120 ^ D121 D122 +error(0.001701853247078384795) D119 D120 ^ D122 D130 +error(0.02682470001186230621) D119 D127 +error(0.003351280911503579096) D119 D127 ^ D129 D130 +error(0.002838809172954709012) D119 D128 +error(0.0001572061157912999277) D119 D128 ^ D129 D130 +error(0.001393373771917199916) D119 D131 +error(0.0001884956742699187113) D119 D131 ^ D122 +error(0.001372135424766430601) D119 D131 ^ D122 D130 +error(0.0001330399799575002629) D119 D131 ^ D130 +error(0.009014877420392431936) D119 ^ D121 L0 +error(0.003935801536233380672) D121 D129 ^ D119 +error(0.01000000000000000021) D120 +error(0.02220618885390944833) D120 D123 +error(0.02105436195791260401) D120 D123 ^ D122 +error(0.0322765734706866661) D120 D128 +error(0.001935169617909809946) D120 D128 ^ D130 +error(0.009555400251384538537) D120 D131 +error(0.002204480404501199878) D120 D131 ^ D122 +error(0.005169913064080980045) D120 D131 ^ D130 +error(0.0006564952203538394456) D120 D131 ^ D130 ^ D122 +error(0.008126478579574632558) D121 D122 +error(0.003396220450673128732) D121 D122 ^ D111 +error(0.01234356543519746566) D121 D122 ^ D119 +error(0.0005596516236200856781) D121 D122 ^ D123 +error(0.0002482138172298047193) D121 D122 ^ D123 ^ D111 +error(0.02841728360156799832) D121 D129 +error(0.005000000000000000104) D121 L0 +error(0.0003172016853723943911) D121 L0 ^ D109 L0 ^ D111 +error(0.0001443879881180337103) D121 L0 ^ D109 L0 ^ D119 +error(0.0009522959210919978426) D121 L0 ^ D119 ^ D111 +error(0.01390683885060832979) D122 +error(0.002839966817347003205) D122 D129 +error(0.002452829707374155899) D122 D129 ^ D119 +error(5.017905351258029412e-05) D122 D129 ^ D131 +error(0.000247197448812605026) D122 D129 ^ D131 ^ D119 +error(0.03308377666233706244) D122 D130 +error(0.001240860359178470266) D122 D130 ^ D119 +error(0.001267847074638612246) D122 D130 ^ D131 +error(0.0007930654563626337965) D122 ^ D110 ^ D112 +error(0.0006216937696868836578) D122 ^ D110 ^ D120 +error(0.00105034782662940477) D122 ^ D120 +error(0.01387042499099926628) D122 ^ D123 +error(0.002030247209399251192) D122 ^ D131 +error(0.002716163382992085266) D123 D131 ^ D122 +error(0.007476592050288623746) D123 +error(0.02358145705777341117) D123 D131 +error(0.03528381097861703342) D124 +error(0.0172005799847827108) D124 D127 +error(0.02035169954812634727) D124 D127 ^ D125 L0 +error(0.007348298839285053417) D124 ^ D125 L0 +error(0.01143652336244499815) D124 ^ D132 L0 +error(0.0153105529069621684) D125 D132 ^ D124 +error(0.01126501150000511556) D125 D126 +error(0.002966750262736267841) D125 D126 ^ D124 +error(0.0005696141811298398305) D125 D126 ^ D127 +error(0.02277069963650137085) D125 D126 ^ D128 +error(0.01865832203242646925) D125 D130 +error(0.009580395997535412142) D125 D130 ^ D127 D128 +error(0.06253555789460546466) D125 D132 +error(0.003477768006388697302) D125 D133 +error(0.003779351348247084619) D125 D133 ^ D127 +error(0.00332393889064217787) D125 D135 +error(0.003531546418602341149) D125 D135 ^ D127 +error(0.001957507823867344829) D125 D135 ^ D127 D128 +error(0.0009706393802764371045) D125 D135 ^ D128 +error(0.01000000000000000021) D125 L0 +error(0.005000000000000000104) D126 +error(0.01835146489433683165) D126 D132 +error(0.00212396066077612548) D126 D132 ^ D124 +error(0.03024948227724844063) D126 D134 +error(0.0009237059373733067218) D126 D135 +error(0.001315747611407503759) D126 D135 ^ D128 +error(0.0006788747466245993777) D126 D135 ^ D128 ^ D127 +error(0.02462708812564298744) D126 ^ D128 +error(0.03314136945540700763) D127 +error(0.007853617052470897655) D127 D128 +error(0.0002438620789212667019) D127 D128 ^ D117 L0 +error(0.002592855556399650992) D127 D128 ^ D125 L0 +error(0.000831547231270854002) D127 D128 ^ D129 D130 +error(0.002194620723663328905) D127 D128 ^ D130 D135 +error(0.0007873200780259140621) D127 ^ D128 ^ D135 +error(0.008570539028521367841) D127 ^ D129 L0 +error(0.005051806065304415352) D129 D133 ^ D127 +error(0.003978230128332949436) D130 D135 ^ D127 +error(0.05237489753215805732) D128 +error(0.02553885833426337848) D128 D131 +error(0.02144594805800051004) D128 D131 ^ D130 +error(0.007530168937842997984) D128 ^ D135 +error(0.0003733406262532939059) D128 ^ D135 ^ D130 +error(0.005843229344514975707) D129 D130 +error(0.003396220450673128732) D129 D130 ^ D119 +error(0.013485932918338394) D129 D130 ^ D127 +error(0.00122307826810631585) D129 D130 ^ D131 +error(0.0002482138172298047193) D129 D130 ^ D131 ^ D119 +error(0.02783589928323708038) D129 D133 +error(0.005244627222147415016) D129 L0 +error(0.0003172016853723943911) D129 L0 ^ D117 L0 ^ D119 +error(0.0001443879881180337103) D129 L0 ^ D117 L0 ^ D127 +error(0.0009522959210919978426) D129 L0 ^ D127 ^ D119 +error(0.02382829664903873823) D130 +error(0.002744651357991380325) D130 D133 +error(0.001728335412086508694) D130 D133 ^ D127 +error(0.03360809150670765466) D130 D135 +error(0.0007930654563626337965) D130 ^ D118 ^ D120 +error(0.0006216937696868836578) D130 ^ D118 ^ D128 +error(0.01176754380915027466) D130 ^ D131 +error(0.02899707938901573828) D131 +error(0.02013014028315235349) D132 D134 +error(0.01717653913671990384) D132 D135 +error(0.03822149658471344497) D132 L0 +error(0.01568561314944857607) D133 D135 +error(0.007696990632822377741) D133 D135 ^ D127 +error(0.009015422562789910527) D133 L0 +error(0.008204971971546827503) D134 +error(0.03616826532378887571) D135 +detector(2, 5, 0) D0 +detector(4, 3, 0) D1 +detector(2, 7, 0) D2 +detector(4, 5, 0) D3 +detector(1, 4, 1) D4 +detector(2, 5, 1) D5 +detector(2, 7, 1) D6 +detector(3, 4, 1) D7 +detector(3, 6, 1) D8 +detector(4, 3, 1) D9 +detector(4, 5, 1) D10 +detector(5, 6, 1) D11 +detector(1, 4, 2) D12 +detector(2, 5, 2) D13 +detector(2, 7, 2) D14 +detector(3, 4, 2) D15 +detector(3, 6, 2) D16 +detector(4, 3, 2) D17 +detector(4, 5, 2) D18 +detector(5, 6, 2) D19 +detector(1, 4, 3) D20 +detector(2, 5, 3) D21 +detector(2, 7, 3) D22 +detector(3, 4, 3) D23 +detector(3, 6, 3) D24 +detector(4, 3, 3) D25 +detector(4, 5, 3) D26 +detector(5, 6, 3) D27 +detector(1, 4, 4) D28 +detector(2, 5, 4) D29 +detector(2, 7, 4) D30 +detector(3, 4, 4) D31 +detector(3, 6, 4) D32 +detector(4, 3, 4) D33 +detector(4, 5, 4) D34 +detector(5, 6, 4) D35 +detector(1, 4, 5) D36 +detector(2, 5, 5) D37 +detector(2, 7, 5) D38 +detector(3, 4, 5) D39 +detector(3, 6, 5) D40 +detector(4, 3, 5) D41 +detector(4, 5, 5) D42 +detector(5, 6, 5) D43 +detector(1, 4, 6) D44 +detector(2, 5, 6) D45 +detector(2, 7, 6) D46 +detector(3, 4, 6) D47 +detector(3, 6, 6) D48 +detector(4, 3, 6) D49 +detector(4, 5, 6) D50 +detector(5, 6, 6) D51 +detector(1, 4, 7) D52 +detector(2, 5, 7) D53 +detector(2, 7, 7) D54 +detector(3, 4, 7) D55 +detector(3, 6, 7) D56 +detector(4, 3, 7) D57 +detector(4, 5, 7) D58 +detector(5, 6, 7) D59 +detector(1, 4, 8) D60 +detector(2, 5, 8) D61 +detector(2, 7, 8) D62 +detector(3, 4, 8) D63 +detector(3, 6, 8) D64 +detector(4, 3, 8) D65 +detector(4, 5, 8) D66 +detector(5, 6, 8) D67 +detector(1, 4, 9) D68 +detector(2, 5, 9) D69 +detector(2, 7, 9) D70 +detector(3, 4, 9) D71 +detector(3, 6, 9) D72 +detector(4, 3, 9) D73 +detector(4, 5, 9) D74 +detector(5, 6, 9) D75 +detector(1, 4, 10) D76 +detector(2, 5, 10) D77 +detector(2, 7, 10) D78 +detector(3, 4, 10) D79 +detector(3, 6, 10) D80 +detector(4, 3, 10) D81 +detector(4, 5, 10) D82 +detector(5, 6, 10) D83 +detector(1, 4, 11) D84 +detector(2, 5, 11) D85 +detector(2, 7, 11) D86 +detector(3, 4, 11) D87 +detector(3, 6, 11) D88 +detector(4, 3, 11) D89 +detector(4, 5, 11) D90 +detector(5, 6, 11) D91 +detector(1, 4, 12) D92 +detector(2, 5, 12) D93 +detector(2, 7, 12) D94 +detector(3, 4, 12) D95 +detector(3, 6, 12) D96 +detector(4, 3, 12) D97 +detector(4, 5, 12) D98 +detector(5, 6, 12) D99 +detector(1, 4, 13) D100 +detector(2, 5, 13) D101 +detector(2, 7, 13) D102 +detector(3, 4, 13) D103 +detector(3, 6, 13) D104 +detector(4, 3, 13) D105 +detector(4, 5, 13) D106 +detector(5, 6, 13) D107 +detector(1, 4, 14) D108 +detector(2, 5, 14) D109 +detector(2, 7, 14) D110 +detector(3, 4, 14) D111 +detector(3, 6, 14) D112 +detector(4, 3, 14) D113 +detector(4, 5, 14) D114 +detector(5, 6, 14) D115 +detector(1, 4, 15) D116 +detector(2, 5, 15) D117 +detector(2, 7, 15) D118 +detector(3, 4, 15) D119 +detector(3, 6, 15) D120 +detector(4, 3, 15) D121 +detector(4, 5, 15) D122 +detector(5, 6, 15) D123 +detector(1, 4, 16) D124 +detector(2, 5, 16) D125 +detector(2, 7, 16) D126 +detector(3, 4, 16) D127 +detector(3, 6, 16) D128 +detector(4, 3, 16) D129 +detector(4, 5, 16) D130 +detector(5, 6, 16) D131 +detector(2, 5, 17) D132 +detector(4, 3, 17) D133 +detector(2, 7, 17) D134 +detector(4, 5, 17) D135 diff --git a/shared/package-files/42/424b4f6007cc7d8c96214c6db655cbe643334a99607a5e8d9f77bb8c23a28bee/blob b/shared/package-files/42/424b4f6007cc7d8c96214c6db655cbe643334a99607a5e8d9f77bb8c23a28bee/blob new file mode 100644 index 0000000000000000000000000000000000000000..92a7e8ad1fb803e0a023a433a83003cdeae79f26 --- /dev/null +++ b/shared/package-files/42/424b4f6007cc7d8c96214c6db655cbe643334a99607a5e8d9f77bb8c23a28bee/blob @@ -0,0 +1,656 @@ +tzdata-2026.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +tzdata-2026.5.dist-info/METADATA,sha256=4HgOi23IiCzofocanUWJ1ZywWgwtZPWLG6Ys3h7pH2o,1358 +tzdata-2026.5.dist-info/RECORD,, +tzdata-2026.5.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109 +tzdata-2026.5.dist-info/licenses/LICENSE,sha256=31j2nqiGgwNdcgtTdbzvDPWuqpih0JjVcuCZLDeN60Y,625 +tzdata-2026.5.dist-info/licenses/licenses/LICENSE_APACHE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357 +tzdata-2026.5.dist-info/top_level.txt,sha256=MO6QqC0xRrN67Gh9xU_nMmadwBVlYzPNkq_h4gYuzaQ,7 +tzdata/__init__.py,sha256=cd9CkYMweBZ1-znHpmxmmWjcEUwILA1JtG4YChSMB7g,252 +tzdata/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Africa/Abidjan,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Accra,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Addis_Ababa,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Algiers,sha256=L2nS4gLNFvuo89p3YtB-lSDYY2284SqkGH9pQQI8uwc,470 +tzdata/zoneinfo/Africa/Asmara,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Asmera,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Bamako,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Bangui,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Banjul,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Bissau,sha256=wa3uva129dJHRCi7tYt04kFOn1-osMS2afMjleO9mDw,149 +tzdata/zoneinfo/Africa/Blantyre,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Brazzaville,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Bujumbura,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Cairo,sha256=icuaNiEvuC6TPc2fqhDv36lpop7IDDIGO7tFGMAz0b4,1309 +tzdata/zoneinfo/Africa/Casablanca,sha256=awJs3LAIaKPcHyT3Byoc46wMP_g7PYR_7l88wB-oX1A,793 +tzdata/zoneinfo/Africa/Ceuta,sha256=oEIgK53afz1SYxYB_D0jR98Ss3g581yb8TnLppPaYcY,562 +tzdata/zoneinfo/Africa/Conakry,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Dakar,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Dar_es_Salaam,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Djibouti,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Douala,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/El_Aaiun,sha256=qg2mybv7i5UmrDXwq5o90ANdaZSaPu7itlqCpzGcUbU,704 +tzdata/zoneinfo/Africa/Freetown,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Gaborone,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Harare,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Johannesburg,sha256=0Zrr4kNcToS_euZVM9I6nUQPmBYuW01pxz94PgIpnsg,190 +tzdata/zoneinfo/Africa/Juba,sha256=VTpoMAP-jJ6cKsDeNVr7l3LKGoKDUxGU2b1gqvDPz34,458 +tzdata/zoneinfo/Africa/Kampala,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Khartoum,sha256=NRwOwIg4SR6XuD11k3hxBz77uoBpzejXq7vxtq2Xys8,458 +tzdata/zoneinfo/Africa/Kigali,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Kinshasa,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Lagos,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Libreville,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Lome,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Luanda,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Lubumbashi,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Lusaka,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Malabo,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Maputo,sha256=kQyXwJHNNK50J8gyJiNM57Ty9CXFgi1macJL5iAQp5I,131 +tzdata/zoneinfo/Africa/Maseru,sha256=0Zrr4kNcToS_euZVM9I6nUQPmBYuW01pxz94PgIpnsg,190 +tzdata/zoneinfo/Africa/Mbabane,sha256=0Zrr4kNcToS_euZVM9I6nUQPmBYuW01pxz94PgIpnsg,190 +tzdata/zoneinfo/Africa/Mogadishu,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Monrovia,sha256=WM-JVfr502Vgy18Fe6iAJ2yMgOWbwwumIQh_yp53eKM,164 +tzdata/zoneinfo/Africa/Nairobi,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Africa/Ndjamena,sha256=Tlj4ZUUNJxEhvAoo7TJKqWv1J7tEYaf1FEMez-K9xEg,160 +tzdata/zoneinfo/Africa/Niamey,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Nouakchott,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Ouagadougou,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Porto-Novo,sha256=5e8SiFccxWxSdsqWbhyKZ1xnR3JtdY7K_n7_zm7Ke-Q,180 +tzdata/zoneinfo/Africa/Sao_Tome,sha256=Pfiutakw5B5xr1OSg1uFvT0GwC6jVOqqxnx69GEJu50,173 +tzdata/zoneinfo/Africa/Timbuktu,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Africa/Tripoli,sha256=zzMBLZZh4VQ4_ARe5k4L_rsuqKP7edKvVt8F6kvj5FM,431 +tzdata/zoneinfo/Africa/Tunis,sha256=uoAEER48RJqNeGoYBuk5IeYqjc8sHvWLvKssuVCd18g,449 +tzdata/zoneinfo/Africa/Windhoek,sha256=g1jLRko_2peGsUTg0_wZycOC4gxTAHwfV2SO9I3KdCM,638 +tzdata/zoneinfo/Africa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Africa/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/America/Adak,sha256=q_sZgOINX4TsX9iBx1gNd6XGwBnzCjg6qpdAQhK0ieA,969 +tzdata/zoneinfo/America/Anchorage,sha256=d8oMIpYvBpmLzl5I2By4ZaFEZsg_9dxgfqpIM0QFi_Y,977 +tzdata/zoneinfo/America/Anguilla,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Antigua,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Araguaina,sha256=TawYX4lVAxq0BxUGhTDx4C8vtBRnLuWi8qLV_oXDiUo,592 +tzdata/zoneinfo/America/Argentina/Buenos_Aires,sha256=IEVOpSfI6oiJJmFNIb9Vb0bOOMIgxO5bghFw7vkHFGk,708 +tzdata/zoneinfo/America/Argentina/Catamarca,sha256=UC0fxx7ZPmjPw3D0BK-5vap-c1cBzbgR293MdmEfOx0,708 +tzdata/zoneinfo/America/Argentina/ComodRivadavia,sha256=UC0fxx7ZPmjPw3D0BK-5vap-c1cBzbgR293MdmEfOx0,708 +tzdata/zoneinfo/America/Argentina/Cordoba,sha256=9Ij3WjT9mWMKQ43LeSUIqQuDb9zS3FSlHYPVNQJTFf0,708 +tzdata/zoneinfo/America/Argentina/Jujuy,sha256=7YpjOcmVaKKpiq31rQe8TTDNExdH9jjZIhdcZv-ShUg,690 +tzdata/zoneinfo/America/Argentina/La_Rioja,sha256=mUkRD5jaWJUy2f8vNFqOlMgKPptULOBn-vf_jMgF6x8,717 +tzdata/zoneinfo/America/Argentina/Mendoza,sha256=dL4q0zgY2FKPbG8cC-Wknnpp8tF2Y7SWgWSC_G_WznI,708 +tzdata/zoneinfo/America/Argentina/Rio_Gallegos,sha256=bCpWMlEI8KWe4c3n6fn8u6WCPnxjYtVy57ERtLTZaEs,708 +tzdata/zoneinfo/America/Argentina/Salta,sha256=H_ybxVycfOe7LlUA3GngoS0jENHkQURIRhjfJQF2kfU,690 +tzdata/zoneinfo/America/Argentina/San_Juan,sha256=Mj5vIUzQl5DtsPe3iMzS7rR-88U9HKW2csQqUda4JNM,717 +tzdata/zoneinfo/America/Argentina/San_Luis,sha256=rka8BokogyvMRFH6jr8D6s1tFIpsUeqHJ_feLK5O6ds,717 +tzdata/zoneinfo/America/Argentina/Tucuman,sha256=yv3aC-hALLio2yqneLIIylZhXKDlbPJGAd_abgsj9gg,726 +tzdata/zoneinfo/America/Argentina/Ushuaia,sha256=mcmZgB1pEHX6i7nlyRzjLnG8bqAtAK1TwMdRD2pZqBE,708 +tzdata/zoneinfo/America/Argentina/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/America/Argentina/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/America/Aruba,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Asuncion,sha256=3JONAueH7Ka_xq5KOrctKkKAauPe3BTg0BOTBA8UNUI,1085 +tzdata/zoneinfo/America/Atikokan,sha256=p41zBnujy9lPiiPf3WqotoyzOxhIS8F7TiDqGuwvCoE,149 +tzdata/zoneinfo/America/Atka,sha256=q_sZgOINX4TsX9iBx1gNd6XGwBnzCjg6qpdAQhK0ieA,969 +tzdata/zoneinfo/America/Bahia,sha256=_-ZFw-HzXc7byacHW_NJHtJ03ADFdqt1kaYgyWYobYw,682 +tzdata/zoneinfo/America/Bahia_Banderas,sha256=lJ8K-PrUqLTefuqpcKp_YWvfvzH0WNNrZ_LIel_0oZQ,700 +tzdata/zoneinfo/America/Barbados,sha256=gdiJf9ZKOMs9QB4ex0-crvdmhNfHpNzXTV2xTaNDCAg,278 +tzdata/zoneinfo/America/Belem,sha256=w0jv-gdBbEBZQBF2z2liKpRM9CEOWA36O1qU1nJKeCs,394 +tzdata/zoneinfo/America/Belize,sha256=uYBPJqnCGnOOeKnoz1IG9POWTvXD5kUirpFuB0PHjVo,1045 +tzdata/zoneinfo/America/Blanc-Sablon,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Boa_Vista,sha256=hYTFFNNZJdl_nSYIdfI8SQhtmfiakjCDI_15TlB-xEw,430 +tzdata/zoneinfo/America/Bogota,sha256=JowvBssyN7qTDWSgvPMMQmbu6J3cnfq_JQzDkA5BHDQ,179 +tzdata/zoneinfo/America/Boise,sha256=Jt3omyPSPRoKE-KXVd-wxVON-CDE5oGaJA7Ar90Q2OM,999 +tzdata/zoneinfo/America/Buenos_Aires,sha256=IEVOpSfI6oiJJmFNIb9Vb0bOOMIgxO5bghFw7vkHFGk,708 +tzdata/zoneinfo/America/Cambridge_Bay,sha256=NFwNVfgxb2YMLzc-42RA-SKtNcODpukEfYf_QWWYTsI,883 +tzdata/zoneinfo/America/Campo_Grande,sha256=mngKYjaH_ENVmJ-mtURVjjFo5kHgLfYNPHZaCVSxQFE,952 +tzdata/zoneinfo/America/Cancun,sha256=YSoUxbjaL2MycKCTB3ZAK9jPVaeMhW7MkOEA8eWakKY,538 +tzdata/zoneinfo/America/Caracas,sha256=UHmUwc0mFPoidR4UDCWb4T4w_mpCBsSb4BkW3SOKIVY,190 +tzdata/zoneinfo/America/Catamarca,sha256=UC0fxx7ZPmjPw3D0BK-5vap-c1cBzbgR293MdmEfOx0,708 +tzdata/zoneinfo/America/Cayenne,sha256=9URU4o1v5759UWuh8xI9vnaANOceOeRW67XoGQuuUa8,151 +tzdata/zoneinfo/America/Cayman,sha256=p41zBnujy9lPiiPf3WqotoyzOxhIS8F7TiDqGuwvCoE,149 +tzdata/zoneinfo/America/Chicago,sha256=wntzn_RqffBZThINcltDkhfhHkTqmlDNxJEwODtUguc,1754 +tzdata/zoneinfo/America/Chihuahua,sha256=tzOmA7trhFykyUZ7QbuMA6A88BSF2o4mumo65aojzqo,691 +tzdata/zoneinfo/America/Ciudad_Juarez,sha256=mEE-VN-sqVDaHFJyFGUBYyOsYHCRspUZcSJqt26Wufg,718 +tzdata/zoneinfo/America/Coral_Harbour,sha256=p41zBnujy9lPiiPf3WqotoyzOxhIS8F7TiDqGuwvCoE,149 +tzdata/zoneinfo/America/Cordoba,sha256=9Ij3WjT9mWMKQ43LeSUIqQuDb9zS3FSlHYPVNQJTFf0,708 +tzdata/zoneinfo/America/Costa_Rica,sha256=ihoqA_tHmYm0YjTRLZu3q8PqsqqOeb1CELjWhPf_HXE,232 +tzdata/zoneinfo/America/Coyhaique,sha256=c_K3bduiI0P_lEnoJUNUZq2qF2-Svfo70xveKg9y9fc,1362 +tzdata/zoneinfo/America/Creston,sha256=rhFFPCHQiYTedfLv7ATckxeKe04jxeUvIJi4vUXMtUc,240 +tzdata/zoneinfo/America/Cuiaba,sha256=OaIle0Cr-BKe0hOik5rwdcoCbQ5LSHkHqBS2cLoCqAU,934 +tzdata/zoneinfo/America/Curacao,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Danmarkshavn,sha256=cQORuA8pR0vw3ZwYfeGkWaT1tPU66nMQ2xRKT1T1Yb4,447 +tzdata/zoneinfo/America/Dawson,sha256=BlKV0U36jqnlxM5-Pxn8OIiY5kJEcLlt3QZo-GsMzlY,1029 +tzdata/zoneinfo/America/Dawson_Creek,sha256=t4USMuIvq1VVL9gYCabraAYs31kmAqAnwf7GzEiJJNc,683 +tzdata/zoneinfo/America/Denver,sha256=m7cDkg7KS2EZ6BoQVYOk9soiBlHxO0GEeat81WxBPz4,1042 +tzdata/zoneinfo/America/Detroit,sha256=I4F8Mt9nx38AF6D-steYskBa_HHO6jKU1-W0yRFr50A,899 +tzdata/zoneinfo/America/Dominica,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Edmonton,sha256=1SFztWooIF2Nb3krz6i8B2FO4NJp979uQ-yR9o1BBgA,1313 +tzdata/zoneinfo/America/Eirunepe,sha256=6tKYaRpnbBSmXiwXy7_m4WW_rbVfn5LUec0keC3J7Iw,436 +tzdata/zoneinfo/America/El_Salvador,sha256=4wjsCpRH9AFk5abLAbnuv-zouhRKcwb0aenk-nWtmz0,176 +tzdata/zoneinfo/America/Ensenada,sha256=r5rqSu5QUUP6XoR2Q8D_4WQZDDhBEBCsfwsXD0CYpsg,1367 +tzdata/zoneinfo/America/Fort_Nelson,sha256=_j7IJ-hXHtV_7dSMg6pxGQLb6z_IaUMj3aJde_F49QQ,1448 +tzdata/zoneinfo/America/Fort_Wayne,sha256=5nj0KhPvvXvg8mqc5T4EscKKWC6rBWEcsBwWg2Qy8Hs,531 +tzdata/zoneinfo/America/Fortaleza,sha256=ugF4DWO3j_khONebf7CLsT9ldL-JOWey_69S0jl2LIA,484 +tzdata/zoneinfo/America/Glace_Bay,sha256=I1posPHAEfg_Lc_FQdX1B8F8_A0NeJnK72p36PE7pKM,880 +tzdata/zoneinfo/America/Godthab,sha256=LlGZ5Y_ud9JwWRvncHnUHRArQbbnNcmmrz3duMhR3Hc,965 +tzdata/zoneinfo/America/Goose_Bay,sha256=gCJA1Sk2ciUg2WInn8DmPBwRAw0FjQbYPaUJK80mtMI,1580 +tzdata/zoneinfo/America/Grand_Turk,sha256=Gp8hpMt9P3QoEHmsIX2bqGNMkUSvlwZqqNzccR-cbe8,853 +tzdata/zoneinfo/America/Grenada,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Guadeloupe,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Guatemala,sha256=BGPGI4lyN6IFF_T0kx1q2lh3U5SEhbyDqLFuW8EFCaU,212 +tzdata/zoneinfo/America/Guayaquil,sha256=8OIaCy-SirKKz4I77l6MQFDgSLHtjN0TvklLVEZ_008,179 +tzdata/zoneinfo/America/Guyana,sha256=PmnEtWtOTamsPJXEo7PcNQCy2Rp-evGyJh4cf0pjAR4,181 +tzdata/zoneinfo/America/Halifax,sha256=kO5ahBM2oTLfWS4KX15FbKXfo5wg-f9vw1_hMOISGig,1672 +tzdata/zoneinfo/America/Havana,sha256=ms5rCuq2yBM49VmTymMtFQN3c5aBN1lkd8jjzKdnNm8,1117 +tzdata/zoneinfo/America/Hermosillo,sha256=Ur1MYSAX3QbT2UX57LmD83o6s2Z-6YbYeOufKvT-zTM,258 +tzdata/zoneinfo/America/Indiana/Indianapolis,sha256=5nj0KhPvvXvg8mqc5T4EscKKWC6rBWEcsBwWg2Qy8Hs,531 +tzdata/zoneinfo/America/Indiana/Knox,sha256=KJCzXct8CTMItVLYLYeBqM6aT6b53gWCg6aDbsH58oI,1016 +tzdata/zoneinfo/America/Indiana/Marengo,sha256=ygWmq8sYee8NFwlSZyQ_tsKopFQMp9Ne557zGGbyF2Y,567 +tzdata/zoneinfo/America/Indiana/Petersburg,sha256=BIrubzHEp5QoyMaPgYbC1zSa_F3LwpXzKM8xH3rHspI,683 +tzdata/zoneinfo/America/Indiana/Tell_City,sha256=em2YMHDWEFXdZH0BKi5bLRAQ8bYDfop2T0Q8SqDh0B8,522 +tzdata/zoneinfo/America/Indiana/Vevay,sha256=dPk334e7MQwl71-avNyREBYVWuFTQcVKfltlRhrlRpw,369 +tzdata/zoneinfo/America/Indiana/Vincennes,sha256=jiODDXepmLP3gvCkBufdE3rp5cEXftBHnKne8_XOOCg,558 +tzdata/zoneinfo/America/Indiana/Winamac,sha256=hsEunaLrbxvspyV3Qm4UD7x7qOAeBtzcbbzANNMrdiw,603 +tzdata/zoneinfo/America/Indiana/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/America/Indiana/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/America/Indianapolis,sha256=5nj0KhPvvXvg8mqc5T4EscKKWC6rBWEcsBwWg2Qy8Hs,531 +tzdata/zoneinfo/America/Inuvik,sha256=vZMnOfyDBz-LmtD1TxJSmDsb6Y1xj31oQ9GpOWMQsYs,1160 +tzdata/zoneinfo/America/Iqaluit,sha256=nONS7zksGHTrbEJj73LYRZW964OncQuj_V6fNjpDoQ0,855 +tzdata/zoneinfo/America/Jamaica,sha256=pDexcAMzrv9TqLWGjVOHwIDcFMLT6Vqlzjb5AbNmkoQ,339 +tzdata/zoneinfo/America/Jujuy,sha256=7YpjOcmVaKKpiq31rQe8TTDNExdH9jjZIhdcZv-ShUg,690 +tzdata/zoneinfo/America/Juneau,sha256=V8IqRaJHSH7onK1gu3YYtW_a4VkNwjx5DCvQXpFdYAo,966 +tzdata/zoneinfo/America/Kentucky/Louisville,sha256=zS2SS573D9TmQZFWtSyRIVN3ZXVN_2FpVBbtqQFMzKU,1242 +tzdata/zoneinfo/America/Kentucky/Monticello,sha256=54or2oQ9bSbM9ifRoOjV7UjRF83jSSPuxfGeXH0nIqk,972 +tzdata/zoneinfo/America/Kentucky/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/America/Kentucky/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/America/Knox_IN,sha256=KJCzXct8CTMItVLYLYeBqM6aT6b53gWCg6aDbsH58oI,1016 +tzdata/zoneinfo/America/Kralendijk,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/La_Paz,sha256=2iYBxnc0HIwAzlx-Q3AI9Lb0GI87VY279oGcroBZSVs,170 +tzdata/zoneinfo/America/Lima,sha256=7vNjRhxzL-X4kyba-NkzXYNAOE-cqqcXvzXTqcTXBhY,283 +tzdata/zoneinfo/America/Los_Angeles,sha256=IA0FdU9tg6Nxz0CNcIUSV5dlezsL6-uh5QjP_oaj5cg,1294 +tzdata/zoneinfo/America/Louisville,sha256=zS2SS573D9TmQZFWtSyRIVN3ZXVN_2FpVBbtqQFMzKU,1242 +tzdata/zoneinfo/America/Lower_Princes,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Maceio,sha256=dSVg0dHedT9w1QO2F1AvWoel4_h8wmuYS4guEaL-5Kk,502 +tzdata/zoneinfo/America/Managua,sha256=ZYsoyN_GIlwAIpIj1spjQDPWGQ9kFZSipjUbO8caGfw,295 +tzdata/zoneinfo/America/Manaus,sha256=9kgrhpryB94YOVoshJliiiDSf9mwjb3OZwX0HusNRrk,412 +tzdata/zoneinfo/America/Marigot,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Martinique,sha256=m3rC6Mogc6cc1a9XJ8FPIYhZaSFNdYkxaZ-pfHhG3X4,178 +tzdata/zoneinfo/America/Matamoros,sha256=KxgAMGkE7TJuug9byFsT3KN836X3OyXq77v-tFpLVvc,437 +tzdata/zoneinfo/America/Mazatlan,sha256=IN7ecQ9SDq9sDNvu_nc_xuMN2LHSiq8X6YQgmVUe6aY,690 +tzdata/zoneinfo/America/Mendoza,sha256=dL4q0zgY2FKPbG8cC-Wknnpp8tF2Y7SWgWSC_G_WznI,708 +tzdata/zoneinfo/America/Menominee,sha256=oUmJmzOZtChYrB9In-E1GqEVi2ogKjPESXlUySUGs94,917 +tzdata/zoneinfo/America/Merida,sha256=LBpOEv4xxUcL5B7wFSNa3UyE762-EiSXb1KPQNKwwCU,654 +tzdata/zoneinfo/America/Metlakatla,sha256=EVj1LkMCgry6mT8Ln_FpHxpJSU0oSncfbHGWIQ0SI_0,586 +tzdata/zoneinfo/America/Mexico_City,sha256=N90r8I8T_OD3B8Ox9M7EAY772cR8g2ew-03rvUYb1y8,773 +tzdata/zoneinfo/America/Miquelon,sha256=Eey-Id5b4HFODINweRFtbDjcgjs_myiC2UwsgYt4kVk,550 +tzdata/zoneinfo/America/Moncton,sha256=knrBNDFwHAGFr0nWJTBQ-10F_fZ5x4n3SnZtH-KI6h8,1493 +tzdata/zoneinfo/America/Monterrey,sha256=1aYsIp-Na0lDAKVrcW4wVKFAXy5BAqDG2wWLT9wTmmQ,709 +tzdata/zoneinfo/America/Montevideo,sha256=l7FjW6qscGzdvfjlbIeZ5CQ_AFWS3ZeVDS5ppMJCNM0,969 +tzdata/zoneinfo/America/Montreal,sha256=gVq023obEpKGfS-SS3GOG7oyRVzp-SIF2y_rZQKcZ2E,1717 +tzdata/zoneinfo/America/Montserrat,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Nassau,sha256=gVq023obEpKGfS-SS3GOG7oyRVzp-SIF2y_rZQKcZ2E,1717 +tzdata/zoneinfo/America/New_York,sha256=1_IgazpFmJ_JrWPVWJIlMvpzUigNX4cXa_HbecsdH6k,1744 +tzdata/zoneinfo/America/Nipigon,sha256=gVq023obEpKGfS-SS3GOG7oyRVzp-SIF2y_rZQKcZ2E,1717 +tzdata/zoneinfo/America/Nome,sha256=_-incQnh0DwK9hJqFaYzO4osUKAUB2k2lae565sblpA,975 +tzdata/zoneinfo/America/Noronha,sha256=Q0r3GtA5y2RGkOj56OTZG5tuBy1B6kfbhyrJqCgf27g,484 +tzdata/zoneinfo/America/North_Dakota/Beulah,sha256=RvaBIS60bNNRmREi6BXSWEbJSrcP7J8Nmxg8OkBcrow,1043 +tzdata/zoneinfo/America/North_Dakota/Center,sha256=M09x4Mx6hcBAwktvwv16YvPRmsuDjZEDwHT0Umkcgyo,990 +tzdata/zoneinfo/America/North_Dakota/New_Salem,sha256=mZca9gyfO2USzax7v0mLJEYBKBVmIqylWqnfLgSsVys,990 +tzdata/zoneinfo/America/North_Dakota/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/America/North_Dakota/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/America/Nuuk,sha256=LlGZ5Y_ud9JwWRvncHnUHRArQbbnNcmmrz3duMhR3Hc,965 +tzdata/zoneinfo/America/Ojinaga,sha256=97mJ9VI8h1lRAREIdJdTz_MCLtwh4b36iaQ9QolETpA,718 +tzdata/zoneinfo/America/Panama,sha256=p41zBnujy9lPiiPf3WqotoyzOxhIS8F7TiDqGuwvCoE,149 +tzdata/zoneinfo/America/Pangnirtung,sha256=nONS7zksGHTrbEJj73LYRZW964OncQuj_V6fNjpDoQ0,855 +tzdata/zoneinfo/America/Paramaribo,sha256=C2v9tR6no54CRECWDFhANTl40UsA4AhHsdnGoNCb4_Q,187 +tzdata/zoneinfo/America/Phoenix,sha256=rhFFPCHQiYTedfLv7ATckxeKe04jxeUvIJi4vUXMtUc,240 +tzdata/zoneinfo/America/Port-au-Prince,sha256=wsS6VbQ__bKJ2IUMPy_Pao0CLRK5pXEBrqkaYuqs3Ns,565 +tzdata/zoneinfo/America/Port_of_Spain,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Porto_Acre,sha256=VjuQUr668phq5bcH40r94BPnZBKHzJf_MQBfM6Db96U,418 +tzdata/zoneinfo/America/Porto_Velho,sha256=9yPU8EXtKDQHLF745ETc9qZZ9Me2CK6jvgb6S53pSKg,394 +tzdata/zoneinfo/America/Puerto_Rico,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Punta_Arenas,sha256=2Aqh7bqo-mQlnMjURDkCOeEYmeXhkzKP7OxFAvhTjjA,1218 +tzdata/zoneinfo/America/Rainy_River,sha256=YHLl-4ApALGTQHI5tPtN6fss6AtD6g9ChqlUZltWXL0,1637 +tzdata/zoneinfo/America/Rankin_Inlet,sha256=JQCXQBdyc8uJTjIFO4jZuzS0OjG0gRHv8MPmdzN93CU,807 +tzdata/zoneinfo/America/Recife,sha256=3yZTwF3MJlkY0D48CQUTzCRwDCfGNq8EXXTZYlBgUTg,484 +tzdata/zoneinfo/America/Regina,sha256=_JHuns225iE-THc9NFp-RBq4PWULAuGw2OLbpOB_UMw,638 +tzdata/zoneinfo/America/Resolute,sha256=2UeJBR2ZSkn1bUZy0G0SEhBtY9vycwSRU4naK-sw044,807 +tzdata/zoneinfo/America/Rio_Branco,sha256=VjuQUr668phq5bcH40r94BPnZBKHzJf_MQBfM6Db96U,418 +tzdata/zoneinfo/America/Rosario,sha256=9Ij3WjT9mWMKQ43LeSUIqQuDb9zS3FSlHYPVNQJTFf0,708 +tzdata/zoneinfo/America/Santa_Isabel,sha256=r5rqSu5QUUP6XoR2Q8D_4WQZDDhBEBCsfwsXD0CYpsg,1367 +tzdata/zoneinfo/America/Santarem,sha256=dDEGsnrm4wrzl4sK6K8PzEroBKD7A1V7HBa8cWW4cMk,409 +tzdata/zoneinfo/America/Santiago,sha256=_QBpU8K0QqLh5m2yqWfdkypIJDkPAc3dnIAc5jRQxxU,1354 +tzdata/zoneinfo/America/Santo_Domingo,sha256=xmJo59mZXN7Wnf-3Jjl37mCC-8GfN6xmk2l_vngyfeI,317 +tzdata/zoneinfo/America/Sao_Paulo,sha256=-izrIi8GXAKJ85l_8MVLoFp0pZm0Uihw-oapbiThiJE,952 +tzdata/zoneinfo/America/Scoresbysund,sha256=wrhIEVAFI29qKT3TdOWiiJwI80AohXwwfb1mCPSAXHo,984 +tzdata/zoneinfo/America/Shiprock,sha256=m7cDkg7KS2EZ6BoQVYOk9soiBlHxO0GEeat81WxBPz4,1042 +tzdata/zoneinfo/America/Sitka,sha256=pF5yln--MOzEMDacNd_Id0HX9pAmge8POfcxyTNh1-0,956 +tzdata/zoneinfo/America/St_Barthelemy,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/St_Johns,sha256=v99q_AFMPll5MMxMp98aqY40cmis2wciTfTqs2_kb0k,1878 +tzdata/zoneinfo/America/St_Kitts,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/St_Lucia,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/St_Thomas,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/St_Vincent,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Swift_Current,sha256=F-b65Yaax23CsuhSmeTDl6Tv9du4IsvWvMbbSuwHkLM,368 +tzdata/zoneinfo/America/Tegucigalpa,sha256=KlvqBJGswa9DIXlE3acU-pgd4IFqDeBRrUz02PmlNC0,194 +tzdata/zoneinfo/America/Thule,sha256=LzL5jdmZkxRkHdA3XkoqJPG_ImllnSRhYYLQpMf_TY8,455 +tzdata/zoneinfo/America/Thunder_Bay,sha256=gVq023obEpKGfS-SS3GOG7oyRVzp-SIF2y_rZQKcZ2E,1717 +tzdata/zoneinfo/America/Tijuana,sha256=r5rqSu5QUUP6XoR2Q8D_4WQZDDhBEBCsfwsXD0CYpsg,1367 +tzdata/zoneinfo/America/Toronto,sha256=gVq023obEpKGfS-SS3GOG7oyRVzp-SIF2y_rZQKcZ2E,1717 +tzdata/zoneinfo/America/Tortola,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Vancouver,sha256=fSNoGzaEmsf1BTe5wCvY06oAC5i9PRglzoXn6j5VNMk,1673 +tzdata/zoneinfo/America/Virgin,sha256=q76GKN1Uh8iJ24Fs46UHe7tH9rr6_rlBHZLW7y9wzo0,177 +tzdata/zoneinfo/America/Whitehorse,sha256=CyY4jNd0fzNSdf1HlYGfaktApmH71tRNRlpOEO32DGs,1029 +tzdata/zoneinfo/America/Winnipeg,sha256=YHLl-4ApALGTQHI5tPtN6fss6AtD6g9ChqlUZltWXL0,1637 +tzdata/zoneinfo/America/Yakutat,sha256=pvHLVNA1mI-H9fBDnlnpI6B9XzVFQeyvI9nyIkaFNYQ,946 +tzdata/zoneinfo/America/Yellowknife,sha256=1SFztWooIF2Nb3krz6i8B2FO4NJp979uQ-yR9o1BBgA,1313 +tzdata/zoneinfo/America/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/America/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Antarctica/Casey,sha256=1jc-FAjvkKnmCjhz8-yQgEKrN_sVmzAi8DVoy9_K8AQ,287 +tzdata/zoneinfo/Antarctica/Davis,sha256=Pom_267rsoZl6yLvYllu_SW1kixIrSPmsd-HLztn33Y,197 +tzdata/zoneinfo/Antarctica/DumontDUrville,sha256=aDABBVtu-dydiHNODt3ReC8cNkO3wTp16c-OkFIAbhk,154 +tzdata/zoneinfo/Antarctica/Macquarie,sha256=aOZlIzIdTwevaTXoQkDlex2LSFDrg64GvRfcLnfCDAM,976 +tzdata/zoneinfo/Antarctica/Mawson,sha256=UYuiBSE0qZ-2kkBAa6Xq5g9NXg-W_R0P-rl2tlO0jHc,152 +tzdata/zoneinfo/Antarctica/McMurdo,sha256=Dgbn5VrtvJLvWz0Qbnw5KrFijP2KQosg6S6ZAooL-7k,1043 +tzdata/zoneinfo/Antarctica/Palmer,sha256=3MXfhQBaRB57_jqHZMl-M_K48NMFe4zALc7vaMyS5xw,887 +tzdata/zoneinfo/Antarctica/Rothera,sha256=XeddRL2YTDfEWzQI7nDqfW-Tfg-5EebxsHsMHyzGudI,132 +tzdata/zoneinfo/Antarctica/South_Pole,sha256=Dgbn5VrtvJLvWz0Qbnw5KrFijP2KQosg6S6ZAooL-7k,1043 +tzdata/zoneinfo/Antarctica/Syowa,sha256=RoU-lCdq8u6o6GwvFSqHHAkt8ZXcUSc7j8cJH6pLRhw,133 +tzdata/zoneinfo/Antarctica/Troll,sha256=s4z0F_uKzx3biKjEzvHwb56132XRs6IR22fCQglW5GI,158 +tzdata/zoneinfo/Antarctica/Vostok,sha256=cDp-B4wKXE8U5b_zqJIlxdGY-AIAMCTJOZG3bRZBKNc,170 +tzdata/zoneinfo/Antarctica/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Antarctica/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Arctic/Longyearbyen,sha256=p_2ZMteF1NaQkAuDTDVjwYEMHPLgFxG8wJJq9sB2fLc,705 +tzdata/zoneinfo/Arctic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Arctic/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Asia/Aden,sha256=RoU-lCdq8u6o6GwvFSqHHAkt8ZXcUSc7j8cJH6pLRhw,133 +tzdata/zoneinfo/Asia/Almaty,sha256=87WNMKCF7W2V6tq5LvX5DXWoi9MuwjCAY3f9dgwui4s,618 +tzdata/zoneinfo/Asia/Amman,sha256=KOnKO4_1XRlQvLG61GTbfKImSthwBHMSnzV1ExW8i5Q,928 +tzdata/zoneinfo/Asia/Anadyr,sha256=30bdZurg4Q__lCpH509TE0U7pOcEY6qxjvuPF9ai5yc,743 +tzdata/zoneinfo/Asia/Aqtau,sha256=bRj27vG5HvGegFg5eIKNmq3dfteYmr7KmTs4JFO-7SM,606 +tzdata/zoneinfo/Asia/Aqtobe,sha256=Pm7yI5cmfzx8CGXR2mQJDjtH12KCpx8ezFKchiJVVJ4,615 +tzdata/zoneinfo/Asia/Ashgabat,sha256=OTLHdQ8jFPDvxu_IwKX_c3W3jdN6e7FGoCSEEb0XKuw,375 +tzdata/zoneinfo/Asia/Ashkhabad,sha256=OTLHdQ8jFPDvxu_IwKX_c3W3jdN6e7FGoCSEEb0XKuw,375 +tzdata/zoneinfo/Asia/Atyrau,sha256=1YG4QzLxPRZQeGHiOrbm0cRs8ERTNg1NF9dWEwW2Pi0,616 +tzdata/zoneinfo/Asia/Baghdad,sha256=zFe6LXSfuoJjGsmYTMGjJtBcAMLiKFkD7j7-VaqKwH8,630 +tzdata/zoneinfo/Asia/Bahrain,sha256=YWDWV1o3HHWxnmwlzwMWC53C84ZYPkK_gYn9-P0Xx4U,152 +tzdata/zoneinfo/Asia/Baku,sha256=_Wh6ONaRatMc9lpwGO6zB9pTE38NZ4oWg4_-sZl17mA,744 +tzdata/zoneinfo/Asia/Bangkok,sha256=zcjiwoLYvJpenDyvL8Rf9OnlzRj13sjLhzNArXxYTWQ,152 +tzdata/zoneinfo/Asia/Barnaul,sha256=UGFYJYvtgYVS8Tqsqvj6p0OQCmN3zdY9wITWg8ODG-k,753 +tzdata/zoneinfo/Asia/Beirut,sha256=FgM4gqbWFp6KuUnVn-H8UIXZgTydBeOxDdbebJ0GpUc,732 +tzdata/zoneinfo/Asia/Bishkek,sha256=RXdxVxaiE5zxX5atQl-7ZesEeZVjsCXBGZ6cJbVU9pE,618 +tzdata/zoneinfo/Asia/Brunei,sha256=3ajgII3xZ-Wc-dqXRTSMw8qQRDSjXlSBIxyE_sDRGTk,320 +tzdata/zoneinfo/Asia/Calcutta,sha256=OgC9vhvElZ5ydWfHMLpRsDRV7NRV98GQxa0UOG63mw0,220 +tzdata/zoneinfo/Asia/Chita,sha256=1Lme3ccO47R5gmTe5VCq1BSb0m_1opWibq21zvZlntg,750 +tzdata/zoneinfo/Asia/Choibalsan,sha256=--I8P6_e4BtRIe3wCSkPtwHOu_k9rPsw-KqQKHJC9vM,594 +tzdata/zoneinfo/Asia/Chongqing,sha256=v4t-2C_m5j5tmPjOqTTurJAc0Wq6hetXVc4_i0KJ6oo,393 +tzdata/zoneinfo/Asia/Chungking,sha256=v4t-2C_m5j5tmPjOqTTurJAc0Wq6hetXVc4_i0KJ6oo,393 +tzdata/zoneinfo/Asia/Colombo,sha256=QAyjK7gtXUWfLuju1M0H3_ew6iTM-bwfzO5obgvaHy8,247 +tzdata/zoneinfo/Asia/Dacca,sha256=rCGmEwbW4qkUU2QfTj5zLrydVCq8HTWl1dsqEDQOvvo,231 +tzdata/zoneinfo/Asia/Damascus,sha256=AtZTDRzHEB7QnKxFXvtWsNUI1cCCe27sAfpDfQd0MwY,1234 +tzdata/zoneinfo/Asia/Dhaka,sha256=rCGmEwbW4qkUU2QfTj5zLrydVCq8HTWl1dsqEDQOvvo,231 +tzdata/zoneinfo/Asia/Dili,sha256=5fcCHkVIZkLV8TcsqBQ8HstILEpz3ay3MGGU6sgNxLA,170 +tzdata/zoneinfo/Asia/Dubai,sha256=DZ6lBT6DGIAypvtNMB1dtoj0MBHltrH5F6EbcaDaexY,133 +tzdata/zoneinfo/Asia/Dushanbe,sha256=8qbn76rf9xu47NYVdfGvjnkf2KZxNN5J8ekFiXUz3AQ,366 +tzdata/zoneinfo/Asia/Famagusta,sha256=385fbaRnx-mdEaXqSyBKVBDDKPzCGKbynWYt75wwCug,940 +tzdata/zoneinfo/Asia/Gaza,sha256=-PC__gGODaDGgv5LLzH7ptNLbNdStPkxGY4LmebvcNU,2950 +tzdata/zoneinfo/Asia/Harbin,sha256=v4t-2C_m5j5tmPjOqTTurJAc0Wq6hetXVc4_i0KJ6oo,393 +tzdata/zoneinfo/Asia/Hebron,sha256=4FujfuE-ECIXgKW4pv0lxq2ZkAj7jDwt0rezuA0fFzg,2968 +tzdata/zoneinfo/Asia/Ho_Chi_Minh,sha256=DW52-5QdBUAhTugfFh9EnGp9w9UV5WVGGKeuQtCs0eE,232 +tzdata/zoneinfo/Asia/Hong_Kong,sha256=9AaPcyRtuXQX9zRnRTVkxX1mRs5JCbn6JTaSPvzX608,775 +tzdata/zoneinfo/Asia/Hovd,sha256=eqAvD2RfuIfSDhtqk58MECIjz5X14OHZ7aO4z14kndk,594 +tzdata/zoneinfo/Asia/Irkutsk,sha256=sWxp8g_aSfFan4ZyF9s6-pEX5Vgwxi_jNv7vwN06XIo,760 +tzdata/zoneinfo/Asia/Istanbul,sha256=KnFjsWuUgG9pmRNI59CmDEbrYbHwMF9fS4P2E9sQgG8,1200 +tzdata/zoneinfo/Asia/Jakarta,sha256=4qCZ6kix9xZriNIZsyb3xENz0IkJzZcjtENGlG_Wo4Q,248 +tzdata/zoneinfo/Asia/Jayapura,sha256=BUa0kX1iOdf0E-v7415h7l0lQv4DBCYX_3dAbYmQ0xU,171 +tzdata/zoneinfo/Asia/Jerusalem,sha256=n83o1YTeoFhfXIcnqvNfSKFJ4NvTqDv2zvi8qcFAIeM,1074 +tzdata/zoneinfo/Asia/Kabul,sha256=pNIwTfiSG71BGKvrhKqo1xdxckAx9vfcx5nJanrL81Q,159 +tzdata/zoneinfo/Asia/Kamchatka,sha256=Qix8x3s-m8UTeiwzNPBy_ZQvAzX_aaihz_PzLfTiUac,727 +tzdata/zoneinfo/Asia/Karachi,sha256=ujo4wv-3oa9tfrFT5jsLcEYcjeGeBRgG2QwdXg_ijU4,266 +tzdata/zoneinfo/Asia/Kashgar,sha256=hJyv03dhHML8K0GJGrY8b7M0OUkEXblh_RYmdZMxWtQ,133 +tzdata/zoneinfo/Asia/Kathmandu,sha256=drjxv-ByIxodnn-FATEOJ8DQgEjEj3Qihgtkd8FCxDg,161 +tzdata/zoneinfo/Asia/Katmandu,sha256=drjxv-ByIxodnn-FATEOJ8DQgEjEj3Qihgtkd8FCxDg,161 +tzdata/zoneinfo/Asia/Khandyga,sha256=fdEDOsDJkLuENybqIXtTiI4k2e24dKHDfBTww9AtbSw,775 +tzdata/zoneinfo/Asia/Kolkata,sha256=OgC9vhvElZ5ydWfHMLpRsDRV7NRV98GQxa0UOG63mw0,220 +tzdata/zoneinfo/Asia/Krasnoyarsk,sha256=buNI5S1g7eedK-PpnrLkBFFZDUyCtHxcxXDQGF2ARos,741 +tzdata/zoneinfo/Asia/Kuala_Lumpur,sha256=CVSy2aMB2U9DSAJGBqcbvLL6JNPNNwn1vIvKYFA5eF0,256 +tzdata/zoneinfo/Asia/Kuching,sha256=3ajgII3xZ-Wc-dqXRTSMw8qQRDSjXlSBIxyE_sDRGTk,320 +tzdata/zoneinfo/Asia/Kuwait,sha256=RoU-lCdq8u6o6GwvFSqHHAkt8ZXcUSc7j8cJH6pLRhw,133 +tzdata/zoneinfo/Asia/Macao,sha256=mr89i_wpMoWhAtqZrF2SGcoILcUw6rYrDkIUNADes7E,791 +tzdata/zoneinfo/Asia/Macau,sha256=mr89i_wpMoWhAtqZrF2SGcoILcUw6rYrDkIUNADes7E,791 +tzdata/zoneinfo/Asia/Magadan,sha256=wAufMGWL_s1Aw2l3myAfBFtrROVPes3dMoNuDEoNwT8,751 +tzdata/zoneinfo/Asia/Makassar,sha256=NV9j_RTuiU47mvJvfKE8daXH5AFYJ8Ki4gvHBJSxyLc,190 +tzdata/zoneinfo/Asia/Manila,sha256=FoGmIyFInHknfE103PbiD65GUwsmnYWzF5oGys03BqY,274 +tzdata/zoneinfo/Asia/Muscat,sha256=DZ6lBT6DGIAypvtNMB1dtoj0MBHltrH5F6EbcaDaexY,133 +tzdata/zoneinfo/Asia/Nicosia,sha256=TYYqWp8sK0AwBUHAp0wuuihZuQ19RXdt28bth33zOBI,597 +tzdata/zoneinfo/Asia/Novokuznetsk,sha256=aYW9rpcxpf_zrOZc2vmpcqgiuCRKMHB1lMrioI43KCw,726 +tzdata/zoneinfo/Asia/Novosibirsk,sha256=I2n4MCElad9sMcyJAAc4YdVT6ewbhR79OoAAuhEJfCY,753 +tzdata/zoneinfo/Asia/Omsk,sha256=y7u47EObB3wI8MxKHBRTFM-BEZZqhGpzDg7x5lcwJXY,741 +tzdata/zoneinfo/Asia/Oral,sha256=Q-Gf85NIvdAtU52Zkgf78rVHPlg85xyMe9Zm9ybh0po,625 +tzdata/zoneinfo/Asia/Phnom_Penh,sha256=zcjiwoLYvJpenDyvL8Rf9OnlzRj13sjLhzNArXxYTWQ,152 +tzdata/zoneinfo/Asia/Pontianak,sha256=o0x0jNTlwjiUqAzGX_HlzvCMru2zUURgQ4xzpS95xds,247 +tzdata/zoneinfo/Asia/Pyongyang,sha256=NxC5da8oTZ4StiFQnlhjlp9FTRuMM-Xwsq3Yg4y0xkA,183 +tzdata/zoneinfo/Asia/Qatar,sha256=YWDWV1o3HHWxnmwlzwMWC53C84ZYPkK_gYn9-P0Xx4U,152 +tzdata/zoneinfo/Asia/Qostanay,sha256=5tZkj1o0p4vaREsPO0YgIiw6eDf1cqO52x-0EMg_2L4,624 +tzdata/zoneinfo/Asia/Qyzylorda,sha256=JltKDEnuHmIQGYdFTAJMDDpdDA_HxjJOAHHaV7kFrlQ,624 +tzdata/zoneinfo/Asia/Rangoon,sha256=6J2DXIEdTaRKqLOGeCzogo3whaoO6PJWYamIHS8A6Qw,187 +tzdata/zoneinfo/Asia/Riyadh,sha256=RoU-lCdq8u6o6GwvFSqHHAkt8ZXcUSc7j8cJH6pLRhw,133 +tzdata/zoneinfo/Asia/Saigon,sha256=DW52-5QdBUAhTugfFh9EnGp9w9UV5WVGGKeuQtCs0eE,232 +tzdata/zoneinfo/Asia/Sakhalin,sha256=M_TBd-03j-3Yc9KwhGEoBTwSJxWO1lPBG7ndst16PGo,755 +tzdata/zoneinfo/Asia/Samarkand,sha256=KZ_q-6GMDVgJb8RFqcrbVcPC0WLczolClC4nZA1HVNU,366 +tzdata/zoneinfo/Asia/Seoul,sha256=ZKcLb7zJtl52Lb0l64m29AwTcUbtyNvU0IHq-s2reN4,415 +tzdata/zoneinfo/Asia/Shanghai,sha256=v4t-2C_m5j5tmPjOqTTurJAc0Wq6hetXVc4_i0KJ6oo,393 +tzdata/zoneinfo/Asia/Singapore,sha256=CVSy2aMB2U9DSAJGBqcbvLL6JNPNNwn1vIvKYFA5eF0,256 +tzdata/zoneinfo/Asia/Srednekolymsk,sha256=06mojetFbDd4ag1p8NK0Fg6rF2OOnZMFRRC90N2ATZc,742 +tzdata/zoneinfo/Asia/Taipei,sha256=oEwscvT3aoMXjQNt2X0VfuHzLkeORN2npcEJI2h-5s8,511 +tzdata/zoneinfo/Asia/Tashkent,sha256=0vpN2gI9GY50z1nea6zCPFf2B6VCu6XQQHx4l6rhnTI,366 +tzdata/zoneinfo/Asia/Tbilisi,sha256=BzF_LoKBB_s90wgO6DEZfIxtNfh7Z8t8XLW7ZCzsE4k,620 +tzdata/zoneinfo/Asia/Tehran,sha256=RS1aCXpsJg_MtOeyKbTt3KVWP1ysMMUVvInLc7xhW3I,812 +tzdata/zoneinfo/Asia/Tel_Aviv,sha256=n83o1YTeoFhfXIcnqvNfSKFJ4NvTqDv2zvi8qcFAIeM,1074 +tzdata/zoneinfo/Asia/Thimbu,sha256=N6d_vfFvYORfMnr1fHJjYSt4DBORSbLi_2T-r2dJBnI,154 +tzdata/zoneinfo/Asia/Thimphu,sha256=N6d_vfFvYORfMnr1fHJjYSt4DBORSbLi_2T-r2dJBnI,154 +tzdata/zoneinfo/Asia/Tokyo,sha256=WaOHFDDw07k-YZ-jCkOkHR6IvdSf8m8J0PQFpQBwb5Y,213 +tzdata/zoneinfo/Asia/Tomsk,sha256=Bf7GoFTcUeP2hYyuYpruJji33tcEoLP-80o38A6i4zU,753 +tzdata/zoneinfo/Asia/Ujung_Pandang,sha256=NV9j_RTuiU47mvJvfKE8daXH5AFYJ8Ki4gvHBJSxyLc,190 +tzdata/zoneinfo/Asia/Ulaanbaatar,sha256=--I8P6_e4BtRIe3wCSkPtwHOu_k9rPsw-KqQKHJC9vM,594 +tzdata/zoneinfo/Asia/Ulan_Bator,sha256=--I8P6_e4BtRIe3wCSkPtwHOu_k9rPsw-KqQKHJC9vM,594 +tzdata/zoneinfo/Asia/Urumqi,sha256=hJyv03dhHML8K0GJGrY8b7M0OUkEXblh_RYmdZMxWtQ,133 +tzdata/zoneinfo/Asia/Ust-Nera,sha256=6NkuV1zOms-4qHQhq-cGc-cqEVgKHk7qd3MLDM-e2BA,771 +tzdata/zoneinfo/Asia/Vientiane,sha256=zcjiwoLYvJpenDyvL8Rf9OnlzRj13sjLhzNArXxYTWQ,152 +tzdata/zoneinfo/Asia/Vladivostok,sha256=zkOXuEDgpxX8HQGgDlh9SbAQzHOaNxX2XSI6Y4gMD-k,742 +tzdata/zoneinfo/Asia/Yakutsk,sha256=xD6zA4E228dC1mIUQ7cMO-9LORSfE-Fok0awGDG6juk,741 +tzdata/zoneinfo/Asia/Yangon,sha256=6J2DXIEdTaRKqLOGeCzogo3whaoO6PJWYamIHS8A6Qw,187 +tzdata/zoneinfo/Asia/Yekaterinburg,sha256=q17eUyqOEK2LJYKXYLCJqylj-vmaCG2vSNMttqrQTRk,760 +tzdata/zoneinfo/Asia/Yerevan,sha256=pLEBdchA8H9l-9hdA6FjHmwaj5T1jupK0u-bor1KKa0,708 +tzdata/zoneinfo/Asia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Asia/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Atlantic/Azores,sha256=6XBp-rgg8hERTe2c-bTKahYPlkDn2sROBuqo9wAdtPE,1401 +tzdata/zoneinfo/Atlantic/Bermuda,sha256=PuxqD2cD99Pzjb8hH99Dws053d_zXnZHjeH0kZ8LSLI,1024 +tzdata/zoneinfo/Atlantic/Canary,sha256=XMmxBlscPIWXhiauKy_d5bxX4xjNMM-5Vw84FwZkT00,478 +tzdata/zoneinfo/Atlantic/Cape_Verde,sha256=E5ss6xpIpD0g_VEDsFMFi-ltsebp98PBSpULoVxIAyU,175 +tzdata/zoneinfo/Atlantic/Faeroe,sha256=Iw0qB0mBuviH5w3Qy8jaxCOes07ZHh2wkW8MPUWJqj0,441 +tzdata/zoneinfo/Atlantic/Faroe,sha256=Iw0qB0mBuviH5w3Qy8jaxCOes07ZHh2wkW8MPUWJqj0,441 +tzdata/zoneinfo/Atlantic/Jan_Mayen,sha256=p_2ZMteF1NaQkAuDTDVjwYEMHPLgFxG8wJJq9sB2fLc,705 +tzdata/zoneinfo/Atlantic/Madeira,sha256=2F3vLmp7OTm4ZMSLxyIVQQ6iXeGUkKKPeUdiGmqVuuI,1372 +tzdata/zoneinfo/Atlantic/Reykjavik,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Atlantic/South_Georgia,sha256=kPGfCLQD2C6_Xc5TyAmqmXP-GYdLLPucpBn3S7ybWu8,132 +tzdata/zoneinfo/Atlantic/St_Helena,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Atlantic/Stanley,sha256=QqQd8IWklNapMKjN5vF7vvVn4K-yl3VKvM5zkCKabCM,789 +tzdata/zoneinfo/Atlantic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Atlantic/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Australia/ACT,sha256=gg1FqGioj4HHMdWyx1i07QAAObYmCoBDP44PCUpgS1k,904 +tzdata/zoneinfo/Australia/Adelaide,sha256=Gk1SdGRVmB233I-WETXAMCZz7L7HVzoN4aUoIcgNr3g,921 +tzdata/zoneinfo/Australia/Brisbane,sha256=2kVWz9CI_qtfdb55g0iL59gUBC7lnO3GUalIQxtHADY,289 +tzdata/zoneinfo/Australia/Broken_Hill,sha256=dzk9LvGA_xRStnAIjAFuTJ8Uwz_s7qGWGQmiXPgDsLY,941 +tzdata/zoneinfo/Australia/Canberra,sha256=gg1FqGioj4HHMdWyx1i07QAAObYmCoBDP44PCUpgS1k,904 +tzdata/zoneinfo/Australia/Currie,sha256=1IAVgf0AA3sBPXFhaxGfu9UQ_cpd4GNpsQ9xio2l4y0,1003 +tzdata/zoneinfo/Australia/Darwin,sha256=ZoexbhgdUlV4leV-dhBu6AxDVkJy43xrPb9UQ3EQCdI,234 +tzdata/zoneinfo/Australia/Eucla,sha256=3NqsFfMzR6-lSUPViNXBAOyJPqyokisse7uDXurURpk,314 +tzdata/zoneinfo/Australia/Hobart,sha256=1IAVgf0AA3sBPXFhaxGfu9UQ_cpd4GNpsQ9xio2l4y0,1003 +tzdata/zoneinfo/Australia/LHI,sha256=82i9JWWcApPQK7eex9rH1bc6kt_6_OFLTdL_uLoRqto,692 +tzdata/zoneinfo/Australia/Lindeman,sha256=iHkCc0QJ7iaQffiTTXQVJ2swsC7QJxLUMHQOGCFlkTk,325 +tzdata/zoneinfo/Australia/Lord_Howe,sha256=82i9JWWcApPQK7eex9rH1bc6kt_6_OFLTdL_uLoRqto,692 +tzdata/zoneinfo/Australia/Melbourne,sha256=X7JPMEj_SYWyfgWFMkp6FOmT6GfyjR-lF9hFGgTavnE,904 +tzdata/zoneinfo/Australia/NSW,sha256=gg1FqGioj4HHMdWyx1i07QAAObYmCoBDP44PCUpgS1k,904 +tzdata/zoneinfo/Australia/North,sha256=ZoexbhgdUlV4leV-dhBu6AxDVkJy43xrPb9UQ3EQCdI,234 +tzdata/zoneinfo/Australia/Perth,sha256=ZsuelcBC1YfWugH2CrlOXQcSDD4gGUJCobB1W-aupHo,306 +tzdata/zoneinfo/Australia/Queensland,sha256=2kVWz9CI_qtfdb55g0iL59gUBC7lnO3GUalIQxtHADY,289 +tzdata/zoneinfo/Australia/South,sha256=Gk1SdGRVmB233I-WETXAMCZz7L7HVzoN4aUoIcgNr3g,921 +tzdata/zoneinfo/Australia/Sydney,sha256=gg1FqGioj4HHMdWyx1i07QAAObYmCoBDP44PCUpgS1k,904 +tzdata/zoneinfo/Australia/Tasmania,sha256=1IAVgf0AA3sBPXFhaxGfu9UQ_cpd4GNpsQ9xio2l4y0,1003 +tzdata/zoneinfo/Australia/Victoria,sha256=X7JPMEj_SYWyfgWFMkp6FOmT6GfyjR-lF9hFGgTavnE,904 +tzdata/zoneinfo/Australia/West,sha256=ZsuelcBC1YfWugH2CrlOXQcSDD4gGUJCobB1W-aupHo,306 +tzdata/zoneinfo/Australia/Yancowinna,sha256=dzk9LvGA_xRStnAIjAFuTJ8Uwz_s7qGWGQmiXPgDsLY,941 +tzdata/zoneinfo/Australia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Australia/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Brazil/Acre,sha256=VjuQUr668phq5bcH40r94BPnZBKHzJf_MQBfM6Db96U,418 +tzdata/zoneinfo/Brazil/DeNoronha,sha256=Q0r3GtA5y2RGkOj56OTZG5tuBy1B6kfbhyrJqCgf27g,484 +tzdata/zoneinfo/Brazil/East,sha256=-izrIi8GXAKJ85l_8MVLoFp0pZm0Uihw-oapbiThiJE,952 +tzdata/zoneinfo/Brazil/West,sha256=9kgrhpryB94YOVoshJliiiDSf9mwjb3OZwX0HusNRrk,412 +tzdata/zoneinfo/Brazil/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Brazil/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/CET,sha256=sQ-VQqhQnwpj68p449gEMt2GuOopZAAoD-vZz6dugog,1103 +tzdata/zoneinfo/CST6CDT,sha256=ZYgFlJ39-ylbvdnEeV2gmknBVP-pdw_XGBcvg4xv_S8,922 +tzdata/zoneinfo/Canada/Atlantic,sha256=kO5ahBM2oTLfWS4KX15FbKXfo5wg-f9vw1_hMOISGig,1672 +tzdata/zoneinfo/Canada/Central,sha256=YHLl-4ApALGTQHI5tPtN6fss6AtD6g9ChqlUZltWXL0,1637 +tzdata/zoneinfo/Canada/Eastern,sha256=gVq023obEpKGfS-SS3GOG7oyRVzp-SIF2y_rZQKcZ2E,1717 +tzdata/zoneinfo/Canada/Mountain,sha256=1SFztWooIF2Nb3krz6i8B2FO4NJp979uQ-yR9o1BBgA,1313 +tzdata/zoneinfo/Canada/Newfoundland,sha256=v99q_AFMPll5MMxMp98aqY40cmis2wciTfTqs2_kb0k,1878 +tzdata/zoneinfo/Canada/Pacific,sha256=fSNoGzaEmsf1BTe5wCvY06oAC5i9PRglzoXn6j5VNMk,1673 +tzdata/zoneinfo/Canada/Saskatchewan,sha256=_JHuns225iE-THc9NFp-RBq4PWULAuGw2OLbpOB_UMw,638 +tzdata/zoneinfo/Canada/Yukon,sha256=CyY4jNd0fzNSdf1HlYGfaktApmH71tRNRlpOEO32DGs,1029 +tzdata/zoneinfo/Canada/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Canada/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Chile/Continental,sha256=_QBpU8K0QqLh5m2yqWfdkypIJDkPAc3dnIAc5jRQxxU,1354 +tzdata/zoneinfo/Chile/EasterIsland,sha256=EwVM74XjsboPVxK9bWmdd4nTrtvasP1zlLdxrMB_YaE,1174 +tzdata/zoneinfo/Chile/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Chile/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Cuba,sha256=ms5rCuq2yBM49VmTymMtFQN3c5aBN1lkd8jjzKdnNm8,1117 +tzdata/zoneinfo/EET,sha256=8f1niwVI4ymziTT2KBJV5pjfp2GtH_hB9sy3lgbGE0U,682 +tzdata/zoneinfo/EST,sha256=p41zBnujy9lPiiPf3WqotoyzOxhIS8F7TiDqGuwvCoE,149 +tzdata/zoneinfo/EST5EDT,sha256=0FxlVQKTLDO_nBY3060ZugTCBgsENR1LcHc4-X8-ZM8,922 +tzdata/zoneinfo/Egypt,sha256=icuaNiEvuC6TPc2fqhDv36lpop7IDDIGO7tFGMAz0b4,1309 +tzdata/zoneinfo/Eire,sha256=25SXsKn8r8ZjCw8GtB7bGCd5Ozsi2feZ0RQZ4EOfluw,1496 +tzdata/zoneinfo/Etc/GMT,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/Etc/GMT+0,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/Etc/GMT+1,sha256=5L9o8TEUgtB11poIag85vRdq08LMDZmZ6DPn7UqPL_g,113 +tzdata/zoneinfo/Etc/GMT+10,sha256=IvBxiqQU76qzNbuxRo8Ah9rPQSRGQGKp_SRs5u1PPkM,114 +tzdata/zoneinfo/Etc/GMT+11,sha256=9MfFpFp_rt9PksMjQ23VOlir3hzTlnLz_5V2tfonhbU,114 +tzdata/zoneinfo/Etc/GMT+12,sha256=l26XCFp9IbgXGvMw7NHgHzIZbHry2B5qGYfhMDHFVrw,114 +tzdata/zoneinfo/Etc/GMT+2,sha256=YbbqH7B6jNoQEIjyV4-8a2cXD9lGC3vQKnEkY2ucDGI,113 +tzdata/zoneinfo/Etc/GMT+3,sha256=q3D9DLfmTBUAo4YMnNUNUUKrAkKSwM5Q-vesd9A6SZQ,113 +tzdata/zoneinfo/Etc/GMT+4,sha256=UghKME3laXSDZ7q74YDb4FcLnzNqXQydcZpQHvssP2k,113 +tzdata/zoneinfo/Etc/GMT+5,sha256=TZ5qaoELlszW_Z5FdqAEMKk8Y_xu5XhZBNZUco55SrM,113 +tzdata/zoneinfo/Etc/GMT+6,sha256=_2k3LZ5x8hVjMwwmCx6GqUwW-v1IvOkBrJjYH5bD6Qw,113 +tzdata/zoneinfo/Etc/GMT+7,sha256=Di8J430WGr98Ww95tdfIo8hGxkVQfJvlx55ansDuoeQ,113 +tzdata/zoneinfo/Etc/GMT+8,sha256=OIIlUFhZwL2ctx3fxINbY2HDDAmSQ7i2ZAUgX7Exjgw,113 +tzdata/zoneinfo/Etc/GMT+9,sha256=1vpkIoPqBiwDWzH-fLFxwNbmdKRY7mqdiJhYQImVxaw,113 +tzdata/zoneinfo/Etc/GMT-0,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/Etc/GMT-1,sha256=S81S9Z0-V-0B5U-0S0Pnbx8fv2iHtwE1LrlZk-ckLto,114 +tzdata/zoneinfo/Etc/GMT-10,sha256=VvdG5IpXB_xJX4omzfrrHblkRUzkbCZXPhTrLngc7vk,115 +tzdata/zoneinfo/Etc/GMT-11,sha256=2sYLfVuDFSy7Kc1WOPiY1EqquHw5Xx4HbDA1QOL1hc4,115 +tzdata/zoneinfo/Etc/GMT-12,sha256=ifHVhk5fczZG3GDy_Nv7YsLNaxf8stB4MrzgWUCINlU,115 +tzdata/zoneinfo/Etc/GMT-13,sha256=CMkORdXsaSyL-4N0n37Cyc1lCr22ZsWyug9_QZVe0E0,115 +tzdata/zoneinfo/Etc/GMT-14,sha256=NK07ElwueU0OP8gORtcXUUug_3v4d04uxfVHMUnLM9U,115 +tzdata/zoneinfo/Etc/GMT-2,sha256=QMToMLcif1S4SNPOMxMtBLqc1skUYnIhbUAjKEdAf9w,114 +tzdata/zoneinfo/Etc/GMT-3,sha256=10GMvfulaJwDQiHiWEJiU_YURyjDfPcl5ugnYBugN3E,114 +tzdata/zoneinfo/Etc/GMT-4,sha256=c6Kx3v41GRkrvky8k71db_UJbpyyp2OZCsjDSvjkr6s,114 +tzdata/zoneinfo/Etc/GMT-5,sha256=94TvO8e_8t52bs8ry70nAquvgK8qJKQTI7lQnVCHX-U,114 +tzdata/zoneinfo/Etc/GMT-6,sha256=3fH8eX--0iDijmYAQHQ0IUXheezaj6-aadZsQNAB4fE,114 +tzdata/zoneinfo/Etc/GMT-7,sha256=DnsTJ3NUYYGLUwFb_L15U_GbaMF-acLVsPyTNySyH-M,114 +tzdata/zoneinfo/Etc/GMT-8,sha256=kvGQUwONDBG7nhEp_wESc4xl4xNXiXEivxAv09nkr_g,114 +tzdata/zoneinfo/Etc/GMT-9,sha256=U1WRFGWQAW91JXK99gY1K9d0rFZYDWHzDUR3z71Lh6Y,114 +tzdata/zoneinfo/Etc/GMT0,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/Etc/Greenwich,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/Etc/UCT,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/Etc/UTC,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/Etc/Universal,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/Etc/Zulu,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/Etc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Etc/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Europe/Amsterdam,sha256=sQ-VQqhQnwpj68p449gEMt2GuOopZAAoD-vZz6dugog,1103 +tzdata/zoneinfo/Europe/Andorra,sha256=leuTyE4uduIBX0aHb_7PK_KlslpWSyS6e0SS84hKFrE,389 +tzdata/zoneinfo/Europe/Astrakhan,sha256=P3E5UDgQ4gqsMi-KdMAWwOSStogdcNl9rLMVUdpFLXI,726 +tzdata/zoneinfo/Europe/Athens,sha256=8f1niwVI4ymziTT2KBJV5pjfp2GtH_hB9sy3lgbGE0U,682 +tzdata/zoneinfo/Europe/Belfast,sha256=Z2VB8LitRXx0TAk_gHWJrcrZCeP9A_kBeH0IeG7tvTM,1599 +tzdata/zoneinfo/Europe/Belgrade,sha256=qMlk8-qnognZplD7FsaMAD6aX8Yv-7sQ-oSdVPs2YtY,478 +tzdata/zoneinfo/Europe/Berlin,sha256=p_2ZMteF1NaQkAuDTDVjwYEMHPLgFxG8wJJq9sB2fLc,705 +tzdata/zoneinfo/Europe/Bratislava,sha256=pukw4zdc3LUffYp0iFr_if0UuGHrt1yzOdD5HBbBRpo,723 +tzdata/zoneinfo/Europe/Brussels,sha256=sQ-VQqhQnwpj68p449gEMt2GuOopZAAoD-vZz6dugog,1103 +tzdata/zoneinfo/Europe/Bucharest,sha256=iY74H96aaTMJvmqAhzUoSI8SjZUtPvv4PGF4ClwFm6U,661 +tzdata/zoneinfo/Europe/Budapest,sha256=qNr-valoDI1mevuQXqOMkOhIcT194EczOKIijxrDMV8,766 +tzdata/zoneinfo/Europe/Busingen,sha256=GZBiscMM_rI3XshMVt9SvlGJGYamKTt6Ek06YlCfRek,497 +tzdata/zoneinfo/Europe/Chisinau,sha256=Q54cpE4kU4cUjBFB19fF6EvMpzGI_4U1GhJsje6g4S4,1207 +tzdata/zoneinfo/Europe/Copenhagen,sha256=p_2ZMteF1NaQkAuDTDVjwYEMHPLgFxG8wJJq9sB2fLc,705 +tzdata/zoneinfo/Europe/Dublin,sha256=25SXsKn8r8ZjCw8GtB7bGCd5Ozsi2feZ0RQZ4EOfluw,1496 +tzdata/zoneinfo/Europe/Gibraltar,sha256=t1hglDTLUIFqs91nY5lulN7oxkoAXHnh0zjyaKG2bG8,1220 +tzdata/zoneinfo/Europe/Guernsey,sha256=Z2VB8LitRXx0TAk_gHWJrcrZCeP9A_kBeH0IeG7tvTM,1599 +tzdata/zoneinfo/Europe/Helsinki,sha256=ccpK9ZmPCZkMXoddNQ_DyONPKAuub-FPNtRpL6znpWM,481 +tzdata/zoneinfo/Europe/Isle_of_Man,sha256=Z2VB8LitRXx0TAk_gHWJrcrZCeP9A_kBeH0IeG7tvTM,1599 +tzdata/zoneinfo/Europe/Istanbul,sha256=KnFjsWuUgG9pmRNI59CmDEbrYbHwMF9fS4P2E9sQgG8,1200 +tzdata/zoneinfo/Europe/Jersey,sha256=Z2VB8LitRXx0TAk_gHWJrcrZCeP9A_kBeH0IeG7tvTM,1599 +tzdata/zoneinfo/Europe/Kaliningrad,sha256=57ov9G8m25w1pPdJF8zoFWzq5I6UoBMVsk2eHPelbA8,904 +tzdata/zoneinfo/Europe/Kiev,sha256=BYnoDd7Ov50wd4mMEpddK-c5PfKFbumSbFNHY-Hia_I,558 +tzdata/zoneinfo/Europe/Kirov,sha256=KqXGcIbMGTuOoKZYBG-5bj7kVzFbKyGMA99PA0414D0,735 +tzdata/zoneinfo/Europe/Kyiv,sha256=BYnoDd7Ov50wd4mMEpddK-c5PfKFbumSbFNHY-Hia_I,558 +tzdata/zoneinfo/Europe/Lisbon,sha256=RNL2z4RzfmoeDa-RQQnpQla-ykC0DJoRt6BOi92u5Ow,1463 +tzdata/zoneinfo/Europe/Ljubljana,sha256=qMlk8-qnognZplD7FsaMAD6aX8Yv-7sQ-oSdVPs2YtY,478 +tzdata/zoneinfo/Europe/London,sha256=Z2VB8LitRXx0TAk_gHWJrcrZCeP9A_kBeH0IeG7tvTM,1599 +tzdata/zoneinfo/Europe/Luxembourg,sha256=sQ-VQqhQnwpj68p449gEMt2GuOopZAAoD-vZz6dugog,1103 +tzdata/zoneinfo/Europe/Madrid,sha256=ylsyHdv8iOB-DQPtL6DIMs5dDdjn2QolIAqOJImMOyE,897 +tzdata/zoneinfo/Europe/Malta,sha256=irX_nDD-BXYObaduu_vhPe1F31xmgL364dSOaT_OVco,928 +tzdata/zoneinfo/Europe/Mariehamn,sha256=ccpK9ZmPCZkMXoddNQ_DyONPKAuub-FPNtRpL6znpWM,481 +tzdata/zoneinfo/Europe/Minsk,sha256=86iP_xDtidkUCqjkoKhH5_El3VI21fSgoIiXl_BzUaU,808 +tzdata/zoneinfo/Europe/Monaco,sha256=zViOd5xXN9cOTkcVja-reUWwJrK7NEVMxHdBgVRZsGg,1105 +tzdata/zoneinfo/Europe/Moscow,sha256=7S4KCZ-0RrJBZoNDjT9W-fxaYqFsdUmn9Zy8k1s2TIo,908 +tzdata/zoneinfo/Europe/Nicosia,sha256=TYYqWp8sK0AwBUHAp0wuuihZuQ19RXdt28bth33zOBI,597 +tzdata/zoneinfo/Europe/Oslo,sha256=p_2ZMteF1NaQkAuDTDVjwYEMHPLgFxG8wJJq9sB2fLc,705 +tzdata/zoneinfo/Europe/Paris,sha256=zViOd5xXN9cOTkcVja-reUWwJrK7NEVMxHdBgVRZsGg,1105 +tzdata/zoneinfo/Europe/Podgorica,sha256=qMlk8-qnognZplD7FsaMAD6aX8Yv-7sQ-oSdVPs2YtY,478 +tzdata/zoneinfo/Europe/Prague,sha256=pukw4zdc3LUffYp0iFr_if0UuGHrt1yzOdD5HBbBRpo,723 +tzdata/zoneinfo/Europe/Riga,sha256=PU8amev-8XVvl4B_JUOOOM1ofSMbotp-3MPGPHpPoTw,694 +tzdata/zoneinfo/Europe/Rome,sha256=hr0moG_jBXs2zyndejOPJSSv-BFu8I0AWqIRTqYSKGk,947 +tzdata/zoneinfo/Europe/Samara,sha256=Vc60AJe-0-b8prNiFwZTUS1bCbWxxuEnnNcgp8YkQRY,732 +tzdata/zoneinfo/Europe/San_Marino,sha256=hr0moG_jBXs2zyndejOPJSSv-BFu8I0AWqIRTqYSKGk,947 +tzdata/zoneinfo/Europe/Sarajevo,sha256=qMlk8-qnognZplD7FsaMAD6aX8Yv-7sQ-oSdVPs2YtY,478 +tzdata/zoneinfo/Europe/Saratov,sha256=0fN3eVFVewG-DSVk9xJABDQB1S_Nyn37bHOjj5X8Bm0,726 +tzdata/zoneinfo/Europe/Simferopol,sha256=y2Nybf9LGVNqNdW_GPS-NIDRLriyH_pyxKpT0zmATK4,865 +tzdata/zoneinfo/Europe/Skopje,sha256=qMlk8-qnognZplD7FsaMAD6aX8Yv-7sQ-oSdVPs2YtY,478 +tzdata/zoneinfo/Europe/Sofia,sha256=LQjC-OJkL4TzZcqD-JUofDAg1-qJui_2Ri6Eoii2MuQ,592 +tzdata/zoneinfo/Europe/Stockholm,sha256=p_2ZMteF1NaQkAuDTDVjwYEMHPLgFxG8wJJq9sB2fLc,705 +tzdata/zoneinfo/Europe/Tallinn,sha256=R6yRfPqESOYQWftlncDWo_fQak61eeiEQKwg_C-C7W8,675 +tzdata/zoneinfo/Europe/Tirane,sha256=I-alATWRd8mfSgvnr3dN_F9vbTB66alvz2GQo0LUbPc,604 +tzdata/zoneinfo/Europe/Tiraspol,sha256=Q54cpE4kU4cUjBFB19fF6EvMpzGI_4U1GhJsje6g4S4,1207 +tzdata/zoneinfo/Europe/Ulyanovsk,sha256=2vK0XahtB_dKjDDXccjMjbQ2bAOfKDe66uMDqtjzHm4,760 +tzdata/zoneinfo/Europe/Uzhgorod,sha256=BYnoDd7Ov50wd4mMEpddK-c5PfKFbumSbFNHY-Hia_I,558 +tzdata/zoneinfo/Europe/Vaduz,sha256=GZBiscMM_rI3XshMVt9SvlGJGYamKTt6Ek06YlCfRek,497 +tzdata/zoneinfo/Europe/Vatican,sha256=hr0moG_jBXs2zyndejOPJSSv-BFu8I0AWqIRTqYSKGk,947 +tzdata/zoneinfo/Europe/Vienna,sha256=q8_UF23-KHqc2ay4ju0qT1TuBSpRTnlB7i6vElk4eJw,658 +tzdata/zoneinfo/Europe/Vilnius,sha256=hXvv1PaQndapT7hdywPO3738Y3ZqbW_hJx87khyaOPM,676 +tzdata/zoneinfo/Europe/Volgograd,sha256=v3P6iFJ-rThJprVNDxB7ZYDrimtsW7IvQi_gJpZiJOQ,753 +tzdata/zoneinfo/Europe/Warsaw,sha256=6I9aUfFoFXpBrC3YpO4OmoeUGchMYSK0dxsaKjPZOkw,923 +tzdata/zoneinfo/Europe/Zagreb,sha256=qMlk8-qnognZplD7FsaMAD6aX8Yv-7sQ-oSdVPs2YtY,478 +tzdata/zoneinfo/Europe/Zaporozhye,sha256=BYnoDd7Ov50wd4mMEpddK-c5PfKFbumSbFNHY-Hia_I,558 +tzdata/zoneinfo/Europe/Zurich,sha256=GZBiscMM_rI3XshMVt9SvlGJGYamKTt6Ek06YlCfRek,497 +tzdata/zoneinfo/Europe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Europe/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Factory,sha256=0ytXntCnQnMWvqJgue4mdUUQRr1YxXxnnCTyZxhgr3Y,113 +tzdata/zoneinfo/GB,sha256=Z2VB8LitRXx0TAk_gHWJrcrZCeP9A_kBeH0IeG7tvTM,1599 +tzdata/zoneinfo/GB-Eire,sha256=Z2VB8LitRXx0TAk_gHWJrcrZCeP9A_kBeH0IeG7tvTM,1599 +tzdata/zoneinfo/GMT,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/GMT+0,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/GMT-0,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/GMT0,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/Greenwich,sha256=3EoHVxsQiE5PTzRQydGhy_TAPvU9Bu0uTqFS2eul1dc,111 +tzdata/zoneinfo/HST,sha256=HapXKaoeDzLNRL4RLQGtTMVnqf522H3LuRgr6NLIj_A,221 +tzdata/zoneinfo/Hongkong,sha256=9AaPcyRtuXQX9zRnRTVkxX1mRs5JCbn6JTaSPvzX608,775 +tzdata/zoneinfo/Iceland,sha256=8-f8qg6YQP9BadNWfY-1kmZEhI9JY9es-SMghDxdSG4,130 +tzdata/zoneinfo/Indian/Antananarivo,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Indian/Chagos,sha256=J_aS7rs0ZG1dPTGeokXxNJpF4Pds8u1ct49cRtX7giY,152 +tzdata/zoneinfo/Indian/Christmas,sha256=zcjiwoLYvJpenDyvL8Rf9OnlzRj13sjLhzNArXxYTWQ,152 +tzdata/zoneinfo/Indian/Cocos,sha256=6J2DXIEdTaRKqLOGeCzogo3whaoO6PJWYamIHS8A6Qw,187 +tzdata/zoneinfo/Indian/Comoro,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Indian/Kerguelen,sha256=lEhfD1j4QnZ-wtuTU51fw6-yvc4WZz2eY8CYjMzWQ44,152 +tzdata/zoneinfo/Indian/Mahe,sha256=DZ6lBT6DGIAypvtNMB1dtoj0MBHltrH5F6EbcaDaexY,133 +tzdata/zoneinfo/Indian/Maldives,sha256=lEhfD1j4QnZ-wtuTU51fw6-yvc4WZz2eY8CYjMzWQ44,152 +tzdata/zoneinfo/Indian/Mauritius,sha256=R6pdJalrHVK5LlGOmEsyD66_-c5a9ptJM-xE71Fo8hQ,179 +tzdata/zoneinfo/Indian/Mayotte,sha256=B4OFT1LDOtprbSpdhnZi8K6OFSONL857mtpPTTGetGY,191 +tzdata/zoneinfo/Indian/Reunion,sha256=DZ6lBT6DGIAypvtNMB1dtoj0MBHltrH5F6EbcaDaexY,133 +tzdata/zoneinfo/Indian/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Indian/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Iran,sha256=RS1aCXpsJg_MtOeyKbTt3KVWP1ysMMUVvInLc7xhW3I,812 +tzdata/zoneinfo/Israel,sha256=n83o1YTeoFhfXIcnqvNfSKFJ4NvTqDv2zvi8qcFAIeM,1074 +tzdata/zoneinfo/Jamaica,sha256=pDexcAMzrv9TqLWGjVOHwIDcFMLT6Vqlzjb5AbNmkoQ,339 +tzdata/zoneinfo/Japan,sha256=WaOHFDDw07k-YZ-jCkOkHR6IvdSf8m8J0PQFpQBwb5Y,213 +tzdata/zoneinfo/Kwajalein,sha256=S-ZFi6idKzDaelLy7DRjGPeD0s7oVud3xLMxZKNlBk8,219 +tzdata/zoneinfo/Libya,sha256=zzMBLZZh4VQ4_ARe5k4L_rsuqKP7edKvVt8F6kvj5FM,431 +tzdata/zoneinfo/MET,sha256=sQ-VQqhQnwpj68p449gEMt2GuOopZAAoD-vZz6dugog,1103 +tzdata/zoneinfo/MST,sha256=rhFFPCHQiYTedfLv7ATckxeKe04jxeUvIJi4vUXMtUc,240 +tzdata/zoneinfo/MST7MDT,sha256=68_sWNC3qS3eBlE4K5ARSZYHP6P2edBq66KAITOEmw8,922 +tzdata/zoneinfo/Mexico/BajaNorte,sha256=r5rqSu5QUUP6XoR2Q8D_4WQZDDhBEBCsfwsXD0CYpsg,1367 +tzdata/zoneinfo/Mexico/BajaSur,sha256=IN7ecQ9SDq9sDNvu_nc_xuMN2LHSiq8X6YQgmVUe6aY,690 +tzdata/zoneinfo/Mexico/General,sha256=N90r8I8T_OD3B8Ox9M7EAY772cR8g2ew-03rvUYb1y8,773 +tzdata/zoneinfo/Mexico/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Mexico/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/NZ,sha256=Dgbn5VrtvJLvWz0Qbnw5KrFijP2KQosg6S6ZAooL-7k,1043 +tzdata/zoneinfo/NZ-CHAT,sha256=pnhY_Lb8V4eo6cK3yL6JZL086SI_etG6rCycppJfTHg,808 +tzdata/zoneinfo/Navajo,sha256=m7cDkg7KS2EZ6BoQVYOk9soiBlHxO0GEeat81WxBPz4,1042 +tzdata/zoneinfo/PRC,sha256=v4t-2C_m5j5tmPjOqTTurJAc0Wq6hetXVc4_i0KJ6oo,393 +tzdata/zoneinfo/PST8PDT,sha256=p7qqB38AANRUAiV8_O5XJqOxh1h0tC2p_WdLDXYFBvY,922 +tzdata/zoneinfo/Pacific/Apia,sha256=3HDEfICrLIehq3VLq4_r_DhQgFniSd_lXnOjdZgI6hQ,407 +tzdata/zoneinfo/Pacific/Auckland,sha256=Dgbn5VrtvJLvWz0Qbnw5KrFijP2KQosg6S6ZAooL-7k,1043 +tzdata/zoneinfo/Pacific/Bougainville,sha256=rqdn1Y4HSarx-vjPk00lsHNfhj3IQgKCViAsumuN_IY,201 +tzdata/zoneinfo/Pacific/Chatham,sha256=pnhY_Lb8V4eo6cK3yL6JZL086SI_etG6rCycppJfTHg,808 +tzdata/zoneinfo/Pacific/Chuuk,sha256=aDABBVtu-dydiHNODt3ReC8cNkO3wTp16c-OkFIAbhk,154 +tzdata/zoneinfo/Pacific/Easter,sha256=EwVM74XjsboPVxK9bWmdd4nTrtvasP1zlLdxrMB_YaE,1174 +tzdata/zoneinfo/Pacific/Efate,sha256=LiX_rTfipQh_Vnqb_m7OGxyBtyAUC9UANVKHUpLoCcU,342 +tzdata/zoneinfo/Pacific/Enderbury,sha256=ojOG-oqi25HOnY6BFhav_3bmWg1LDILT4v-kxOFVuqI,172 +tzdata/zoneinfo/Pacific/Fakaofo,sha256=Uf8zeML2X8doPg8CX-p0mMGP-IOj7aHAMe7ULD5khxA,153 +tzdata/zoneinfo/Pacific/Fiji,sha256=umCNhtTuBziTXne-WAxzvYvGKqZxTYOTwK-tJhYh4MQ,396 +tzdata/zoneinfo/Pacific/Funafuti,sha256=CQNWIL2DFpej6Qcvgt40z8pekS1QyNpUdzmqLyj7bY4,134 +tzdata/zoneinfo/Pacific/Galapagos,sha256=Z1KJPZSvO8M_Pay9WLcNAxzjo8imPrQ7FnXNOXfZl8c,175 +tzdata/zoneinfo/Pacific/Gambier,sha256=yIh86hjpDk1wRWTVJROOGqn9tkc7e9_O6zNxqs-wBoM,132 +tzdata/zoneinfo/Pacific/Guadalcanal,sha256=Ui8PN0th4sb1-n0Z8ceszNCeSiE0Yu47QskNMr8r8Yw,134 +tzdata/zoneinfo/Pacific/Guam,sha256=i57eM6syriUFvAbrVALnziCw_I4lENyzBcJdOaH71yU,350 +tzdata/zoneinfo/Pacific/Honolulu,sha256=HapXKaoeDzLNRL4RLQGtTMVnqf522H3LuRgr6NLIj_A,221 +tzdata/zoneinfo/Pacific/Johnston,sha256=HapXKaoeDzLNRL4RLQGtTMVnqf522H3LuRgr6NLIj_A,221 +tzdata/zoneinfo/Pacific/Kanton,sha256=ojOG-oqi25HOnY6BFhav_3bmWg1LDILT4v-kxOFVuqI,172 +tzdata/zoneinfo/Pacific/Kiritimati,sha256=cUVGmMRBgllfuYJ3X0B0zg0Bf-LPo9l7Le5ju882dx4,174 +tzdata/zoneinfo/Pacific/Kosrae,sha256=pQMLJXilygPhlkm0jCo5JuVmpmYJgLIdiTVxeP59ZEg,242 +tzdata/zoneinfo/Pacific/Kwajalein,sha256=S-ZFi6idKzDaelLy7DRjGPeD0s7oVud3xLMxZKNlBk8,219 +tzdata/zoneinfo/Pacific/Majuro,sha256=CQNWIL2DFpej6Qcvgt40z8pekS1QyNpUdzmqLyj7bY4,134 +tzdata/zoneinfo/Pacific/Marquesas,sha256=ilprkRvn-N1XjptSI_0ZwUjeuokP-5l64uKjRBp0kxw,139 +tzdata/zoneinfo/Pacific/Midway,sha256=ZQ2Rh1E2ZZBVMGPNaBWS_cqKCZV-DOLBjWaX7Dhe95Y,146 +tzdata/zoneinfo/Pacific/Nauru,sha256=wahZONjreNAmYwhQ2CWdKMAE3SVm4S2aYvMZqcAlSYc,183 +tzdata/zoneinfo/Pacific/Niue,sha256=8WWebtgCnrMBKjuLNEYEWlktNI2op2kkKgk0Vcz8GaM,154 +tzdata/zoneinfo/Pacific/Norfolk,sha256=vL8G6W5CScYqp76g0b15UPIYHw2Lt60qOktHUF7caDs,237 +tzdata/zoneinfo/Pacific/Noumea,sha256=ezUyn7AYWBblrZbStlItJYu7XINCLiihrCBZB-Bl-Qw,198 +tzdata/zoneinfo/Pacific/Pago_Pago,sha256=ZQ2Rh1E2ZZBVMGPNaBWS_cqKCZV-DOLBjWaX7Dhe95Y,146 +tzdata/zoneinfo/Pacific/Palau,sha256=VkLRsKUUVXo3zrhAXn9iM-pKySbGIVfzWoopDhmceMA,148 +tzdata/zoneinfo/Pacific/Pitcairn,sha256=AJh6olJxXQzCMWKOE5ye4jHfgg1VA-9-gCZ5MbrX_8E,153 +tzdata/zoneinfo/Pacific/Pohnpei,sha256=Ui8PN0th4sb1-n0Z8ceszNCeSiE0Yu47QskNMr8r8Yw,134 +tzdata/zoneinfo/Pacific/Ponape,sha256=Ui8PN0th4sb1-n0Z8ceszNCeSiE0Yu47QskNMr8r8Yw,134 +tzdata/zoneinfo/Pacific/Port_Moresby,sha256=aDABBVtu-dydiHNODt3ReC8cNkO3wTp16c-OkFIAbhk,154 +tzdata/zoneinfo/Pacific/Rarotonga,sha256=J6a2mOrTp4bsZNovj3HjJK9AVJ89PhdEpQMMVD__i18,406 +tzdata/zoneinfo/Pacific/Saipan,sha256=i57eM6syriUFvAbrVALnziCw_I4lENyzBcJdOaH71yU,350 +tzdata/zoneinfo/Pacific/Samoa,sha256=ZQ2Rh1E2ZZBVMGPNaBWS_cqKCZV-DOLBjWaX7Dhe95Y,146 +tzdata/zoneinfo/Pacific/Tahiti,sha256=Ivcs04hthxEQj1I_6aACc70By0lmxlvhgGFYh843e14,133 +tzdata/zoneinfo/Pacific/Tarawa,sha256=CQNWIL2DFpej6Qcvgt40z8pekS1QyNpUdzmqLyj7bY4,134 +tzdata/zoneinfo/Pacific/Tongatapu,sha256=mjGjNSUATfw0yLGB0zsLxz3_L1uWxPANML8K4HQQIMY,237 +tzdata/zoneinfo/Pacific/Truk,sha256=aDABBVtu-dydiHNODt3ReC8cNkO3wTp16c-OkFIAbhk,154 +tzdata/zoneinfo/Pacific/Wake,sha256=CQNWIL2DFpej6Qcvgt40z8pekS1QyNpUdzmqLyj7bY4,134 +tzdata/zoneinfo/Pacific/Wallis,sha256=CQNWIL2DFpej6Qcvgt40z8pekS1QyNpUdzmqLyj7bY4,134 +tzdata/zoneinfo/Pacific/Yap,sha256=aDABBVtu-dydiHNODt3ReC8cNkO3wTp16c-OkFIAbhk,154 +tzdata/zoneinfo/Pacific/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/Pacific/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/Poland,sha256=6I9aUfFoFXpBrC3YpO4OmoeUGchMYSK0dxsaKjPZOkw,923 +tzdata/zoneinfo/Portugal,sha256=RNL2z4RzfmoeDa-RQQnpQla-ykC0DJoRt6BOi92u5Ow,1463 +tzdata/zoneinfo/ROC,sha256=oEwscvT3aoMXjQNt2X0VfuHzLkeORN2npcEJI2h-5s8,511 +tzdata/zoneinfo/ROK,sha256=ZKcLb7zJtl52Lb0l64m29AwTcUbtyNvU0IHq-s2reN4,415 +tzdata/zoneinfo/Singapore,sha256=CVSy2aMB2U9DSAJGBqcbvLL6JNPNNwn1vIvKYFA5eF0,256 +tzdata/zoneinfo/Turkey,sha256=KnFjsWuUgG9pmRNI59CmDEbrYbHwMF9fS4P2E9sQgG8,1200 +tzdata/zoneinfo/UCT,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/US/Alaska,sha256=d8oMIpYvBpmLzl5I2By4ZaFEZsg_9dxgfqpIM0QFi_Y,977 +tzdata/zoneinfo/US/Aleutian,sha256=q_sZgOINX4TsX9iBx1gNd6XGwBnzCjg6qpdAQhK0ieA,969 +tzdata/zoneinfo/US/Arizona,sha256=rhFFPCHQiYTedfLv7ATckxeKe04jxeUvIJi4vUXMtUc,240 +tzdata/zoneinfo/US/Central,sha256=wntzn_RqffBZThINcltDkhfhHkTqmlDNxJEwODtUguc,1754 +tzdata/zoneinfo/US/East-Indiana,sha256=5nj0KhPvvXvg8mqc5T4EscKKWC6rBWEcsBwWg2Qy8Hs,531 +tzdata/zoneinfo/US/Eastern,sha256=1_IgazpFmJ_JrWPVWJIlMvpzUigNX4cXa_HbecsdH6k,1744 +tzdata/zoneinfo/US/Hawaii,sha256=HapXKaoeDzLNRL4RLQGtTMVnqf522H3LuRgr6NLIj_A,221 +tzdata/zoneinfo/US/Indiana-Starke,sha256=KJCzXct8CTMItVLYLYeBqM6aT6b53gWCg6aDbsH58oI,1016 +tzdata/zoneinfo/US/Michigan,sha256=I4F8Mt9nx38AF6D-steYskBa_HHO6jKU1-W0yRFr50A,899 +tzdata/zoneinfo/US/Mountain,sha256=m7cDkg7KS2EZ6BoQVYOk9soiBlHxO0GEeat81WxBPz4,1042 +tzdata/zoneinfo/US/Pacific,sha256=IA0FdU9tg6Nxz0CNcIUSV5dlezsL6-uh5QjP_oaj5cg,1294 +tzdata/zoneinfo/US/Samoa,sha256=ZQ2Rh1E2ZZBVMGPNaBWS_cqKCZV-DOLBjWaX7Dhe95Y,146 +tzdata/zoneinfo/US/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/US/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/UTC,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/Universal,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/W-SU,sha256=7S4KCZ-0RrJBZoNDjT9W-fxaYqFsdUmn9Zy8k1s2TIo,908 +tzdata/zoneinfo/WET,sha256=RNL2z4RzfmoeDa-RQQnpQla-ykC0DJoRt6BOi92u5Ow,1463 +tzdata/zoneinfo/Zulu,sha256=_dzh5kihcyrCmv2aFhUbKXPN8ILn7AxpD35CvmtZi5M,111 +tzdata/zoneinfo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +tzdata/zoneinfo/__pycache__/__init__.cpython-310.pyc,, +tzdata/zoneinfo/iso3166.tab,sha256=g3yAeFCAyEM_2dTqh-ePFhrHpAOJMBxRU9T5AZi66yo,4841 +tzdata/zoneinfo/leapseconds,sha256=jwZvKXo3p5jVEDMhlXxfX08cndoPPQXbMLd77DSRZZ4,3694 +tzdata/zoneinfo/tzdata.zi,sha256=o37OJMzRU-utLEWPQwAj62gR9sZkjHcJZEKiLjtQZc8,104917 +tzdata/zoneinfo/zone.tab,sha256=4ujjHE4Q9EV2x5NF52BgWR27Pu9s4U4AavyKNzyqlZM,18809 +tzdata/zoneinfo/zone1970.tab,sha256=XyN4FwK_UUCP8VgdqhCas7klf7QzsVVOV52SFyiSwM8,17592 +tzdata/zoneinfo/zonenow.tab,sha256=f50cEURa96F4YsIKkIEibTGgmhcw4nD_WaNMjStMf38,8425 +tzdata/zones,sha256=KNjz6yWDkJX6iiCZl7sg6CLr--viHmDtxIOj1eINyIE,9102 diff --git a/shared/package-files/42/424cd47c12a51c7bb8d8169fac80fb5601f152bd78468b241d4b115bf7d22f20/blob b/shared/package-files/42/424cd47c12a51c7bb8d8169fac80fb5601f152bd78468b241d4b115bf7d22f20/blob new file mode 100644 index 0000000000000000000000000000000000000000..463b09d386eb40c03fa4e067bb6fe432d6581b53 Binary files /dev/null and b/shared/package-files/42/424cd47c12a51c7bb8d8169fac80fb5601f152bd78468b241d4b115bf7d22f20/blob differ diff --git a/shared/package-files/42/424e10e8e929674c6c2d491c190555ad89336f4a33a322fa625499f3fe6d1f52/blob b/shared/package-files/42/424e10e8e929674c6c2d491c190555ad89336f4a33a322fa625499f3fe6d1f52/blob new file mode 100644 index 0000000000000000000000000000000000000000..836b74ac3866b73cb2680829c67e1b6e29399877 --- /dev/null +++ b/shared/package-files/42/424e10e8e929674c6c2d491c190555ad89336f4a33a322fa625499f3fe6d1f52/blob @@ -0,0 +1,36 @@ +project('checks', 'c', 'cython') + +py = import('python').find_installation(pure: false) + +cc = meson.get_compiler('c') +cy = meson.get_compiler('cython') + +if not cy.version().version_compare('>=0.29.35') + error('tests requires Cython >= 0.29.35') +endif + +npy_include_path = run_command(py, [ + '-c', + 'import os; os.chdir(".."); import numpy; print(os.path.abspath(numpy.get_include()))' + ], check: true).stdout().strip() + +npy_path = run_command(py, [ + '-c', + 'import os; os.chdir(".."); import numpy; print(os.path.dirname(numpy.__file__).removesuffix("numpy"))' + ], check: true).stdout().strip() + +# TODO: This is a hack due to gh-25135, where cython may not find the right +# __init__.pyd file. +add_project_arguments('-I', npy_path, language : 'cython') + +py.extension_module( + 'checks', + 'checks.pyx', + install: false, + c_args: [ + '-DNPY_NO_DEPRECATED_API=0', # Cython still uses old NumPy C API + # Require 1.25+ to test datetime additions + '-DNPY_TARGET_VERSION=NPY_2_0_API_VERSION', + ], + include_directories: [npy_include_path], +) diff --git a/shared/package-files/42/424e72f83e7e39d4582a40a073e92d7312863464823ed788484b01c9715623d3/blob b/shared/package-files/42/424e72f83e7e39d4582a40a073e92d7312863464823ed788484b01c9715623d3/blob new file mode 100644 index 0000000000000000000000000000000000000000..b1884c497f0ad7000351e131ef11dadab4a7c700 --- /dev/null +++ b/shared/package-files/42/424e72f83e7e39d4582a40a073e92d7312863464823ed788484b01c9715623d3/blob @@ -0,0 +1,41 @@ +from pandas.core.reshape.concat import concat +from pandas.core.reshape.encoding import ( + from_dummies, + get_dummies, +) +from pandas.core.reshape.melt import ( + lreshape, + melt, + wide_to_long, +) +from pandas.core.reshape.merge import ( + merge, + merge_asof, + merge_ordered, +) +from pandas.core.reshape.pivot import ( + crosstab, + pivot, + pivot_table, +) +from pandas.core.reshape.tile import ( + cut, + qcut, +) + +__all__ = [ + "concat", + "crosstab", + "cut", + "from_dummies", + "get_dummies", + "lreshape", + "melt", + "merge", + "merge_asof", + "merge_ordered", + "pivot", + "pivot_table", + "qcut", + "wide_to_long", +] diff --git a/shared/package-files/42/4252ff9c9bc49066e17962389360203dffc567d4107702aff34ef2d5e1622e9e/blob b/shared/package-files/42/4252ff9c9bc49066e17962389360203dffc567d4107702aff34ef2d5e1622e9e/blob new file mode 100644 index 0000000000000000000000000000000000000000..1c4f97134d20b8d3acb1bea54c8384c510314aaa --- /dev/null +++ b/shared/package-files/42/4252ff9c9bc49066e17962389360203dffc567d4107702aff34ef2d5e1622e9e/blob @@ -0,0 +1,216 @@ +""" +======================================== +Interpolation (:mod:`scipy.interpolate`) +======================================== + +.. currentmodule:: scipy.interpolate + +Sub-package for objects used in interpolation. + +As listed below, this sub-package contains spline functions and classes, +1-D and multidimensional (univariate and multivariate) +interpolation classes, Lagrange and Taylor polynomial interpolators, and +wrappers for `FITPACK `__ +and DFITPACK functions. + +Univariate interpolation +======================== + +.. autosummary:: + :toctree: generated/ + + interp1d + BarycentricInterpolator + KroghInterpolator + barycentric_interpolate + krogh_interpolate + pchip_interpolate + CubicHermiteSpline + PchipInterpolator + Akima1DInterpolator + CubicSpline + PPoly + BPoly + FloaterHormannInterpolator + + +Multivariate interpolation +========================== + +Unstructured data: + +.. autosummary:: + :toctree: generated/ + + griddata + LinearNDInterpolator + NearestNDInterpolator + CloughTocher2DInterpolator + RBFInterpolator + Rbf + interp2d + +For data on a grid: + +.. autosummary:: + :toctree: generated/ + + interpn + RegularGridInterpolator + RectBivariateSpline + +.. seealso:: + + `scipy.ndimage.map_coordinates` + +Tensor product polynomials: + +.. autosummary:: + :toctree: generated/ + + NdPPoly + NdBSpline + +1-D Splines +=========== + +.. autosummary:: + :toctree: generated/ + + BSpline + make_interp_spline + make_lsq_spline + make_smoothing_spline + generate_knots + make_splrep + make_splprep + +Functional interface to FITPACK routines: + +.. autosummary:: + :toctree: generated/ + + splrep + splprep + splev + splint + sproot + spalde + splder + splantider + insert + +Object-oriented FITPACK interface: + +.. autosummary:: + :toctree: generated/ + + UnivariateSpline + InterpolatedUnivariateSpline + LSQUnivariateSpline + + + +2-D Splines +=========== + +For data on a grid: + +.. autosummary:: + :toctree: generated/ + + RectBivariateSpline + RectSphereBivariateSpline + +For unstructured data: + +.. autosummary:: + :toctree: generated/ + + BivariateSpline + SmoothBivariateSpline + SmoothSphereBivariateSpline + LSQBivariateSpline + LSQSphereBivariateSpline + +Low-level interface to FITPACK functions: + +.. autosummary:: + :toctree: generated/ + + bisplrep + bisplev + +Rational Approximation +====================== + +.. autosummary:: + :toctree: generated/ + + pade + AAA + +Additional tools +================ + +.. autosummary:: + :toctree: generated/ + + lagrange + approximate_taylor_polynomial + +.. seealso:: + + `scipy.ndimage.map_coordinates`, + `scipy.ndimage.spline_filter`, + `scipy.signal.resample`, + `scipy.signal.bspline`, + `scipy.signal.gauss_spline`, + `scipy.signal.qspline1d`, + `scipy.signal.cspline1d`, + `scipy.signal.qspline1d_eval`, + `scipy.signal.cspline1d_eval`, + `scipy.signal.qspline2d`, + `scipy.signal.cspline2d`. + +``pchip`` is an alias of `PchipInterpolator` for backward compatibility +(should not be used in new code). +""" +from ._interpolate import * +from ._fitpack_py import * + +# New interface to fitpack library: +from ._fitpack2 import * + +from ._rbf import Rbf + +from ._rbfinterp import * + +from ._polyint import * + +from ._cubic import * + +from ._ndgriddata import * + +from ._bsplines import * +from ._fitpack_repro import generate_knots, make_splrep, make_splprep + +from ._pade import * + +from ._rgi import * + +from ._ndbspline import NdBSpline + +from ._bary_rational import * + +# Deprecated namespaces, to be removed in v2.0.0 +from . import fitpack, fitpack2, interpolate, ndgriddata, polyint, rbf, interpnd + +__all__ = [s for s in dir() if not s.startswith('_')] + +from scipy._lib._testutils import PytestTester +test = PytestTester(__name__) +del PytestTester + +# Backward compatibility +pchip = PchipInterpolator diff --git a/shared/package-files/42/42562ea18a375d024bd2c4a47e390da479de9bd257049642d7f28c343278c177/blob b/shared/package-files/42/42562ea18a375d024bd2c4a47e390da479de9bd257049642d7f28c343278c177/blob new file mode 100644 index 0000000000000000000000000000000000000000..d5858e9fb1714d55f2ed9f2dca9444327abb72c9 --- /dev/null +++ b/shared/package-files/42/42562ea18a375d024bd2c4a47e390da479de9bd257049642d7f28c343278c177/blob @@ -0,0 +1,13 @@ +*** Sun, 21 Aug 2016 09:34:22 *** +OPTIMAL ENDOGENOUS LAGS FROM INFORMATION CRITERIA + +endogenous variables: Dp R +deterministic variables: CONST S1 S2 S3 TREND +sample range: [1975 Q1, 1998 Q4], T = 96 + +optimal number of lags (searched up to 10 lags of 1. differences): +Akaike Info Criterion: 3 +Final Prediction Error: 3 +Hannan-Quinn Criterion: 0 +Schwarz Criterion: 0 + diff --git a/shared/package-files/42/425663fd5d8c1df64d079b6e0a725922a12134ec889a840899d1d87119d7d490/blob b/shared/package-files/42/425663fd5d8c1df64d079b6e0a725922a12134ec889a840899d1d87119d7d490/blob new file mode 100644 index 0000000000000000000000000000000000000000..981ab6f5f0d362a55a1f694db47b900b93baa1a2 --- /dev/null +++ b/shared/package-files/42/425663fd5d8c1df64d079b6e0a725922a12134ec889a840899d1d87119d7d490/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API ::std::tuple> histogramdd(const at::Tensor & self, at::IntArrayRef bins, c10::optional> range=c10::nullopt, const c10::optional & weight={}, bool density=false); +TORCH_API ::std::tuple> histogramdd(const at::Tensor & self, int64_t bins, c10::optional> range=c10::nullopt, const c10::optional & weight={}, bool density=false); +TORCH_API ::std::tuple> histogramdd(const at::Tensor & self, at::TensorList bins, c10::optional> range=c10::nullopt, const c10::optional & weight={}, bool density=false); +} // namespace native +} // namespace at diff --git a/shared/package-files/42/425f7b9e3c4d2a6367efa73cfafa2648033b3fe575e28fb5ed2388806e3b57e5/blob b/shared/package-files/42/425f7b9e3c4d2a6367efa73cfafa2648033b3fe575e28fb5ed2388806e3b57e5/blob new file mode 100644 index 0000000000000000000000000000000000000000..e1de0b3bb845e76087dbf3b3537299a409384c1e --- /dev/null +++ b/shared/package-files/42/425f7b9e3c4d2a6367efa73cfafa2648033b3fe575e28fb5ed2388806e3b57e5/blob @@ -0,0 +1,3 @@ +import logging + +logger: logging.Logger diff --git a/shared/package-files/42/42612911c1872c5e4b43f6ae0e8ee59467cd350332241cf72ce90640264fae6a/blob b/shared/package-files/42/42612911c1872c5e4b43f6ae0e8ee59467cd350332241cf72ce90640264fae6a/blob new file mode 100644 index 0000000000000000000000000000000000000000..910537bd33412dd9b70c4d07cedd41b519be7fb5 --- /dev/null +++ b/shared/package-files/42/42612911c1872c5e4b43f6ae0e8ee59467cd350332241cf72ce90640264fae6a/blob @@ -0,0 +1,29 @@ +BSD 3-Clause License + +Copyright (c) 2008-2021, The joblib developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/shared/package-files/42/42612c0f28049219743661a1a9cc8658188238cdf8e88a275794378d15b720fd/blob b/shared/package-files/42/42612c0f28049219743661a1a9cc8658188238cdf8e88a275794378d15b720fd/blob new file mode 100644 index 0000000000000000000000000000000000000000..64ee81e1c147d2617f2716e56ae4e2bb12c492f4 --- /dev/null +++ b/shared/package-files/42/42612c0f28049219743661a1a9cc8658188238cdf8e88a275794378d15b720fd/blob @@ -0,0 +1,71 @@ +# Copyright 2016 Grist Labs, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import bisect +import re + +_line_start_re = re.compile(r'^', re.M) + +class LineNumbers(object): + """ + Class to convert between character offsets in a text string, and pairs (line, column) of 1-based + line and 0-based column numbers, as used by tokens and AST nodes. + + This class expects unicode for input and stores positions in unicode. But it supports + translating to and from utf8 offsets, which are used by ast parsing. + """ + def __init__(self, text): + # A list of character offsets of each line's first character. + self._line_offsets = [m.start(0) for m in _line_start_re.finditer(text)] + self._text = text + self._text_len = len(text) + self._utf8_offset_cache = {} # maps line num to list of char offset for each byte in line + + def from_utf8_col(self, line, utf8_column): + """ + Given a 1-based line number and 0-based utf8 column, returns a 0-based unicode column. + """ + offsets = self._utf8_offset_cache.get(line) + if offsets is None: + end_offset = self._line_offsets[line] if line < len(self._line_offsets) else self._text_len + line_text = self._text[self._line_offsets[line - 1] : end_offset] + + offsets = [i for i,c in enumerate(line_text) for byte in c.encode('utf8')] + offsets.append(len(line_text)) + self._utf8_offset_cache[line] = offsets + + return offsets[max(0, min(len(offsets)-1, utf8_column))] + + def line_to_offset(self, line, column): + """ + Converts 1-based line number and 0-based column to 0-based character offset into text. + """ + line -= 1 + if line >= len(self._line_offsets): + return self._text_len + elif line < 0: + return 0 + else: + return min(self._line_offsets[line] + max(0, column), self._text_len) + + def offset_to_line(self, offset): + """ + Converts 0-based character offset to pair (line, col) of 1-based line and 0-based column + numbers. + """ + offset = max(0, min(self._text_len, offset)) + line_index = bisect.bisect_right(self._line_offsets, offset) - 1 + return (line_index + 1, offset - self._line_offsets[line_index]) + + diff --git a/shared/package-files/42/42618dc884da404098a47f8c8cc7406530609bc5fcb70ca193496cadc59a7da7/blob b/shared/package-files/42/42618dc884da404098a47f8c8cc7406530609bc5fcb70ca193496cadc59a7da7/blob new file mode 100644 index 0000000000000000000000000000000000000000..a3ae01542754d506b10539bfc07bc0664c1daba5 --- /dev/null +++ b/shared/package-files/42/42618dc884da404098a47f8c8cc7406530609bc5fcb70ca193496cadc59a7da7/blob @@ -0,0 +1,98 @@ +import numpy as np +import numba + +from pynndescent.utils import tau_rand_int, norm + +###################################################### +# Alternative tree approach; should be the basis +# for a dask-distributed version of the algorithm +###################################################### + + +@numba.njit(fastmath=True, nogil=True) +def apply_hyperplane( + data, + hyperplane_vector, + hyperplane_offset, + hyperplane_node_num, + current_num_nodes, + data_node_loc, + rng_state, +): + + left_node = current_num_nodes + right_node = current_num_nodes + 1 + + for i in range(data_node_loc.shape[0]): + if data_node_loc[i] != hyperplane_node_num: + continue + + margin = hyperplane_offset + for d in range(hyperplane_vector.shape[0]): + margin += hyperplane_vector[d] * data[i, d] + + if margin == 0: + if abs(tau_rand_int(rng_state)) % 2 == 0: + data_node_loc[i] = left_node + else: + data_node_loc[i] = right_node + elif margin > 0: + data_node_loc[i] = left_node + else: + data_node_loc[i] = right_node + + return + + +@numba.njit(fastmath=True, nogil=True) +def make_euclidean_hyperplane(data, indices, rng_state): + left_index = tau_rand_int(rng_state) % indices.shape[0] + right_index = tau_rand_int(rng_state) % indices.shape[0] + right_index += left_index == right_index + right_index = right_index % indices.shape[0] + left = indices[left_index] + right = indices[right_index] + + # Compute the normal vector to the hyperplane (the vector between + # the two points) and the offset from the origin + hyperplane_offset = 0.0 + hyperplane_vector = np.empty(data.shape[1], dtype=np.float32) + + for d in range(data.shape[1]): + hyperplane_vector[d] = data[left, d] - data[right, d] + hyperplane_offset -= ( + hyperplane_vector[d] * (data[left, d] + data[right, d]) / 2.0 + ) + + return hyperplane_vector, hyperplane_offset + + +@numba.njit(fastmath=True, nogil=True) +def make_angular_hyperplane(data, indices, rng_state): + left_index = tau_rand_int(rng_state) % indices.shape[0] + right_index = tau_rand_int(rng_state) % indices.shape[0] + right_index += left_index == right_index + right_index = right_index % indices.shape[0] + left = indices[left_index] + right = indices[right_index] + + left_norm = norm(data[left]) + right_norm = norm(data[right]) + + if left_norm == 0.0: + left_norm = 1.0 + + if right_norm == 0.0: + right_norm = 1.0 + + # Compute the normal vector to the hyperplane (the vector between + # the two points) and the offset from the origin + hyperplane_offset = 0.0 + hyperplane_vector = np.empty(data.shape[1], dtype=np.float32) + + for d in range(data.shape[1]): + hyperplane_vector[d] = (data[left, d] / left_norm) - ( + data[right, d] / right_norm + ) + + return hyperplane_vector, hyperplane_offset diff --git a/shared/package-files/42/4261d494e96763a81f41c868af179d8e9f171733b6eed824b31c2da30f58e3ef/blob b/shared/package-files/42/4261d494e96763a81f41c868af179d8e9f171733b6eed824b31c2da30f58e3ef/blob new file mode 100644 index 0000000000000000000000000000000000000000..063c7836932af00125d6650261da84b7fb90b4ce --- /dev/null +++ b/shared/package-files/42/4261d494e96763a81f41c868af179d8e9f171733b6eed824b31c2da30f58e3ef/blob @@ -0,0 +1,96 @@ +#pragma once + +#include +#include + +namespace c10::cuda { + +#ifdef TORCH_USE_CUDA_DSA +// Copy string from `src` to `dst` +static __device__ void dstrcpy(char* dst, const char* src) { + int i = 0; + // Copy string from source to destination, ensuring that it + // isn't longer than `C10_CUDA_DSA_MAX_STR_LEN-1` + while (*src != '\0' && i++ < C10_CUDA_DSA_MAX_STR_LEN - 1) { + *dst++ = *src++; + } + *dst = '\0'; +} + +static __device__ void dsa_add_new_assertion_failure( + DeviceAssertionsData* assertions_data, + const char* assertion_msg, + const char* filename, + const char* function_name, + const int line_number, + const uint32_t caller, + const dim3 block_id, + const dim3 thread_id) { + // `assertions_data` may be nullptr if device-side assertion checking + // is disabled at run-time. If it is disabled at compile time this + // function will never be called + if (!assertions_data) { + return; + } + + // Atomically increment so other threads can fail at the same time + // Note that incrementing this means that the CPU can observe that + // a failure has happened and can begin to respond before we've + // written information about that failure out to the buffer. + const auto nid = atomicAdd(&(assertions_data->assertion_count), 1); + + if (nid >= C10_CUDA_DSA_ASSERTION_COUNT) { + // At this point we're ran out of assertion buffer space. + // We could print a message about this, but that'd get + // spammy if a lot of threads did it, so we just silently + // ignore any other assertion failures. In most cases the + // failures will all probably be analogous anyway. + return; + } + + // Write information about the assertion failure to memory. + // Note that this occurs only after the `assertion_count` + // increment broadcasts that there's been a problem. + auto& self = assertions_data->assertions[nid]; + dstrcpy(self.assertion_msg, assertion_msg); + dstrcpy(self.filename, filename); + dstrcpy(self.function_name, function_name); + self.line_number = line_number; + self.caller = caller; + self.block_id[0] = block_id.x; + self.block_id[1] = block_id.y; + self.block_id[2] = block_id.z; + self.thread_id[0] = thread_id.x; + self.thread_id[1] = thread_id.y; + self.thread_id[2] = thread_id.z; +} + +// Emulates a kernel assertion. The assertion won't stop the kernel's progress, +// so you should assume everything the kernel produces is garbage if there's an +// assertion failure. +// NOTE: This assumes that `assertions_data` and `assertion_caller_id` are +// arguments of the kernel and therefore accessible. +#define CUDA_KERNEL_ASSERT2(condition) \ + do { \ + if (C10_UNLIKELY(!(condition))) { \ + /* Has an atomic element so threads can fail at the same time */ \ + c10::cuda::dsa_add_new_assertion_failure( \ + assertions_data, \ + C10_STRINGIZE(condition), \ + __FILE__, \ + __FUNCTION__, \ + __LINE__, \ + assertion_caller_id, \ + blockIdx, \ + threadIdx); \ + /* Now that the kernel has failed we early exit the kernel, but */ \ + /* otherwise keep going and rely on the host to check UVM and */ \ + /* determine we've had a problem */ \ + return; \ + } \ + } while (false) +#else +#define CUDA_KERNEL_ASSERT2(condition) assert(condition) +#endif + +} // namespace c10::cuda diff --git a/shared/package-files/42/4263bd083aab02cbc170b36023314121605362c49409127f0a3d66cafef72a51/blob b/shared/package-files/42/4263bd083aab02cbc170b36023314121605362c49409127f0a3d66cafef72a51/blob new file mode 100644 index 0000000000000000000000000000000000000000..1c7a3d683dd78d3227a7de88f5c47569d2f4e17f --- /dev/null +++ b/shared/package-files/42/4263bd083aab02cbc170b36023314121605362c49409127f0a3d66cafef72a51/blob @@ -0,0 +1,693 @@ +from ._basic import _dispatch +from scipy._lib.uarray import Dispatchable +import numpy as np + +__all__ = ['dct', 'idct', 'dst', 'idst', 'dctn', 'idctn', 'dstn', 'idstn'] + + +@_dispatch +def dctn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False, + workers=None, *, orthogonalize=None): + """ + Return multidimensional Discrete Cosine Transform along the specified axes. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DCT (see Notes). Default type is 2. + s : int or array_like of ints or None, optional + The shape of the result. If both `s` and `axes` (see below) are None, + `s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is + ``numpy.take(x.shape, axes, axis=0)``. + If ``s[i] > x.shape[i]``, the ith dimension of the input is padded with zeros. + If ``s[i] < x.shape[i]``, the ith dimension of the input is truncated to length + ``s[i]``. + If any element of `s` is -1, the size of the corresponding dimension of + `x` is used. + axes : int or array_like of ints or None, optional + Axes over which the DCT is computed. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized DCT variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + y : ndarray of real + The transformed input array. + + See Also + -------- + idctn : Inverse multidimensional DCT + + Notes + ----- + For full details of the DCT types and normalization modes, as well as + references, see `dct`. + + Examples + -------- + >>> import numpy as np + >>> from scipy.fft import dctn, idctn + >>> rng = np.random.default_rng() + >>> y = rng.standard_normal((16, 16)) + >>> np.allclose(y, idctn(dctn(y))) + True + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def idctn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False, + workers=None, orthogonalize=None): + """ + Return multidimensional Inverse Discrete Cosine Transform along the specified axes. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DCT (see Notes). Default type is 2. + s : int or array_like of ints or None, optional + The shape of the result. If both `s` and `axes` (see below) are + None, `s` is ``x.shape``; if `s` is None but `axes` is + not None, then `s` is ``numpy.take(x.shape, axes, axis=0)``. + If ``s[i] > x.shape[i]``, the ith dimension of the input is padded with zeros. + If ``s[i] < x.shape[i]``, the ith dimension of the input is truncated to length + ``s[i]``. + If any element of `s` is -1, the size of the corresponding dimension of + `x` is used. + axes : int or array_like of ints or None, optional + Axes over which the IDCT is computed. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized IDCT variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + y : ndarray of real + The transformed input array. + + See Also + -------- + dctn : multidimensional DCT + + Notes + ----- + For full details of the IDCT types and normalization modes, as well as + references, see `idct`. + + Examples + -------- + >>> import numpy as np + >>> from scipy.fft import dctn, idctn + >>> rng = np.random.default_rng() + >>> y = rng.standard_normal((16, 16)) + >>> np.allclose(y, idctn(dctn(y))) + True + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def dstn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False, + workers=None, orthogonalize=None): + """ + Return multidimensional Discrete Sine Transform along the specified axes. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DST (see Notes). Default type is 2. + s : int or array_like of ints or None, optional + The shape of the result. If both `s` and `axes` (see below) are None, + `s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is + ``numpy.take(x.shape, axes, axis=0)``. + If ``s[i] > x.shape[i]``, the ith dimension of the input is padded with zeros. + If ``s[i] < x.shape[i]``, the ith dimension of the input is truncated to length + ``s[i]``. + If any element of `shape` is -1, the size of the corresponding dimension + of `x` is used. + axes : int or array_like of ints or None, optional + Axes over which the DST is computed. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized DST variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + y : ndarray of real + The transformed input array. + + See Also + -------- + idstn : Inverse multidimensional DST + + Notes + ----- + For full details of the DST types and normalization modes, as well as + references, see `dst`. + + Examples + -------- + >>> import numpy as np + >>> from scipy.fft import dstn, idstn + >>> rng = np.random.default_rng() + >>> y = rng.standard_normal((16, 16)) + >>> np.allclose(y, idstn(dstn(y))) + True + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def idstn(x, type=2, s=None, axes=None, norm=None, overwrite_x=False, + workers=None, orthogonalize=None): + """ + Return multidimensional Inverse Discrete Sine Transform along the specified axes. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DST (see Notes). Default type is 2. + s : int or array_like of ints or None, optional + The shape of the result. If both `s` and `axes` (see below) are None, + `s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is + ``numpy.take(x.shape, axes, axis=0)``. + If ``s[i] > x.shape[i]``, the ith dimension of the input is padded with zeros. + If ``s[i] < x.shape[i]``, the ith dimension of the input is truncated to length + ``s[i]``. + If any element of `s` is -1, the size of the corresponding dimension of + `x` is used. + axes : int or array_like of ints or None, optional + Axes over which the IDST is computed. If not given, the last ``len(s)`` + axes are used, or all axes if `s` is also not specified. + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized IDST variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + y : ndarray of real + The transformed input array. + + See Also + -------- + dstn : multidimensional DST + + Notes + ----- + For full details of the IDST types and normalization modes, as well as + references, see `idst`. + + Examples + -------- + >>> import numpy as np + >>> from scipy.fft import dstn, idstn + >>> rng = np.random.default_rng() + >>> y = rng.standard_normal((16, 16)) + >>> np.allclose(y, idstn(dstn(y))) + True + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def dct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, + orthogonalize=None): + r"""Return the Discrete Cosine Transform of arbitrary type sequence x. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DCT (see Notes). Default type is 2. + n : int, optional + Length of the transform. If ``n < x.shape[axis]``, `x` is + truncated. If ``n > x.shape[axis]``, `x` is zero-padded. The + default results in ``n = x.shape[axis]``. + axis : int, optional + Axis along which the dct is computed; the default is over the + last axis (i.e., ``axis=-1``). + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized DCT variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + y : ndarray of real + The transformed input array. + + See Also + -------- + idct : Inverse DCT + + Notes + ----- + For a single dimension array ``x``, ``dct(x, norm='ortho')`` is equal to + MATLAB ``dct(x)``. + + .. warning:: For ``type in {1, 2, 3}``, ``norm="ortho"`` breaks the direct + correspondence with the direct Fourier transform. To recover + it you must specify ``orthogonalize=False``. + + For ``norm="ortho"`` both the `dct` and `idct` are scaled by the same + overall factor in both directions. By default, the transform is also + orthogonalized which for types 1, 2 and 3 means the transform definition is + modified to give orthogonality of the DCT matrix (see below). + + For ``norm="backward"``, there is no scaling on `dct` and the `idct` is + scaled by ``1/N`` where ``N`` is the "logical" size of the DCT. For + ``norm="forward"`` the ``1/N`` normalization is applied to the forward + `dct` instead and the `idct` is unnormalized. + + There are, theoretically, 8 types of the DCT, only the first 4 types are + implemented in SciPy.'The' DCT generally refers to DCT type 2, and 'the' + Inverse DCT generally refers to DCT type 3. + + **Type I** + + There are several definitions of the DCT-I; we use the following + (for ``norm="backward"``) + + .. math:: + + y_k = x_0 + (-1)^k x_{N-1} + 2 \sum_{n=1}^{N-2} x_n \cos\left( + \frac{\pi k n}{N-1} \right) + + If ``orthogonalize=True``, ``x[0]`` and ``x[N-1]`` are multiplied by a + scaling factor of :math:`\sqrt{2}`, and ``y[0]`` and ``y[N-1]`` are divided + by :math:`\sqrt{2}`. When combined with ``norm="ortho"``, this makes the + corresponding matrix of coefficients orthonormal (``O @ O.T = np.eye(N)``). + + .. note:: + The DCT-I is only supported for input size > 1. + + **Type II** + + There are several definitions of the DCT-II; we use the following + (for ``norm="backward"``) + + .. math:: + + y_k = 2 \sum_{n=0}^{N-1} x_n \cos\left(\frac{\pi k(2n+1)}{2N} \right) + + If ``orthogonalize=True``, ``y[0]`` is divided by :math:`\sqrt{2}` which, + when combined with ``norm="ortho"``, makes the corresponding matrix of + coefficients orthonormal (``O @ O.T = np.eye(N)``). + + **Type III** + + There are several definitions, we use the following (for + ``norm="backward"``) + + .. math:: + + y_k = x_0 + 2 \sum_{n=1}^{N-1} x_n \cos\left(\frac{\pi(2k+1)n}{2N}\right) + + If ``orthogonalize=True``, ``x[0]`` terms are multiplied by + :math:`\sqrt{2}` which, when combined with ``norm="ortho"``, makes the + corresponding matrix of coefficients orthonormal (``O @ O.T = np.eye(N)``). + + The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up + to a factor `2N`. The orthonormalized DCT-III is exactly the inverse of + the orthonormalized DCT-II. + + **Type IV** + + There are several definitions of the DCT-IV; we use the following + (for ``norm="backward"``) + + .. math:: + + y_k = 2 \sum_{n=0}^{N-1} x_n \cos\left(\frac{\pi(2k+1)(2n+1)}{4N} \right) + + ``orthogonalize`` has no effect here, as the DCT-IV matrix is already + orthogonal up to a scale factor of ``2N``. + + References + ---------- + .. [1] 'A Fast Cosine Transform in One and Two Dimensions', by J. + Makhoul, `IEEE Transactions on acoustics, speech and signal + processing` vol. 28(1), pp. 27-34, + :doi:`10.1109/TASSP.1980.1163351` (1980). + .. [2] Wikipedia, "Discrete cosine transform", + https://en.wikipedia.org/wiki/Discrete_cosine_transform + + Examples + -------- + The Type 1 DCT is equivalent to the FFT (though faster) for real, + even-symmetrical inputs. The output is also real and even-symmetrical. + Half of the FFT input is used to generate half of the FFT output: + + >>> from scipy.fft import fft, dct + >>> import numpy as np + >>> fft(np.array([4., 3., 5., 10., 5., 3.])).real + array([ 30., -8., 6., -2., 6., -8.]) + >>> dct(np.array([4., 3., 5., 10.]), 1) + array([ 30., -8., 6., -2.]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def idct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, + workers=None, orthogonalize=None): + """ + Return the Inverse Discrete Cosine Transform of an arbitrary type sequence. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DCT (see Notes). Default type is 2. + n : int, optional + Length of the transform. If ``n < x.shape[axis]``, `x` is + truncated. If ``n > x.shape[axis]``, `x` is zero-padded. The + default results in ``n = x.shape[axis]``. + axis : int, optional + Axis along which the idct is computed; the default is over the + last axis (i.e., ``axis=-1``). + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized IDCT variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + idct : ndarray of real + The transformed input array. + + See Also + -------- + dct : Forward DCT + + Notes + ----- + For a single dimension array `x`, ``idct(x, norm='ortho')`` is equal to + MATLAB ``idct(x)``. + + .. warning:: For ``type in {1, 2, 3}``, ``norm="ortho"`` breaks the direct + correspondence with the inverse direct Fourier transform. To + recover it you must specify ``orthogonalize=False``. + + For ``norm="ortho"`` both the `dct` and `idct` are scaled by the same + overall factor in both directions. By default, the transform is also + orthogonalized which for types 1, 2 and 3 means the transform definition is + modified to give orthogonality of the IDCT matrix (see `dct` for the full + definitions). + + 'The' IDCT is the IDCT-II, which is the same as the normalized DCT-III. + + The IDCT is equivalent to a normal DCT except for the normalization and + type. DCT type 1 and 4 are their own inverse and DCTs 2 and 3 are each + other's inverses. + + Examples + -------- + The Type 1 DCT is equivalent to the DFT for real, even-symmetrical + inputs. The output is also real and even-symmetrical. Half of the IFFT + input is used to generate half of the IFFT output: + + >>> from scipy.fft import ifft, idct + >>> import numpy as np + >>> ifft(np.array([ 30., -8., 6., -2., 6., -8.])).real + array([ 4., 3., 5., 10., 5., 3.]) + >>> idct(np.array([ 30., -8., 6., -2.]), 1) + array([ 4., 3., 5., 10.]) + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, + orthogonalize=None): + r""" + Return the Discrete Sine Transform of arbitrary type sequence x. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DST (see Notes). Default type is 2. + n : int, optional + Length of the transform. If ``n < x.shape[axis]``, `x` is + truncated. If ``n > x.shape[axis]``, `x` is zero-padded. The + default results in ``n = x.shape[axis]``. + axis : int, optional + Axis along which the dst is computed; the default is over the + last axis (i.e., ``axis=-1``). + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized DST variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + dst : ndarray of reals + The transformed input array. + + See Also + -------- + idst : Inverse DST + + Notes + ----- + .. warning:: For ``type in {2, 3}``, ``norm="ortho"`` breaks the direct + correspondence with the direct Fourier transform. To recover + it you must specify ``orthogonalize=False``. + + For ``norm="ortho"`` both the `dst` and `idst` are scaled by the same + overall factor in both directions. By default, the transform is also + orthogonalized which for types 2 and 3 means the transform definition is + modified to give orthogonality of the DST matrix (see below). + + For ``norm="backward"``, there is no scaling on the `dst` and the `idst` is + scaled by ``1/N`` where ``N`` is the "logical" size of the DST. + + There are, theoretically, 8 types of the DST for different combinations of + even/odd boundary conditions and boundary off sets [1]_, only the first + 4 types are implemented in SciPy. + + **Type I** + + There are several definitions of the DST-I; we use the following for + ``norm="backward"``. DST-I assumes the input is odd around :math:`n=-1` and + :math:`n=N`. + + .. math:: + + y_k = 2 \sum_{n=0}^{N-1} x_n \sin\left(\frac{\pi(k+1)(n+1)}{N+1}\right) + + Note that the DST-I is only supported for input size > 1. + The (unnormalized) DST-I is its own inverse, up to a factor :math:`2(N+1)`. + The orthonormalized DST-I is exactly its own inverse. + + ``orthogonalize`` has no effect here, as the DST-I matrix is already + orthogonal up to a scale factor of ``2N``. + + **Type II** + + There are several definitions of the DST-II; we use the following for + ``norm="backward"``. DST-II assumes the input is odd around :math:`n=-1/2` and + :math:`n=N-1/2`; the output is odd around :math:`k=-1` and even around :math:`k=N-1` + + .. math:: + + y_k = 2 \sum_{n=0}^{N-1} x_n \sin\left(\frac{\pi(k+1)(2n+1)}{2N}\right) + + If ``orthogonalize=True``, ``y[-1]`` is divided :math:`\sqrt{2}` which, when + combined with ``norm="ortho"``, makes the corresponding matrix of + coefficients orthonormal (``O @ O.T = np.eye(N)``). + + **Type III** + + There are several definitions of the DST-III, we use the following (for + ``norm="backward"``). DST-III assumes the input is odd around :math:`n=-1` and + even around :math:`n=N-1` + + .. math:: + + y_k = (-1)^k x_{N-1} + 2 \sum_{n=0}^{N-2} x_n \sin\left( + \frac{\pi(2k+1)(n+1)}{2N}\right) + + If ``orthogonalize=True``, ``x[-1]`` is multiplied by :math:`\sqrt{2}` + which, when combined with ``norm="ortho"``, makes the corresponding matrix + of coefficients orthonormal (``O @ O.T = np.eye(N)``). + + The (unnormalized) DST-III is the inverse of the (unnormalized) DST-II, up + to a factor :math:`2N`. The orthonormalized DST-III is exactly the inverse of the + orthonormalized DST-II. + + **Type IV** + + There are several definitions of the DST-IV, we use the following (for + ``norm="backward"``). DST-IV assumes the input is odd around :math:`n=-0.5` and + even around :math:`n=N-0.5` + + .. math:: + + y_k = 2 \sum_{n=0}^{N-1} x_n \sin\left(\frac{\pi(2k+1)(2n+1)}{4N}\right) + + ``orthogonalize`` has no effect here, as the DST-IV matrix is already + orthogonal up to a scale factor of ``2N``. + + The (unnormalized) DST-IV is its own inverse, up to a factor :math:`2N`. The + orthonormalized DST-IV is exactly its own inverse. + + References + ---------- + .. [1] Wikipedia, "Discrete sine transform", + https://en.wikipedia.org/wiki/Discrete_sine_transform + + """ + return (Dispatchable(x, np.ndarray),) + + +@_dispatch +def idst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, + workers=None, orthogonalize=None): + """ + Return the Inverse Discrete Sine Transform of an arbitrary type sequence. + + Parameters + ---------- + x : array_like + The input array. + type : {1, 2, 3, 4}, optional + Type of the DST (see Notes). Default type is 2. + n : int, optional + Length of the transform. If ``n < x.shape[axis]``, `x` is + truncated. If ``n > x.shape[axis]``, `x` is zero-padded. The + default results in ``n = x.shape[axis]``. + axis : int, optional + Axis along which the idst is computed; the default is over the + last axis (i.e., ``axis=-1``). + norm : {"backward", "ortho", "forward"}, optional + Normalization mode (see Notes). Default is "backward". + overwrite_x : bool, optional + If True, the contents of `x` can be destroyed; the default is False. + workers : int, optional + Maximum number of workers to use for parallel computation. If negative, + the value wraps around from ``os.cpu_count()``. + See :func:`~scipy.fft.fft` for more details. + orthogonalize : bool, optional + Whether to use the orthogonalized IDST variant (see Notes). + Defaults to ``True`` when ``norm="ortho"`` and ``False`` otherwise. + + .. versionadded:: 1.8.0 + + Returns + ------- + idst : ndarray of real + The transformed input array. + + See Also + -------- + dst : Forward DST + + Notes + ----- + .. warning:: For ``type in {2, 3}``, ``norm="ortho"`` breaks the direct + correspondence with the inverse direct Fourier transform. + + For ``norm="ortho"`` both the `dst` and `idst` are scaled by the same + overall factor in both directions. By default, the transform is also + orthogonalized which for types 2 and 3 means the transform definition is + modified to give orthogonality of the DST matrix (see `dst` for the full + definitions). + + 'The' IDST is the IDST-II, which is the same as the normalized DST-III. + + The IDST is equivalent to a normal DST except for the normalization and + type. DST type 1 and 4 are their own inverse and DSTs 2 and 3 are each + other's inverses. + + """ + return (Dispatchable(x, np.ndarray),) diff --git a/shared/package-files/42/4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61/blob b/shared/package-files/42/4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61/blob new file mode 100644 index 0000000000000000000000000000000000000000..5fc60185a663e8f33d5fd10591df989190e038f8 --- /dev/null +++ b/shared/package-files/42/4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61/blob @@ -0,0 +1,33 @@ +"Test runscript, coverage 16%." + +from idlelib import runscript +import unittest +from test.support import requires +from tkinter import Tk +from idlelib.editor import EditorWindow + + +class ScriptBindingTest(unittest.TestCase): + + @classmethod + def setUpClass(cls): + requires('gui') + cls.root = Tk() + cls.root.withdraw() + + @classmethod + def tearDownClass(cls): + cls.root.update_idletasks() + for id in cls.root.tk.call('after', 'info'): + cls.root.after_cancel(id) # Need for EditorWindow. + cls.root.destroy() + del cls.root + + def test_init(self): + ew = EditorWindow(root=self.root) + sb = runscript.ScriptBinding(ew) + ew._close() + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/shared/package-files/42/4266b3b46ee4fd4113854660b650dcc07c500129a2978c5533c65f1ba1d0f9c8/blob b/shared/package-files/42/4266b3b46ee4fd4113854660b650dcc07c500129a2978c5533c65f1ba1d0f9c8/blob new file mode 100644 index 0000000000000000000000000000000000000000..086aaaea22340ca21ca0bc6dfa7f59a5175c4861 --- /dev/null +++ b/shared/package-files/42/4266b3b46ee4fd4113854660b650dcc07c500129a2978c5533c65f1ba1d0f9c8/blob @@ -0,0 +1,219 @@ +from datetime import datetime, timedelta +from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union, Iterable + +from django.db.models.lookups import Lookup +from django.db.models.sql.compiler import SQLCompiler + +from django.db.models import Q, QuerySet +from django.db.models.fields import Field +from django.db.models.query import _BaseQuerySet + +_OutputField = Union[Field, str] + +class SQLiteNumericMixin: + def as_sqlite(self, compiler: SQLCompiler, connection: Any, **extra_context: Any) -> Tuple[str, List[float]]: ... + +_Self = TypeVar("_Self") + +class Combinable: + ADD: str = ... + SUB: str = ... + MUL: str = ... + DIV: str = ... + POW: str = ... + MOD: str = ... + BITAND: str = ... + BITOR: str = ... + BITLEFTSHIFT: str = ... + BITRIGHTSHIFT: str = ... + def __neg__(self: _Self) -> _Self: ... + def __add__(self: _Self, other: Optional[Union[timedelta, Combinable, float, str]]) -> _Self: ... + def __sub__(self: _Self, other: Union[timedelta, Combinable, float]) -> _Self: ... + def __mul__(self: _Self, other: Union[timedelta, Combinable, float]) -> _Self: ... + def __truediv__(self: _Self, other: Union[Combinable, float]) -> _Self: ... + def __itruediv__(self: _Self, other: Union[Combinable, float]) -> _Self: ... + def __mod__(self: _Self, other: Union[int, Combinable]) -> _Self: ... + def __pow__(self: _Self, other: Union[float, Combinable]) -> _Self: ... + def __and__(self: _Self, other: Combinable) -> _Self: ... + def bitand(self: _Self, other: int) -> _Self: ... + def bitleftshift(self: _Self, other: int) -> _Self: ... + def bitrightshift(self: _Self, other: int) -> _Self: ... + def __or__(self: _Self, other: Combinable) -> _Self: ... + def bitor(self: _Self, other: int) -> _Self: ... + def __radd__(self, other: Optional[Union[datetime, float, Combinable]]) -> Combinable: ... + def __rsub__(self, other: Union[float, Combinable]) -> Combinable: ... + def __rmul__(self, other: Union[float, Combinable]) -> Combinable: ... + def __rtruediv__(self, other: Union[float, Combinable]) -> Combinable: ... + def __rmod__(self, other: Union[int, Combinable]) -> Combinable: ... + def __rpow__(self, other: Union[float, Combinable]) -> Combinable: ... + def __rand__(self, other: Any) -> Combinable: ... + def __ror__(self, other: Any) -> Combinable: ... + +class BaseExpression: + is_summary: bool = ... + filterable: bool = ... + window_compatible: bool = ... + def __init__(self, output_field: Optional[_OutputField] = ...) -> None: ... + def get_db_converters(self, connection: Any) -> List[Callable]: ... + def get_source_expressions(self) -> List[Any]: ... + def set_source_expressions(self, exprs: Sequence[Combinable]) -> None: ... + @property + def contains_aggregate(self) -> bool: ... + @property + def contains_over_clause(self) -> bool: ... + @property + def contains_column_references(self) -> bool: ... + def resolve_expression( + self: _Self, + query: Any = ..., + allow_joins: bool = ..., + reuse: Optional[Set[str]] = ..., + summarize: bool = ..., + for_save: bool = ..., + ) -> _Self: ... + @property + def field(self) -> Field: ... + @property + def output_field(self) -> Field: ... + @property + def convert_value(self) -> Callable: ... + def get_lookup(self, lookup: str) -> Optional[Type[Lookup]]: ... + def get_transform(self, name: str) -> Optional[Type[Expression]]: ... + def relabeled_clone(self, change_map: Dict[Optional[str], str]) -> Expression: ... + def copy(self) -> BaseExpression: ... + def get_group_by_cols(self: _Self) -> List[_Self]: ... + def get_source_fields(self) -> List[Optional[Field]]: ... + def asc(self, **kwargs: Any) -> Expression: ... + def desc(self, **kwargs: Any) -> Expression: ... + def reverse_ordering(self): ... + def flatten(self) -> Iterator[Expression]: ... + def deconstruct(self) -> Any: ... + def as_sqlite(self, compiler: SQLCompiler, connection: Any) -> Any: ... + def as_sql(self, compiler: SQLCompiler, connection: Any, **extra_context: Any) -> Any: ... + def as_mysql(self, compiler: Any, connection: Any) -> Any: ... + def as_postgresql(self, compiler: Any, connection: Any) -> Any: ... + def as_oracle(self, compiler: Any, connection: Any): ... + +class Expression(BaseExpression, Combinable): ... + +class CombinedExpression(SQLiteNumericMixin, Expression): + connector: Any = ... + lhs: Any = ... + rhs: Any = ... + def __init__( + self, lhs: Combinable, connector: str, rhs: Combinable, output_field: Optional[_OutputField] = ... + ) -> None: ... + +class F(Combinable): + name: str + def __init__(self, name: str): ... + def resolve_expression( + self: _Self, + query: Any = ..., + allow_joins: bool = ..., + reuse: Optional[Set[str]] = ..., + summarize: bool = ..., + for_save: bool = ..., + ) -> _Self: ... + def asc(self, **kwargs) -> OrderBy: ... + def desc(self, **kwargs) -> OrderBy: ... + def deconstruct(self) -> Any: ... + +class OuterRef(F): + def __init__(self, name: Union[str, OuterRef]): ... + +class Subquery(Expression): + template: str = ... + queryset: QuerySet = ... + extra: Dict[Any, Any] = ... + def __init__(self, queryset: _BaseQuerySet, output_field: Optional[_OutputField] = ..., **extra: Any) -> None: ... + +class Exists(Subquery): + negated: bool = ... + def __init__(self, *args: Any, negated: bool = ..., **kwargs: Any) -> None: ... + def __invert__(self) -> Exists: ... + +class OrderBy(BaseExpression): + template: str = ... + nulls_first: bool = ... + nulls_last: bool = ... + descending: bool = ... + expression: Expression = ... + def __init__( + self, expression: Combinable, descending: bool = ..., nulls_first: bool = ..., nulls_last: bool = ... + ) -> None: ... + +class Value(Expression): + value: Any = ... + def __init__(self, value: Any, output_field: Optional[_OutputField] = ...) -> None: ... + +class RawSQL(Expression): + params: List[Any] + sql: str + def __init__(self, sql: str, params: Sequence[Any], output_field: Optional[_OutputField] = ...) -> None: ... + +class Func(SQLiteNumericMixin, Expression): + function: str = ... + name: str = ... + template: str = ... + arg_joiner: str = ... + arity: int = ... + source_expressions: List[Combinable] = ... + extra: Dict[Any, Any] = ... + def __init__(self, *expressions: Any, output_field: Optional[_OutputField] = ..., **extra: Any) -> None: ... + +class When(Expression): + template: str = ... + condition: Any = ... + result: Any = ... + def __init__(self, condition: Any = ..., then: Any = ..., **lookups: Any) -> None: ... + +class Case(Expression): + template: str = ... + case_joiner: str = ... + cases: Any = ... + default: Any = ... + extra: Any = ... + def __init__( + self, *cases: Any, default: Optional[Any] = ..., output_field: Optional[_OutputField] = ..., **extra: Any + ) -> None: ... + +class ExpressionWrapper(Expression): + def __init__(self, expression: Union[Q, Combinable], output_field: _OutputField): ... + +class Col(Expression): + def __init__(self, alias: str, target: str, output_field: Optional[_OutputField] = ...): ... + +class SimpleCol(Expression): + contains_column_references: bool = ... + def __init__(self, target: Field, output_field: Optional[_OutputField] = ...): ... + +class Ref(Expression): + def __init__(self, refs: str, source: Expression): ... + +class ExpressionList(Func): + def __init__(self, *expressions: Union[BaseExpression, Combinable], **extra: Any) -> None: ... + +class Random(Expression): ... + +class Window(Expression): + template: str = ... + contains_aggregate: bool = ... + contains_over_clause: bool = ... + def __init__( + self, + expression: BaseExpression, + partition_by: Optional[Union[str, Iterable[Union[BaseExpression, F]], F, BaseExpression]] = ..., + order_by: Optional[Union[Sequence[Union[BaseExpression, F]], Union[BaseExpression, F]]] = ..., + frame: Optional[WindowFrame] = ..., + output_field: Optional[_OutputField] = ..., + ) -> None: ... + +class WindowFrame(Expression): + template: str = ... + frame_type: str = ... + def __init__(self, start: Optional[int] = ..., end: Optional[int] = ...) -> None: ... + def window_frame_start_end(self, connection: Any, start: Optional[int], end: Optional[int]) -> Tuple[int, int]: ... + +class RowRange(WindowFrame): ... +class ValueRange(WindowFrame): ... diff --git a/shared/package-files/42/42673d3cfe63d9fb2225f425b625af832c2034b3d0553732a1f1f698daa65a62/blob b/shared/package-files/42/42673d3cfe63d9fb2225f425b625af832c2034b3d0553732a1f1f698daa65a62/blob new file mode 100644 index 0000000000000000000000000000000000000000..7e0b36ff7a0ce104d82d88e6f2c029507405e0d5 --- /dev/null +++ b/shared/package-files/42/42673d3cfe63d9fb2225f425b625af832c2034b3d0553732a1f1f698daa65a62/blob @@ -0,0 +1,24 @@ +from typing import Optional + +from cryptography.hazmat.backends.interfaces import HashBackend, HMACBackend +from cryptography.hazmat.primitives.hashes import HashAlgorithm +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + +class ConcatKDFHash(KeyDerivationFunction): + def __init__( + self, algorithm: HashAlgorithm, length: int, otherinfo: Optional[bytes], backend: Optional[HashBackend] = ... + ): ... + def derive(self, key_material: bytes) -> bytes: ... + def verify(self, key_material: bytes, expected_key: bytes) -> None: ... + +class ConcatKDFHMAC(KeyDerivationFunction): + def __init__( + self, + algorithm: HashAlgorithm, + length: int, + salt: Optional[bytes], + otherinfo: Optional[bytes], + backend: Optional[HMACBackend] = ..., + ): ... + def derive(self, key_material: bytes) -> bytes: ... + def verify(self, key_material: bytes, expected_key: bytes) -> None: ... diff --git a/shared/package-files/42/42693654e510f0309b210d16aafcba1cb2f8d58b7f87204eabe3e1556dbf201b/blob b/shared/package-files/42/42693654e510f0309b210d16aafcba1cb2f8d58b7f87204eabe3e1556dbf201b/blob new file mode 100644 index 0000000000000000000000000000000000000000..5fe3f7801bd2b20422e8c4546bf6e7547ff98535 --- /dev/null +++ b/shared/package-files/42/42693654e510f0309b210d16aafcba1cb2f8d58b7f87204eabe3e1556dbf201b/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & _sparse_csr_prod_dim_dtype_out(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, c10::optional dtype, at::Tensor & out); +TORCH_API at::Tensor _sparse_csr_prod_cpu(const at::Tensor & self, at::IntArrayRef dim, bool keepdim=false, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor _sparse_csr_prod_cuda(const at::Tensor & self, at::IntArrayRef dim, bool keepdim=false, c10::optional dtype=c10::nullopt); +} // namespace native +} // namespace at diff --git a/shared/package-files/42/4269df8d245ef8e1e7fb2eb41d37fd33c7d7b3621351e39dd255eeb1bc41f1f5/blob b/shared/package-files/42/4269df8d245ef8e1e7fb2eb41d37fd33c7d7b3621351e39dd255eeb1bc41f1f5/blob new file mode 100644 index 0000000000000000000000000000000000000000..c70b3dda29a6a457d02d556aa84f6a0d156ebc05 --- /dev/null +++ b/shared/package-files/42/4269df8d245ef8e1e7fb2eb41d37fd33c7d7b3621351e39dd255eeb1bc41f1f5/blob @@ -0,0 +1,58 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::mean(Tensor self, *, ScalarType? dtype=None) -> Tensor +inline at::Tensor mean(const at::Tensor & self, c10::optional dtype=c10::nullopt) { + return at::_ops::mean::call(self, dtype); +} + +// aten::mean.dim(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor +inline at::Tensor mean(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim=false, c10::optional dtype=c10::nullopt) { + return at::_ops::mean_dim::call(self, dim, keepdim, dtype); +} + +// aten::mean.out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & mean_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim=false, c10::optional dtype=c10::nullopt) { + return at::_ops::mean_out::call(self, dim, keepdim, dtype, out); +} +// aten::mean.out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & mean_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, c10::optional dtype, at::Tensor & out) { + return at::_ops::mean_out::call(self, dim, keepdim, dtype, out); +} + +// aten::mean.names_dim(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor +inline at::Tensor mean(const at::Tensor & self, at::DimnameList dim, bool keepdim=false, c10::optional dtype=c10::nullopt) { + return at::_ops::mean_names_dim::call(self, dim, keepdim, dtype); +} + +// aten::mean.names_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & mean_out(at::Tensor & out, const at::Tensor & self, at::DimnameList dim, bool keepdim=false, c10::optional dtype=c10::nullopt) { + return at::_ops::mean_names_out::call(self, dim, keepdim, dtype, out); +} +// aten::mean.names_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & mean_outf(const at::Tensor & self, at::DimnameList dim, bool keepdim, c10::optional dtype, at::Tensor & out) { + return at::_ops::mean_names_out::call(self, dim, keepdim, dtype, out); +} + +} diff --git a/shared/package-files/42/426aaaa8b3bac1aa9e48638a8c3354c23be89f9dd9ef2aa297901fa9f7ed0d66/blob b/shared/package-files/42/426aaaa8b3bac1aa9e48638a8c3354c23be89f9dd9ef2aa297901fa9f7ed0d66/blob new file mode 100644 index 0000000000000000000000000000000000000000..fcf73cefbac8bc41c2f02f7895706423d3676e96 --- /dev/null +++ b/shared/package-files/42/426aaaa8b3bac1aa9e48638a8c3354c23be89f9dd9ef2aa297901fa9f7ed0d66/blob @@ -0,0 +1,592 @@ +""" +formlayout +========== + +Module creating Qt form dialogs/layouts to edit various type of parameters + + +formlayout License Agreement (MIT License) +------------------------------------------ + +Copyright (c) 2009 Pierre Raybaut + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. +""" + +# History: +# 1.0.10: added float validator +# (disable "Ok" and "Apply" button when not valid) +# 1.0.7: added support for "Apply" button +# 1.0.6: code cleaning + +__version__ = '1.0.10' +__license__ = __doc__ + +from ast import literal_eval + +import copy +import datetime +import logging +from numbers import Integral, Real + +from matplotlib import _api, colors as mcolors +from matplotlib.backends.qt_compat import _to_int, QtGui, QtWidgets, QtCore + +_log = logging.getLogger(__name__) + +BLACKLIST = {"title", "label"} + + +class ColorButton(QtWidgets.QPushButton): + """ + Color choosing push button + """ + colorChanged = QtCore.Signal(QtGui.QColor) + + def __init__(self, parent=None): + super().__init__(parent) + self.setFixedSize(20, 20) + self.setIconSize(QtCore.QSize(12, 12)) + self.clicked.connect(self.choose_color) + self._color = QtGui.QColor() + + def choose_color(self): + color = QtWidgets.QColorDialog.getColor( + self._color, self.parentWidget(), "", + QtWidgets.QColorDialog.ColorDialogOption.ShowAlphaChannel) + if color.isValid(): + self.set_color(color) + + def get_color(self): + return self._color + + @QtCore.Slot(QtGui.QColor) + def set_color(self, color): + if color != self._color: + self._color = color + self.colorChanged.emit(self._color) + pixmap = QtGui.QPixmap(self.iconSize()) + pixmap.fill(color) + self.setIcon(QtGui.QIcon(pixmap)) + + color = QtCore.Property(QtGui.QColor, get_color, set_color) + + +def to_qcolor(color): + """Create a QColor from a matplotlib color""" + qcolor = QtGui.QColor() + try: + rgba = mcolors.to_rgba(color) + except ValueError: + _api.warn_external(f'Ignoring invalid color {color!r}') + return qcolor # return invalid QColor + qcolor.setRgbF(*rgba) + return qcolor + + +class ColorLayout(QtWidgets.QHBoxLayout): + """Color-specialized QLineEdit layout""" + def __init__(self, color, parent=None): + super().__init__() + assert isinstance(color, QtGui.QColor) + self.lineedit = QtWidgets.QLineEdit( + mcolors.to_hex(color.getRgbF(), keep_alpha=True), parent) + self.lineedit.editingFinished.connect(self.update_color) + self.addWidget(self.lineedit) + self.colorbtn = ColorButton(parent) + self.colorbtn.color = color + self.colorbtn.colorChanged.connect(self.update_text) + self.addWidget(self.colorbtn) + + def update_color(self): + color = self.text() + qcolor = to_qcolor(color) # defaults to black if not qcolor.isValid() + self.colorbtn.color = qcolor + + def update_text(self, color): + self.lineedit.setText(mcolors.to_hex(color.getRgbF(), keep_alpha=True)) + + def text(self): + return self.lineedit.text() + + +def font_is_installed(font): + """Check if font is installed""" + return [fam for fam in QtGui.QFontDatabase().families() + if str(fam) == font] + + +def tuple_to_qfont(tup): + """ + Create a QFont from tuple: + (family [string], size [int], italic [bool], bold [bool]) + """ + if not (isinstance(tup, tuple) and len(tup) == 4 + and font_is_installed(tup[0]) + and isinstance(tup[1], Integral) + and isinstance(tup[2], bool) + and isinstance(tup[3], bool)): + return None + font = QtGui.QFont() + family, size, italic, bold = tup + font.setFamily(family) + font.setPointSize(size) + font.setItalic(italic) + font.setBold(bold) + return font + + +def qfont_to_tuple(font): + return (str(font.family()), int(font.pointSize()), + font.italic(), font.bold()) + + +class FontLayout(QtWidgets.QGridLayout): + """Font selection""" + def __init__(self, value, parent=None): + super().__init__() + font = tuple_to_qfont(value) + assert font is not None + + # Font family + self.family = QtWidgets.QFontComboBox(parent) + self.family.setCurrentFont(font) + self.addWidget(self.family, 0, 0, 1, -1) + + # Font size + self.size = QtWidgets.QComboBox(parent) + self.size.setEditable(True) + sizelist = [*range(6, 12), *range(12, 30, 2), 36, 48, 72] + size = font.pointSize() + if size not in sizelist: + sizelist.append(size) + sizelist.sort() + self.size.addItems([str(s) for s in sizelist]) + self.size.setCurrentIndex(sizelist.index(size)) + self.addWidget(self.size, 1, 0) + + # Italic or not + self.italic = QtWidgets.QCheckBox(self.tr("Italic"), parent) + self.italic.setChecked(font.italic()) + self.addWidget(self.italic, 1, 1) + + # Bold or not + self.bold = QtWidgets.QCheckBox(self.tr("Bold"), parent) + self.bold.setChecked(font.bold()) + self.addWidget(self.bold, 1, 2) + + def get_font(self): + font = self.family.currentFont() + font.setItalic(self.italic.isChecked()) + font.setBold(self.bold.isChecked()) + font.setPointSize(int(self.size.currentText())) + return qfont_to_tuple(font) + + +def is_edit_valid(edit): + text = edit.text() + state = edit.validator().validate(text, 0)[0] + return state == QtGui.QDoubleValidator.State.Acceptable + + +class FormWidget(QtWidgets.QWidget): + update_buttons = QtCore.Signal() + + def __init__(self, data, comment="", with_margin=False, parent=None): + """ + Parameters + ---------- + data : list of (label, value) pairs + The data to be edited in the form. + comment : str, optional + with_margin : bool, default: False + If False, the form elements reach to the border of the widget. + This is the desired behavior if the FormWidget is used as a widget + alongside with other widgets such as a QComboBox, which also do + not have a margin around them. + However, a margin can be desired if the FormWidget is the only + widget within a container, e.g. a tab in a QTabWidget. + parent : QWidget or None + The parent widget. + """ + super().__init__(parent) + self.data = copy.deepcopy(data) + self.widgets = [] + self.formlayout = QtWidgets.QFormLayout(self) + if not with_margin: + self.formlayout.setContentsMargins(0, 0, 0, 0) + if comment: + self.formlayout.addRow(QtWidgets.QLabel(comment)) + self.formlayout.addRow(QtWidgets.QLabel(" ")) + + def get_dialog(self): + """Return FormDialog instance""" + dialog = self.parent() + while not isinstance(dialog, QtWidgets.QDialog): + dialog = dialog.parent() + return dialog + + def setup(self): + for label, value in self.data: + if label is None and value is None: + # Separator: (None, None) + self.formlayout.addRow(QtWidgets.QLabel(" "), + QtWidgets.QLabel(" ")) + self.widgets.append(None) + continue + elif label is None: + # Comment + self.formlayout.addRow(QtWidgets.QLabel(value)) + self.widgets.append(None) + continue + elif tuple_to_qfont(value) is not None: + field = FontLayout(value, self) + elif (label.lower() not in BLACKLIST + and mcolors.is_color_like(value)): + field = ColorLayout(to_qcolor(value), self) + elif isinstance(value, str): + field = QtWidgets.QLineEdit(value, self) + elif isinstance(value, (list, tuple)): + if isinstance(value, tuple): + value = list(value) + # Note: get() below checks the type of value[0] in self.data so + # it is essential that value gets modified in-place. + # This means that the code is actually broken in the case where + # value is a tuple, but fortunately we always pass a list... + selindex = value.pop(0) + field = QtWidgets.QComboBox(self) + if isinstance(value[0], (list, tuple)): + keys = [key for key, _val in value] + value = [val for _key, val in value] + else: + keys = value + field.addItems(value) + if selindex in value: + selindex = value.index(selindex) + elif selindex in keys: + selindex = keys.index(selindex) + elif not isinstance(selindex, Integral): + _log.warning( + "index '%s' is invalid (label: %s, value: %s)", + selindex, label, value) + selindex = 0 + field.setCurrentIndex(selindex) + elif isinstance(value, bool): + field = QtWidgets.QCheckBox(self) + field.setChecked(value) + elif isinstance(value, Integral): + field = QtWidgets.QSpinBox(self) + field.setRange(-10**9, 10**9) + field.setValue(value) + elif isinstance(value, Real): + field = QtWidgets.QLineEdit(repr(value), self) + field.setCursorPosition(0) + field.setValidator(QtGui.QDoubleValidator(field)) + field.validator().setLocale(QtCore.QLocale("C")) + dialog = self.get_dialog() + dialog.register_float_field(field) + field.textChanged.connect(lambda text: dialog.update_buttons()) + elif isinstance(value, datetime.datetime): + field = QtWidgets.QDateTimeEdit(self) + field.setDateTime(value) + elif isinstance(value, datetime.date): + field = QtWidgets.QDateEdit(self) + field.setDate(value) + else: + field = QtWidgets.QLineEdit(repr(value), self) + self.formlayout.addRow(label, field) + self.widgets.append(field) + + def get(self): + valuelist = [] + for index, (label, value) in enumerate(self.data): + field = self.widgets[index] + if label is None: + # Separator / Comment + continue + elif tuple_to_qfont(value) is not None: + value = field.get_font() + elif isinstance(value, str) or mcolors.is_color_like(value): + value = str(field.text()) + elif isinstance(value, (list, tuple)): + index = int(field.currentIndex()) + if isinstance(value[0], (list, tuple)): + value = value[index][0] + else: + value = value[index] + elif isinstance(value, bool): + value = field.isChecked() + elif isinstance(value, Integral): + value = int(field.value()) + elif isinstance(value, Real): + value = float(str(field.text())) + elif isinstance(value, datetime.datetime): + datetime_ = field.dateTime() + if hasattr(datetime_, "toPyDateTime"): + value = datetime_.toPyDateTime() + else: + value = datetime_.toPython() + elif isinstance(value, datetime.date): + date_ = field.date() + if hasattr(date_, "toPyDate"): + value = date_.toPyDate() + else: + value = date_.toPython() + else: + value = literal_eval(str(field.text())) + valuelist.append(value) + return valuelist + + +class FormComboWidget(QtWidgets.QWidget): + update_buttons = QtCore.Signal() + + def __init__(self, datalist, comment="", parent=None): + super().__init__(parent) + layout = QtWidgets.QVBoxLayout() + self.setLayout(layout) + self.combobox = QtWidgets.QComboBox() + layout.addWidget(self.combobox) + + self.stackwidget = QtWidgets.QStackedWidget(self) + layout.addWidget(self.stackwidget) + self.combobox.currentIndexChanged.connect( + self.stackwidget.setCurrentIndex) + + self.widgetlist = [] + for data, title, comment in datalist: + self.combobox.addItem(title) + widget = FormWidget(data, comment=comment, parent=self) + self.stackwidget.addWidget(widget) + self.widgetlist.append(widget) + + def setup(self): + for widget in self.widgetlist: + widget.setup() + + def get(self): + return [widget.get() for widget in self.widgetlist] + + +class FormTabWidget(QtWidgets.QWidget): + update_buttons = QtCore.Signal() + + def __init__(self, datalist, comment="", parent=None): + super().__init__(parent) + layout = QtWidgets.QVBoxLayout() + self.tabwidget = QtWidgets.QTabWidget() + layout.addWidget(self.tabwidget) + layout.setContentsMargins(0, 0, 0, 0) + self.setLayout(layout) + self.widgetlist = [] + for data, title, comment in datalist: + if len(data[0]) == 3: + widget = FormComboWidget(data, comment=comment, parent=self) + else: + widget = FormWidget(data, with_margin=True, comment=comment, + parent=self) + index = self.tabwidget.addTab(widget, title) + self.tabwidget.setTabToolTip(index, comment) + self.widgetlist.append(widget) + + def setup(self): + for widget in self.widgetlist: + widget.setup() + + def get(self): + return [widget.get() for widget in self.widgetlist] + + +class FormDialog(QtWidgets.QDialog): + """Form Dialog""" + def __init__(self, data, title="", comment="", + icon=None, parent=None, apply=None): + super().__init__(parent) + + self.apply_callback = apply + + # Form + if isinstance(data[0][0], (list, tuple)): + self.formwidget = FormTabWidget(data, comment=comment, + parent=self) + elif len(data[0]) == 3: + self.formwidget = FormComboWidget(data, comment=comment, + parent=self) + else: + self.formwidget = FormWidget(data, comment=comment, + parent=self) + layout = QtWidgets.QVBoxLayout() + layout.addWidget(self.formwidget) + + self.float_fields = [] + self.formwidget.setup() + + # Button box + self.bbox = bbox = QtWidgets.QDialogButtonBox( + QtWidgets.QDialogButtonBox.StandardButton( + _to_int(QtWidgets.QDialogButtonBox.StandardButton.Ok) | + _to_int(QtWidgets.QDialogButtonBox.StandardButton.Cancel) + )) + self.formwidget.update_buttons.connect(self.update_buttons) + if self.apply_callback is not None: + apply_btn = bbox.addButton( + QtWidgets.QDialogButtonBox.StandardButton.Apply) + apply_btn.clicked.connect(self.apply) + + bbox.accepted.connect(self.accept) + bbox.rejected.connect(self.reject) + layout.addWidget(bbox) + + self.setLayout(layout) + + self.setWindowTitle(title) + if not isinstance(icon, QtGui.QIcon): + icon = QtWidgets.QWidget().style().standardIcon( + QtWidgets.QStyle.SP_MessageBoxQuestion) + self.setWindowIcon(icon) + + def register_float_field(self, field): + self.float_fields.append(field) + + def update_buttons(self): + valid = True + for field in self.float_fields: + if not is_edit_valid(field): + valid = False + for btn_type in ["Ok", "Apply"]: + btn = self.bbox.button( + getattr(QtWidgets.QDialogButtonBox.StandardButton, + btn_type)) + if btn is not None: + btn.setEnabled(valid) + + def accept(self): + self.data = self.formwidget.get() + self.apply_callback(self.data) + super().accept() + + def reject(self): + self.data = None + super().reject() + + def apply(self): + self.apply_callback(self.formwidget.get()) + + def get(self): + """Return form result""" + return self.data + + +def fedit(data, title="", comment="", icon=None, parent=None, apply=None): + """ + Create form dialog + + data: datalist, datagroup + title: str + comment: str + icon: QIcon instance + parent: parent QWidget + apply: apply callback (function) + + datalist: list/tuple of (field_name, field_value) + datagroup: list/tuple of (datalist *or* datagroup, title, comment) + + -> one field for each member of a datalist + -> one tab for each member of a top-level datagroup + -> one page (of a multipage widget, each page can be selected with a combo + box) for each member of a datagroup inside a datagroup + + Supported types for field_value: + - int, float, str, bool + - colors: in Qt-compatible text form, i.e. in hex format or name + (red, ...) (automatically detected from a string) + - list/tuple: + * the first element will be the selected index (or value) + * the other elements can be couples (key, value) or only values + """ + + # Create a QApplication instance if no instance currently exists + # (e.g., if the module is used directly from the interpreter) + if QtWidgets.QApplication.startingUp(): + _app = QtWidgets.QApplication([]) + dialog = FormDialog(data, title, comment, icon, parent, apply) + + if parent is not None: + if hasattr(parent, "_fedit_dialog"): + parent._fedit_dialog.close() + parent._fedit_dialog = dialog + + dialog.show() + + +if __name__ == "__main__": + + _app = QtWidgets.QApplication([]) + + def create_datalist_example(): + return [('str', 'this is a string'), + ('list', [0, '1', '3', '4']), + ('list2', ['--', ('none', 'None'), ('--', 'Dashed'), + ('-.', 'DashDot'), ('-', 'Solid'), + ('steps', 'Steps'), (':', 'Dotted')]), + ('float', 1.2), + (None, 'Other:'), + ('int', 12), + ('font', ('Arial', 10, False, True)), + ('color', '#123409'), + ('bool', True), + ('date', datetime.date(2010, 10, 10)), + ('datetime', datetime.datetime(2010, 10, 10)), + ] + + def create_datagroup_example(): + datalist = create_datalist_example() + return ((datalist, "Category 1", "Category 1 comment"), + (datalist, "Category 2", "Category 2 comment"), + (datalist, "Category 3", "Category 3 comment")) + + # --------- datalist example + datalist = create_datalist_example() + + def apply_test(data): + print("data:", data) + fedit(datalist, title="Example", + comment="This is just an example.", + apply=apply_test) + + _app.exec() + + # --------- datagroup example + datagroup = create_datagroup_example() + fedit(datagroup, "Global title", + apply=apply_test) + _app.exec() + + # --------- datagroup inside a datagroup example + datalist = create_datalist_example() + datagroup = create_datagroup_example() + fedit(((datagroup, "Title 1", "Tab 1 comment"), + (datalist, "Title 2", "Tab 2 comment"), + (datalist, "Title 3", "Tab 3 comment")), + "Global title", + apply=apply_test) + _app.exec() diff --git a/shared/package-files/42/426ad943632d7f26a8eaa5a0fb09841806d3c24b89e7802703315ff4dcd91e0e/blob b/shared/package-files/42/426ad943632d7f26a8eaa5a0fb09841806d3c24b89e7802703315ff4dcd91e0e/blob new file mode 100644 index 0000000000000000000000000000000000000000..83182e3f54002fbdef9c8fcae89f64ad0ff87d5f --- /dev/null +++ b/shared/package-files/42/426ad943632d7f26a8eaa5a0fb09841806d3c24b89e7802703315ff4dcd91e0e/blob @@ -0,0 +1,397 @@ +from collections import OrderedDict +import logging +import urllib.parse + +import numpy as np + +from matplotlib import _text_helpers, dviread +from matplotlib.font_manager import ( + FontProperties, get_font, fontManager as _fontManager +) +from matplotlib.ft2font import LoadFlags +from matplotlib.mathtext import MathTextParser +from matplotlib.path import Path +from matplotlib.texmanager import TexManager +from matplotlib.transforms import Affine2D + +_log = logging.getLogger(__name__) + + +class TextToPath: + """A class that converts strings to paths.""" + + FONT_SCALE = 100. + DPI = 72 + + def __init__(self): + self.mathtext_parser = MathTextParser('path') + self._texmanager = None + + def _get_font(self, prop): + """ + Find the `FT2Font` matching font properties *prop*, with its size set. + """ + filenames = _fontManager._find_fonts_by_props(prop) + font = get_font(filenames) + font.set_size(self.FONT_SCALE, self.DPI) + return font + + def _get_hinting_flag(self): + return LoadFlags.NO_HINTING + + def _get_char_id(self, font, ccode): + """ + Return a unique id for the given font and character-code set. + """ + return urllib.parse.quote(f"{font.postscript_name}-{ccode:x}") + + def get_text_width_height_descent(self, s, prop, ismath): + fontsize = prop.get_size_in_points() + + if ismath == "TeX": + return TexManager().get_text_width_height_descent(s, fontsize) + + scale = fontsize / self.FONT_SCALE + + if ismath: + prop = prop.copy() + prop.set_size(self.FONT_SCALE) + width, height, descent, *_ = \ + self.mathtext_parser.parse(s, 72, prop) + return width * scale, height * scale, descent * scale + + font = self._get_font(prop) + font.set_text(s, 0.0, flags=LoadFlags.NO_HINTING) + w, h = font.get_width_height() + w /= 64.0 # convert from subpixels + h /= 64.0 + d = font.get_descent() + d /= 64.0 + return w * scale, h * scale, d * scale + + def get_text_path(self, prop, s, ismath=False): + """ + Convert text *s* to path (a tuple of vertices and codes for + matplotlib.path.Path). + + Parameters + ---------- + prop : `~matplotlib.font_manager.FontProperties` + The font properties for the text. + s : str + The text to be converted. + ismath : {False, True, "TeX"} + If True, use mathtext parser. If "TeX", use tex for rendering. + + Returns + ------- + verts : list + A list of arrays containing the (x, y) coordinates of the vertices. + codes : list + A list of path codes. + + Examples + -------- + Create a list of vertices and codes from a text, and create a `.Path` + from those:: + + from matplotlib.path import Path + from matplotlib.text import TextToPath + from matplotlib.font_manager import FontProperties + + fp = FontProperties(family="Comic Neue", style="italic") + verts, codes = TextToPath().get_text_path(fp, "ABC") + path = Path(verts, codes, closed=False) + + Also see `TextPath` for a more direct way to create a path from a text. + """ + if ismath == "TeX": + glyph_info, glyph_map, rects = self.get_glyphs_tex(prop, s) + elif not ismath: + font = self._get_font(prop) + glyph_info, glyph_map, rects = self.get_glyphs_with_font(font, s) + else: + glyph_info, glyph_map, rects = self.get_glyphs_mathtext(prop, s) + + verts, codes = [], [] + for glyph_id, xposition, yposition, scale in glyph_info: + verts1, codes1 = glyph_map[glyph_id] + verts.extend(verts1 * scale + [xposition, yposition]) + codes.extend(codes1) + for verts1, codes1 in rects: + verts.extend(verts1) + codes.extend(codes1) + + # Make sure an empty string or one with nothing to print + # (e.g. only spaces & newlines) will be valid/empty path + if not verts: + verts = np.empty((0, 2)) + + return verts, codes + + def get_glyphs_with_font(self, font, s, glyph_map=None, + return_new_glyphs_only=False): + """ + Convert string *s* to vertices and codes using the provided ttf font. + """ + + if glyph_map is None: + glyph_map = OrderedDict() + + if return_new_glyphs_only: + glyph_map_new = OrderedDict() + else: + glyph_map_new = glyph_map + + xpositions = [] + glyph_ids = [] + for item in _text_helpers.layout(s, font): + char_id = self._get_char_id(item.ft_object, ord(item.char)) + glyph_ids.append(char_id) + xpositions.append(item.x) + if char_id not in glyph_map: + glyph_map_new[char_id] = item.ft_object.get_path() + + ypositions = [0] * len(xpositions) + sizes = [1.] * len(xpositions) + + rects = [] + + return (list(zip(glyph_ids, xpositions, ypositions, sizes)), + glyph_map_new, rects) + + def get_glyphs_mathtext(self, prop, s, glyph_map=None, + return_new_glyphs_only=False): + """ + Parse mathtext string *s* and convert it to a (vertices, codes) pair. + """ + + prop = prop.copy() + prop.set_size(self.FONT_SCALE) + + width, height, descent, glyphs, rects = self.mathtext_parser.parse( + s, self.DPI, prop) + + if not glyph_map: + glyph_map = OrderedDict() + + if return_new_glyphs_only: + glyph_map_new = OrderedDict() + else: + glyph_map_new = glyph_map + + xpositions = [] + ypositions = [] + glyph_ids = [] + sizes = [] + + for font, fontsize, ccode, ox, oy in glyphs: + char_id = self._get_char_id(font, ccode) + if char_id not in glyph_map: + font.clear() + font.set_size(self.FONT_SCALE, self.DPI) + font.load_char(ccode, flags=LoadFlags.NO_HINTING) + glyph_map_new[char_id] = font.get_path() + + xpositions.append(ox) + ypositions.append(oy) + glyph_ids.append(char_id) + size = fontsize / self.FONT_SCALE + sizes.append(size) + + myrects = [] + for ox, oy, w, h in rects: + vert1 = [(ox, oy), (ox, oy + h), (ox + w, oy + h), + (ox + w, oy), (ox, oy), (0, 0)] + code1 = [Path.MOVETO, + Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, + Path.CLOSEPOLY] + myrects.append((vert1, code1)) + + return (list(zip(glyph_ids, xpositions, ypositions, sizes)), + glyph_map_new, myrects) + + def get_glyphs_tex(self, prop, s, glyph_map=None, + return_new_glyphs_only=False): + """Convert the string *s* to vertices and codes using usetex mode.""" + # Mostly borrowed from pdf backend. + + dvifile = TexManager().make_dvi(s, self.FONT_SCALE) + with dviread.Dvi(dvifile, self.DPI) as dvi: + page, = dvi + + if glyph_map is None: + glyph_map = OrderedDict() + + if return_new_glyphs_only: + glyph_map_new = OrderedDict() + else: + glyph_map_new = glyph_map + + glyph_ids, xpositions, ypositions, sizes = [], [], [], [] + + # Gather font information and do some setup for combining + # characters into strings. + for text in page.text: + font = get_font(text.font_path) + char_id = self._get_char_id(font, text.glyph) + if char_id not in glyph_map: + font.clear() + font.set_size(self.FONT_SCALE, self.DPI) + glyph_name_or_index = text.glyph_name_or_index + if isinstance(glyph_name_or_index, str): + index = font.get_name_index(glyph_name_or_index) + font.load_glyph(index, flags=LoadFlags.TARGET_LIGHT) + elif isinstance(glyph_name_or_index, int): + self._select_native_charmap(font) + font.load_char( + glyph_name_or_index, flags=LoadFlags.TARGET_LIGHT) + else: # Should not occur. + raise TypeError(f"Glyph spec of unexpected type: " + f"{glyph_name_or_index!r}") + glyph_map_new[char_id] = font.get_path() + + glyph_ids.append(char_id) + xpositions.append(text.x) + ypositions.append(text.y) + sizes.append(text.font_size / self.FONT_SCALE) + + myrects = [] + + for ox, oy, h, w in page.boxes: + vert1 = [(ox, oy), (ox + w, oy), (ox + w, oy + h), + (ox, oy + h), (ox, oy), (0, 0)] + code1 = [Path.MOVETO, + Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, + Path.CLOSEPOLY] + myrects.append((vert1, code1)) + + return (list(zip(glyph_ids, xpositions, ypositions, sizes)), + glyph_map_new, myrects) + + @staticmethod + def _select_native_charmap(font): + # Select the native charmap. (we can't directly identify it but it's + # typically an Adobe charmap). + for charmap_code in [ + 1094992451, # ADOBE_CUSTOM. + 1094995778, # ADOBE_STANDARD. + ]: + try: + font.select_charmap(charmap_code) + except (ValueError, RuntimeError): + pass + else: + break + else: + _log.warning("No supported encoding in font (%s).", font.fname) + + +text_to_path = TextToPath() + + +class TextPath(Path): + """ + Create a path from the text. + """ + + def __init__(self, xy, s, size=None, prop=None, + _interpolation_steps=1, usetex=False): + r""" + Create a path from the text. Note that it simply is a path, + not an artist. You need to use the `.PathPatch` (or other artists) + to draw this path onto the canvas. + + Parameters + ---------- + xy : tuple or array of two float values + Position of the text. For no offset, use ``xy=(0, 0)``. + + s : str + The text to convert to a path. + + size : float, optional + Font size in points. Defaults to the size specified via the font + properties *prop*. + + prop : `~matplotlib.font_manager.FontProperties`, optional + Font property. If not provided, will use a default + `.FontProperties` with parameters from the + :ref:`rcParams`. + + _interpolation_steps : int, optional + (Currently ignored) + + usetex : bool, default: False + Whether to use tex rendering. + + Examples + -------- + The following creates a path from the string "ABC" with Helvetica + font face; and another path from the latex fraction 1/2:: + + from matplotlib.text import TextPath + from matplotlib.font_manager import FontProperties + + fp = FontProperties(family="Helvetica", style="italic") + path1 = TextPath((12, 12), "ABC", size=12, prop=fp) + path2 = TextPath((0, 0), r"$\frac{1}{2}$", size=12, usetex=True) + + Also see :doc:`/gallery/text_labels_and_annotations/demo_text_path`. + """ + # Circular import. + from matplotlib.text import Text + + prop = FontProperties._from_any(prop) + if size is None: + size = prop.get_size_in_points() + + self._xy = xy + self.set_size(size) + + self._cached_vertices = None + s, ismath = Text(usetex=usetex)._preprocess_math(s) + super().__init__( + *text_to_path.get_text_path(prop, s, ismath=ismath), + _interpolation_steps=_interpolation_steps, + readonly=True) + self._should_simplify = False + + def set_size(self, size): + """Set the text size.""" + self._size = size + self._invalid = True + + def get_size(self): + """Get the text size.""" + return self._size + + @property + def vertices(self): + """ + Return the cached path after updating it if necessary. + """ + self._revalidate_path() + return self._cached_vertices + + @property + def codes(self): + """ + Return the codes + """ + return self._codes + + def _revalidate_path(self): + """ + Update the path if necessary. + + The path for the text is initially create with the font size of + `.FONT_SCALE`, and this path is rescaled to other size when necessary. + """ + if self._invalid or self._cached_vertices is None: + tr = (Affine2D() + .scale(self._size / text_to_path.FONT_SCALE) + .translate(*self._xy)) + self._cached_vertices = tr.transform(self._vertices) + self._cached_vertices.flags.writeable = False + self._invalid = False diff --git a/shared/package-files/42/426b3e044ec308960d4aaf55779bad9ca8b0553a91214ccb6181223324dda5f1/blob b/shared/package-files/42/426b3e044ec308960d4aaf55779bad9ca8b0553a91214ccb6181223324dda5f1/blob new file mode 100644 index 0000000000000000000000000000000000000000..775b26a8bf5922f7fa3634ad6c8c708a96820931 --- /dev/null +++ b/shared/package-files/42/426b3e044ec308960d4aaf55779bad9ca8b0553a91214ccb6181223324dda5f1/blob @@ -0,0 +1,197 @@ +from scipy._lib._array_api import ( + array_namespace, is_numpy, xp_unsupported_param_msg, is_complex, xp_float_to_complex +) +from . import _pocketfft +import numpy as np + + +def _validate_fft_args(workers, plan, norm): + if workers is not None: + raise ValueError(xp_unsupported_param_msg("workers")) + if plan is not None: + raise ValueError(xp_unsupported_param_msg("plan")) + if norm is None: + norm = 'backward' + return norm + + +# these functions expect complex input in the fft standard extension +complex_funcs = {'fft', 'ifft', 'fftn', 'ifftn', 'hfft', 'irfft', 'irfftn'} + +# pocketfft is used whenever SCIPY_ARRAY_API is not set, +# or x is a NumPy array or array-like. +# When SCIPY_ARRAY_API is set, we try to use xp.fft for CuPy arrays, +# PyTorch arrays and other array API standard supporting objects. +# If xp.fft does not exist, we attempt to convert to np and back to use pocketfft. + +def _execute_1D(func_str, pocketfft_func, x, n, axis, norm, overwrite_x, workers, plan): + xp = array_namespace(x) + + if is_numpy(xp): + x = np.asarray(x) + return pocketfft_func(x, n=n, axis=axis, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + norm = _validate_fft_args(workers, plan, norm) + if hasattr(xp, 'fft'): + xp_func = getattr(xp.fft, func_str) + if func_str in complex_funcs: + try: + res = xp_func(x, n=n, axis=axis, norm=norm) + except: # backends may require complex input # noqa: E722 + x = xp_float_to_complex(x, xp) + res = xp_func(x, n=n, axis=axis, norm=norm) + return res + return xp_func(x, n=n, axis=axis, norm=norm) + + x = np.asarray(x) + y = pocketfft_func(x, n=n, axis=axis, norm=norm) + return xp.asarray(y) + + +def _execute_nD(func_str, pocketfft_func, x, s, axes, norm, overwrite_x, workers, plan): + xp = array_namespace(x) + + if is_numpy(xp): + x = np.asarray(x) + return pocketfft_func(x, s=s, axes=axes, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + norm = _validate_fft_args(workers, plan, norm) + if hasattr(xp, 'fft'): + xp_func = getattr(xp.fft, func_str) + if func_str in complex_funcs: + try: + res = xp_func(x, s=s, axes=axes, norm=norm) + except: # backends may require complex input # noqa: E722 + x = xp_float_to_complex(x, xp) + res = xp_func(x, s=s, axes=axes, norm=norm) + return res + return xp_func(x, s=s, axes=axes, norm=norm) + + x = np.asarray(x) + y = pocketfft_func(x, s=s, axes=axes, norm=norm) + return xp.asarray(y) + + +def fft(x, n=None, axis=-1, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_1D('fft', _pocketfft.fft, x, n=n, axis=axis, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def ifft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, + plan=None): + return _execute_1D('ifft', _pocketfft.ifft, x, n=n, axis=axis, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def rfft(x, n=None, axis=-1, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_1D('rfft', _pocketfft.rfft, x, n=n, axis=axis, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def irfft(x, n=None, axis=-1, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_1D('irfft', _pocketfft.irfft, x, n=n, axis=axis, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def hfft(x, n=None, axis=-1, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_1D('hfft', _pocketfft.hfft, x, n=n, axis=axis, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def ihfft(x, n=None, axis=-1, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_1D('ihfft', _pocketfft.ihfft, x, n=n, axis=axis, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def fftn(x, s=None, axes=None, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_nD('fftn', _pocketfft.fftn, x, s=s, axes=axes, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + + +def ifftn(x, s=None, axes=None, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_nD('ifftn', _pocketfft.ifftn, x, s=s, axes=axes, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def fft2(x, s=None, axes=(-2, -1), norm=None, + overwrite_x=False, workers=None, *, plan=None): + return fftn(x, s, axes, norm, overwrite_x, workers, plan=plan) + + +def ifft2(x, s=None, axes=(-2, -1), norm=None, + overwrite_x=False, workers=None, *, plan=None): + return ifftn(x, s, axes, norm, overwrite_x, workers, plan=plan) + + +def rfftn(x, s=None, axes=None, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_nD('rfftn', _pocketfft.rfftn, x, s=s, axes=axes, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def rfft2(x, s=None, axes=(-2, -1), norm=None, + overwrite_x=False, workers=None, *, plan=None): + return rfftn(x, s, axes, norm, overwrite_x, workers, plan=plan) + + +def irfftn(x, s=None, axes=None, norm=None, + overwrite_x=False, workers=None, *, plan=None): + return _execute_nD('irfftn', _pocketfft.irfftn, x, s=s, axes=axes, norm=norm, + overwrite_x=overwrite_x, workers=workers, plan=plan) + + +def irfft2(x, s=None, axes=(-2, -1), norm=None, + overwrite_x=False, workers=None, *, plan=None): + return irfftn(x, s, axes, norm, overwrite_x, workers, plan=plan) + + +def _swap_direction(norm): + if norm in (None, 'backward'): + norm = 'forward' + elif norm == 'forward': + norm = 'backward' + elif norm != 'ortho': + raise ValueError(f'Invalid norm value {norm}; should be "backward", ' + '"ortho", or "forward".') + return norm + + +def hfftn(x, s=None, axes=None, norm=None, + overwrite_x=False, workers=None, *, plan=None): + xp = array_namespace(x) + if is_numpy(xp): + x = np.asarray(x) + return _pocketfft.hfftn(x, s, axes, norm, overwrite_x, workers, plan=plan) + if is_complex(x, xp): + x = xp.conj(x) + return irfftn(x, s, axes, _swap_direction(norm), + overwrite_x, workers, plan=plan) + + +def hfft2(x, s=None, axes=(-2, -1), norm=None, + overwrite_x=False, workers=None, *, plan=None): + return hfftn(x, s, axes, norm, overwrite_x, workers, plan=plan) + + +def ihfftn(x, s=None, axes=None, norm=None, + overwrite_x=False, workers=None, *, plan=None): + xp = array_namespace(x) + if is_numpy(xp): + x = np.asarray(x) + return _pocketfft.ihfftn(x, s, axes, norm, overwrite_x, workers, plan=plan) + return xp.conj(rfftn(x, s, axes, _swap_direction(norm), + overwrite_x, workers, plan=plan)) + +def ihfft2(x, s=None, axes=(-2, -1), norm=None, + overwrite_x=False, workers=None, *, plan=None): + return ihfftn(x, s, axes, norm, overwrite_x, workers, plan=plan) diff --git a/shared/package-files/42/426ce43a75a0f5b712aefdf551c683e82928e79015f863cb2d8e40a9bfc39afb/blob b/shared/package-files/42/426ce43a75a0f5b712aefdf551c683e82928e79015f863cb2d8e40a9bfc39afb/blob new file mode 100644 index 0000000000000000000000000000000000000000..0d578b4bf0fc07e1bcce0b6a178c3057f168258a --- /dev/null +++ b/shared/package-files/42/426ce43a75a0f5b712aefdf551c683e82928e79015f863cb2d8e40a9bfc39afb/blob @@ -0,0 +1,176 @@ +from pytest import approx + +from networkx import is_connected, neighbors +from networkx.generators.internet_as_graphs import random_internet_as_graph + + +class TestInternetASTopology: + @classmethod + def setup_class(cls): + cls.n = 1000 + cls.seed = 42 + cls.G = random_internet_as_graph(cls.n, cls.seed) + cls.T = [] + cls.M = [] + cls.C = [] + cls.CP = [] + cls.customers = {} + cls.providers = {} + + for i in cls.G.nodes(): + if cls.G.nodes[i]["type"] == "T": + cls.T.append(i) + elif cls.G.nodes[i]["type"] == "M": + cls.M.append(i) + elif cls.G.nodes[i]["type"] == "C": + cls.C.append(i) + elif cls.G.nodes[i]["type"] == "CP": + cls.CP.append(i) + else: + raise ValueError("Inconsistent data in the graph node attributes") + cls.set_customers(i) + cls.set_providers(i) + + @classmethod + def set_customers(cls, i): + if i not in cls.customers: + cls.customers[i] = set() + for j in neighbors(cls.G, i): + e = cls.G.edges[(i, j)] + if e["type"] == "transit": + customer = int(e["customer"]) + if j == customer: + cls.set_customers(j) + cls.customers[i] = cls.customers[i].union(cls.customers[j]) + cls.customers[i].add(j) + elif i != customer: + raise ValueError( + "Inconsistent data in the graph edge attributes" + ) + + @classmethod + def set_providers(cls, i): + if i not in cls.providers: + cls.providers[i] = set() + for j in neighbors(cls.G, i): + e = cls.G.edges[(i, j)] + if e["type"] == "transit": + customer = int(e["customer"]) + if i == customer: + cls.set_providers(j) + cls.providers[i] = cls.providers[i].union(cls.providers[j]) + cls.providers[i].add(j) + elif j != customer: + raise ValueError( + "Inconsistent data in the graph edge attributes" + ) + + def test_wrong_input(self): + G = random_internet_as_graph(0) + assert len(G.nodes()) == 0 + + G = random_internet_as_graph(-1) + assert len(G.nodes()) == 0 + + G = random_internet_as_graph(1) + assert len(G.nodes()) == 1 + + def test_node_numbers(self): + assert len(self.G.nodes()) == self.n + assert len(self.T) < 7 + assert len(self.M) == round(self.n * 0.15) + assert len(self.CP) == round(self.n * 0.05) + numb = self.n - len(self.T) - len(self.M) - len(self.CP) + assert len(self.C) == numb + + def test_connectivity(self): + assert is_connected(self.G) + + def test_relationships(self): + # T nodes are not customers of anyone + for i in self.T: + assert len(self.providers[i]) == 0 + + # C nodes are not providers of anyone + for i in self.C: + assert len(self.customers[i]) == 0 + + # CP nodes are not providers of anyone + for i in self.CP: + assert len(self.customers[i]) == 0 + + # test whether there is a customer-provider loop + for i in self.G.nodes(): + assert len(self.customers[i].intersection(self.providers[i])) == 0 + + # test whether there is a peering with a customer or provider + for i, j in self.G.edges(): + if self.G.edges[(i, j)]["type"] == "peer": + assert j not in self.customers[i] + assert i not in self.customers[j] + assert j not in self.providers[i] + assert i not in self.providers[j] + + def test_degree_values(self): + d_m = 0 # multihoming degree for M nodes + d_cp = 0 # multihoming degree for CP nodes + d_c = 0 # multihoming degree for C nodes + p_m_m = 0 # avg number of peering edges between M and M + p_cp_m = 0 # avg number of peering edges between CP and M + p_cp_cp = 0 # avg number of peering edges between CP and CP + t_m = 0 # probability M's provider is T + t_cp = 0 # probability CP's provider is T + t_c = 0 # probability C's provider is T + + for i, j in self.G.edges(): + e = self.G.edges[(i, j)] + if e["type"] == "transit": + cust = int(e["customer"]) + if i == cust: + prov = j + elif j == cust: + prov = i + else: + raise ValueError("Inconsistent data in the graph edge attributes") + if cust in self.M: + d_m += 1 + if self.G.nodes[prov]["type"] == "T": + t_m += 1 + elif cust in self.C: + d_c += 1 + if self.G.nodes[prov]["type"] == "T": + t_c += 1 + elif cust in self.CP: + d_cp += 1 + if self.G.nodes[prov]["type"] == "T": + t_cp += 1 + else: + raise ValueError("Inconsistent data in the graph edge attributes") + elif e["type"] == "peer": + if self.G.nodes[i]["type"] == "M" and self.G.nodes[j]["type"] == "M": + p_m_m += 1 + if self.G.nodes[i]["type"] == "CP" and self.G.nodes[j]["type"] == "CP": + p_cp_cp += 1 + if ( + self.G.nodes[i]["type"] == "M" + and self.G.nodes[j]["type"] == "CP" + or self.G.nodes[i]["type"] == "CP" + and self.G.nodes[j]["type"] == "M" + ): + p_cp_m += 1 + else: + raise ValueError("Unexpected data in the graph edge attributes") + + assert d_m / len(self.M) == approx((2 + (2.5 * self.n) / 10000), abs=1e-0) + assert d_cp / len(self.CP) == approx((2 + (1.5 * self.n) / 10000), abs=1e-0) + assert d_c / len(self.C) == approx((1 + (5 * self.n) / 100000), abs=1e-0) + + assert p_m_m / len(self.M) == approx((1 + (2 * self.n) / 10000), abs=1e-0) + assert p_cp_m / len(self.CP) == approx((0.2 + (2 * self.n) / 10000), abs=1e-0) + assert p_cp_cp / len(self.CP) == approx( + (0.05 + (2 * self.n) / 100000), abs=1e-0 + ) + + assert t_m / d_m == approx(0.375, abs=1e-1) + assert t_cp / d_cp == approx(0.375, abs=1e-1) + assert t_c / d_c == approx(0.125, abs=1e-1) diff --git a/shared/package-files/42/4271efd83b278c57a2611681d706ee0eb000e269e0d270b5e3830cfd86bac152/blob b/shared/package-files/42/4271efd83b278c57a2611681d706ee0eb000e269e0d270b5e3830cfd86bac152/blob new file mode 100644 index 0000000000000000000000000000000000000000..55efbb9d76f9f6daf7105f3b2c34ecb2f5d970bb --- /dev/null +++ b/shared/package-files/42/4271efd83b278c57a2611681d706ee0eb000e269e0d270b5e3830cfd86bac152/blob @@ -0,0 +1,191 @@ +"""fontTools.pens.pointInsidePen -- Pen implementing "point inside" testing +for shapes. +""" + +from fontTools.pens.basePen import BasePen +from fontTools.misc.bezierTools import solveQuadratic, solveCubic + +__all__ = ["PointInsidePen"] + + +class PointInsidePen(BasePen): + """This pen implements "point inside" testing: to test whether + a given point lies inside the shape (black) or outside (white). + Instances of this class can be recycled, as long as the + setTestPoint() method is used to set the new point to test. + + :Example: + .. code-block:: + + pen = PointInsidePen(glyphSet, (100, 200)) + outline.draw(pen) + isInside = pen.getResult() + + Both the even-odd algorithm and the non-zero-winding-rule + algorithm are implemented. The latter is the default, specify + True for the evenOdd argument of __init__ or setTestPoint + to use the even-odd algorithm. + """ + + # This class implements the classical "shoot a ray from the test point + # to infinity and count how many times it intersects the outline" (as well + # as the non-zero variant, where the counter is incremented if the outline + # intersects the ray in one direction and decremented if it intersects in + # the other direction). + # I found an amazingly clear explanation of the subtleties involved in + # implementing this correctly for polygons here: + # http://graphics.cs.ucdavis.edu/~okreylos/TAship/Spring2000/PointInPolygon.html + # I extended the principles outlined on that page to curves. + + def __init__(self, glyphSet, testPoint, evenOdd=False): + BasePen.__init__(self, glyphSet) + self.setTestPoint(testPoint, evenOdd) + + def setTestPoint(self, testPoint, evenOdd=False): + """Set the point to test. Call this _before_ the outline gets drawn.""" + self.testPoint = testPoint + self.evenOdd = evenOdd + self.firstPoint = None + self.intersectionCount = 0 + + def getWinding(self): + if self.firstPoint is not None: + # always make sure the sub paths are closed; the algorithm only works + # for closed paths. + self.closePath() + return self.intersectionCount + + def getResult(self): + """After the shape has been drawn, getResult() returns True if the test + point lies within the (black) shape, and False if it doesn't. + """ + winding = self.getWinding() + if self.evenOdd: + result = winding % 2 + else: # non-zero + result = self.intersectionCount != 0 + return not not result + + def _addIntersection(self, goingUp): + if self.evenOdd or goingUp: + self.intersectionCount += 1 + else: + self.intersectionCount -= 1 + + def _moveTo(self, point): + if self.firstPoint is not None: + # always make sure the sub paths are closed; the algorithm only works + # for closed paths. + self.closePath() + self.firstPoint = point + + def _lineTo(self, point): + x, y = self.testPoint + x1, y1 = self._getCurrentPoint() + x2, y2 = point + + if x1 < x and x2 < x: + return + if y1 < y and y2 < y: + return + if y1 >= y and y2 >= y: + return + + dx = x2 - x1 + dy = y2 - y1 + t = (y - y1) / dy + ix = dx * t + x1 + if ix < x: + return + self._addIntersection(y2 > y1) + + def _curveToOne(self, bcp1, bcp2, point): + x, y = self.testPoint + x1, y1 = self._getCurrentPoint() + x2, y2 = bcp1 + x3, y3 = bcp2 + x4, y4 = point + + if x1 < x and x2 < x and x3 < x and x4 < x: + return + if y1 < y and y2 < y and y3 < y and y4 < y: + return + if y1 >= y and y2 >= y and y3 >= y and y4 >= y: + return + + dy = y1 + cy = (y2 - dy) * 3.0 + by = (y3 - y2) * 3.0 - cy + ay = y4 - dy - cy - by + solutions = sorted(solveCubic(ay, by, cy, dy - y)) + solutions = [t for t in solutions if -0.0 <= t <= 1.0] + if not solutions: + return + + dx = x1 + cx = (x2 - dx) * 3.0 + bx = (x3 - x2) * 3.0 - cx + ax = x4 - dx - cx - bx + + above = y1 >= y + lastT = None + for t in solutions: + if t == lastT: + continue + lastT = t + t2 = t * t + t3 = t2 * t + + direction = 3 * ay * t2 + 2 * by * t + cy + incomingGoingUp = outgoingGoingUp = direction > 0.0 + if direction == 0.0: + direction = 6 * ay * t + 2 * by + outgoingGoingUp = direction > 0.0 + incomingGoingUp = not outgoingGoingUp + if direction == 0.0: + direction = ay + incomingGoingUp = outgoingGoingUp = direction > 0.0 + + xt = ax * t3 + bx * t2 + cx * t + dx + if xt < x: + continue + + if t in (0.0, -0.0): + if not outgoingGoingUp: + self._addIntersection(outgoingGoingUp) + elif t == 1.0: + if incomingGoingUp: + self._addIntersection(incomingGoingUp) + else: + if incomingGoingUp == outgoingGoingUp: + self._addIntersection(outgoingGoingUp) + # else: + # we're not really intersecting, merely touching + + def _qCurveToOne_unfinished(self, bcp, point): + # XXX need to finish this, for now doing it through a cubic + # (BasePen implements _qCurveTo in terms of a cubic) will + # have to do. + x, y = self.testPoint + x1, y1 = self._getCurrentPoint() + x2, y2 = bcp + x3, y3 = point + c = y1 + b = (y2 - c) * 2.0 + a = y3 - c - b + solutions = sorted(solveQuadratic(a, b, c - y)) + solutions = [ + t for t in solutions if ZERO_MINUS_EPSILON <= t <= ONE_PLUS_EPSILON + ] + if not solutions: + return + # XXX + + def _closePath(self): + if self._getCurrentPoint() != self.firstPoint: + self.lineTo(self.firstPoint) + self.firstPoint = None + + def _endPath(self): + """Insideness is not defined for open contours.""" + raise NotImplementedError diff --git a/shared/package-files/42/42787120499ab3b186e62705dfc10e7703643e975db9a8ebc6d38b0be7b9832e/blob b/shared/package-files/42/42787120499ab3b186e62705dfc10e7703643e975db9a8ebc6d38b0be7b9832e/blob new file mode 100644 index 0000000000000000000000000000000000000000..17c88985e430cd509b3f10809cfd6d5bd2bbd1b3 --- /dev/null +++ b/shared/package-files/42/42787120499ab3b186e62705dfc10e7703643e975db9a8ebc6d38b0be7b9832e/blob @@ -0,0 +1,14 @@ +prefix=/opt/conda +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include + +KDB5_DB_LIB= + +Name: kdb +Description: Kerberos database access libraries +Version: 1.20.1 +Requires.private: mit-krb5-gssapi mit-krb5 gssrpc +Cflags: -I${includedir} +Libs: -L${libdir} -lkdb5 +Libs.private: ${KDB5_DB_LIB} diff --git a/shared/package-files/42/42792127e945706af4624b6420bd92dc287caa7b6ef79356836475b00b8f180d/blob b/shared/package-files/42/42792127e945706af4624b6420bd92dc287caa7b6ef79356836475b00b8f180d/blob new file mode 100644 index 0000000000000000000000000000000000000000..b72a04c75d8bfa95a2dd029cfc279d660bb2e28d --- /dev/null +++ b/shared/package-files/42/42792127e945706af4624b6420bd92dc287caa7b6ef79356836475b00b8f180d/blob @@ -0,0 +1,119 @@ +""" + pygments.styles.paraiso_light + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Paraíso (Light) by Jan T. Sott + + Pygments template by Jan T. Sott (https://github.com/idleberg) + Created with Base16 Builder by Chris Kempson + (https://github.com/chriskempson/base16-builder). + + :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +from pygments.style import Style +from pygments.token import Keyword, Name, Comment, String, Error, Text, \ + Number, Operator, Generic, Whitespace, Punctuation, Other, Literal + + +BACKGROUND = "#e7e9db" +CURRENT_LINE = "#b9b6b0" +SELECTION = "#a39e9b" +FOREGROUND = "#2f1e2e" +COMMENT = "#8d8687" +RED = "#ef6155" +ORANGE = "#f99b15" +YELLOW = "#fec418" +GREEN = "#48b685" +AQUA = "#5bc4bf" +BLUE = "#06b6ef" +PURPLE = "#815ba4" + + +class ParaisoLightStyle(Style): + + background_color = BACKGROUND + highlight_color = SELECTION + + styles = { + # No corresponding class for the following: + Text: FOREGROUND, # class: '' + Whitespace: "", # class: 'w' + Error: RED, # class: 'err' + Other: "", # class 'x' + + Comment: COMMENT, # class: 'c' + Comment.Multiline: "", # class: 'cm' + Comment.Preproc: "", # class: 'cp' + Comment.Single: "", # class: 'c1' + Comment.Special: "", # class: 'cs' + + Keyword: PURPLE, # class: 'k' + Keyword.Constant: "", # class: 'kc' + Keyword.Declaration: "", # class: 'kd' + Keyword.Namespace: AQUA, # class: 'kn' + Keyword.Pseudo: "", # class: 'kp' + Keyword.Reserved: "", # class: 'kr' + Keyword.Type: YELLOW, # class: 'kt' + + Operator: AQUA, # class: 'o' + Operator.Word: "", # class: 'ow' - like keywords + + Punctuation: FOREGROUND, # class: 'p' + + Name: FOREGROUND, # class: 'n' + Name.Attribute: BLUE, # class: 'na' - to be revised + Name.Builtin: "", # class: 'nb' + Name.Builtin.Pseudo: "", # class: 'bp' + Name.Class: YELLOW, # class: 'nc' - to be revised + Name.Constant: RED, # class: 'no' - to be revised + Name.Decorator: AQUA, # class: 'nd' - to be revised + Name.Entity: "", # class: 'ni' + Name.Exception: RED, # class: 'ne' + Name.Function: BLUE, # class: 'nf' + Name.Property: "", # class: 'py' + Name.Label: "", # class: 'nl' + Name.Namespace: YELLOW, # class: 'nn' - to be revised + Name.Other: BLUE, # class: 'nx' + Name.Tag: AQUA, # class: 'nt' - like a keyword + Name.Variable: RED, # class: 'nv' - to be revised + Name.Variable.Class: "", # class: 'vc' - to be revised + Name.Variable.Global: "", # class: 'vg' - to be revised + Name.Variable.Instance: "", # class: 'vi' - to be revised + + Number: ORANGE, # class: 'm' + Number.Float: "", # class: 'mf' + Number.Hex: "", # class: 'mh' + Number.Integer: "", # class: 'mi' + Number.Integer.Long: "", # class: 'il' + Number.Oct: "", # class: 'mo' + + Literal: ORANGE, # class: 'l' + Literal.Date: GREEN, # class: 'ld' + + String: GREEN, # class: 's' + String.Backtick: "", # class: 'sb' + String.Char: FOREGROUND, # class: 'sc' + String.Doc: COMMENT, # class: 'sd' - like a comment + String.Double: "", # class: 's2' + String.Escape: ORANGE, # class: 'se' + String.Heredoc: "", # class: 'sh' + String.Interpol: ORANGE, # class: 'si' + String.Other: "", # class: 'sx' + String.Regex: "", # class: 'sr' + String.Single: "", # class: 's1' + String.Symbol: "", # class: 'ss' + + Generic: "", # class: 'g' + Generic.Deleted: RED, # class: 'gd', + Generic.Emph: "italic", # class: 'ge' + Generic.Error: "", # class: 'gr' + Generic.Heading: "bold " + FOREGROUND, # class: 'gh' + Generic.Inserted: GREEN, # class: 'gi' + Generic.Output: "", # class: 'go' + Generic.Prompt: "bold " + COMMENT, # class: 'gp' + Generic.Strong: "bold", # class: 'gs' + Generic.Subheading: "bold " + AQUA, # class: 'gu' + Generic.Traceback: "", # class: 'gt' + } diff --git a/shared/package-files/42/42793b95896c4d11e795943a35735daff7f8309c19436d64712d3c2856ecc98f/blob b/shared/package-files/42/42793b95896c4d11e795943a35735daff7f8309c19436d64712d3c2856ecc98f/blob new file mode 100644 index 0000000000000000000000000000000000000000..2555f0b242591cde7738f46932fd1cbe2d0a6ccf --- /dev/null +++ b/shared/package-files/42/42793b95896c4d11e795943a35735daff7f8309c19436d64712d3c2856ecc98f/blob @@ -0,0 +1,305 @@ +"""CFF to CFF2 converter.""" + +from fontTools.ttLib import TTFont, newTable +from fontTools.misc.cliTools import makeOutputFileName +from fontTools.misc.psCharStrings import T2WidthExtractor +from fontTools.cffLib import ( + TopDictIndex, + FDArrayIndex, + FontDict, + buildOrder, + topDictOperators, + privateDictOperators, + topDictOperators2, + privateDictOperators2, +) +from io import BytesIO +import logging + +__all__ = ["convertCFFToCFF2", "main"] + + +log = logging.getLogger("fontTools.cffLib") + + +class _NominalWidthUsedError(Exception): + def __add__(self, other): + raise self + + def __radd__(self, other): + raise self + + +def _convertCFFToCFF2(cff, otFont): + """Converts this object from CFF format to CFF2 format. This conversion + is done 'in-place'. The conversion cannot be reversed. + + This assumes a decompiled CFF table. (i.e. that the object has been + filled via :meth:`decompile` and e.g. not loaded from XML.)""" + + # Clean up T2CharStrings + + topDict = cff.topDictIndex[0] + fdArray = topDict.FDArray if hasattr(topDict, "FDArray") else None + charStrings = topDict.CharStrings + globalSubrs = cff.GlobalSubrs + localSubrs = ( + [getattr(fd.Private, "Subrs", []) for fd in fdArray] + if fdArray + else ( + [topDict.Private.Subrs] + if hasattr(topDict, "Private") and hasattr(topDict.Private, "Subrs") + else [] + ) + ) + + for glyphName in charStrings.keys(): + cs, fdIndex = charStrings.getItemAndSelector(glyphName) + cs.decompile() + + # Clean up subroutines first + for subrs in [globalSubrs] + localSubrs: + for subr in subrs: + program = subr.program + i = j = len(program) + try: + i = program.index("return") + except ValueError: + pass + try: + j = program.index("endchar") + except ValueError: + pass + program[min(i, j) :] = [] + + # Clean up glyph charstrings + removeUnusedSubrs = False + nominalWidthXError = _NominalWidthUsedError() + for glyphName in charStrings.keys(): + cs, fdIndex = charStrings.getItemAndSelector(glyphName) + program = cs.program + + thisLocalSubrs = ( + localSubrs[fdIndex] + if fdIndex is not None + else ( + getattr(topDict.Private, "Subrs", []) + if hasattr(topDict, "Private") + else [] + ) + ) + + # Intentionally use custom type for nominalWidthX, such that any + # CharString that has an explicit width encoded will throw back to us. + extractor = T2WidthExtractor( + thisLocalSubrs, + globalSubrs, + nominalWidthXError, + 0, + ) + try: + extractor.execute(cs) + except _NominalWidthUsedError: + # Program has explicit width. We want to drop it, but can't + # just pop the first number since it may be a subroutine call. + # Instead, when seeing that, we embed the subroutine and recurse. + # If this ever happened, we later prune unused subroutines. + while len(program) >= 2 and program[1] in ["callsubr", "callgsubr"]: + removeUnusedSubrs = True + subrNumber = program.pop(0) + assert isinstance(subrNumber, int), subrNumber + op = program.pop(0) + bias = extractor.localBias if op == "callsubr" else extractor.globalBias + subrNumber += bias + subrSet = thisLocalSubrs if op == "callsubr" else globalSubrs + subrProgram = subrSet[subrNumber].program + program[:0] = subrProgram + # Now pop the actual width + assert len(program) >= 1, program + program.pop(0) + + if program and program[-1] == "endchar": + program.pop() + + if removeUnusedSubrs: + cff.remove_unused_subroutines() + + # Upconvert TopDict + + cff.major = 2 + cff2GetGlyphOrder = cff.otFont.getGlyphOrder + topDictData = TopDictIndex(None, cff2GetGlyphOrder) + for item in cff.topDictIndex: + # Iterate over, such that all are decompiled + topDictData.append(item) + cff.topDictIndex = topDictData + topDict = topDictData[0] + if hasattr(topDict, "Private"): + privateDict = topDict.Private + else: + privateDict = None + opOrder = buildOrder(topDictOperators2) + topDict.order = opOrder + topDict.cff2GetGlyphOrder = cff2GetGlyphOrder + + if not hasattr(topDict, "FDArray"): + fdArray = topDict.FDArray = FDArrayIndex() + fdArray.strings = None + fdArray.GlobalSubrs = topDict.GlobalSubrs + topDict.GlobalSubrs.fdArray = fdArray + charStrings = topDict.CharStrings + if charStrings.charStringsAreIndexed: + charStrings.charStringsIndex.fdArray = fdArray + else: + charStrings.fdArray = fdArray + fontDict = FontDict() + fontDict.setCFF2(True) + fdArray.append(fontDict) + fontDict.Private = privateDict + privateOpOrder = buildOrder(privateDictOperators2) + if privateDict is not None: + for entry in privateDictOperators: + key = entry[1] + if key not in privateOpOrder: + if key in privateDict.rawDict: + # print "Removing private dict", key + del privateDict.rawDict[key] + if hasattr(privateDict, key): + delattr(privateDict, key) + # print "Removing privateDict attr", key + else: + # clean up the PrivateDicts in the fdArray + fdArray = topDict.FDArray + privateOpOrder = buildOrder(privateDictOperators2) + for fontDict in fdArray: + fontDict.setCFF2(True) + for key in list(fontDict.rawDict.keys()): + if key not in fontDict.order: + del fontDict.rawDict[key] + if hasattr(fontDict, key): + delattr(fontDict, key) + + privateDict = fontDict.Private + for entry in privateDictOperators: + key = entry[1] + if key not in privateOpOrder: + if key in list(privateDict.rawDict.keys()): + # print "Removing private dict", key + del privateDict.rawDict[key] + if hasattr(privateDict, key): + delattr(privateDict, key) + # print "Removing privateDict attr", key + + # Now delete up the deprecated topDict operators from CFF 1.0 + for entry in topDictOperators: + key = entry[1] + # We seem to need to keep the charset operator for now, + # or we fail to compile with some fonts, like AdditionFont.otf. + # I don't know which kind of CFF font those are. But keeping + # charset seems to work. It will be removed when we save and + # read the font again. + # + # AdditionFont.otf has . + if key == "charset": + continue + if key not in opOrder: + if key in topDict.rawDict: + del topDict.rawDict[key] + if hasattr(topDict, key): + delattr(topDict, key) + + # TODO(behdad): What does the following comment even mean? Both CFF and CFF2 + # use the same T2Charstring class. I *think* what it means is that the CharStrings + # were loaded for CFF1, and we need to reload them for CFF2 to set varstore, etc + # on them. At least that's what I understand. It's probably safe to remove this + # and just set vstore where needed. + # + # See comment above about charset as well. + + # At this point, the Subrs and Charstrings are all still T2Charstring class + # easiest to fix this by compiling, then decompiling again + file = BytesIO() + cff.compile(file, otFont, isCFF2=True) + file.seek(0) + cff.decompile(file, otFont, isCFF2=True) + + +def convertCFFToCFF2(font): + cff = font["CFF "].cff + del font["CFF "] + _convertCFFToCFF2(cff, font) + table = font["CFF2"] = newTable("CFF2") + table.cff = cff + + +def main(args=None): + """Convert CFF OTF font to CFF2 OTF font""" + if args is None: + import sys + + args = sys.argv[1:] + + import argparse + + parser = argparse.ArgumentParser( + "fonttools cffLib.CFFToCFF2", + description="Upgrade a CFF font to CFF2.", + ) + parser.add_argument( + "input", metavar="INPUT.ttf", help="Input OTF file with CFF table." + ) + parser.add_argument( + "-o", + "--output", + metavar="OUTPUT.ttf", + default=None, + help="Output instance OTF file (default: INPUT-CFF2.ttf).", + ) + parser.add_argument( + "--no-recalc-timestamp", + dest="recalc_timestamp", + action="store_false", + help="Don't set the output font's timestamp to the current time.", + ) + loggingGroup = parser.add_mutually_exclusive_group(required=False) + loggingGroup.add_argument( + "-v", "--verbose", action="store_true", help="Run more verbosely." + ) + loggingGroup.add_argument( + "-q", "--quiet", action="store_true", help="Turn verbosity off." + ) + options = parser.parse_args(args) + + from fontTools import configLogger + + configLogger( + level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO") + ) + + import os + + infile = options.input + if not os.path.isfile(infile): + parser.error("No such file '{}'".format(infile)) + + outfile = ( + makeOutputFileName(infile, overWrite=True, suffix="-CFF2") + if not options.output + else options.output + ) + + font = TTFont(infile, recalcTimestamp=options.recalc_timestamp, recalcBBoxes=False) + + convertCFFToCFF2(font) + + log.info( + "Saving %s", + outfile, + ) + font.save(outfile) + + +if __name__ == "__main__": + import sys + + sys.exit(main(sys.argv[1:])) diff --git a/shared/package-files/42/427a18556f36f13335eeeabedc42de7ad8599bc5cdd98d03904693737b0baf74/blob b/shared/package-files/42/427a18556f36f13335eeeabedc42de7ad8599bc5cdd98d03904693737b0baf74/blob new file mode 100644 index 0000000000000000000000000000000000000000..a0d42b6541fdf8817b996ef9804db8a87a2bcd2c --- /dev/null +++ b/shared/package-files/42/427a18556f36f13335eeeabedc42de7ad8599bc5cdd98d03904693737b0baf74/blob @@ -0,0 +1,16 @@ +""" public toolkit API """ +from pandas.api import ( + extensions, + indexers, + interchange, + types, + typing, +) + +__all__ = [ + "interchange", + "extensions", + "indexers", + "types", + "typing", +] diff --git a/shared/package-files/42/427bb48aecb6f9e8a7f4a915a122f5b7bd7f5bf5456647630d5b0e9d84e73f7f/blob b/shared/package-files/42/427bb48aecb6f9e8a7f4a915a122f5b7bd7f5bf5456647630d5b0e9d84e73f7f/blob new file mode 100644 index 0000000000000000000000000000000000000000..d018e799a833ef19db0ef7ec7536ed950bf7dc60 --- /dev/null +++ b/shared/package-files/42/427bb48aecb6f9e8a7f4a915a122f5b7bd7f5bf5456647630d5b0e9d84e73f7f/blob @@ -0,0 +1,50 @@ +// +// ios.h +// DateTimeLib +// +// The MIT License (MIT) +// +// Copyright (c) 2016 Alexander Kormanovsky +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#ifndef ios_hpp +#define ios_hpp + +#if __APPLE__ +# include +# if TARGET_OS_IPHONE +# include + + namespace arrow_vendored::date + { + namespace iOSUtils + { + + std::string get_tzdata_path(); + std::string get_current_timezone(); + + } // namespace iOSUtils + } // namespace arrow_vendored::date + +# endif // TARGET_OS_IPHONE +#else // !__APPLE__ +# define TARGET_OS_IPHONE 0 +#endif // !__APPLE__ +#endif // ios_hpp diff --git a/shared/package-files/42/427d9efef856b92ee058d91307eeb26865abffa74f31e3d309e8f01a9609c489/blob b/shared/package-files/42/427d9efef856b92ee058d91307eeb26865abffa74f31e3d309e8f01a9609c489/blob new file mode 100644 index 0000000000000000000000000000000000000000..cee721d7bc8f6e560b8ad9ef2e995fc23708b25f --- /dev/null +++ b/shared/package-files/42/427d9efef856b92ee058d91307eeb26865abffa74f31e3d309e8f01a9609c489/blob @@ -0,0 +1,103 @@ +/** + * Transformer-specific NestedTensor utility functions. + * + * Not co-located with NestedTensor core code yet because they only + * support specific cases needed in transformers. + */ +#pragma once + +#include + +#include +#include + +namespace c10 { +class Scalar; +} // namespace c10 + +namespace at { +class Tensor; +namespace native { +struct NestedTensorImpl; + +// Requires that self is a contiguous NestedTensor, other is not a +// NestedTensor, self.dim() == 3, and other.dim() == 2. Also, self +// must have a consistent last dimension across its included Tensors +// and that dimension must match other.size(0). +Tensor NestedTensor_matmul(const Tensor& self, const Tensor& other); + +// Requires that mat1 is a contiguous NestedTensor, self & mat2 are +// not NestedTensors, mat1.dim() == 3, mat2.dim() == 2, and that mat1 +// has a consistent last dimension across its included Tensors that +// matches mat2.size(0). +Tensor NestedTensor_times_Tensor_plus_Tensor_addmm( + const Tensor& self, + const Tensor& mat1, + const Tensor& mat2, + const c10::Scalar& beta, + const c10::Scalar& alpha, + c10::optional use_gelu = c10::nullopt); + +Tensor NestedTensor_add_NestedTensor_in_place( + const Tensor& self, + const Tensor& other); + +TORCH_API Tensor NestedTensor_batch_offsets_from_size_tensor( + const Tensor& sizes, + int64_t extra_elements); + +Tensor NestedTensor_from_padded_tensor_cpu( + const Tensor& padded, + const NestedTensorImpl& nt); + +Tensor NestedTensor_to_mask(const Tensor& nt, c10::optional mask_dim, c10::optional mask_dim_length); + +template +void remove_padding_kernelLauncher( + const T* input, + T* output, + const int* offsets, + const int* input_sizes, + const int* output_sizes, + int output_dim, + const int batch_size); + +template +void remove_padding_transform0213_kernelLauncher( + const T* input, + T* output, + const int* offsets, + const int* input_sizes, + const int* output_sizes, + int output_dim, + const int batch_size); + +template +void add_padding_kernelLauncher( + T* input, + T* output, + T padding_value, + const int* offsets, + const int* input_sizes, + int input_dim, + const std::vector& output_sizes, + const int batch_size, + const int output_batch_size); + +TORCH_API Tensor flash_attention_helper( + const Tensor& query, + const Tensor& key, + const Tensor& value, + double dropout_p, + bool need_attn_weights, + bool is_causal); + +TORCH_API std::tuple mem_efficient_helper_nested_unpacked( + const Tensor& query, + const Tensor& key, + const Tensor& value, + double dropout_p, + bool need_attn_weights, + bool is_causal); +} // namespace native +} // namespace at diff --git a/shared/package-files/42/427dc1debb2a48ddfdec9876e71b38a1db76a5f090b5692825ef9ed3ea17f1de/blob b/shared/package-files/42/427dc1debb2a48ddfdec9876e71b38a1db76a5f090b5692825ef9ed3ea17f1de/blob new file mode 100644 index 0000000000000000000000000000000000000000..6b134f7432f43323df28fc9d960d7ec133bfe9f1 --- /dev/null +++ b/shared/package-files/42/427dc1debb2a48ddfdec9876e71b38a1db76a5f090b5692825ef9ed3ea17f1de/blob @@ -0,0 +1,162 @@ +import sys +from typing import Any, Literal + +import numpy as np +import numpy.typing as npt + +if sys.version_info >= (3, 11): + from typing import assert_type +else: + from typing_extensions import assert_type + +b: np.bool_ +u8: np.uint64 +i8: np.int64 +f8: np.float64 +c8: np.complex64 +c16: np.complex128 +m: np.timedelta64 +U: np.str_ +S: np.bytes_ +V: np.void + +assert_type(c8.real, np.float32) +assert_type(c8.imag, np.float32) + +assert_type(c8.real.real, np.float32) +assert_type(c8.real.imag, np.float32) + +assert_type(c8.itemsize, int) +assert_type(c8.shape, tuple[()]) +assert_type(c8.strides, tuple[()]) + +assert_type(c8.ndim, Literal[0]) +assert_type(c8.size, Literal[1]) + +assert_type(c8.squeeze(), np.complex64) +assert_type(c8.byteswap(), np.complex64) +assert_type(c8.transpose(), np.complex64) + +assert_type(c8.dtype, np.dtype[np.complex64]) + +assert_type(c8.real, np.float32) +assert_type(c16.imag, np.float64) + +assert_type(np.str_('foo'), np.str_) + +assert_type(V[0], Any) +assert_type(V["field1"], Any) +assert_type(V[["field1", "field2"]], np.void) +V[0] = 5 + +# Aliases +assert_type(np.byte(), np.byte) +assert_type(np.short(), np.short) +assert_type(np.intc(), np.intc) +assert_type(np.intp(), np.intp) +assert_type(np.int_(), np.int_) +assert_type(np.longlong(), np.longlong) + +assert_type(np.ubyte(), np.ubyte) +assert_type(np.ushort(), np.ushort) +assert_type(np.uintc(), np.uintc) +assert_type(np.uintp(), np.uintp) +assert_type(np.uint(), np.uint) +assert_type(np.ulonglong(), np.ulonglong) + +assert_type(np.half(), np.half) +assert_type(np.single(), np.single) +assert_type(np.double(), np.double) +assert_type(np.longdouble(), np.longdouble) +assert_type(np.float_(), np.float_) +assert_type(np.longfloat(), np.longfloat) + +assert_type(np.csingle(), np.csingle) +assert_type(np.cdouble(), np.cdouble) +assert_type(np.clongdouble(), np.clongdouble) +assert_type(np.singlecomplex(), np.singlecomplex) +assert_type(np.complex_(), np.complex_) +assert_type(np.cfloat(), np.cfloat) +assert_type(np.clongfloat(), np.clongfloat) +assert_type(np.longcomplex(), np.longcomplex) + +assert_type(b.item(), bool) +assert_type(i8.item(), int) +assert_type(u8.item(), int) +assert_type(f8.item(), float) +assert_type(c16.item(), complex) +assert_type(U.item(), str) +assert_type(S.item(), bytes) + +assert_type(b.tolist(), bool) +assert_type(i8.tolist(), int) +assert_type(u8.tolist(), int) +assert_type(f8.tolist(), float) +assert_type(c16.tolist(), complex) +assert_type(U.tolist(), str) +assert_type(S.tolist(), bytes) + +assert_type(b.ravel(), npt.NDArray[np.bool_]) +assert_type(i8.ravel(), npt.NDArray[np.int64]) +assert_type(u8.ravel(), npt.NDArray[np.uint64]) +assert_type(f8.ravel(), npt.NDArray[np.float64]) +assert_type(c16.ravel(), npt.NDArray[np.complex128]) +assert_type(U.ravel(), npt.NDArray[np.str_]) +assert_type(S.ravel(), npt.NDArray[np.bytes_]) + +assert_type(b.flatten(), npt.NDArray[np.bool_]) +assert_type(i8.flatten(), npt.NDArray[np.int64]) +assert_type(u8.flatten(), npt.NDArray[np.uint64]) +assert_type(f8.flatten(), npt.NDArray[np.float64]) +assert_type(c16.flatten(), npt.NDArray[np.complex128]) +assert_type(U.flatten(), npt.NDArray[np.str_]) +assert_type(S.flatten(), npt.NDArray[np.bytes_]) + +assert_type(b.reshape(1), npt.NDArray[np.bool_]) +assert_type(i8.reshape(1), npt.NDArray[np.int64]) +assert_type(u8.reshape(1), npt.NDArray[np.uint64]) +assert_type(f8.reshape(1), npt.NDArray[np.float64]) +assert_type(c16.reshape(1), npt.NDArray[np.complex128]) +assert_type(U.reshape(1), npt.NDArray[np.str_]) +assert_type(S.reshape(1), npt.NDArray[np.bytes_]) + +assert_type(i8.astype(float), Any) +assert_type(i8.astype(np.float64), np.float64) + +assert_type(i8.view(), np.int64) +assert_type(i8.view(np.float64), np.float64) +assert_type(i8.view(float), Any) +assert_type(i8.view(np.float64, np.ndarray), np.float64) + +assert_type(i8.getfield(float), Any) +assert_type(i8.getfield(np.float64), np.float64) +assert_type(i8.getfield(np.float64, 8), np.float64) + +assert_type(f8.as_integer_ratio(), tuple[int, int]) +assert_type(f8.is_integer(), bool) +assert_type(f8.__trunc__(), int) +assert_type(f8.__getformat__("float"), str) +assert_type(f8.hex(), str) +assert_type(np.float64.fromhex("0x0.0p+0"), np.float64) + +assert_type(f8.__getnewargs__(), tuple[float]) +assert_type(c16.__getnewargs__(), tuple[float, float]) + +assert_type(i8.numerator, np.int64) +assert_type(i8.denominator, Literal[1]) +assert_type(u8.numerator, np.uint64) +assert_type(u8.denominator, Literal[1]) +assert_type(m.numerator, np.timedelta64) +assert_type(m.denominator, Literal[1]) + +assert_type(round(i8), int) +assert_type(round(i8, 3), np.int64) +assert_type(round(u8), int) +assert_type(round(u8, 3), np.uint64) +assert_type(round(f8), int) +assert_type(round(f8, 3), np.float64) + +assert_type(f8.__ceil__(), int) +assert_type(f8.__floor__(), int) + +assert_type(i8.is_integer(), Literal[True]) diff --git a/shared/package-files/42/427f42f0fe4343ec6649e2e5ab7e34b8acb9cc698e633bc493c8c406f6c9b643/blob b/shared/package-files/42/427f42f0fe4343ec6649e2e5ab7e34b8acb9cc698e633bc493c8c406f6c9b643/blob new file mode 100644 index 0000000000000000000000000000000000000000..9c5d35e2b02d66f23ed2460a3975082a69065908 --- /dev/null +++ b/shared/package-files/42/427f42f0fe4343ec6649e2e5ab7e34b8acb9cc698e633bc493c8c406f6c9b643/blob @@ -0,0 +1,30 @@ +../../../bin/conda-content-trust,sha256=XWMpcXFGek5_fV0gcMTaZaG8hzAEwc6Em4dnVuTNWQw,503 +conda_content_trust-0.2.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +conda_content_trust-0.2.0.dist-info/METADATA,sha256=RTjLkS99TMEuE48_CtxTeUF1q2urd2nEvJ1wWBj15Fk,5708 +conda_content_trust-0.2.0.dist-info/RECORD,, +conda_content_trust-0.2.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +conda_content_trust-0.2.0.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87 +conda_content_trust-0.2.0.dist-info/direct_url.json,sha256=DUYG_CRawP_GQdZ6dgRD7O4WYpJcVTgwZdADj8jShiU,79 +conda_content_trust-0.2.0.dist-info/entry_points.txt,sha256=8kIfTSV2muIUqQV0jZzZU-XWcLOhJebM1VmiODqvSYA,126 +conda_content_trust-0.2.0.dist-info/licenses/AUTHORS.md,sha256=M67rb4QLM9565Na6CHZnKeljEOtcozVchaRP011OG_0,281 +conda_content_trust-0.2.0.dist-info/licenses/LICENSE,sha256=Cd-oJyYTQWtOISHqn9-XCaJeGr8UTkwXyBqXWm_Xcck,1505 +conda_content_trust/__init__.py,sha256=EVu6odFu6gXZj7TD4O2hc9Lc8zkOH_VgOlp2BxvI1eU,126 +conda_content_trust/__main__.py,sha256=2913q-WtZP4QWmmL4HVY6oMURX1oOXvNzXwbpKzC4HA,122 +conda_content_trust/__pycache__/__init__.cpython-310.pyc,, +conda_content_trust/__pycache__/__main__.cpython-310.pyc,, +conda_content_trust/__pycache__/__version__.cpython-310.pyc,, +conda_content_trust/__pycache__/authentication.cpython-310.pyc,, +conda_content_trust/__pycache__/cli.cpython-310.pyc,, +conda_content_trust/__pycache__/common.cpython-310.pyc,, +conda_content_trust/__pycache__/metadata_construction.cpython-310.pyc,, +conda_content_trust/__pycache__/plugin.cpython-310.pyc,, +conda_content_trust/__pycache__/root_signing.cpython-310.pyc,, +conda_content_trust/__pycache__/signing.cpython-310.pyc,, +conda_content_trust/__version__.py,sha256=dQUHa1PGpJsNE2x_SQFxtOX-jousEqplwH1bdsk6mnE,160 +conda_content_trust/authentication.py,sha256=uZD63uParw7Yl41gkxh6IBBgqbH3WOaheQt8xFgfwQE,22695 +conda_content_trust/cli.py,sha256=XG_yINHDWkEeMihUa3Ewxpgoqxse-clkeOmlFEtlzgk,18553 +conda_content_trust/common.py,sha256=w23tDH1DmGcNbO6HVe1daV1tAsEfu92MShlv8SYwd4M,33377 +conda_content_trust/metadata_construction.py,sha256=nlo9NmnyU3MVoGeDXidG0Q6sIw6R4T0JhVbWhjxztH4,10325 +conda_content_trust/plugin.py,sha256=VrFwespayVyRwMPVWxVM4w7DjZ8XUOgR5Ygehnq9k9M,326 +conda_content_trust/root_signing.py,sha256=fwLOo8I8H_nnLtJVLZ3wBrrau_yWT2KAnBPVTOXDKFs,15395 +conda_content_trust/signing.py,sha256=Z23g2W_1WrRLCpKpKbF_YeC3HzclARp5HdvIclrNLKY,8741 diff --git a/shared/package-files/42/428063452afc64fe62f27148c8e09d52ddddcfd18b04a7577a18fae61b27c29c/blob b/shared/package-files/42/428063452afc64fe62f27148c8e09d52ddddcfd18b04a7577a18fae61b27c29c/blob new file mode 100644 index 0000000000000000000000000000000000000000..24920a15075e9c124c872fba20e37722c584519d --- /dev/null +++ b/shared/package-files/42/428063452afc64fe62f27148c8e09d52ddddcfd18b04a7577a18fae61b27c29c/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor special_chebyshev_polynomial_w(const at::Tensor & x, const at::Tensor & n); +TORCH_API at::Tensor & special_chebyshev_polynomial_w_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n); +TORCH_API at::Tensor & special_chebyshev_polynomial_w_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/shared/package-files/42/4284d76c28aa8cae2d0431d46ead5328fa7436ba1891e85e16346af95c65b0fd/blob b/shared/package-files/42/4284d76c28aa8cae2d0431d46ead5328fa7436ba1891e85e16346af95c65b0fd/blob new file mode 100644 index 0000000000000000000000000000000000000000..7b2c81aaf17de3785e62a2d989394259b2496085 --- /dev/null +++ b/shared/package-files/42/4284d76c28aa8cae2d0431d46ead5328fa7436ba1891e85e16346af95c65b0fd/blob @@ -0,0 +1,45 @@ +import numpy as np +import pytest + +import pandas as pd +from pandas import ( + DatetimeIndex, + Index, +) +import pandas._testing as tm + +dtlike_dtypes = [ + np.dtype("timedelta64[ns]"), + np.dtype("datetime64[ns]"), + pd.DatetimeTZDtype("ns", "Asia/Tokyo"), + pd.PeriodDtype("ns"), +] + + +@pytest.mark.parametrize("ldtype", dtlike_dtypes) +@pytest.mark.parametrize("rdtype", dtlike_dtypes) +def test_get_indexer_non_unique_wrong_dtype(ldtype, rdtype): + vals = np.tile(3600 * 10**9 * np.arange(3, dtype=np.int64), 2) + + def construct(dtype): + if dtype is dtlike_dtypes[-1]: + # PeriodArray will try to cast ints to strings + return DatetimeIndex(vals).astype(dtype) + return Index(vals, dtype=dtype) + + left = construct(ldtype) + right = construct(rdtype) + + result = left.get_indexer_non_unique(right) + + if ldtype is rdtype: + ex1 = np.array([0, 3, 1, 4, 2, 5] * 2, dtype=np.intp) + ex2 = np.array([], dtype=np.intp) + tm.assert_numpy_array_equal(result[0], ex1) + tm.assert_numpy_array_equal(result[1], ex2) + + else: + no_matches = np.array([-1] * 6, dtype=np.intp) + missing = np.arange(6, dtype=np.intp) + tm.assert_numpy_array_equal(result[0], no_matches) + tm.assert_numpy_array_equal(result[1], missing) diff --git a/shared/package-files/42/428548c665f38b3517167f57623c5938d4c15596f1c0aa520031c88ec96fa039/blob b/shared/package-files/42/428548c665f38b3517167f57623c5938d4c15596f1c0aa520031c88ec96fa039/blob new file mode 100644 index 0000000000000000000000000000000000000000..f178ffe51a2a47b6d248b0932803285b62c46eb6 --- /dev/null +++ b/shared/package-files/42/428548c665f38b3517167f57623c5938d4c15596f1c0aa520031c88ec96fa039/blob @@ -0,0 +1,33 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor fill(const at::Tensor & self, const at::Scalar & value); +TORCH_API at::Tensor & fill_Scalar_out(const at::Tensor & self, const at::Scalar & value, at::Tensor & out); +TORCH_API at::Tensor & fill_(at::Tensor & self, const at::Scalar & value); +TORCH_API at::Tensor & fill_nested_(at::Tensor & self, const at::Scalar & value); +TORCH_API at::Tensor & fill_sparse_csr_(at::Tensor & self, const at::Scalar & value); +TORCH_API at::Tensor & fill_meta_(at::Tensor & self, const at::Scalar & value); +TORCH_API at::Tensor & fill_quantized_(at::Tensor & self, const at::Scalar & value); +TORCH_API at::Tensor fill(const at::Tensor & self, const at::Tensor & value); +TORCH_API at::Tensor & fill_Tensor_out(const at::Tensor & self, const at::Tensor & value, at::Tensor & out); +TORCH_API at::Tensor & fill_(at::Tensor & self, const at::Tensor & value); +TORCH_API at::Tensor & fill_nested_(at::Tensor & self, const at::Tensor & value); +TORCH_API at::Tensor & fill_meta_(at::Tensor & self, const at::Tensor & value); +TORCH_API at::Tensor & fill_quantized_(at::Tensor & self, const at::Tensor & value); +} // namespace native +} // namespace at diff --git a/shared/package-files/42/4285e2d6b07a64ba7919f3a6bf98d8e3b5afd884b6d3e352edb4edd4f873f167/blob b/shared/package-files/42/4285e2d6b07a64ba7919f3a6bf98d8e3b5afd884b6d3e352edb4edd4f873f167/blob new file mode 100644 index 0000000000000000000000000000000000000000..da21c8e68b72d35b4ba907c47630502f7556c92f --- /dev/null +++ b/shared/package-files/42/4285e2d6b07a64ba7919f3a6bf98d8e3b5afd884b6d3e352edb4edd4f873f167/blob @@ -0,0 +1,181 @@ +# Authors: The scikit-learn developers +# SPDX-License-Identifier: BSD-3-Clause + +from contextlib import suppress + +import numpy as np +from scipy import sparse as sp + +from ._missing import is_scalar_nan +from ._param_validation import validate_params +from .fixes import _object_dtype_isnan + + +def _get_dense_mask(X, value_to_mask): + with suppress(ImportError, AttributeError): + # We also suppress `AttributeError` because older versions of pandas do + # not have `NA`. + import pandas + + if value_to_mask is pandas.NA: + return pandas.isna(X) + + if is_scalar_nan(value_to_mask): + if X.dtype.kind == "f": + Xt = np.isnan(X) + elif X.dtype.kind in ("i", "u"): + # can't have NaNs in integer array. + Xt = np.zeros(X.shape, dtype=bool) + else: + # np.isnan does not work on object dtypes. + Xt = _object_dtype_isnan(X) + else: + Xt = X == value_to_mask + + return Xt + + +def _get_mask(X, value_to_mask): + """Compute the boolean mask X == value_to_mask. + + Parameters + ---------- + X : {ndarray, sparse matrix} of shape (n_samples, n_features) + Input data, where ``n_samples`` is the number of samples and + ``n_features`` is the number of features. + + value_to_mask : {int, float} + The value which is to be masked in X. + + Returns + ------- + X_mask : {ndarray, sparse matrix} of shape (n_samples, n_features) + Missing mask. + """ + if not sp.issparse(X): + # For all cases apart of a sparse input where we need to reconstruct + # a sparse output + return _get_dense_mask(X, value_to_mask) + + Xt = _get_dense_mask(X.data, value_to_mask) + + sparse_constructor = sp.csr_matrix if X.format == "csr" else sp.csc_matrix + Xt_sparse = sparse_constructor( + (Xt, X.indices.copy(), X.indptr.copy()), shape=X.shape, dtype=bool + ) + + return Xt_sparse + + +@validate_params( + { + "X": ["array-like", "sparse matrix"], + "mask": ["array-like"], + }, + prefer_skip_nested_validation=True, +) +def safe_mask(X, mask): + """Return a mask which is safe to use on X. + + Parameters + ---------- + X : {array-like, sparse matrix} + Data on which to apply mask. + + mask : array-like + Mask to be used on X. + + Returns + ------- + mask : ndarray + Array that is safe to use on X. + + Examples + -------- + >>> from sklearn.utils import safe_mask + >>> from scipy.sparse import csr_matrix + >>> data = csr_matrix([[1], [2], [3], [4], [5]]) + >>> condition = [False, True, True, False, True] + >>> mask = safe_mask(data, condition) + >>> data[mask].toarray() + array([[2], + [3], + [5]]) + """ + mask = np.asarray(mask) + if np.issubdtype(mask.dtype, np.signedinteger): + return mask + + if hasattr(X, "toarray"): + ind = np.arange(mask.shape[0]) + mask = ind[mask] + return mask + + +def axis0_safe_slice(X, mask, len_mask): + """Return a mask which is safer to use on X than safe_mask. + + This mask is safer than safe_mask since it returns an + empty array, when a sparse matrix is sliced with a boolean mask + with all False, instead of raising an unhelpful error in older + versions of SciPy. + + See: https://github.com/scipy/scipy/issues/5361 + + Also note that we can avoid doing the dot product by checking if + the len_mask is not zero in _huber_loss_and_gradient but this + is not going to be the bottleneck, since the number of outliers + and non_outliers are typically non-zero and it makes the code + tougher to follow. + + Parameters + ---------- + X : {array-like, sparse matrix} + Data on which to apply mask. + + mask : ndarray + Mask to be used on X. + + len_mask : int + The length of the mask. + + Returns + ------- + mask : ndarray + Array that is safe to use on X. + """ + if len_mask != 0: + return X[safe_mask(X, mask), :] + return np.zeros(shape=(0, X.shape[1])) + + +def indices_to_mask(indices, mask_length): + """Convert list of indices to boolean mask. + + Parameters + ---------- + indices : list-like + List of integers treated as indices. + mask_length : int + Length of boolean mask to be generated. + This parameter must be greater than max(indices). + + Returns + ------- + mask : 1d boolean nd-array + Boolean array that is True where indices are present, else False. + + Examples + -------- + >>> from sklearn.utils._mask import indices_to_mask + >>> indices = [1, 2 , 3, 4] + >>> indices_to_mask(indices, 5) + array([False, True, True, True, True]) + """ + if mask_length <= np.max(indices): + raise ValueError("mask_length must be greater than max(indices)") + + mask = np.zeros(mask_length, dtype=bool) + mask[indices] = True + + return mask diff --git a/shared/package-files/42/42864efe330a0d47c29afc480949e810cc082ac3417d30d43702c2dc5548be69/blob b/shared/package-files/42/42864efe330a0d47c29afc480949e810cc082ac3417d30d43702c2dc5548be69/blob new file mode 100644 index 0000000000000000000000000000000000000000..c0d7cdc3636c76617e196b0646dde829eeaa2ce6 --- /dev/null +++ b/shared/package-files/42/42864efe330a0d47c29afc480949e810cc082ac3417d30d43702c2dc5548be69/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42864efe330a0d47c29afc480949e810cc082ac3417d30d43702c2dc5548be69 +size 215824 diff --git a/shared/package-files/42/4289e3c9d25ed3e6925993c2de444f023f1ea858e5c92ab39768a8a97eafdc1e/blob b/shared/package-files/42/4289e3c9d25ed3e6925993c2de444f023f1ea858e5c92ab39768a8a97eafdc1e/blob new file mode 100644 index 0000000000000000000000000000000000000000..0207839f44b7c3dd18beb31dcc8cca26a30a77df Binary files /dev/null and b/shared/package-files/42/4289e3c9d25ed3e6925993c2de444f023f1ea858e5c92ab39768a8a97eafdc1e/blob differ diff --git a/shared/package-files/42/428d9aa831e284841cfcc0b65e064fcf703092099c42ec246ea271829195a28a/blob b/shared/package-files/42/428d9aa831e284841cfcc0b65e064fcf703092099c42ec246ea271829195a28a/blob new file mode 100644 index 0000000000000000000000000000000000000000..7af52be2459f8fc2548921b04ff3d728d3d098c1 --- /dev/null +++ b/shared/package-files/42/428d9aa831e284841cfcc0b65e064fcf703092099c42ec246ea271829195a28a/blob @@ -0,0 +1,108 @@ +# image2.tcl -- +# +# This demonstration script creates a simple collection of widgets +# that allow you to select and view images in a Tk label. + +if {![info exists widgetDemo]} { + error "This script should be run from the \"widget\" demo." +} + +package require Tk + +# loadDir -- +# This procedure reloads the directory listbox from the directory +# named in the demo's entry. +# +# Arguments: +# w - Name of the toplevel window of the demo. + +proc loadDir w { + global dirName + + $w.f.list delete 0 end + foreach i [lsort [glob -type f -directory $dirName *]] { + $w.f.list insert end [file tail $i] + } +} + +# selectAndLoadDir -- +# This procedure pops up a dialog to ask for a directory to load into +# the listobx and (if the user presses OK) reloads the directory +# listbox from the directory named in the demo's entry. +# +# Arguments: +# w - Name of the toplevel window of the demo. + +proc selectAndLoadDir w { + global dirName + set dir [tk_chooseDirectory -initialdir $dirName -parent $w -mustexist 1] + if {$dir ne ""} { + set dirName $dir + loadDir $w + } +} + +# loadImage -- +# Given the name of the toplevel window of the demo and the mouse +# position, extracts the directory entry under the mouse and loads +# that file into a photo image for display. +# +# Arguments: +# w - Name of the toplevel window of the demo. +# x, y- Mouse position within the listbox. + +proc loadImage {w x y} { + global dirName + + set file [file join $dirName [$w.f.list get @$x,$y]] + if {[catch { + image2a configure -file $file + }]} then { + # Mark the file as not loadable + $w.f.list itemconfigure @$x,$y -bg \#c00000 -selectbackground \#ff0000 + } +} + +set w .image2 +catch {destroy $w} +toplevel $w +wm title $w "Image Demonstration #2" +wm iconname $w "Image2" +positionWindow $w + +label $w.msg -font $font -wraplength 4i -justify left -text "This demonstration allows you to view images using a Tk \"photo\" image. First type a directory name in the listbox, then type Return to load the directory into the listbox. Then double-click on a file name in the listbox to see that image." +pack $w.msg -side top + +## See Code / Dismiss buttons +set btns [addSeeDismiss $w.buttons $w] +pack $btns -side bottom -fill x + +frame $w.mid +pack $w.mid -fill both -expand 1 + +labelframe $w.dir -text "Directory:" +# Main widget program sets variable tk_demoDirectory +set dirName [file join $tk_demoDirectory images] +entry $w.dir.e -width 30 -textvariable dirName +button $w.dir.b -pady 0 -padx 2m -text "Select Dir." \ + -command "selectAndLoadDir $w" +bind $w.dir.e "loadDir $w" +pack $w.dir.e -side left -fill both -padx 2m -pady 2m -expand true +pack $w.dir.b -side left -fill y -padx {0 2m} -pady 2m +labelframe $w.f -text "File:" -padx 2m -pady 2m + +listbox $w.f.list -width 20 -height 10 -yscrollcommand "$w.f.scroll set" +ttk::scrollbar $w.f.scroll -command "$w.f.list yview" +pack $w.f.list $w.f.scroll -side left -fill y -expand 1 +$w.f.list insert 0 earth.gif earthris.gif teapot.ppm +bind $w.f.list "loadImage $w %x %y" + +catch {image delete image2a} +image create photo image2a +labelframe $w.image -text "Image:" +label $w.image.image -image image2a +pack $w.image.image -padx 2m -pady 2m + +grid $w.dir - -sticky ew -padx 1m -pady 1m -in $w.mid +grid $w.f $w.image -sticky nw -padx 1m -pady 1m -in $w.mid +grid columnconfigure $w.mid 1 -weight 1 diff --git a/shared/package-files/42/428fc98aa61da6898c1539b82d4e4fe5ab439b79d54664a70fcac99d55127778/blob b/shared/package-files/42/428fc98aa61da6898c1539b82d4e4fe5ab439b79d54664a70fcac99d55127778/blob new file mode 100644 index 0000000000000000000000000000000000000000..08c8728d5895ab505712bc5d028582521f308b78 --- /dev/null +++ b/shared/package-files/42/428fc98aa61da6898c1539b82d4e4fe5ab439b79d54664a70fcac99d55127778/blob @@ -0,0 +1,9 @@ +# Find the TH includes and library +# +# ATEN_INCLUDE_DIR -- where to find the includes +# ATEN_LIBRARIES -- list of libraries to link against +# ATEN_FOUND -- set to 1 if found + +set(ATEN_FOUND 1) +set(ATEN_INCLUDE_DIR "/opt/conda/conda-bld/pytorch_1712608935911/work/torch/include") +set(ATEN_LIBRARIES "") diff --git a/shared/package-files/42/4296205a5ffff0300c2a9d5cb5ff8ee7df8ac9b6263d6ab5ed38cf5f253730c9/blob b/shared/package-files/42/4296205a5ffff0300c2a9d5cb5ff8ee7df8ac9b6263d6ab5ed38cf5f253730c9/blob new file mode 100644 index 0000000000000000000000000000000000000000..6dd6d5ef77f09264b9814fbce99264f442bf2251 --- /dev/null +++ b/shared/package-files/42/4296205a5ffff0300c2a9d5cb5ff8ee7df8ac9b6263d6ab5ed38cf5f253730c9/blob @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor upsample_trilinear3d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor upsample_trilinear3d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_trilinear3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_trilinear3d_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & out); +TORCH_API at::Tensor & upsample_trilinear3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_trilinear3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/shared/package-files/42/42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be/blob b/shared/package-files/42/42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be/blob new file mode 100644 index 0000000000000000000000000000000000000000..5d6fae9a2575bf502999b3c59aeecb7b93a37385 --- /dev/null +++ b/shared/package-files/42/42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be/blob @@ -0,0 +1,109 @@ +"""Python version compatibility support for minidom. + +This module contains internal implementation details and +should not be imported; use xml.dom.minidom instead. +""" + +# This module should only be imported using "import *". +# +# The following names are defined: +# +# NodeList -- lightest possible NodeList implementation +# +# EmptyNodeList -- lightest possible NodeList that is guaranteed to +# remain empty (immutable) +# +# StringTypes -- tuple of defined string types +# +# defproperty -- function used in conjunction with GetattrMagic; +# using these together is needed to make them work +# as efficiently as possible in both Python 2.2+ +# and older versions. For example: +# +# class MyClass(GetattrMagic): +# def _get_myattr(self): +# return something +# +# defproperty(MyClass, "myattr", +# "return some value") +# +# For Python 2.2 and newer, this will construct a +# property object on the class, which avoids +# needing to override __getattr__(). It will only +# work for read-only attributes. +# +# For older versions of Python, inheriting from +# GetattrMagic will use the traditional +# __getattr__() hackery to achieve the same effect, +# but less efficiently. +# +# defproperty() should be used for each version of +# the relevant _get_() function. + +__all__ = ["NodeList", "EmptyNodeList", "StringTypes", "defproperty"] + +import xml.dom + +StringTypes = (str,) + + +class NodeList(list): + __slots__ = () + + def item(self, index): + if 0 <= index < len(self): + return self[index] + + def _get_length(self): + return len(self) + + def _set_length(self, value): + raise xml.dom.NoModificationAllowedErr( + "attempt to modify read-only attribute 'length'") + + length = property(_get_length, _set_length, + doc="The number of nodes in the NodeList.") + + # For backward compatibility + def __setstate__(self, state): + if state is None: + state = [] + self[:] = state + + +class EmptyNodeList(tuple): + __slots__ = () + + def __add__(self, other): + NL = NodeList() + NL.extend(other) + return NL + + def __radd__(self, other): + NL = NodeList() + NL.extend(other) + return NL + + def item(self, index): + return None + + def _get_length(self): + return 0 + + def _set_length(self, value): + raise xml.dom.NoModificationAllowedErr( + "attempt to modify read-only attribute 'length'") + + length = property(_get_length, _set_length, + doc="The number of nodes in the NodeList.") + + +def defproperty(klass, name, doc): + get = getattr(klass, ("_get_" + name)) + def set(self, value, name=name): + raise xml.dom.NoModificationAllowedErr( + "attempt to modify read-only attribute " + repr(name)) + assert not hasattr(klass, "_set_" + name), \ + "expected not to find _set_" + name + prop = property(get, set, doc=doc) + setattr(klass, name, prop) diff --git a/shared/package-files/42/42991ff02a445b9b36a4a331c0055f833db34389a25bb93277e16239e1f2bc6f/blob b/shared/package-files/42/42991ff02a445b9b36a4a331c0055f833db34389a25bb93277e16239e1f2bc6f/blob new file mode 100644 index 0000000000000000000000000000000000000000..1c78b48a25727e12a03bacf7b79330cbd9f988cc --- /dev/null +++ b/shared/package-files/42/42991ff02a445b9b36a4a331c0055f833db34389a25bb93277e16239e1f2bc6f/blob @@ -0,0 +1,66 @@ +import io +from typing import Any + +from . import _collections, exceptions +from .connection import BaseSSLError as BaseSSLError, HTTPException as HTTPException +from .util import response + +HTTPHeaderDict = _collections.HTTPHeaderDict +ProtocolError = exceptions.ProtocolError +DecodeError = exceptions.DecodeError +ReadTimeoutError = exceptions.ReadTimeoutError +binary_type = bytes # six.binary_type +PY3 = True # six.PY3 +is_fp_closed = response.is_fp_closed + +class DeflateDecoder: + def __init__(self) -> None: ... + def __getattr__(self, name): ... + def decompress(self, data): ... + +class GzipDecoder: + def __init__(self) -> None: ... + def __getattr__(self, name): ... + def decompress(self, data): ... + +class HTTPResponse(io.IOBase): + CONTENT_DECODERS: Any + REDIRECT_STATUSES: Any + headers: Any + status: Any + version: Any + reason: Any + strict: Any + decode_content: Any + def __init__( + self, + body=..., + headers=..., + status=..., + version=..., + reason=..., + strict=..., + preload_content=..., + decode_content=..., + original_response=..., + pool=..., + connection=..., + ) -> None: ... + def get_redirect_location(self): ... + def release_conn(self): ... + @property + def data(self): ... + def tell(self): ... + def read(self, amt=..., decode_content=..., cache_content=...): ... + def stream(self, amt=..., decode_content=...): ... + @classmethod + def from_httplib(cls, r, **response_kw): ... + def getheaders(self): ... + def getheader(self, name, default=...): ... + def close(self): ... + @property + def closed(self): ... + def fileno(self): ... + def flush(self): ... + def readable(self): ... + def readinto(self, b): ... diff --git a/shared/package-files/42/42994f52084c42fee2da891ad5cb29e73395b4f1de6e88dbf5ca36a2a59fa86b/blob b/shared/package-files/42/42994f52084c42fee2da891ad5cb29e73395b4f1de6e88dbf5ca36a2a59fa86b/blob new file mode 100644 index 0000000000000000000000000000000000000000..40dbbb5b913af0ca725ef5c6cab9fee1a3ffec70 --- /dev/null +++ b/shared/package-files/42/42994f52084c42fee2da891ad5cb29e73395b4f1de6e88dbf5ca36a2a59fa86b/blob @@ -0,0 +1,11 @@ +from torch._C import _get_cpp_backtrace + +def get_cpp_backtrace(frames_to_skip=0, maximum_number_of_frames=64) -> str: + r""" + Return a string containing the C++ stack trace of the current thread. + + Args: + frames_to_skip (int): the number of frames to skip from the top of the stack + maximum_number_of_frames (int): the maximum number of frames to return + """ + return _get_cpp_backtrace(frames_to_skip, maximum_number_of_frames) diff --git a/shared/package-files/42/4299d4d765e09fe506b14d5369ed5806f2e57545923ef62bd231ebd677812eb6/blob b/shared/package-files/42/4299d4d765e09fe506b14d5369ed5806f2e57545923ef62bd231ebd677812eb6/blob new file mode 100644 index 0000000000000000000000000000000000000000..4857b963881f784eb72115cdbb6560282796c4b4 --- /dev/null +++ b/shared/package-files/42/4299d4d765e09fe506b14d5369ed5806f2e57545923ef62bd231ebd677812eb6/blob @@ -0,0 +1,199 @@ +import inspect +from typing import Any, Callable, Dict, Iterable, Optional, Tuple, Type, Union + +import torch +from torch._streambase import _EventBase, _StreamBase + +get_cuda_stream: Optional[Callable[[int], int]] +if torch.cuda._is_compiled(): + from torch._C import _cuda_getCurrentRawStream as get_cuda_stream +else: + get_cuda_stream = None + +_device_t = Union[torch.device, str, int, None] + +# Recording the device properties in the main process but used in worker process. +caching_worker_device_properties: Dict[str, Any] = {} +caching_worker_current_devices: Dict[str, int] = {} + + +class DeviceInterfaceMeta(type): + def __new__(metacls, *args, **kwargs): + class_member = args[2] + if "Event" in class_member: + assert inspect.isclass(class_member["Event"]) and issubclass( + class_member["Event"], _EventBase + ), "DeviceInterface member Event should be inherit from _EventBase" + if "Stream" in class_member: + assert inspect.isclass(class_member["Stream"]) and issubclass( + class_member["Stream"], _StreamBase + ), "DeviceInterface member Stream should be inherit from _StreamBase" + return super().__new__(metacls, *args, **kwargs) + + +class DeviceInterface(metaclass=DeviceInterfaceMeta): + """ + This is a simple device runtime interface for Inductor. It enables custom + backends to be integrated with Inductor in a device-agnostic semantic. + """ + + class device: + def __new__(cls, device: _device_t): + raise NotImplementedError() + + class Worker: + """ + Worker API to query device properties that will work in multi processing + workers that cannot use the GPU APIs (due to processing fork() and + initialization time issues). Properties are recorded in the main process + before we fork the workers. + """ + + @staticmethod + def set_device(device: int): + raise NotImplementedError() + + @staticmethod + def current_device() -> int: + raise NotImplementedError() + + @staticmethod + def get_device_properties(device: _device_t = None): + raise NotImplementedError() + + @staticmethod + def current_device(): + raise NotImplementedError() + + @staticmethod + def set_device(device: _device_t): + raise NotImplementedError() + + @staticmethod + def device_count(): + raise NotImplementedError() + + @staticmethod + def is_available() -> bool: + raise NotImplementedError() + + @staticmethod + def stream(stream: torch.Stream): + raise NotImplementedError() + + @staticmethod + def current_stream(): + raise NotImplementedError() + + @staticmethod + def set_stream(stream: torch.Stream): + raise NotImplementedError() + + @staticmethod + def _set_stream_by_id(stream_id: int, device_index: int, device_type: int): + raise NotImplementedError() + + @staticmethod + def get_raw_stream(): + raise NotImplementedError() + + @staticmethod + def synchronize(device: _device_t = None): + raise NotImplementedError() + + @staticmethod + def get_device_properties(device: _device_t = None): + raise NotImplementedError() + + @staticmethod + def get_compute_capability(device: _device_t = None): + raise NotImplementedError() + + +class CudaInterface(DeviceInterface): + device = torch.cuda.device + + # register Event and Stream class into the backend interface + # make sure Event and Stream are implemented and inherited from the _EventBase and _StreamBase + Event = torch.cuda.Event + Stream = torch.cuda.Stream + + class Worker: + @staticmethod + def set_device(device: int): + caching_worker_current_devices["cuda"] = device + + @staticmethod + def current_device() -> int: + if "cuda" in caching_worker_current_devices: + return caching_worker_current_devices["cuda"] + return torch.cuda.current_device() + + @staticmethod + def get_device_properties(device: _device_t = None): + if device is not None: + if isinstance(device, str): + device = torch.device(device) + assert device.type == "cuda" + if isinstance(device, torch.device): + device = device.index + if device is None: + device = CudaInterface.Worker.current_device() + + if "cuda" not in caching_worker_device_properties: + device_prop = [ + torch.cuda.get_device_properties(i) + for i in range(torch.cuda.device_count()) + ] + caching_worker_device_properties["cuda"] = device_prop + + return caching_worker_device_properties["cuda"][device] + + current_device = staticmethod(torch.cuda.current_device) + set_device = staticmethod(torch.cuda.set_device) + device_count = staticmethod(torch.cuda.device_count) + stream = staticmethod(torch.cuda.stream) # type: ignore[assignment] + current_stream = staticmethod(torch.cuda.current_stream) + set_stream = staticmethod(torch.cuda.set_stream) # type: ignore[assignment] + _set_stream_by_id = staticmethod(torch.cuda._set_stream_by_id) # type: ignore[assignment] + synchronize = staticmethod(torch.cuda.synchronize) + get_device_properties = staticmethod(torch.cuda.get_device_properties) # type: ignore[assignment] + get_raw_stream = staticmethod(get_cuda_stream) # type: ignore[arg-type] + + # Can be mock patched by @patch decorator. + @staticmethod + def is_available() -> bool: + return torch.cuda.is_available() + + @staticmethod + def get_compute_capability(device: _device_t = None): + major, min = torch.cuda.get_device_capability(device) + return major * 10 + min + + +device_interfaces: Dict[str, Type[DeviceInterface]] = {} + + +def register_interface_for_device( + device: Union[str, torch.device], device_interface: Type[DeviceInterface] +): + if isinstance(device, torch.device): + device = str(device) + device_interfaces[device] = device_interface + + +def get_interface_for_device(device: Union[str, torch.device]) -> Type[DeviceInterface]: + if isinstance(device, torch.device): + device = str(device) + if device in device_interfaces: + return device_interfaces[device] + raise NotImplementedError(f"No interface for device {device}") + + +def get_registered_device_interfaces() -> Iterable[Tuple[str, Type[DeviceInterface]]]: + return device_interfaces.items() + + +register_interface_for_device("cuda", CudaInterface) +for i in range(torch.cuda.device_count()): + register_interface_for_device(f"cuda:{i}", CudaInterface) diff --git a/shared/package-files/42/429e8315e6eea0c816134e67e0021f73ba5ab2e9083574b028bae4a912bb4c9a/blob b/shared/package-files/42/429e8315e6eea0c816134e67e0021f73ba5ab2e9083574b028bae4a912bb4c9a/blob new file mode 100644 index 0000000000000000000000000000000000000000..9b7197d74390c142744ec6d64df967b6c7f25903 --- /dev/null +++ b/shared/package-files/42/429e8315e6eea0c816134e67e0021f73ba5ab2e9083574b028bae4a912bb4c9a/blob @@ -0,0 +1,20 @@ +#ifndef THCP_STREAM_INC +#define THCP_STREAM_INC + +#include +#include +#include + +// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init) +struct THCPStream : THPStream { + at::cuda::CUDAStream cuda_stream; +}; +extern PyObject* THCPStreamClass; + +void THCPStream_init(PyObject* module); + +inline bool THCPStream_Check(PyObject* obj) { + return THCPStreamClass && PyObject_IsInstance(obj, THCPStreamClass); +} + +#endif // THCP_STREAM_INC diff --git a/shared/package-files/42/42a15924c5015675394a9641eb7b423875f70aa65b8e07ac39973a9f16e1a787/blob b/shared/package-files/42/42a15924c5015675394a9641eb7b423875f70aa65b8e07ac39973a9f16e1a787/blob new file mode 100644 index 0000000000000000000000000000000000000000..6d581b5b92e0c8cbcfe21dbbdfb0f99ca05c1a4e --- /dev/null +++ b/shared/package-files/42/42a15924c5015675394a9641eb7b423875f70aa65b8e07ac39973a9f16e1a787/blob @@ -0,0 +1,254 @@ +import numpy as np +import pytest + +from pandas import ( + DataFrame, + reset_option, + set_eng_float_format, +) + +from pandas.io.formats.format import EngFormatter + + +@pytest.fixture(autouse=True) +def reset_float_format(): + yield + reset_option("display.float_format") + + +class TestEngFormatter: + def test_eng_float_formatter2(self, float_frame): + df = float_frame + df.loc[5] = 0 + + set_eng_float_format() + repr(df) + + set_eng_float_format(use_eng_prefix=True) + repr(df) + + set_eng_float_format(accuracy=0) + repr(df) + + def test_eng_float_formatter(self): + df = DataFrame({"A": [1.41, 141.0, 14100, 1410000.0]}) + + set_eng_float_format() + result = df.to_string() + expected = ( + " A\n" + "0 1.410E+00\n" + "1 141.000E+00\n" + "2 14.100E+03\n" + "3 1.410E+06" + ) + assert result == expected + + set_eng_float_format(use_eng_prefix=True) + result = df.to_string() + expected = " A\n0 1.410\n1 141.000\n2 14.100k\n3 1.410M" + assert result == expected + + set_eng_float_format(accuracy=0) + result = df.to_string() + expected = " A\n0 1E+00\n1 141E+00\n2 14E+03\n3 1E+06" + assert result == expected + + def compare(self, formatter, input, output): + formatted_input = formatter(input) + assert formatted_input == output + + def compare_all(self, formatter, in_out): + """ + Parameters: + ----------- + formatter: EngFormatter under test + in_out: list of tuples. Each tuple = (number, expected_formatting) + + It is tested if 'formatter(number) == expected_formatting'. + *number* should be >= 0 because formatter(-number) == fmt is also + tested. *fmt* is derived from *expected_formatting* + """ + for input, output in in_out: + self.compare(formatter, input, output) + self.compare(formatter, -input, "-" + output[1:]) + + def test_exponents_with_eng_prefix(self): + formatter = EngFormatter(accuracy=3, use_eng_prefix=True) + f = np.sqrt(2) + in_out = [ + (f * 10**-24, " 1.414y"), + (f * 10**-23, " 14.142y"), + (f * 10**-22, " 141.421y"), + (f * 10**-21, " 1.414z"), + (f * 10**-20, " 14.142z"), + (f * 10**-19, " 141.421z"), + (f * 10**-18, " 1.414a"), + (f * 10**-17, " 14.142a"), + (f * 10**-16, " 141.421a"), + (f * 10**-15, " 1.414f"), + (f * 10**-14, " 14.142f"), + (f * 10**-13, " 141.421f"), + (f * 10**-12, " 1.414p"), + (f * 10**-11, " 14.142p"), + (f * 10**-10, " 141.421p"), + (f * 10**-9, " 1.414n"), + (f * 10**-8, " 14.142n"), + (f * 10**-7, " 141.421n"), + (f * 10**-6, " 1.414u"), + (f * 10**-5, " 14.142u"), + (f * 10**-4, " 141.421u"), + (f * 10**-3, " 1.414m"), + (f * 10**-2, " 14.142m"), + (f * 10**-1, " 141.421m"), + (f * 10**0, " 1.414"), + (f * 10**1, " 14.142"), + (f * 10**2, " 141.421"), + (f * 10**3, " 1.414k"), + (f * 10**4, " 14.142k"), + (f * 10**5, " 141.421k"), + (f * 10**6, " 1.414M"), + (f * 10**7, " 14.142M"), + (f * 10**8, " 141.421M"), + (f * 10**9, " 1.414G"), + (f * 10**10, " 14.142G"), + (f * 10**11, " 141.421G"), + (f * 10**12, " 1.414T"), + (f * 10**13, " 14.142T"), + (f * 10**14, " 141.421T"), + (f * 10**15, " 1.414P"), + (f * 10**16, " 14.142P"), + (f * 10**17, " 141.421P"), + (f * 10**18, " 1.414E"), + (f * 10**19, " 14.142E"), + (f * 10**20, " 141.421E"), + (f * 10**21, " 1.414Z"), + (f * 10**22, " 14.142Z"), + (f * 10**23, " 141.421Z"), + (f * 10**24, " 1.414Y"), + (f * 10**25, " 14.142Y"), + (f * 10**26, " 141.421Y"), + ] + self.compare_all(formatter, in_out) + + def test_exponents_without_eng_prefix(self): + formatter = EngFormatter(accuracy=4, use_eng_prefix=False) + f = np.pi + in_out = [ + (f * 10**-24, " 3.1416E-24"), + (f * 10**-23, " 31.4159E-24"), + (f * 10**-22, " 314.1593E-24"), + (f * 10**-21, " 3.1416E-21"), + (f * 10**-20, " 31.4159E-21"), + (f * 10**-19, " 314.1593E-21"), + (f * 10**-18, " 3.1416E-18"), + (f * 10**-17, " 31.4159E-18"), + (f * 10**-16, " 314.1593E-18"), + (f * 10**-15, " 3.1416E-15"), + (f * 10**-14, " 31.4159E-15"), + (f * 10**-13, " 314.1593E-15"), + (f * 10**-12, " 3.1416E-12"), + (f * 10**-11, " 31.4159E-12"), + (f * 10**-10, " 314.1593E-12"), + (f * 10**-9, " 3.1416E-09"), + (f * 10**-8, " 31.4159E-09"), + (f * 10**-7, " 314.1593E-09"), + (f * 10**-6, " 3.1416E-06"), + (f * 10**-5, " 31.4159E-06"), + (f * 10**-4, " 314.1593E-06"), + (f * 10**-3, " 3.1416E-03"), + (f * 10**-2, " 31.4159E-03"), + (f * 10**-1, " 314.1593E-03"), + (f * 10**0, " 3.1416E+00"), + (f * 10**1, " 31.4159E+00"), + (f * 10**2, " 314.1593E+00"), + (f * 10**3, " 3.1416E+03"), + (f * 10**4, " 31.4159E+03"), + (f * 10**5, " 314.1593E+03"), + (f * 10**6, " 3.1416E+06"), + (f * 10**7, " 31.4159E+06"), + (f * 10**8, " 314.1593E+06"), + (f * 10**9, " 3.1416E+09"), + (f * 10**10, " 31.4159E+09"), + (f * 10**11, " 314.1593E+09"), + (f * 10**12, " 3.1416E+12"), + (f * 10**13, " 31.4159E+12"), + (f * 10**14, " 314.1593E+12"), + (f * 10**15, " 3.1416E+15"), + (f * 10**16, " 31.4159E+15"), + (f * 10**17, " 314.1593E+15"), + (f * 10**18, " 3.1416E+18"), + (f * 10**19, " 31.4159E+18"), + (f * 10**20, " 314.1593E+18"), + (f * 10**21, " 3.1416E+21"), + (f * 10**22, " 31.4159E+21"), + (f * 10**23, " 314.1593E+21"), + (f * 10**24, " 3.1416E+24"), + (f * 10**25, " 31.4159E+24"), + (f * 10**26, " 314.1593E+24"), + ] + self.compare_all(formatter, in_out) + + def test_rounding(self): + formatter = EngFormatter(accuracy=3, use_eng_prefix=True) + in_out = [ + (5.55555, " 5.556"), + (55.5555, " 55.556"), + (555.555, " 555.555"), + (5555.55, " 5.556k"), + (55555.5, " 55.556k"), + (555555, " 555.555k"), + ] + self.compare_all(formatter, in_out) + + formatter = EngFormatter(accuracy=1, use_eng_prefix=True) + in_out = [ + (5.55555, " 5.6"), + (55.5555, " 55.6"), + (555.555, " 555.6"), + (5555.55, " 5.6k"), + (55555.5, " 55.6k"), + (555555, " 555.6k"), + ] + self.compare_all(formatter, in_out) + + formatter = EngFormatter(accuracy=0, use_eng_prefix=True) + in_out = [ + (5.55555, " 6"), + (55.5555, " 56"), + (555.555, " 556"), + (5555.55, " 6k"), + (55555.5, " 56k"), + (555555, " 556k"), + ] + self.compare_all(formatter, in_out) + + formatter = EngFormatter(accuracy=3, use_eng_prefix=True) + result = formatter(0) + assert result == " 0.000" + + def test_nan(self): + # Issue #11981 + + formatter = EngFormatter(accuracy=1, use_eng_prefix=True) + result = formatter(np.nan) + assert result == "NaN" + + df = DataFrame( + { + "a": [1.5, 10.3, 20.5], + "b": [50.3, 60.67, 70.12], + "c": [100.2, 101.33, 120.33], + } + ) + pt = df.pivot_table(values="a", index="b", columns="c") + set_eng_float_format(accuracy=1) + result = pt.to_string() + assert "NaN" in result + + def test_inf(self): + # Issue #11981 + + formatter = EngFormatter(accuracy=1, use_eng_prefix=True) + result = formatter(np.inf) + assert result == "inf" diff --git a/shared/package-files/42/42a41df085a494d6a930a8cde6f17bbef567e0afb297754abcce7390229a6c23/blob b/shared/package-files/42/42a41df085a494d6a930a8cde6f17bbef567e0afb297754abcce7390229a6c23/blob new file mode 100644 index 0000000000000000000000000000000000000000..1a4c8ea86361731f4d7e854ac66d96a5ce6b2dbf Binary files /dev/null and b/shared/package-files/42/42a41df085a494d6a930a8cde6f17bbef567e0afb297754abcce7390229a6c23/blob differ diff --git a/shared/package-files/42/42a7f21599971b32cbd56ba11a173b496b0dabaf93011009b9fb2db13b8c8d0c/blob b/shared/package-files/42/42a7f21599971b32cbd56ba11a173b496b0dabaf93011009b9fb2db13b8c8d0c/blob new file mode 100644 index 0000000000000000000000000000000000000000..9bb1bfccc42a1971568346fbb6bce859d0f3018a --- /dev/null +++ b/shared/package-files/42/42a7f21599971b32cbd56ba11a173b496b0dabaf93011009b9fb2db13b8c8d0c/blob @@ -0,0 +1,14 @@ +/// Flush-To-Zero and Denormals-Are-Zero mode +/// +/// Flush-To-Zero (FTZ) and Denormals-Are-Zero (DAZ) are modes that bypass +/// IEEE 754 methods of dealing with denormal floating-point numbers on x86-64 +/// and some x86 CPUs. They result in reduced precision for values near zero, +/// but increased performance. +/// +/// See https://software.intel.com/en-us/articles/x87-and-sse-floating-point-assists-in-ia-32-flush-to-zero-ftz-and-denormals-are-zero-daz + +namespace at::cpu { + +bool set_flush_denormal(bool on); + +} // namespace at::cpu diff --git a/shared/package-files/42/42a876922ccd8b965cf2fa5e4447e6943c830b7b81972ec3b9d598a870357274/blob b/shared/package-files/42/42a876922ccd8b965cf2fa5e4447e6943c830b7b81972ec3b9d598a870357274/blob new file mode 100644 index 0000000000000000000000000000000000000000..ae91bcecba73ae4a147c248af1058b486b4fe454 --- /dev/null +++ b/shared/package-files/42/42a876922ccd8b965cf2fa5e4447e6943c830b7b81972ec3b9d598a870357274/blob @@ -0,0 +1,81 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::sort.values(Tensor self, int dim=-1, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim=-1, bool descending=false) { + return at::_ops::sort_values::call(self, dim, descending, values, indices); +} +// aten::sort.values(Tensor self, int dim=-1, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_outf(const at::Tensor & self, int64_t dim, bool descending, at::Tensor & values, at::Tensor & indices) { + return at::_ops::sort_values::call(self, dim, descending, values, indices); +} + +// aten::sort.values_stable(Tensor self, *, bool? stable, int dim=-1, bool descending=False, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, c10::optional stable, int64_t dim=-1, bool descending=false) { + return at::_ops::sort_values_stable::call(self, stable, dim, descending, values, indices); +} +// aten::sort.values_stable(Tensor self, *, bool? stable, int dim=-1, bool descending=False, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_outf(const at::Tensor & self, c10::optional stable, int64_t dim, bool descending, at::Tensor & values, at::Tensor & indices) { + return at::_ops::sort_values_stable::call(self, stable, dim, descending, values, indices); +} + +// aten::sort(Tensor self, int dim=-1, bool descending=False) -> (Tensor values, Tensor indices) +inline ::std::tuple sort(const at::Tensor & self, int64_t dim=-1, bool descending=false) { + return at::_ops::sort::call(self, dim, descending); +} + +// aten::sort.stable(Tensor self, *, bool? stable, int dim=-1, bool descending=False) -> (Tensor values, Tensor indices) +inline ::std::tuple sort(const at::Tensor & self, c10::optional stable, int64_t dim=-1, bool descending=false) { + return at::_ops::sort_stable::call(self, stable, dim, descending); +} + +// aten::sort.dimname_values(Tensor self, Dimname dim, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, at::Dimname dim, bool descending=false) { + return at::_ops::sort_dimname_values::call(self, dim, descending, values, indices); +} +// aten::sort.dimname_values(Tensor self, Dimname dim, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_outf(const at::Tensor & self, at::Dimname dim, bool descending, at::Tensor & values, at::Tensor & indices) { + return at::_ops::sort_dimname_values::call(self, dim, descending, values, indices); +} + +// aten::sort.dimname_values_stable(Tensor self, *, bool? stable, Dimname dim, bool descending=False, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, c10::optional stable, at::Dimname dim, bool descending=false) { + return at::_ops::sort_dimname_values_stable::call(self, stable, dim, descending, values, indices); +} +// aten::sort.dimname_values_stable(Tensor self, *, bool? stable, Dimname dim, bool descending=False, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) +inline ::std::tuple sort_outf(const at::Tensor & self, c10::optional stable, at::Dimname dim, bool descending, at::Tensor & values, at::Tensor & indices) { + return at::_ops::sort_dimname_values_stable::call(self, stable, dim, descending, values, indices); +} + +// aten::sort.dimname(Tensor self, Dimname dim, bool descending=False) -> (Tensor values, Tensor indices) +inline ::std::tuple sort(const at::Tensor & self, at::Dimname dim, bool descending=false) { + return at::_ops::sort_dimname::call(self, dim, descending); +} + +// aten::sort.dimname_stable(Tensor self, *, bool? stable, Dimname dim, bool descending=False) -> (Tensor values, Tensor indices) +inline ::std::tuple sort(const at::Tensor & self, c10::optional stable, at::Dimname dim, bool descending=false) { + return at::_ops::sort_dimname_stable::call(self, stable, dim, descending); +} + +} diff --git a/shared/package-files/42/42a92096d0b25d755f69b1e6ec050aec8e8c0afca7a8bd23b2043eaee5fe9dc9/blob b/shared/package-files/42/42a92096d0b25d755f69b1e6ec050aec8e8c0afca7a8bd23b2043eaee5fe9dc9/blob new file mode 100644 index 0000000000000000000000000000000000000000..d9d6a6494bfa59432661e638f3774a2118985287 --- /dev/null +++ b/shared/package-files/42/42a92096d0b25d755f69b1e6ec050aec8e8c0afca7a8bd23b2043eaee5fe9dc9/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Tensor & other); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/42/42aa4c8b138fbc4b282b87cd1744266da9e4aa1e1627cfe30df21933df7ddc42/blob b/shared/package-files/42/42aa4c8b138fbc4b282b87cd1744266da9e4aa1e1627cfe30df21933df7ddc42/blob new file mode 100644 index 0000000000000000000000000000000000000000..a6d583ed4efb7c5d7cf74114ce3847cca8c06580 --- /dev/null +++ b/shared/package-files/42/42aa4c8b138fbc4b282b87cd1744266da9e4aa1e1627cfe30df21933df7ddc42/blob @@ -0,0 +1,102 @@ +#pragma once + +#include +#include + +namespace torch { +namespace jit { +namespace tensorexpr { + +class CppVarNameRewriter; + +// Generates C++ code from the IR. +// +// Vector operations are unrolled. +// For example: +// C[Ramp(0, 1, 3)] = A[Ramp(0, 2, 3)] + B[Ramp(0, 3, 3)]; +// is unrolled into: +// C[0] = A[0] + B[0]; +// C[1] = A[2] + B[3]; +// C[2] = A[4] + B[6]; +class TORCH_API CppPrinter : public IRPrinter { + public: + explicit CppPrinter(std::ostream* os); + ~CppPrinter() override; + + void printPrologue(); + + using IRPrinter::visit; + + // Binary expressions. + void visit(ModPtr) override; + void visit(MaxPtr) override; + void visit(MinPtr) override; + + // Conditional expressions. + void visit(CompareSelectPtr) override; + void visit(IfThenElsePtr) override; + + // Tensor operations. + void visit(AllocatePtr) override; + void visit(FreePtr) override; + void visit(LoadPtr) override; + void visit(StorePtr) override; + + // Casts. + void visit(CastPtr) override; + void visit(BitCastPtr) override; + + // Calls. + void visit(IntrinsicsPtr) override; + void visit(ExternalCallPtr) override; + + // Vars. + void visit(LetPtr) override; + void visit(VarPtr) override; + + // Vector data types. + void visit(RampPtr) override; + void visit(BroadcastPtr) override; + + private: + int lane_; + std::unordered_map vector_vars_; +}; + +class TORCH_API CppCodeGen : public CodeGen { + public: + CppCodeGen( + StmtPtr stmt, + const std::vector& buffer_args, + at::Device device = at::kCPU, + const std::string& kernel_func_name = "func"); + + ~CppCodeGen() override; + + void call(const std::vector& args) override; + void call_raw(const std::vector& args) override; + + template + void operator()(const Ts&... ts) { + call(std::vector({CallArg(ts)...})); + } + + std::string getCodeText(const std::string& attr = "") override { + return oss_.str(); + } + + private: + void init(); + + std::ostream& os() { + return printer_->os(); + } + + std::ostringstream oss_; + std::unique_ptr printer_; + std::unique_ptr var_name_rewriter_; +}; + +} // namespace tensorexpr +} // namespace jit +} // namespace torch diff --git a/shared/package-files/42/42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7/blob b/shared/package-files/42/42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7/blob new file mode 100644 index 0000000000000000000000000000000000000000..4801a6c1d47bd9e0a8ada16089221c8237b777d5 --- /dev/null +++ b/shared/package-files/42/42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7/blob @@ -0,0 +1,350 @@ +"""A lexical analyzer class for simple shell-like syntaxes.""" + +# Module and documentation by Eric S. Raymond, 21 Dec 1998 +# Input stacking and error message cleanup added by ESR, March 2000 +# push_source() and pop_source() made explicit by ESR, January 2001. +# Posix compliance, split(), string arguments, and +# iterator interface by Gustavo Niemeyer, April 2003. +# changes to tokenize more like Posix shells by Vinay Sajip, July 2016. + +import os +import re +import sys +from collections import deque + +from io import StringIO + +__all__ = ["shlex", "split", "quote", "join"] + +class shlex: + "A lexical analyzer class for simple shell-like syntaxes." + def __init__(self, instream=None, infile=None, posix=False, + punctuation_chars=False): + if isinstance(instream, str): + instream = StringIO(instream) + if instream is not None: + self.instream = instream + self.infile = infile + else: + self.instream = sys.stdin + self.infile = None + self.posix = posix + if posix: + self.eof = None + else: + self.eof = '' + self.commenters = '#' + self.wordchars = ('abcdfeghijklmnopqrstuvwxyz' + 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_') + if self.posix: + self.wordchars += ('ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ' + 'ÀÃÂÃÄÅÆÇÈÉÊËÌÃÃŽÃÃÑÒÓÔÕÖØÙÚÛÜÃÞ') + self.whitespace = ' \t\r\n' + self.whitespace_split = False + self.quotes = '\'"' + self.escape = '\\' + self.escapedquotes = '"' + self.state = ' ' + self.pushback = deque() + self.lineno = 1 + self.debug = 0 + self.token = '' + self.filestack = deque() + self.source = None + if not punctuation_chars: + punctuation_chars = '' + elif punctuation_chars is True: + punctuation_chars = '();<>|&' + self._punctuation_chars = punctuation_chars + if punctuation_chars: + # _pushback_chars is a push back queue used by lookahead logic + self._pushback_chars = deque() + # these chars added because allowed in file names, args, wildcards + self.wordchars += '~-./*?=' + #remove any punctuation chars from wordchars + t = self.wordchars.maketrans(dict.fromkeys(punctuation_chars)) + self.wordchars = self.wordchars.translate(t) + + @property + def punctuation_chars(self): + return self._punctuation_chars + + def push_token(self, tok): + "Push a token onto the stack popped by the get_token method" + if self.debug >= 1: + print("shlex: pushing token " + repr(tok)) + self.pushback.appendleft(tok) + + def push_source(self, newstream, newfile=None): + "Push an input source onto the lexer's input source stack." + if isinstance(newstream, str): + newstream = StringIO(newstream) + self.filestack.appendleft((self.infile, self.instream, self.lineno)) + self.infile = newfile + self.instream = newstream + self.lineno = 1 + if self.debug: + if newfile is not None: + print('shlex: pushing to file %s' % (self.infile,)) + else: + print('shlex: pushing to stream %s' % (self.instream,)) + + def pop_source(self): + "Pop the input source stack." + self.instream.close() + (self.infile, self.instream, self.lineno) = self.filestack.popleft() + if self.debug: + print('shlex: popping to %s, line %d' \ + % (self.instream, self.lineno)) + self.state = ' ' + + def get_token(self): + "Get a token from the input stream (or from stack if it's nonempty)" + if self.pushback: + tok = self.pushback.popleft() + if self.debug >= 1: + print("shlex: popping token " + repr(tok)) + return tok + # No pushback. Get a token. + raw = self.read_token() + # Handle inclusions + if self.source is not None: + while raw == self.source: + spec = self.sourcehook(self.read_token()) + if spec: + (newfile, newstream) = spec + self.push_source(newstream, newfile) + raw = self.get_token() + # Maybe we got EOF instead? + while raw == self.eof: + if not self.filestack: + return self.eof + else: + self.pop_source() + raw = self.get_token() + # Neither inclusion nor EOF + if self.debug >= 1: + if raw != self.eof: + print("shlex: token=" + repr(raw)) + else: + print("shlex: token=EOF") + return raw + + def read_token(self): + quoted = False + escapedstate = ' ' + while True: + if self.punctuation_chars and self._pushback_chars: + nextchar = self._pushback_chars.pop() + else: + nextchar = self.instream.read(1) + if nextchar == '\n': + self.lineno += 1 + if self.debug >= 3: + print("shlex: in state %r I see character: %r" % (self.state, + nextchar)) + if self.state is None: + self.token = '' # past end of file + break + elif self.state == ' ': + if not nextchar: + self.state = None # end of file + break + elif nextchar in self.whitespace: + if self.debug >= 2: + print("shlex: I see whitespace in whitespace state") + if self.token or (self.posix and quoted): + break # emit current token + else: + continue + elif nextchar in self.commenters: + self.instream.readline() + self.lineno += 1 + elif self.posix and nextchar in self.escape: + escapedstate = 'a' + self.state = nextchar + elif nextchar in self.wordchars: + self.token = nextchar + self.state = 'a' + elif nextchar in self.punctuation_chars: + self.token = nextchar + self.state = 'c' + elif nextchar in self.quotes: + if not self.posix: + self.token = nextchar + self.state = nextchar + elif self.whitespace_split: + self.token = nextchar + self.state = 'a' + else: + self.token = nextchar + if self.token or (self.posix and quoted): + break # emit current token + else: + continue + elif self.state in self.quotes: + quoted = True + if not nextchar: # end of file + if self.debug >= 2: + print("shlex: I see EOF in quotes state") + # XXX what error should be raised here? + raise ValueError("No closing quotation") + if nextchar == self.state: + if not self.posix: + self.token += nextchar + self.state = ' ' + break + else: + self.state = 'a' + elif (self.posix and nextchar in self.escape and self.state + in self.escapedquotes): + escapedstate = self.state + self.state = nextchar + else: + self.token += nextchar + elif self.state in self.escape: + if not nextchar: # end of file + if self.debug >= 2: + print("shlex: I see EOF in escape state") + # XXX what error should be raised here? + raise ValueError("No escaped character") + # In posix shells, only the quote itself or the escape + # character may be escaped within quotes. + if (escapedstate in self.quotes and + nextchar != self.state and nextchar != escapedstate): + self.token += self.state + self.token += nextchar + self.state = escapedstate + elif self.state in ('a', 'c'): + if not nextchar: + self.state = None # end of file + break + elif nextchar in self.whitespace: + if self.debug >= 2: + print("shlex: I see whitespace in word state") + self.state = ' ' + if self.token or (self.posix and quoted): + break # emit current token + else: + continue + elif nextchar in self.commenters: + self.instream.readline() + self.lineno += 1 + if self.posix: + self.state = ' ' + if self.token or (self.posix and quoted): + break # emit current token + else: + continue + elif self.state == 'c': + if nextchar in self.punctuation_chars: + self.token += nextchar + else: + if nextchar not in self.whitespace: + self._pushback_chars.append(nextchar) + self.state = ' ' + break + elif self.posix and nextchar in self.quotes: + self.state = nextchar + elif self.posix and nextchar in self.escape: + escapedstate = 'a' + self.state = nextchar + elif (nextchar in self.wordchars or nextchar in self.quotes + or (self.whitespace_split and + nextchar not in self.punctuation_chars)): + self.token += nextchar + else: + if self.punctuation_chars: + self._pushback_chars.append(nextchar) + else: + self.pushback.appendleft(nextchar) + if self.debug >= 2: + print("shlex: I see punctuation in word state") + self.state = ' ' + if self.token or (self.posix and quoted): + break # emit current token + else: + continue + result = self.token + self.token = '' + if self.posix and not quoted and result == '': + result = None + if self.debug > 1: + if result: + print("shlex: raw token=" + repr(result)) + else: + print("shlex: raw token=EOF") + return result + + def sourcehook(self, newfile): + "Hook called on a filename to be sourced." + if newfile[0] == '"': + newfile = newfile[1:-1] + # This implements cpp-like semantics for relative-path inclusion. + if isinstance(self.infile, str) and not os.path.isabs(newfile): + newfile = os.path.join(os.path.dirname(self.infile), newfile) + return (newfile, open(newfile, "r")) + + def error_leader(self, infile=None, lineno=None): + "Emit a C-compiler-like, Emacs-friendly error-message leader." + if infile is None: + infile = self.infile + if lineno is None: + lineno = self.lineno + return "\"%s\", line %d: " % (infile, lineno) + + def __iter__(self): + return self + + def __next__(self): + token = self.get_token() + if token == self.eof: + raise StopIteration + return token + +def split(s, comments=False, posix=True): + """Split the string *s* using shell-like syntax.""" + if s is None: + import warnings + warnings.warn("Passing None for 's' to shlex.split() is deprecated.", + DeprecationWarning, stacklevel=2) + lex = shlex(s, posix=posix) + lex.whitespace_split = True + if not comments: + lex.commenters = '' + return list(lex) + + +def join(split_command): + """Return a shell-escaped string from *split_command*.""" + return ' '.join(quote(arg) for arg in split_command) + + +_find_unsafe = re.compile(r'[^\w@%+=:,./-]', re.ASCII).search + +def quote(s): + """Return a shell-escaped version of the string *s*.""" + if not s: + return "''" + if _find_unsafe(s) is None: + return s + + # use single quotes, and put single quotes into double quotes + # the string $'b is then quoted as '$'"'"'b' + return "'" + s.replace("'", "'\"'\"'") + "'" + + +def _print_tokens(lexer): + while 1: + tt = lexer.get_token() + if not tt: + break + print("Token: " + repr(tt)) + +if __name__ == '__main__': + if len(sys.argv) == 1: + _print_tokens(shlex()) + else: + fn = sys.argv[1] + with open(fn) as f: + _print_tokens(shlex(f, fn)) diff --git a/shared/package-files/42/42ac5048b5dba0f5c45701f3f93c84d8978897f4c2fab3ee8337e8db99db727b/blob b/shared/package-files/42/42ac5048b5dba0f5c45701f3f93c84d8978897f4c2fab3ee8337e8db99db727b/blob new file mode 100644 index 0000000000000000000000000000000000000000..10b87e052b385e5ee3f95e5f383f4923043c3ba3 --- /dev/null +++ b/shared/package-files/42/42ac5048b5dba0f5c45701f3f93c84d8978897f4c2fab3ee8337e8db99db727b/blob @@ -0,0 +1,88 @@ +""" +Tests of the ._exceptions module. Primarily for exercising the __str__ methods. +""" + +import pickle + +import pytest +import numpy as np + +_ArrayMemoryError = np.core._exceptions._ArrayMemoryError +_UFuncNoLoopError = np.core._exceptions._UFuncNoLoopError + +class TestArrayMemoryError: + def test_pickling(self): + """ Test that _ArrayMemoryError can be pickled """ + error = _ArrayMemoryError((1023,), np.dtype(np.uint8)) + res = pickle.loads(pickle.dumps(error)) + assert res._total_size == error._total_size + + def test_str(self): + e = _ArrayMemoryError((1023,), np.dtype(np.uint8)) + str(e) # not crashing is enough + + # testing these properties is easier than testing the full string repr + def test__size_to_string(self): + """ Test e._size_to_string """ + f = _ArrayMemoryError._size_to_string + Ki = 1024 + assert f(0) == '0 bytes' + assert f(1) == '1 bytes' + assert f(1023) == '1023 bytes' + assert f(Ki) == '1.00 KiB' + assert f(Ki+1) == '1.00 KiB' + assert f(10*Ki) == '10.0 KiB' + assert f(int(999.4*Ki)) == '999. KiB' + assert f(int(1023.4*Ki)) == '1023. KiB' + assert f(int(1023.5*Ki)) == '1.00 MiB' + assert f(Ki*Ki) == '1.00 MiB' + + # 1023.9999 Mib should round to 1 GiB + assert f(int(Ki*Ki*Ki*0.9999)) == '1.00 GiB' + assert f(Ki*Ki*Ki*Ki*Ki*Ki) == '1.00 EiB' + # larger than sys.maxsize, adding larger prefixes isn't going to help + # anyway. + assert f(Ki*Ki*Ki*Ki*Ki*Ki*123456) == '123456. EiB' + + def test__total_size(self): + """ Test e._total_size """ + e = _ArrayMemoryError((1,), np.dtype(np.uint8)) + assert e._total_size == 1 + + e = _ArrayMemoryError((2, 4), np.dtype((np.uint64, 16))) + assert e._total_size == 1024 + + +class TestUFuncNoLoopError: + def test_pickling(self): + """ Test that _UFuncNoLoopError can be pickled """ + assert isinstance(pickle.dumps(_UFuncNoLoopError), bytes) + + +@pytest.mark.parametrize("args", [ + (2, 1, None), + (2, 1, "test_prefix"), + ("test message",), +]) +class TestAxisError: + def test_attr(self, args): + """Validate attribute types.""" + exc = np.AxisError(*args) + if len(args) == 1: + assert exc.axis is None + assert exc.ndim is None + else: + axis, ndim, *_ = args + assert exc.axis == axis + assert exc.ndim == ndim + + def test_pickling(self, args): + """Test that `AxisError` can be pickled.""" + exc = np.AxisError(*args) + exc2 = pickle.loads(pickle.dumps(exc)) + + assert type(exc) is type(exc2) + for name in ("axis", "ndim", "args"): + attr1 = getattr(exc, name) + attr2 = getattr(exc2, name) + assert attr1 == attr2, name diff --git a/shared/package-files/42/42adab6246fe575e39d57395027f9e61c9c3da016c3e1741b1802875415918ef/blob b/shared/package-files/42/42adab6246fe575e39d57395027f9e61c9c3da016c3e1741b1802875415918ef/blob new file mode 100644 index 0000000000000000000000000000000000000000..95b573ea89758442e13a34914632718f36cfd1b6 --- /dev/null +++ b/shared/package-files/42/42adab6246fe575e39d57395027f9e61c9c3da016c3e1741b1802875415918ef/blob @@ -0,0 +1,297 @@ +# Copyright (C) 2012 Anaconda, Inc +# SPDX-License-Identifier: BSD-3-Clause +import fnmatch +import shutil +import sys +from errno import ENOENT +from logging import getLogger +from os import environ, getcwd, makedirs, rename, rmdir, scandir, unlink, walk +from os.path import ( + abspath, + basename, + dirname, + exists, + isdir, + isfile, + join, + normpath, + split, +) +from subprocess import STDOUT, CalledProcessError, check_output + +from ...base.constants import CONDA_TEMP_EXTENSION +from ...base.context import context +from ...common.compat import on_win +from . import MAX_TRIES, exp_backoff_fn +from .link import islink, lexists +from .permissions import make_writable, recursive_make_writable + +if not on_win: + from shutil import which + + +log = getLogger(__name__) + + +def rmtree(path, *args, **kwargs): + # subprocessing to delete large folders can be quite a bit faster + path = normpath(path) + if on_win: + try: + # the fastest way seems to be using DEL to recursively delete files + # https://www.ghacks.net/2017/07/18/how-to-delete-large-folders-in-windows-super-fast/ + # However, this is not entirely safe, as it can end up following symlinks to folders + # https://superuser.com/a/306618/184799 + # so, we stick with the slower, but hopefully safer way. Maybe if we figured out how + # to scan for any possible symlinks, we could do the faster way. + # out = check_output('DEL /F/Q/S *.* > NUL 2> NUL'.format(path), shell=True, + # stderr=STDOUT, cwd=path) + + out = check_output( + f'RD /S /Q "{path}" > NUL 2> NUL', shell=True, stderr=STDOUT + ) + except: + try: + # Try to delete in Unicode + name = None + from conda.auxlib.compat import Utf8NamedTemporaryFile + from conda.utils import quote_for_shell + + with Utf8NamedTemporaryFile( + mode="w", suffix=".bat", delete=False + ) as batch_file: + batch_file.write(f"RD /S {quote_for_shell(path)}\n") + batch_file.write("chcp 65001\n") + batch_file.write(f"RD /S {quote_for_shell(path)}\n") + batch_file.write("EXIT 0\n") + name = batch_file.name + # If the above is bugged we can end up deleting hard-drives, so we check + # that 'path' appears in it. This is not bulletproof but it could save you (me). + with open(name) as contents: + content = contents.read() + assert path in content + comspec = environ["COMSPEC"] + CREATE_NO_WINDOW = 0x08000000 + # It is essential that we `pass stdout=None, stderr=None, stdin=None` here because + # if we do not, then the standard console handles get attached and chcp affects the + # parent process (and any which share those console handles!) + out = check_output( + [comspec, "/d", "/c", name], + shell=False, + stdout=None, + stderr=None, + stdin=None, + creationflags=CREATE_NO_WINDOW, + ) + + except CalledProcessError as e: + if e.returncode != 5: + log.error( + "Removing folder {} the fast way failed. Output was: {}".format( + name, out + ) + ) + raise + else: + log.debug( + "removing dir contents the fast way failed. Output was: {}".format( + out + ) + ) + else: + try: + makedirs(".empty") + except: + pass + # yes, this looks strange. See + # https://unix.stackexchange.com/a/79656/34459 + # https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html # NOQA + + if isdir(".empty"): + rsync = which("rsync") + + if rsync: + try: + out = check_output( + [ + rsync, + "-a", + "--force", + "--delete", + join(getcwd(), ".empty") + "/", + path + "/", + ], + stderr=STDOUT, + ) + except CalledProcessError: + log.debug( + f"removing dir contents the fast way failed. Output was: {out}" + ) + + shutil.rmtree(".empty") + shutil.rmtree(path) + + +def unlink_or_rename_to_trash(path): + """If files are in use, especially on windows, we can't remove them. + The fallback path is to rename them (but keep their folder the same), + which maintains the file handle validity. See comments at: + https://serverfault.com/a/503769 + """ + try: + make_writable(path) + unlink(path) + except OSError: + try: + rename(path, path + ".conda_trash") + except OSError: + if on_win: + # on windows, it is important to use the rename program, as just using python's + # rename leads to permission errors when files are in use. + condabin_dir = join(context.conda_prefix, "condabin") + trash_script = join(condabin_dir, "rename_tmp.bat") + if exists(trash_script): + _dirname, _fn = split(path) + dest_fn = path + ".conda_trash" + counter = 1 + while isfile(dest_fn): + dest_fn = dest_fn.splitext[0] + f".conda_trash_{counter}" + counter += 1 + out = "< empty >" + try: + out = check_output( + [ + "cmd.exe", + "/C", + trash_script, + _dirname, + _fn, + basename(dest_fn), + ], + stderr=STDOUT, + ) + except CalledProcessError: + log.debug( + "renaming file path {} to trash failed. Output was: {}".format( + path, out + ) + ) + + else: + log.debug( + "{} is missing. Conda was not installed correctly or has been " + "corrupted. Please file an issue on the conda github repo.".format( + trash_script + ) + ) + log.warn( + "Could not remove or rename {}. Please remove this file manually (you " + "may need to reboot to free file handles)".format(path) + ) + + +def remove_empty_parent_paths(path): + # recurse to clean up empty folders that were created to have a nested hierarchy + parent_path = dirname(path) + + while isdir(parent_path) and not next(scandir(parent_path), None): + rmdir(parent_path) + parent_path = dirname(parent_path) + + +def rm_rf(path, max_retries=5, trash=True, clean_empty_parents=False, *args, **kw): + """ + Completely delete path + max_retries is the number of times to retry on failure. The default is 5. This only applies + to deleting a directory. + If removing path fails and trash is True, files will be moved to the trash directory. + """ + try: + path = abspath(path) + log.trace("rm_rf %s", path) + if isdir(path) and not islink(path): + backoff_rmdir(path) + elif lexists(path): + unlink_or_rename_to_trash(path) + else: + log.trace("rm_rf failed. Not a link, file, or directory: %s", path) + finally: + if lexists(path): + log.info("rm_rf failed for %s", path) + return False + if isdir(path): + delete_trash(path) + if clean_empty_parents: + remove_empty_parent_paths(path) + return True + + +# aliases that all do the same thing (legacy compat) +try_rmdir_all_empty = move_to_trash = move_path_to_trash = rm_rf + + +def delete_trash(prefix): + if not prefix: + prefix = sys.prefix + exclude = {"envs", "pkgs"} + for root, dirs, files in walk(prefix, topdown=True): + dirs[:] = [d for d in dirs if d not in exclude] + for fn in files: + if fnmatch.fnmatch(fn, "*.conda_trash*") or fnmatch.fnmatch( + fn, "*" + CONDA_TEMP_EXTENSION + ): + filename = join(root, fn) + try: + unlink(filename) + remove_empty_parent_paths(filename) + except OSError as e: + log.debug("%r errno %d\nCannot unlink %s.", e, e.errno, filename) + + +def backoff_rmdir(dirpath, max_tries=MAX_TRIES): + if not isdir(dirpath): + return + + def retry(func, path, exc_info): + if getattr(exc_info[1], "errno", None) == ENOENT: + return + recursive_make_writable(dirname(path), max_tries=max_tries) + func(path) + + def _rmdir(path): + try: + recursive_make_writable(path) + exp_backoff_fn(rmtree, path, onerror=retry, max_tries=max_tries) + except OSError as e: + if e.errno == ENOENT: + log.trace("no such file or directory: %s", path) + else: + raise + + try: + rmtree(dirpath) + # we don't really care about errors that much. We'll catch remaining files + # with slower python logic. + except: + pass + + for root, dirs, files in walk(dirpath, topdown=False): + for file in files: + unlink_or_rename_to_trash(join(root, file)) + + +def path_is_clean(path): + """Sometimes we can't completely remove a path because files are considered in use + by python (hardlinking confusion). For our tests, it is sufficient that either the + folder doesn't exist, or nothing but temporary file copies are left. + """ + clean = not exists(path) + if not clean: + for root, dirs, fns in walk(path): + for fn in fns: + if not ( + fnmatch.fnmatch(fn, "*.conda_trash*") + or fnmatch.fnmatch(fn, "*" + CONDA_TEMP_EXTENSION) + ): + return False + return True diff --git a/shared/package-files/42/42ae44ea2512ec9309232993ed8a2a948f0cb6ab55cb49abf6deb3585b5673d6/blob b/shared/package-files/42/42ae44ea2512ec9309232993ed8a2a948f0cb6ab55cb49abf6deb3585b5673d6/blob new file mode 100644 index 0000000000000000000000000000000000000000..78b9daa373d2aa2856eafcc92ebc6d899cafde5c Binary files /dev/null and b/shared/package-files/42/42ae44ea2512ec9309232993ed8a2a948f0cb6ab55cb49abf6deb3585b5673d6/blob differ diff --git a/shared/package-files/42/42b4100cb195d513798207d4c253522493b53c5c222efae6db300090b0313d9e/blob b/shared/package-files/42/42b4100cb195d513798207d4c253522493b53c5c222efae6db300090b0313d9e/blob new file mode 100644 index 0000000000000000000000000000000000000000..4110d0cd4aad2ce26e005ae992c40bd3f00b3815 --- /dev/null +++ b/shared/package-files/42/42b4100cb195d513798207d4c253522493b53c5c222efae6db300090b0313d9e/blob @@ -0,0 +1,24 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor linalg_matrix_norm(const at::Tensor & self, const at::Scalar & ord, at::IntArrayRef dim={-2,-1}, bool keepdim=false, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor & linalg_matrix_norm_out(const at::Tensor & self, const at::Scalar & ord, at::IntArrayRef dim, bool keepdim, c10::optional dtype, at::Tensor & out); +TORCH_API at::Tensor linalg_matrix_norm(const at::Tensor & self, c10::string_view ord="fro", at::IntArrayRef dim={-2,-1}, bool keepdim=false, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor & linalg_matrix_norm_out(const at::Tensor & self, c10::string_view ord, at::IntArrayRef dim, bool keepdim, c10::optional dtype, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/shared/package-files/42/42b44677d583f1bfa935199f1bdb7a5b970d41b74b30c33da58e8c56ad46f4bb/blob b/shared/package-files/42/42b44677d583f1bfa935199f1bdb7a5b970d41b74b30c33da58e8c56ad46f4bb/blob new file mode 100644 index 0000000000000000000000000000000000000000..14f484255bea239498ed11334c93fc9311e4120f --- /dev/null +++ b/shared/package-files/42/42b44677d583f1bfa935199f1bdb7a5b970d41b74b30c33da58e8c56ad46f4bb/blob @@ -0,0 +1,221 @@ +import logging +from typing import List, Optional + +import torch +from torch import Tensor +from torch._dynamo.utils import counters +from torch._inductor import utils + +from ..pattern_matcher import ( + Arg, + CallFunction, + config_flag, + Ignored, + Match, + register_graph_pattern, +) +from .post_grad import decompose_mm_pass + +aten = torch.ops.aten +log = logging.getLogger(__name__) + +# TODO: need a better strategy for decomposing mm +MIN_FIRST_DIMENSION_DECOMPOSITION = 10240 +MAX_OTHER_DIMENSION_DECOMPOSITION = 32 + + +def check_device(a: Tensor, b: Tensor) -> bool: + return a.is_cuda and b.is_cuda + + +def should_decompose_common( + mat1: Tensor, mat2: Tensor, input: Optional[Tensor] = None +) -> bool: + return ( + torch._inductor.config.decompose_mem_bound_mm + and check_device(mat1, mat2) + and not utils.any_is_symbolic(mat1, mat2, input) + ) + + +def should_decompose_bmm(mat1, mat2) -> bool: + if is_node_meta_valid(mat1) and is_node_meta_valid(mat2): + mat1 = mat1.meta["val"] + mat2 = mat2.meta["val"] + else: + return False + if not should_decompose_common(mat1, mat2): + return False + else: + if len(mat1.shape) != 3 or len(mat2.shape) != 3: + return False + if mat1.shape[0] < MIN_FIRST_DIMENSION_DECOMPOSITION: + return False + # 2 of m, n, k must be <= MAX_OTHER_DIMENSION_DECOMPOSITION + if (mat1.shape[1] < MAX_OTHER_DIMENSION_DECOMPOSITION) + ( + mat1.shape[2] < MAX_OTHER_DIMENSION_DECOMPOSITION + ) + (mat2.shape[2] < MAX_OTHER_DIMENSION_DECOMPOSITION) < 2: + return False + return True + + +def should_decompose_mm(mat1, mat2) -> bool: + if is_node_meta_valid(mat1) and is_node_meta_valid(mat2): + mat1 = mat1.meta["val"] + mat2 = mat2.meta["val"] + else: + return False + return ( + should_decompose_common(mat1, mat2) + and len(mat1.shape) == 2 + and len(mat2.shape) == 2 + and mat1.shape[0] >= MIN_FIRST_DIMENSION_DECOMPOSITION + and mat2.shape[0] < MAX_OTHER_DIMENSION_DECOMPOSITION + and mat2.shape[1] < MAX_OTHER_DIMENSION_DECOMPOSITION + ) + + +def should_decompose_mmt(mat1, mat2) -> bool: + if is_node_meta_valid(mat1) and is_node_meta_valid(mat2): + mat1 = mat1.meta["val"] + mat2 = mat2.meta["val"] + else: + return False + return ( + should_decompose_common(mat1, mat2) + and len(mat1.shape) == 2 + and len(mat2.shape) == 2 + and mat1.shape[0] >= MIN_FIRST_DIMENSION_DECOMPOSITION + and mat1.shape[1] < MAX_OTHER_DIMENSION_DECOMPOSITION + and mat2.shape[1] < MAX_OTHER_DIMENSION_DECOMPOSITION + ) + + +def should_decompose_mm_largek(mat1, mat2) -> bool: + if is_node_meta_valid(mat1) and is_node_meta_valid(mat2): + mat1 = mat1.meta["val"] + mat2 = mat2.meta["val"] + else: + return False + return ( + should_decompose_common(mat1, mat2) + and len(mat1.shape) == 2 + and len(mat2.shape) == 2 + and mat1.shape[1] >= MIN_FIRST_DIMENSION_DECOMPOSITION + and mat1.shape[0] < MAX_OTHER_DIMENSION_DECOMPOSITION + and mat2.shape[1] < MAX_OTHER_DIMENSION_DECOMPOSITION + ) + + +def is_node_meta_valid(node: torch.fx.Node): + return "val" in node.meta + + +def print_decompose_pattern(match: Match, inputs: List[torch.fx.Node]): + node = match.nodes[-1] + log.debug( + "Decompose %s with input shape: %s", + node.target, + ", ".join( + str(input.meta["val"].shape) if "val" in input.meta else "None" + for input in inputs + ), + ) + + +@register_graph_pattern( + CallFunction(aten.bmm, Arg(), Arg()), + pass_dict=decompose_mm_pass, + extra_check=config_flag("decompose_mem_bound_mm"), +) +def decompose_bmm(match: Match, mat1: torch.fx.Node, mat2: torch.fx.Node): + def repl(mat1, mat2): + return torch.sum(mat1[:, :, :, None] * mat2[:, None, :, :], dim=-2) + + if should_decompose_bmm(mat1, mat2): + counters["inductor"]["decompose_bmm"] += 1 + match.replace_by_example(repl, [mat1, mat2]) + print_decompose_pattern(match, [mat1, mat2]) + return + + +@register_graph_pattern( + CallFunction(aten.addmm, Arg(), Arg(), Arg()), + pass_dict=decompose_mm_pass, + extra_check=config_flag("decompose_mem_bound_mm"), +) +def decompose_addmm( + match: Match, + mat1: torch.fx.Node, + mat2: torch.fx.Node, + mat3: torch.fx.Node, +): + def repl(mat1, mat2, mat3): + return torch.sum(mat2[:, :, None] * mat3[None, :, :], dim=-2) + mat1 + + if should_decompose_mm(mat2, mat3): + counters["inductor"]["decompose_addmm"] += 1 + match.replace_by_example(repl, [mat1, mat2, mat3]) + print_decompose_pattern(match, [mat1, mat2, mat3]) + return + + +@register_graph_pattern( + CallFunction(aten.mm, CallFunction(aten.permute, Arg(), Ignored()), Arg()), + pass_dict=decompose_mm_pass, + extra_check=config_flag("decompose_mem_bound_mm"), +) +def decompose_mmt( + match: Match, + mat1: torch.fx.Node, + mat2: torch.fx.Node, +): + def repl(mat1, mat2): + return torch.sum(mat1[:, :, None] * mat2[:, None, :], dim=0) + + if should_decompose_mmt(mat1, mat2): + counters["inductor"]["decompose_mmt"] += 1 + match.replace_by_example(repl, [mat1, mat2]) + print_decompose_pattern(match, [mat1, mat2]) + return + + +@register_graph_pattern( + CallFunction(aten.mm, Arg(), Arg()), + pass_dict=decompose_mm_pass, + extra_check=config_flag("decompose_mem_bound_mm"), +) +def decompose_mm( + match: Match, + mat1: torch.fx.Node, + mat2: torch.fx.Node, +): + def repl(mat1, mat2): + return torch.sum(mat1[:, :, None] * mat2[None, :, :], dim=-2) + + if should_decompose_mm(mat1, mat2): + counters["inductor"]["decompose_mm"] += 1 + match.replace_by_example(repl, [mat1, mat2]) + print_decompose_pattern(match, [mat1, mat2]) + return + + +@register_graph_pattern( + CallFunction(aten.mm, Arg(), Arg()), + pass_dict=decompose_mm_pass, + extra_check=config_flag("decompose_mem_bound_mm"), +) +def decompose_mm_large_k( + match: Match, + mat1: torch.fx.Node, + mat2: torch.fx.Node, +): + def repl(mat1, mat2): + mat1 = mat1.permute(1, 0) + return torch.sum(mat1[:, :, None] * mat2[:, None, :], dim=0) + + if should_decompose_mm_largek(mat1, mat2): + counters["inductor"]["decompose_mm_large_k"] += 1 + match.replace_by_example(repl, [mat1, mat2]) + print_decompose_pattern(match, [mat1, mat2]) + return diff --git a/shared/package-files/42/42bace4a50322971cda8cab2df8fcadd4bb66d272f258eb329ee713064eefa85/blob b/shared/package-files/42/42bace4a50322971cda8cab2df8fcadd4bb66d272f258eb329ee713064eefa85/blob new file mode 100644 index 0000000000000000000000000000000000000000..acdd565ec48a92cf2395ba759195f6caaf58f6b9 --- /dev/null +++ b/shared/package-files/42/42bace4a50322971cda8cab2df8fcadd4bb66d272f258eb329ee713064eefa85/blob @@ -0,0 +1,1662 @@ +"""Ttk wrapper. + +This module provides classes to allow using Tk themed widget set. + +Ttk is based on a revised and enhanced version of +TIP #48 (http://tip.tcl.tk/48) specified style engine. + +Its basic idea is to separate, to the extent possible, the code +implementing a widget's behavior from the code implementing its +appearance. Widget class bindings are primarily responsible for +maintaining the widget state and invoking callbacks, all aspects +of the widgets appearance lies at Themes. +""" + +__version__ = "0.3.1" + +__author__ = "Guilherme Polo " + +__all__ = ["Button", "Checkbutton", "Combobox", "Entry", "Frame", "Label", + "Labelframe", "LabelFrame", "Menubutton", "Notebook", "Panedwindow", + "PanedWindow", "Progressbar", "Radiobutton", "Scale", "Scrollbar", + "Separator", "Sizegrip", "Spinbox", "Style", "Treeview", + # Extensions + "LabeledScale", "OptionMenu", + # functions + "tclobjs_to_py", "setup_master"] + +import tkinter +from tkinter import _flatten, _join, _stringify, _splitdict + +# Verify if Tk is new enough to not need the Tile package +_REQUIRE_TILE = True if tkinter.TkVersion < 8.5 else False + +def _load_tile(master): + if _REQUIRE_TILE: + import os + tilelib = os.environ.get('TILE_LIBRARY') + if tilelib: + # append custom tile path to the list of directories that + # Tcl uses when attempting to resolve packages with the package + # command + master.tk.eval( + 'global auto_path; ' + 'lappend auto_path {%s}' % tilelib) + + master.tk.eval('package require tile') # TclError may be raised here + master._tile_loaded = True + +def _format_optvalue(value, script=False): + """Internal function.""" + if script: + # if caller passes a Tcl script to tk.call, all the values need to + # be grouped into words (arguments to a command in Tcl dialect) + value = _stringify(value) + elif isinstance(value, (list, tuple)): + value = _join(value) + return value + +def _format_optdict(optdict, script=False, ignore=None): + """Formats optdict to a tuple to pass it to tk.call. + + E.g. (script=False): + {'foreground': 'blue', 'padding': [1, 2, 3, 4]} returns: + ('-foreground', 'blue', '-padding', '1 2 3 4')""" + + opts = [] + for opt, value in optdict.items(): + if not ignore or opt not in ignore: + opts.append("-%s" % opt) + if value is not None: + opts.append(_format_optvalue(value, script)) + + return _flatten(opts) + +def _mapdict_values(items): + # each value in mapdict is expected to be a sequence, where each item + # is another sequence containing a state (or several) and a value + # E.g. (script=False): + # [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])] + # returns: + # ['active selected', 'grey', 'focus', [1, 2, 3, 4]] + opt_val = [] + for *state, val in items: + if len(state) == 1: + # if it is empty (something that evaluates to False), then + # format it to Tcl code to denote the "normal" state + state = state[0] or '' + else: + # group multiple states + state = ' '.join(state) # raise TypeError if not str + opt_val.append(state) + if val is not None: + opt_val.append(val) + return opt_val + +def _format_mapdict(mapdict, script=False): + """Formats mapdict to pass it to tk.call. + + E.g. (script=False): + {'expand': [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])]} + + returns: + + ('-expand', '{active selected} grey focus {1, 2, 3, 4}')""" + + opts = [] + for opt, value in mapdict.items(): + opts.extend(("-%s" % opt, + _format_optvalue(_mapdict_values(value), script))) + + return _flatten(opts) + +def _format_elemcreate(etype, script=False, *args, **kw): + """Formats args and kw according to the given element factory etype.""" + spec = None + opts = () + if etype in ("image", "vsapi"): + if etype == "image": # define an element based on an image + # first arg should be the default image name + iname = args[0] + # next args, if any, are statespec/value pairs which is almost + # a mapdict, but we just need the value + imagespec = _join(_mapdict_values(args[1:])) + spec = "%s %s" % (iname, imagespec) + + else: + # define an element whose visual appearance is drawn using the + # Microsoft Visual Styles API which is responsible for the + # themed styles on Windows XP and Vista. + # Availability: Tk 8.6, Windows XP and Vista. + class_name, part_id = args[:2] + statemap = _join(_mapdict_values(args[2:])) + spec = "%s %s %s" % (class_name, part_id, statemap) + + opts = _format_optdict(kw, script) + + elif etype == "from": # clone an element + # it expects a themename and optionally an element to clone from, + # otherwise it will clone {} (empty element) + spec = args[0] # theme name + if len(args) > 1: # elementfrom specified + opts = (_format_optvalue(args[1], script),) + + if script: + spec = '{%s}' % spec + opts = ' '.join(opts) + + return spec, opts + +def _format_layoutlist(layout, indent=0, indent_size=2): + """Formats a layout list so we can pass the result to ttk::style + layout and ttk::style settings. Note that the layout doesn't have to + be a list necessarily. + + E.g.: + [("Menubutton.background", None), + ("Menubutton.button", {"children": + [("Menubutton.focus", {"children": + [("Menubutton.padding", {"children": + [("Menubutton.label", {"side": "left", "expand": 1})] + })] + })] + }), + ("Menubutton.indicator", {"side": "right"}) + ] + + returns: + + Menubutton.background + Menubutton.button -children { + Menubutton.focus -children { + Menubutton.padding -children { + Menubutton.label -side left -expand 1 + } + } + } + Menubutton.indicator -side right""" + script = [] + + for layout_elem in layout: + elem, opts = layout_elem + opts = opts or {} + fopts = ' '.join(_format_optdict(opts, True, ("children",))) + head = "%s%s%s" % (' ' * indent, elem, (" %s" % fopts) if fopts else '') + + if "children" in opts: + script.append(head + " -children {") + indent += indent_size + newscript, indent = _format_layoutlist(opts['children'], indent, + indent_size) + script.append(newscript) + indent -= indent_size + script.append('%s}' % (' ' * indent)) + else: + script.append(head) + + return '\n'.join(script), indent + +def _script_from_settings(settings): + """Returns an appropriate script, based on settings, according to + theme_settings definition to be used by theme_settings and + theme_create.""" + script = [] + # a script will be generated according to settings passed, which + # will then be evaluated by Tcl + for name, opts in settings.items(): + # will format specific keys according to Tcl code + if opts.get('configure'): # format 'configure' + s = ' '.join(_format_optdict(opts['configure'], True)) + script.append("ttk::style configure %s %s;" % (name, s)) + + if opts.get('map'): # format 'map' + s = ' '.join(_format_mapdict(opts['map'], True)) + script.append("ttk::style map %s %s;" % (name, s)) + + if 'layout' in opts: # format 'layout' which may be empty + if not opts['layout']: + s = 'null' # could be any other word, but this one makes sense + else: + s, _ = _format_layoutlist(opts['layout']) + script.append("ttk::style layout %s {\n%s\n}" % (name, s)) + + if opts.get('element create'): # format 'element create' + eopts = opts['element create'] + etype = eopts[0] + + # find where args end, and where kwargs start + argc = 1 # etype was the first one + while argc < len(eopts) and not hasattr(eopts[argc], 'items'): + argc += 1 + + elemargs = eopts[1:argc] + elemkw = eopts[argc] if argc < len(eopts) and eopts[argc] else {} + spec, opts = _format_elemcreate(etype, True, *elemargs, **elemkw) + + script.append("ttk::style element create %s %s %s %s" % ( + name, etype, spec, opts)) + + return '\n'.join(script) + +def _list_from_statespec(stuple): + """Construct a list from the given statespec tuple according to the + accepted statespec accepted by _format_mapdict.""" + if isinstance(stuple, str): + return stuple + result = [] + it = iter(stuple) + for state, val in zip(it, it): + if hasattr(state, 'typename'): # this is a Tcl object + state = str(state).split() + elif isinstance(state, str): + state = state.split() + elif not isinstance(state, (tuple, list)): + state = (state,) + if hasattr(val, 'typename'): + val = str(val) + result.append((*state, val)) + + return result + +def _list_from_layouttuple(tk, ltuple): + """Construct a list from the tuple returned by ttk::layout, this is + somewhat the reverse of _format_layoutlist.""" + ltuple = tk.splitlist(ltuple) + res = [] + + indx = 0 + while indx < len(ltuple): + name = ltuple[indx] + opts = {} + res.append((name, opts)) + indx += 1 + + while indx < len(ltuple): # grab name's options + opt, val = ltuple[indx:indx + 2] + if not opt.startswith('-'): # found next name + break + + opt = opt[1:] # remove the '-' from the option + indx += 2 + + if opt == 'children': + val = _list_from_layouttuple(tk, val) + + opts[opt] = val + + return res + +def _val_or_dict(tk, options, *args): + """Format options then call Tk command with args and options and return + the appropriate result. + + If no option is specified, a dict is returned. If an option is + specified with the None value, the value for that option is returned. + Otherwise, the function just sets the passed options and the caller + shouldn't be expecting a return value anyway.""" + options = _format_optdict(options) + res = tk.call(*(args + options)) + + if len(options) % 2: # option specified without a value, return its value + return res + + return _splitdict(tk, res, conv=_tclobj_to_py) + +def _convert_stringval(value): + """Converts a value to, hopefully, a more appropriate Python object.""" + value = str(value) + try: + value = int(value) + except (ValueError, TypeError): + pass + + return value + +def _to_number(x): + if isinstance(x, str): + if '.' in x: + x = float(x) + else: + x = int(x) + return x + +def _tclobj_to_py(val): + """Return value converted from Tcl object to Python object.""" + if val and hasattr(val, '__len__') and not isinstance(val, str): + if getattr(val[0], 'typename', None) == 'StateSpec': + val = _list_from_statespec(val) + else: + val = list(map(_convert_stringval, val)) + + elif hasattr(val, 'typename'): # some other (single) Tcl object + val = _convert_stringval(val) + + return val + +def tclobjs_to_py(adict): + """Returns adict with its values converted from Tcl objects to Python + objects.""" + for opt, val in adict.items(): + adict[opt] = _tclobj_to_py(val) + + return adict + +def setup_master(master=None): + """If master is not None, itself is returned. If master is None, + the default master is returned if there is one, otherwise a new + master is created and returned. + + If it is not allowed to use the default root and master is None, + RuntimeError is raised.""" + if master is None: + master = tkinter._get_default_root() + return master + + +class Style(object): + """Manipulate style database.""" + + _name = "ttk::style" + + def __init__(self, master=None): + master = setup_master(master) + + if not getattr(master, '_tile_loaded', False): + # Load tile now, if needed + _load_tile(master) + + self.master = master + self.tk = self.master.tk + + + def configure(self, style, query_opt=None, **kw): + """Query or sets the default value of the specified option(s) in + style. + + Each key in kw is an option and each value is either a string or + a sequence identifying the value for that option.""" + if query_opt is not None: + kw[query_opt] = None + result = _val_or_dict(self.tk, kw, self._name, "configure", style) + if result or query_opt: + return result + + + def map(self, style, query_opt=None, **kw): + """Query or sets dynamic values of the specified option(s) in + style. + + Each key in kw is an option and each value should be a list or a + tuple (usually) containing statespecs grouped in tuples, or list, + or something else of your preference. A statespec is compound of + one or more states and then a value.""" + if query_opt is not None: + result = self.tk.call(self._name, "map", style, '-%s' % query_opt) + return _list_from_statespec(self.tk.splitlist(result)) + + result = self.tk.call(self._name, "map", style, *_format_mapdict(kw)) + return {k: _list_from_statespec(self.tk.splitlist(v)) + for k, v in _splitdict(self.tk, result).items()} + + + def lookup(self, style, option, state=None, default=None): + """Returns the value specified for option in style. + + If state is specified it is expected to be a sequence of one + or more states. If the default argument is set, it is used as + a fallback value in case no specification for option is found.""" + state = ' '.join(state) if state else '' + + return self.tk.call(self._name, "lookup", style, '-%s' % option, + state, default) + + + def layout(self, style, layoutspec=None): + """Define the widget layout for given style. If layoutspec is + omitted, return the layout specification for given style. + + layoutspec is expected to be a list or an object different than + None that evaluates to False if you want to "turn off" that style. + If it is a list (or tuple, or something else), each item should be + a tuple where the first item is the layout name and the second item + should have the format described below: + + LAYOUTS + + A layout can contain the value None, if takes no options, or + a dict of options specifying how to arrange the element. + The layout mechanism uses a simplified version of the pack + geometry manager: given an initial cavity, each element is + allocated a parcel. Valid options/values are: + + side: whichside + Specifies which side of the cavity to place the + element; one of top, right, bottom or left. If + omitted, the element occupies the entire cavity. + + sticky: nswe + Specifies where the element is placed inside its + allocated parcel. + + children: [sublayout... ] + Specifies a list of elements to place inside the + element. Each element is a tuple (or other sequence) + where the first item is the layout name, and the other + is a LAYOUT.""" + lspec = None + if layoutspec: + lspec = _format_layoutlist(layoutspec)[0] + elif layoutspec is not None: # will disable the layout ({}, '', etc) + lspec = "null" # could be any other word, but this may make sense + # when calling layout(style) later + + return _list_from_layouttuple(self.tk, + self.tk.call(self._name, "layout", style, lspec)) + + + def element_create(self, elementname, etype, *args, **kw): + """Create a new element in the current theme of given etype.""" + spec, opts = _format_elemcreate(etype, False, *args, **kw) + self.tk.call(self._name, "element", "create", elementname, etype, + spec, *opts) + + + def element_names(self): + """Returns the list of elements defined in the current theme.""" + return tuple(n.lstrip('-') for n in self.tk.splitlist( + self.tk.call(self._name, "element", "names"))) + + + def element_options(self, elementname): + """Return the list of elementname's options.""" + return tuple(o.lstrip('-') for o in self.tk.splitlist( + self.tk.call(self._name, "element", "options", elementname))) + + + def theme_create(self, themename, parent=None, settings=None): + """Creates a new theme. + + It is an error if themename already exists. If parent is + specified, the new theme will inherit styles, elements and + layouts from the specified parent theme. If settings are present, + they are expected to have the same syntax used for theme_settings.""" + script = _script_from_settings(settings) if settings else '' + + if parent: + self.tk.call(self._name, "theme", "create", themename, + "-parent", parent, "-settings", script) + else: + self.tk.call(self._name, "theme", "create", themename, + "-settings", script) + + + def theme_settings(self, themename, settings): + """Temporarily sets the current theme to themename, apply specified + settings and then restore the previous theme. + + Each key in settings is a style and each value may contain the + keys 'configure', 'map', 'layout' and 'element create' and they + are expected to have the same format as specified by the methods + configure, map, layout and element_create respectively.""" + script = _script_from_settings(settings) + self.tk.call(self._name, "theme", "settings", themename, script) + + + def theme_names(self): + """Returns a list of all known themes.""" + return self.tk.splitlist(self.tk.call(self._name, "theme", "names")) + + + def theme_use(self, themename=None): + """If themename is None, returns the theme in use, otherwise, set + the current theme to themename, refreshes all widgets and emits + a <> event.""" + if themename is None: + # Starting on Tk 8.6, checking this global is no longer needed + # since it allows doing self.tk.call(self._name, "theme", "use") + return self.tk.eval("return $ttk::currentTheme") + + # using "ttk::setTheme" instead of "ttk::style theme use" causes + # the variable currentTheme to be updated, also, ttk::setTheme calls + # "ttk::style theme use" in order to change theme. + self.tk.call("ttk::setTheme", themename) + + +class Widget(tkinter.Widget): + """Base class for Tk themed widgets.""" + + def __init__(self, master, widgetname, kw=None): + """Constructs a Ttk Widget with the parent master. + + STANDARD OPTIONS + + class, cursor, takefocus, style + + SCROLLABLE WIDGET OPTIONS + + xscrollcommand, yscrollcommand + + LABEL WIDGET OPTIONS + + text, textvariable, underline, image, compound, width + + WIDGET STATES + + active, disabled, focus, pressed, selected, background, + readonly, alternate, invalid + """ + master = setup_master(master) + if not getattr(master, '_tile_loaded', False): + # Load tile now, if needed + _load_tile(master) + tkinter.Widget.__init__(self, master, widgetname, kw=kw) + + + def identify(self, x, y): + """Returns the name of the element at position x, y, or the empty + string if the point does not lie within any element. + + x and y are pixel coordinates relative to the widget.""" + return self.tk.call(self._w, "identify", x, y) + + + def instate(self, statespec, callback=None, *args, **kw): + """Test the widget's state. + + If callback is not specified, returns True if the widget state + matches statespec and False otherwise. If callback is specified, + then it will be invoked with *args, **kw if the widget state + matches statespec. statespec is expected to be a sequence.""" + ret = self.tk.getboolean( + self.tk.call(self._w, "instate", ' '.join(statespec))) + if ret and callback is not None: + return callback(*args, **kw) + + return ret + + + def state(self, statespec=None): + """Modify or inquire widget state. + + Widget state is returned if statespec is None, otherwise it is + set according to the statespec flags and then a new state spec + is returned indicating which flags were changed. statespec is + expected to be a sequence.""" + if statespec is not None: + statespec = ' '.join(statespec) + + return self.tk.splitlist(str(self.tk.call(self._w, "state", statespec))) + + +class Button(Widget): + """Ttk Button widget, displays a textual label and/or image, and + evaluates a command when pressed.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Button widget with the parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + command, default, width + """ + Widget.__init__(self, master, "ttk::button", kw) + + + def invoke(self): + """Invokes the command associated with the button.""" + return self.tk.call(self._w, "invoke") + + +class Checkbutton(Widget): + """Ttk Checkbutton widget which is either in on- or off-state.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Checkbutton widget with the parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + command, offvalue, onvalue, variable + """ + Widget.__init__(self, master, "ttk::checkbutton", kw) + + + def invoke(self): + """Toggles between the selected and deselected states and + invokes the associated command. If the widget is currently + selected, sets the option variable to the offvalue option + and deselects the widget; otherwise, sets the option variable + to the option onvalue. + + Returns the result of the associated command.""" + return self.tk.call(self._w, "invoke") + + +class Entry(Widget, tkinter.Entry): + """Ttk Entry widget displays a one-line text string and allows that + string to be edited by the user.""" + + def __init__(self, master=None, widget=None, **kw): + """Constructs a Ttk Entry widget with the parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus, xscrollcommand + + WIDGET-SPECIFIC OPTIONS + + exportselection, invalidcommand, justify, show, state, + textvariable, validate, validatecommand, width + + VALIDATION MODES + + none, key, focus, focusin, focusout, all + """ + Widget.__init__(self, master, widget or "ttk::entry", kw) + + + def bbox(self, index): + """Return a tuple of (x, y, width, height) which describes the + bounding box of the character given by index.""" + return self._getints(self.tk.call(self._w, "bbox", index)) + + + def identify(self, x, y): + """Returns the name of the element at position x, y, or the + empty string if the coordinates are outside the window.""" + return self.tk.call(self._w, "identify", x, y) + + + def validate(self): + """Force revalidation, independent of the conditions specified + by the validate option. Returns False if validation fails, True + if it succeeds. Sets or clears the invalid state accordingly.""" + return self.tk.getboolean(self.tk.call(self._w, "validate")) + + +class Combobox(Entry): + """Ttk Combobox widget combines a text field with a pop-down list of + values.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Combobox widget with the parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + exportselection, justify, height, postcommand, state, + textvariable, values, width + """ + Entry.__init__(self, master, "ttk::combobox", **kw) + + + def current(self, newindex=None): + """If newindex is supplied, sets the combobox value to the + element at position newindex in the list of values. Otherwise, + returns the index of the current value in the list of values + or -1 if the current value does not appear in the list.""" + if newindex is None: + return self.tk.getint(self.tk.call(self._w, "current")) + return self.tk.call(self._w, "current", newindex) + + + def set(self, value): + """Sets the value of the combobox to value.""" + self.tk.call(self._w, "set", value) + + +class Frame(Widget): + """Ttk Frame widget is a container, used to group other widgets + together.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Frame with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + borderwidth, relief, padding, width, height + """ + Widget.__init__(self, master, "ttk::frame", kw) + + +class Label(Widget): + """Ttk Label widget displays a textual label and/or image.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Label with parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, style, takefocus, text, + textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + anchor, background, font, foreground, justify, padding, + relief, text, wraplength + """ + Widget.__init__(self, master, "ttk::label", kw) + + +class Labelframe(Widget): + """Ttk Labelframe widget is a container used to group other widgets + together. It has an optional label, which may be a plain text string + or another widget.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Labelframe with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + labelanchor, text, underline, padding, labelwidget, width, + height + """ + Widget.__init__(self, master, "ttk::labelframe", kw) + +LabelFrame = Labelframe # tkinter name compatibility + + +class Menubutton(Widget): + """Ttk Menubutton widget displays a textual label and/or image, and + displays a menu when pressed.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Menubutton with parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + direction, menu + """ + Widget.__init__(self, master, "ttk::menubutton", kw) + + +class Notebook(Widget): + """Ttk Notebook widget manages a collection of windows and displays + a single one at a time. Each child window is associated with a tab, + which the user may select to change the currently-displayed window.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Notebook with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + height, padding, width + + TAB OPTIONS + + state, sticky, padding, text, image, compound, underline + + TAB IDENTIFIERS (tab_id) + + The tab_id argument found in several methods may take any of + the following forms: + + * An integer between zero and the number of tabs + * The name of a child window + * A positional specification of the form "@x,y", which + defines the tab + * The string "current", which identifies the + currently-selected tab + * The string "end", which returns the number of tabs (only + valid for method index) + """ + Widget.__init__(self, master, "ttk::notebook", kw) + + + def add(self, child, **kw): + """Adds a new tab to the notebook. + + If window is currently managed by the notebook but hidden, it is + restored to its previous position.""" + self.tk.call(self._w, "add", child, *(_format_optdict(kw))) + + + def forget(self, tab_id): + """Removes the tab specified by tab_id, unmaps and unmanages the + associated window.""" + self.tk.call(self._w, "forget", tab_id) + + + def hide(self, tab_id): + """Hides the tab specified by tab_id. + + The tab will not be displayed, but the associated window remains + managed by the notebook and its configuration remembered. Hidden + tabs may be restored with the add command.""" + self.tk.call(self._w, "hide", tab_id) + + + def identify(self, x, y): + """Returns the name of the tab element at position x, y, or the + empty string if none.""" + return self.tk.call(self._w, "identify", x, y) + + + def index(self, tab_id): + """Returns the numeric index of the tab specified by tab_id, or + the total number of tabs if tab_id is the string "end".""" + return self.tk.getint(self.tk.call(self._w, "index", tab_id)) + + + def insert(self, pos, child, **kw): + """Inserts a pane at the specified position. + + pos is either the string end, an integer index, or the name of + a managed child. If child is already managed by the notebook, + moves it to the specified position.""" + self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw))) + + + def select(self, tab_id=None): + """Selects the specified tab. + + The associated child window will be displayed, and the + previously-selected window (if different) is unmapped. If tab_id + is omitted, returns the widget name of the currently selected + pane.""" + return self.tk.call(self._w, "select", tab_id) + + + def tab(self, tab_id, option=None, **kw): + """Query or modify the options of the specific tab_id. + + If kw is not given, returns a dict of the tab option values. If option + is specified, returns the value of that option. Otherwise, sets the + options to the corresponding values.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "tab", tab_id) + + + def tabs(self): + """Returns a list of windows managed by the notebook.""" + return self.tk.splitlist(self.tk.call(self._w, "tabs") or ()) + + + def enable_traversal(self): + """Enable keyboard traversal for a toplevel window containing + this notebook. + + This will extend the bindings for the toplevel window containing + this notebook as follows: + + Control-Tab: selects the tab following the currently selected + one + + Shift-Control-Tab: selects the tab preceding the currently + selected one + + Alt-K: where K is the mnemonic (underlined) character of any + tab, will select that tab. + + Multiple notebooks in a single toplevel may be enabled for + traversal, including nested notebooks. However, notebook traversal + only works properly if all panes are direct children of the + notebook.""" + # The only, and good, difference I see is about mnemonics, which works + # after calling this method. Control-Tab and Shift-Control-Tab always + # works (here at least). + self.tk.call("ttk::notebook::enableTraversal", self._w) + + +class Panedwindow(Widget, tkinter.PanedWindow): + """Ttk Panedwindow widget displays a number of subwindows, stacked + either vertically or horizontally.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Panedwindow with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + orient, width, height + + PANE OPTIONS + + weight + """ + Widget.__init__(self, master, "ttk::panedwindow", kw) + + + forget = tkinter.PanedWindow.forget # overrides Pack.forget + + + def insert(self, pos, child, **kw): + """Inserts a pane at the specified positions. + + pos is either the string end, and integer index, or the name + of a child. If child is already managed by the paned window, + moves it to the specified position.""" + self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw))) + + + def pane(self, pane, option=None, **kw): + """Query or modify the options of the specified pane. + + pane is either an integer index or the name of a managed subwindow. + If kw is not given, returns a dict of the pane option values. If + option is specified then the value for that option is returned. + Otherwise, sets the options to the corresponding values.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "pane", pane) + + + def sashpos(self, index, newpos=None): + """If newpos is specified, sets the position of sash number index. + + May adjust the positions of adjacent sashes to ensure that + positions are monotonically increasing. Sash positions are further + constrained to be between 0 and the total size of the widget. + + Returns the new position of sash number index.""" + return self.tk.getint(self.tk.call(self._w, "sashpos", index, newpos)) + +PanedWindow = Panedwindow # tkinter name compatibility + + +class Progressbar(Widget): + """Ttk Progressbar widget shows the status of a long-running + operation. They can operate in two modes: determinate mode shows the + amount completed relative to the total amount of work to be done, and + indeterminate mode provides an animated display to let the user know + that something is happening.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Progressbar with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + orient, length, mode, maximum, value, variable, phase + """ + Widget.__init__(self, master, "ttk::progressbar", kw) + + + def start(self, interval=None): + """Begin autoincrement mode: schedules a recurring timer event + that calls method step every interval milliseconds. + + interval defaults to 50 milliseconds (20 steps/second) if omitted.""" + self.tk.call(self._w, "start", interval) + + + def step(self, amount=None): + """Increments the value option by amount. + + amount defaults to 1.0 if omitted.""" + self.tk.call(self._w, "step", amount) + + + def stop(self): + """Stop autoincrement mode: cancels any recurring timer event + initiated by start.""" + self.tk.call(self._w, "stop") + + +class Radiobutton(Widget): + """Ttk Radiobutton widgets are used in groups to show or change a + set of mutually-exclusive options.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Radiobutton with parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + command, value, variable + """ + Widget.__init__(self, master, "ttk::radiobutton", kw) + + + def invoke(self): + """Sets the option variable to the option value, selects the + widget, and invokes the associated command. + + Returns the result of the command, or an empty string if + no command is specified.""" + return self.tk.call(self._w, "invoke") + + +class Scale(Widget, tkinter.Scale): + """Ttk Scale widget is typically used to control the numeric value of + a linked variable that varies uniformly over some range.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Scale with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + command, from, length, orient, to, value, variable + """ + Widget.__init__(self, master, "ttk::scale", kw) + + + def configure(self, cnf=None, **kw): + """Modify or query scale options. + + Setting a value for any of the "from", "from_" or "to" options + generates a <> event.""" + retval = Widget.configure(self, cnf, **kw) + if not isinstance(cnf, (type(None), str)): + kw.update(cnf) + if any(['from' in kw, 'from_' in kw, 'to' in kw]): + self.event_generate('<>') + return retval + + + def get(self, x=None, y=None): + """Get the current value of the value option, or the value + corresponding to the coordinates x, y if they are specified. + + x and y are pixel coordinates relative to the scale widget + origin.""" + return self.tk.call(self._w, 'get', x, y) + + +class Scrollbar(Widget, tkinter.Scrollbar): + """Ttk Scrollbar controls the viewport of a scrollable widget.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Scrollbar with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + command, orient + """ + Widget.__init__(self, master, "ttk::scrollbar", kw) + + +class Separator(Widget): + """Ttk Separator widget displays a horizontal or vertical separator + bar.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Separator with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + orient + """ + Widget.__init__(self, master, "ttk::separator", kw) + + +class Sizegrip(Widget): + """Ttk Sizegrip allows the user to resize the containing toplevel + window by pressing and dragging the grip.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Sizegrip with parent master. + + STANDARD OPTIONS + + class, cursor, state, style, takefocus + """ + Widget.__init__(self, master, "ttk::sizegrip", kw) + + +class Spinbox(Entry): + """Ttk Spinbox is an Entry with increment and decrement arrows + + It is commonly used for number entry or to select from a list of + string values. + """ + + def __init__(self, master=None, **kw): + """Construct a Ttk Spinbox widget with the parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus, validate, + validatecommand, xscrollcommand, invalidcommand + + WIDGET-SPECIFIC OPTIONS + + to, from_, increment, values, wrap, format, command + """ + Entry.__init__(self, master, "ttk::spinbox", **kw) + + + def set(self, value): + """Sets the value of the Spinbox to value.""" + self.tk.call(self._w, "set", value) + + +class Treeview(Widget, tkinter.XView, tkinter.YView): + """Ttk Treeview widget displays a hierarchical collection of items. + + Each item has a textual label, an optional image, and an optional list + of data values. The data values are displayed in successive columns + after the tree label.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Treeview with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus, xscrollcommand, + yscrollcommand + + WIDGET-SPECIFIC OPTIONS + + columns, displaycolumns, height, padding, selectmode, show + + ITEM OPTIONS + + text, image, values, open, tags + + TAG OPTIONS + + foreground, background, font, image + """ + Widget.__init__(self, master, "ttk::treeview", kw) + + + def bbox(self, item, column=None): + """Returns the bounding box (relative to the treeview widget's + window) of the specified item in the form x y width height. + + If column is specified, returns the bounding box of that cell. + If the item is not visible (i.e., if it is a descendant of a + closed item or is scrolled offscreen), returns an empty string.""" + return self._getints(self.tk.call(self._w, "bbox", item, column)) or '' + + + def get_children(self, item=None): + """Returns a tuple of children belonging to item. + + If item is not specified, returns root children.""" + return self.tk.splitlist( + self.tk.call(self._w, "children", item or '') or ()) + + + def set_children(self, item, *newchildren): + """Replaces item's child with newchildren. + + Children present in item that are not present in newchildren + are detached from tree. No items in newchildren may be an + ancestor of item.""" + self.tk.call(self._w, "children", item, newchildren) + + + def column(self, column, option=None, **kw): + """Query or modify the options for the specified column. + + If kw is not given, returns a dict of the column option values. If + option is specified then the value for that option is returned. + Otherwise, sets the options to the corresponding values.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "column", column) + + + def delete(self, *items): + """Delete all specified items and all their descendants. The root + item may not be deleted.""" + self.tk.call(self._w, "delete", items) + + + def detach(self, *items): + """Unlinks all of the specified items from the tree. + + The items and all of their descendants are still present, and may + be reinserted at another point in the tree, but will not be + displayed. The root item may not be detached.""" + self.tk.call(self._w, "detach", items) + + + def exists(self, item): + """Returns True if the specified item is present in the tree, + False otherwise.""" + return self.tk.getboolean(self.tk.call(self._w, "exists", item)) + + + def focus(self, item=None): + """If item is specified, sets the focus item to item. Otherwise, + returns the current focus item, or '' if there is none.""" + return self.tk.call(self._w, "focus", item) + + + def heading(self, column, option=None, **kw): + """Query or modify the heading options for the specified column. + + If kw is not given, returns a dict of the heading option values. If + option is specified then the value for that option is returned. + Otherwise, sets the options to the corresponding values. + + Valid options/values are: + text: text + The text to display in the column heading + image: image_name + Specifies an image to display to the right of the column + heading + anchor: anchor + Specifies how the heading text should be aligned. One of + the standard Tk anchor values + command: callback + A callback to be invoked when the heading label is + pressed. + + To configure the tree column heading, call this with column = "#0" """ + cmd = kw.get('command') + if cmd and not isinstance(cmd, str): + # callback not registered yet, do it now + kw['command'] = self.master.register(cmd, self._substitute) + + if option is not None: + kw[option] = None + + return _val_or_dict(self.tk, kw, self._w, 'heading', column) + + + def identify(self, component, x, y): + """Returns a description of the specified component under the + point given by x and y, or the empty string if no such component + is present at that position.""" + return self.tk.call(self._w, "identify", component, x, y) + + + def identify_row(self, y): + """Returns the item ID of the item at position y.""" + return self.identify("row", 0, y) + + + def identify_column(self, x): + """Returns the data column identifier of the cell at position x. + + The tree column has ID #0.""" + return self.identify("column", x, 0) + + + def identify_region(self, x, y): + """Returns one of: + + heading: Tree heading area. + separator: Space between two columns headings; + tree: The tree area. + cell: A data cell. + + * Availability: Tk 8.6""" + return self.identify("region", x, y) + + + def identify_element(self, x, y): + """Returns the element at position x, y. + + * Availability: Tk 8.6""" + return self.identify("element", x, y) + + + def index(self, item): + """Returns the integer index of item within its parent's list + of children.""" + return self.tk.getint(self.tk.call(self._w, "index", item)) + + + def insert(self, parent, index, iid=None, **kw): + """Creates a new item and return the item identifier of the newly + created item. + + parent is the item ID of the parent item, or the empty string + to create a new top-level item. index is an integer, or the value + end, specifying where in the list of parent's children to insert + the new item. If index is less than or equal to zero, the new node + is inserted at the beginning, if index is greater than or equal to + the current number of children, it is inserted at the end. If iid + is specified, it is used as the item identifier, iid must not + already exist in the tree. Otherwise, a new unique identifier + is generated.""" + opts = _format_optdict(kw) + if iid is not None: + res = self.tk.call(self._w, "insert", parent, index, + "-id", iid, *opts) + else: + res = self.tk.call(self._w, "insert", parent, index, *opts) + + return res + + + def item(self, item, option=None, **kw): + """Query or modify the options for the specified item. + + If no options are given, a dict with options/values for the item + is returned. If option is specified then the value for that option + is returned. Otherwise, sets the options to the corresponding + values as given by kw.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "item", item) + + + def move(self, item, parent, index): + """Moves item to position index in parent's list of children. + + It is illegal to move an item under one of its descendants. If + index is less than or equal to zero, item is moved to the + beginning, if greater than or equal to the number of children, + it is moved to the end. If item was detached it is reattached.""" + self.tk.call(self._w, "move", item, parent, index) + + reattach = move # A sensible method name for reattaching detached items + + + def next(self, item): + """Returns the identifier of item's next sibling, or '' if item + is the last child of its parent.""" + return self.tk.call(self._w, "next", item) + + + def parent(self, item): + """Returns the ID of the parent of item, or '' if item is at the + top level of the hierarchy.""" + return self.tk.call(self._w, "parent", item) + + + def prev(self, item): + """Returns the identifier of item's previous sibling, or '' if + item is the first child of its parent.""" + return self.tk.call(self._w, "prev", item) + + + def see(self, item): + """Ensure that item is visible. + + Sets all of item's ancestors open option to True, and scrolls + the widget if necessary so that item is within the visible + portion of the tree.""" + self.tk.call(self._w, "see", item) + + + def selection(self): + """Returns the tuple of selected items.""" + return self.tk.splitlist(self.tk.call(self._w, "selection")) + + + def _selection(self, selop, items): + if len(items) == 1 and isinstance(items[0], (tuple, list)): + items = items[0] + + self.tk.call(self._w, "selection", selop, items) + + + def selection_set(self, *items): + """The specified items becomes the new selection.""" + self._selection("set", items) + + + def selection_add(self, *items): + """Add all of the specified items to the selection.""" + self._selection("add", items) + + + def selection_remove(self, *items): + """Remove all of the specified items from the selection.""" + self._selection("remove", items) + + + def selection_toggle(self, *items): + """Toggle the selection state of each specified item.""" + self._selection("toggle", items) + + + def set(self, item, column=None, value=None): + """Query or set the value of given item. + + With one argument, return a dictionary of column/value pairs + for the specified item. With two arguments, return the current + value of the specified column. With three arguments, set the + value of given column in given item to the specified value.""" + res = self.tk.call(self._w, "set", item, column, value) + if column is None and value is None: + return _splitdict(self.tk, res, + cut_minus=False, conv=_tclobj_to_py) + else: + return res + + + def tag_bind(self, tagname, sequence=None, callback=None): + """Bind a callback for the given event sequence to the tag tagname. + When an event is delivered to an item, the callbacks for each + of the item's tags option are called.""" + self._bind((self._w, "tag", "bind", tagname), sequence, callback, add=0) + + + def tag_configure(self, tagname, option=None, **kw): + """Query or modify the options for the specified tagname. + + If kw is not given, returns a dict of the option settings for tagname. + If option is specified, returns the value for that option for the + specified tagname. Otherwise, sets the options to the corresponding + values for the given tagname.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "tag", "configure", + tagname) + + + def tag_has(self, tagname, item=None): + """If item is specified, returns 1 or 0 depending on whether the + specified item has the given tagname. Otherwise, returns a list of + all items which have the specified tag. + + * Availability: Tk 8.6""" + if item is None: + return self.tk.splitlist( + self.tk.call(self._w, "tag", "has", tagname)) + else: + return self.tk.getboolean( + self.tk.call(self._w, "tag", "has", tagname, item)) + + +# Extensions + +class LabeledScale(Frame): + """A Ttk Scale widget with a Ttk Label widget indicating its + current value. + + The Ttk Scale can be accessed through instance.scale, and Ttk Label + can be accessed through instance.label""" + + def __init__(self, master=None, variable=None, from_=0, to=10, **kw): + """Construct a horizontal LabeledScale with parent master, a + variable to be associated with the Ttk Scale widget and its range. + If variable is not specified, a tkinter.IntVar is created. + + WIDGET-SPECIFIC OPTIONS + + compound: 'top' or 'bottom' + Specifies how to display the label relative to the scale. + Defaults to 'top'. + """ + self._label_top = kw.pop('compound', 'top') == 'top' + + Frame.__init__(self, master, **kw) + self._variable = variable or tkinter.IntVar(master) + self._variable.set(from_) + self._last_valid = from_ + + self.label = Label(self) + self.scale = Scale(self, variable=self._variable, from_=from_, to=to) + self.scale.bind('<>', self._adjust) + + # position scale and label according to the compound option + scale_side = 'bottom' if self._label_top else 'top' + label_side = 'top' if scale_side == 'bottom' else 'bottom' + self.scale.pack(side=scale_side, fill='x') + # Dummy required to make frame correct height + dummy = Label(self) + dummy.pack(side=label_side) + dummy.lower() + self.label.place(anchor='n' if label_side == 'top' else 's') + + # update the label as scale or variable changes + self.__tracecb = self._variable.trace_variable('w', self._adjust) + self.bind('', self._adjust) + self.bind('', self._adjust) + + + def destroy(self): + """Destroy this widget and possibly its associated variable.""" + try: + self._variable.trace_vdelete('w', self.__tracecb) + except AttributeError: + pass + else: + del self._variable + super().destroy() + self.label = None + self.scale = None + + + def _adjust(self, *args): + """Adjust the label position according to the scale.""" + def adjust_label(): + self.update_idletasks() # "force" scale redraw + + x, y = self.scale.coords() + if self._label_top: + y = self.scale.winfo_y() - self.label.winfo_reqheight() + else: + y = self.scale.winfo_reqheight() + self.label.winfo_reqheight() + + self.label.place_configure(x=x, y=y) + + from_ = _to_number(self.scale['from']) + to = _to_number(self.scale['to']) + if to < from_: + from_, to = to, from_ + newval = self._variable.get() + if not from_ <= newval <= to: + # value outside range, set value back to the last valid one + self.value = self._last_valid + return + + self._last_valid = newval + self.label['text'] = newval + self.after_idle(adjust_label) + + @property + def value(self): + """Return current scale value.""" + return self._variable.get() + + @value.setter + def value(self, val): + """Set new scale value.""" + self._variable.set(val) + + +class OptionMenu(Menubutton): + """Themed OptionMenu, based after tkinter's OptionMenu, which allows + the user to select a value from a menu.""" + + def __init__(self, master, variable, default=None, *values, **kwargs): + """Construct a themed OptionMenu widget with master as the parent, + the resource textvariable set to variable, the initially selected + value specified by the default parameter, the menu values given by + *values and additional keywords. + + WIDGET-SPECIFIC OPTIONS + + style: stylename + Menubutton style. + direction: 'above', 'below', 'left', 'right', or 'flush' + Menubutton direction. + command: callback + A callback that will be invoked after selecting an item. + """ + kw = {'textvariable': variable, 'style': kwargs.pop('style', None), + 'direction': kwargs.pop('direction', None)} + Menubutton.__init__(self, master, **kw) + self['menu'] = tkinter.Menu(self, tearoff=False) + + self._variable = variable + self._callback = kwargs.pop('command', None) + if kwargs: + raise tkinter.TclError('unknown option -%s' % ( + next(iter(kwargs.keys())))) + + self.set_menu(default, *values) + + + def __getitem__(self, item): + if item == 'menu': + return self.nametowidget(Menubutton.__getitem__(self, item)) + + return Menubutton.__getitem__(self, item) + + + def set_menu(self, default=None, *values): + """Build a new menu of radiobuttons with *values and optionally + a default value.""" + menu = self['menu'] + menu.delete(0, 'end') + for val in values: + menu.add_radiobutton(label=val, + command=( + None if self._callback is None + else lambda val=val: self._callback(val) + ), + variable=self._variable) + + if default: + self._variable.set(default) + + + def destroy(self): + """Destroy this widget and its associated variable.""" + try: + del self._variable + except AttributeError: + pass + super().destroy() diff --git a/shared/package-files/42/42baf24ac88db8dfaadd38575ac0eb274c9f6df3af362d9df35846d053d0ce5a/blob b/shared/package-files/42/42baf24ac88db8dfaadd38575ac0eb274c9f6df3af362d9df35846d053d0ce5a/blob new file mode 100644 index 0000000000000000000000000000000000000000..b29ad007de7355846850aa8a17a2a554b8294be6 --- /dev/null +++ b/shared/package-files/42/42baf24ac88db8dfaadd38575ac0eb274c9f6df3af362d9df35846d053d0ce5a/blob @@ -0,0 +1,153 @@ +#pragma once + +#include +#include + +namespace torch { +namespace nn { + +/// Base class for all (dimension-specialized) instance norm modules +template +class InstanceNormImpl + : public torch::nn::NormImplBase { + private: + inline Tensor apply_instance_norm(const Tensor& input) { + return torch::nn::functional::detail::instance_norm( + input, + this->running_mean, + this->running_var, + this->weight, + this->bias, + this->is_training() || !this->options.track_running_stats(), + this->options.momentum(), + this->options.eps()); + } + + inline Tensor handle_no_batch_input(const Tensor& input) { + return this->apply_instance_norm(input.unsqueeze(0)).squeeze(0); + } + + public: + using torch::nn::NormImplBase::NormImplBase; + + Tensor forward(const Tensor& input) { + this->_check_input_dim(input); + + // For InstanceNorm1D, 2D is unbatched and 3D is batched + // For InstanceNorm2D, 3D is unbatched and 4D is batched + // For InstanceNorm3D, 4D is unbatched and 5D is batched + // check if input does not have a batch-dim + if (input.dim() == D + 1) { + return this->handle_no_batch_input(input); + } + + return this->apply_instance_norm(input); + } + + /// Pretty prints the `InstanceNorm{1,2,3}d` module into the given `stream`. + void pretty_print(std::ostream& stream) const override { + stream << std::boolalpha << "torch::nn::InstanceNorm" << D << "d(" + << this->options.num_features() << ", " + << "eps=" << this->options.eps() << ", " + << "momentum=" << this->options.momentum() << ", " + << "affine=" << this->options.affine() << ", " + << "track_running_stats=" << this->options.track_running_stats() + << ")"; + } +}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ InstanceNorm1d +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +/// Applies the InstanceNorm1d function. +/// See https://pytorch.org/docs/master/nn.html#torch.nn.InstanceNorm1d to learn +/// about the exact behavior of this module. +/// +/// See the documentation for `torch::nn::InstanceNorm1dOptions` class to learn +/// what constructor arguments are supported for this module. +/// +/// Example: +/// ``` +/// InstanceNorm1d +/// model(InstanceNorm1dOptions(4).eps(0.5).momentum(0.1).affine(false).track_running_stats(true)); +/// ``` +class TORCH_API InstanceNorm1dImpl + : public InstanceNormImpl<1, InstanceNorm1dImpl> { + protected: + void _check_input_dim(const Tensor& input) override; + + public: + using InstanceNormImpl<1, InstanceNorm1dImpl>::InstanceNormImpl; +}; + +/// A `ModuleHolder` subclass for `InstanceNorm1dImpl`. +/// See the documentation for `InstanceNorm1dImpl` class to learn what methods +/// it provides, and examples of how to use `InstanceNorm1d` with +/// `torch::nn::InstanceNorm1dOptions`. See the documentation for `ModuleHolder` +/// to learn about PyTorch's module storage semantics. +TORCH_MODULE(InstanceNorm1d); + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ InstanceNorm2d +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +/// Applies the InstanceNorm2d function. +/// See https://pytorch.org/docs/master/nn.html#torch.nn.InstanceNorm2d to learn +/// about the exact behavior of this module. +/// +/// See the documentation for `torch::nn::InstanceNorm2dOptions` class to learn +/// what constructor arguments are supported for this module. +/// +/// Example: +/// ``` +/// InstanceNorm2d +/// model(InstanceNorm2dOptions(4).eps(0.5).momentum(0.1).affine(false).track_running_stats(true)); +/// ``` +class TORCH_API InstanceNorm2dImpl + : public InstanceNormImpl<2, InstanceNorm2dImpl> { + protected: + void _check_input_dim(const Tensor& input) override; + + public: + using InstanceNormImpl<2, InstanceNorm2dImpl>::InstanceNormImpl; +}; + +/// A `ModuleHolder` subclass for `InstanceNorm2dImpl`. +/// See the documentation for `InstanceNorm2dImpl` class to learn what methods +/// it provides, and examples of how to use `InstanceNorm2d` with +/// `torch::nn::InstanceNorm2dOptions`. See the documentation for `ModuleHolder` +/// to learn about PyTorch's module storage semantics. +TORCH_MODULE(InstanceNorm2d); + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ InstanceNorm3d +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +/// Applies the InstanceNorm3d function. +/// See https://pytorch.org/docs/master/nn.html#torch.nn.InstanceNorm3d to learn +/// about the exact behavior of this module. +/// +/// See the documentation for `torch::nn::InstanceNorm3dOptions` class to learn +/// what constructor arguments are supported for this module. +/// +/// Example: +/// ``` +/// InstanceNorm3d +/// model(InstanceNorm3dOptions(4).eps(0.5).momentum(0.1).affine(false).track_running_stats(true)); +/// ``` +class TORCH_API InstanceNorm3dImpl + : public InstanceNormImpl<3, InstanceNorm3dImpl> { + protected: + void _check_input_dim(const Tensor& input) override; + + public: + using InstanceNormImpl<3, InstanceNorm3dImpl>::InstanceNormImpl; +}; + +/// A `ModuleHolder` subclass for `InstanceNorm3dImpl`. +/// See the documentation for `InstanceNorm3dImpl` class to learn what methods +/// it provides, and examples of how to use `InstanceNorm3d` with +/// `torch::nn::InstanceNorm3dOptions`. See the documentation for `ModuleHolder` +/// to learn about PyTorch's module storage semantics. +TORCH_MODULE(InstanceNorm3d); + +} // namespace nn +} // namespace torch diff --git a/shared/package-files/42/42bf222c2146deaf9dc412a739f760ced1d6662ff719e426f8d29631f47f77a7/blob b/shared/package-files/42/42bf222c2146deaf9dc412a739f760ced1d6662ff719e426f8d29631f47f77a7/blob new file mode 100644 index 0000000000000000000000000000000000000000..2d819597d9b079bafb0c04793d3de365dd04fe5e --- /dev/null +++ b/shared/package-files/42/42bf222c2146deaf9dc412a739f760ced1d6662ff719e426f8d29631f47f77a7/blob @@ -0,0 +1,93 @@ +""" +Testing GLSAR against STATA + +Created on Wed May 30 09:25:24 2012 + +Author: Josef Perktold +""" + +import numpy as np +from numpy.testing import assert_allclose, assert_almost_equal, assert_equal + +from statsmodels.datasets import macrodata +from statsmodels.regression.linear_model import GLSAR +from statsmodels.tools.tools import add_constant + + +class CheckStataResultsMixin: + + def test_params_table(self): + res, results = self.res, self.results + assert_almost_equal(res.params, results.params, 3) + assert_almost_equal(res.bse, results.bse, 3) + # assert_almost_equal(res.tvalues, results.tvalues, 3) 0.0003 + assert_allclose(res.tvalues, results.tvalues, atol=0, rtol=0.004) + assert_allclose(res.pvalues, results.pvalues, atol=1e-7, rtol=0.004) + + +class CheckStataResultsPMixin(CheckStataResultsMixin): + + def test_predicted(self): + res, results = self.res, self.results + assert_allclose(res.fittedvalues, results.fittedvalues, rtol=0.002) + predicted = res.predict(res.model.exog) # should be equal + assert_allclose(predicted, results.fittedvalues, rtol=0.0016) + # not yet + # assert_almost_equal(res.fittedvalues_se, results.fittedvalues_se, 4) + + +class TestGLSARCorc(CheckStataResultsPMixin): + + @classmethod + def setup_class(cls): + d2 = macrodata.load_pandas().data + g_gdp = 400*np.diff(np.log(d2["realgdp"].values)) + g_inv = 400*np.diff(np.log(d2["realinv"].values)) + exogg = add_constant(np.c_[g_gdp, d2["realint"][:-1].values], prepend=False) + + mod1 = GLSAR(g_inv, exogg, 1) + cls.res = mod1.iterative_fit(5) + + from .results.macro_gr_corc_stata import results + cls.results = results + + def test_rho(self): + assert_almost_equal(self.res.model.rho, self.results.rho, 3) # pylint: disable-msg=E1101 + + assert_almost_equal(self.res.llf, self.results.ll, 4) + + def test_glsar_arima(self): + from statsmodels.tsa.arima.model import ARIMA + + endog = self.res.model.endog + exog = self.res.model.exog + mod1 = GLSAR(endog, exog, 3) + res = mod1.iterative_fit(10) + mod_arma = ARIMA(endog, order=(3, 0, 0), exog=exog[:, :-1]) + res_arma = mod_arma.fit() + assert_allclose(res.params, res_arma.params[[1, 2, 0]], atol=0.01, rtol=1e-2) + assert_allclose(res.model.rho, res_arma.params[3:6], atol=0.05, rtol=1e-3) + assert_allclose(res.bse, res_arma.bse[[1, 2, 0]], atol=0.1, rtol=1e-3) + + assert_equal(len(res.history["params"]), 5) + # this should be identical, history has last fit + assert_equal(res.history["params"][-1], res.params) + + res2 = mod1.iterative_fit(4, rtol=0) + assert_equal(len(res2.history["params"]), 4) + assert_equal(len(res2.history["rho"]), 4) + + def test_glsar_iter0(self): + endog = self.res.model.endog + exog = self.res.model.exog + + rho = np.array([0.207, 0.275, 1.033]) + mod1 = GLSAR(endog, exog, rho) + res1 = mod1.fit() + res0 = mod1.iterative_fit(0) + res0b = mod1.iterative_fit(1) + # check iterative_fit(0) or iterative_fit(1) does not update rho + assert_allclose(res0.params, res1.params, rtol=1e-11) + assert_allclose(res0b.params, res1.params, rtol=1e-11) + assert_allclose(res0.model.rho, rho, rtol=1e-11) + assert_allclose(res0b.model.rho, rho, rtol=1e-11) diff --git a/shared/package-files/42/42c03e036a218f7affb40125b76fbda738b8ec9894d35b4d9513c3229b6a9e1e/blob b/shared/package-files/42/42c03e036a218f7affb40125b76fbda738b8ec9894d35b4d9513c3229b6a9e1e/blob new file mode 100644 index 0000000000000000000000000000000000000000..42acffcdc52e0215508a5038ffa292396a457549 --- /dev/null +++ b/shared/package-files/42/42c03e036a218f7affb40125b76fbda738b8ec9894d35b4d9513c3229b6a9e1e/blob @@ -0,0 +1,71 @@ +from matplotlib.axes import Axes +from matplotlib.collections import PolyCollection, TriMesh +from matplotlib.colors import Normalize, Colormap +from matplotlib.tri._triangulation import Triangulation + +from numpy.typing import ArrayLike + +from typing import overload, Literal + +@overload +def tripcolor( + ax: Axes, + triangulation: Triangulation, + c: ArrayLike = ..., + *, + alpha: float = ..., + norm: str | Normalize | None = ..., + cmap: str | Colormap | None = ..., + vmin: float | None = ..., + vmax: float | None = ..., + shading: Literal["flat"] = ..., + facecolors: ArrayLike | None = ..., + **kwargs +) -> PolyCollection: ... +@overload +def tripcolor( + ax: Axes, + x: ArrayLike, + y: ArrayLike, + c: ArrayLike = ..., + *, + alpha: float = ..., + norm: str | Normalize | None = ..., + cmap: str | Colormap | None = ..., + vmin: float | None = ..., + vmax: float | None = ..., + shading: Literal["flat"] = ..., + facecolors: ArrayLike | None = ..., + **kwargs +) -> PolyCollection: ... +@overload +def tripcolor( + ax: Axes, + triangulation: Triangulation, + c: ArrayLike = ..., + *, + alpha: float = ..., + norm: str | Normalize | None = ..., + cmap: str | Colormap | None = ..., + vmin: float | None = ..., + vmax: float | None = ..., + shading: Literal["gouraud"], + facecolors: ArrayLike | None = ..., + **kwargs +) -> TriMesh: ... +@overload +def tripcolor( + ax: Axes, + x: ArrayLike, + y: ArrayLike, + c: ArrayLike = ..., + *, + alpha: float = ..., + norm: str | Normalize | None = ..., + cmap: str | Colormap | None = ..., + vmin: float | None = ..., + vmax: float | None = ..., + shading: Literal["gouraud"], + facecolors: ArrayLike | None = ..., + **kwargs +) -> TriMesh: ... diff --git a/shared/package-files/42/42c0cdf0a48aac4bce482171422495f6b8c7fb79db19a64a445b0170708a15b7/blob b/shared/package-files/42/42c0cdf0a48aac4bce482171422495f6b8c7fb79db19a64a445b0170708a15b7/blob new file mode 100644 index 0000000000000000000000000000000000000000..5c688ce325bae7142bedad64c7ed5df231980b69 --- /dev/null +++ b/shared/package-files/42/42c0cdf0a48aac4bce482171422495f6b8c7fb79db19a64a445b0170708a15b7/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & cudnn_convolution_relu_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups); +TORCH_API at::Tensor & cudnn_convolution_relu_outf(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups, at::Tensor & out); +TORCH_API at::Tensor & cudnn_convolution_relu_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups); +TORCH_API at::Tensor & cudnn_convolution_relu_symint_outf(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/42/42c2519e45b0d02dcfc4f3ec94d9e074c52b2e6bdb19a0956163fde1c821c5a5/blob b/shared/package-files/42/42c2519e45b0d02dcfc4f3ec94d9e074c52b2e6bdb19a0956163fde1c821c5a5/blob new file mode 100644 index 0000000000000000000000000000000000000000..211b9fe4ebf60200af1b28578de77e8015c672c4 --- /dev/null +++ b/shared/package-files/42/42c2519e45b0d02dcfc4f3ec94d9e074c52b2e6bdb19a0956163fde1c821c5a5/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _nested_view_from_buffer { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_nested_view_from_buffer") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_nested_view_from_buffer(Tensor(a) self, Tensor nested_size, Tensor nested_strides, Tensor offsets) -> Tensor(a)") + static at::Tensor call(const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/42/42c34d02a6079c4d0d683750b3809f345637bc6d814652c3fb0b344b66b70c79/blob b/shared/package-files/42/42c34d02a6079c4d0d683750b3809f345637bc6d814652c3fb0b344b66b70c79/blob new file mode 100644 index 0000000000000000000000000000000000000000..6111473c58fc4c760d0113f2387e9e49957d8622 --- /dev/null +++ b/shared/package-files/42/42c34d02a6079c4d0d683750b3809f345637bc6d814652c3fb0b344b66b70c79/blob @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset te DAYS_OF_WEEK_ABBREV [list \ + "\u0c06\u0c26\u0c3f"\ + "\u0c38\u0c4b\u0c2e"\ + "\u0c2e\u0c02\u0c17\u0c33"\ + "\u0c2c\u0c41\u0c27"\ + "\u0c17\u0c41\u0c30\u0c41"\ + "\u0c36\u0c41\u0c15\u0c4d\u0c30"\ + "\u0c36\u0c28\u0c3f"] + ::msgcat::mcset te DAYS_OF_WEEK_FULL [list \ + "\u0c06\u0c26\u0c3f\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c38\u0c4b\u0c2e\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c2e\u0c02\u0c17\u0c33\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c2c\u0c41\u0c27\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c17\u0c41\u0c30\u0c41\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c36\u0c41\u0c15\u0c4d\u0c30\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c36\u0c28\u0c3f\u0c35\u0c3e\u0c30\u0c02"] + ::msgcat::mcset te MONTHS_ABBREV [list \ + "\u0c1c\u0c28\u0c35\u0c30\u0c3f"\ + "\u0c2b\u0c3f\u0c2c\u0c4d\u0c30\u0c35\u0c30\u0c3f"\ + "\u0c2e\u0c3e\u0c30\u0c4d\u0c1a\u0c3f"\ + "\u0c0f\u0c2a\u0c4d\u0c30\u0c3f\u0c32\u0c4d"\ + "\u0c2e\u0c47"\ + "\u0c1c\u0c42\u0c28\u0c4d"\ + "\u0c1c\u0c42\u0c32\u0c48"\ + "\u0c06\u0c17\u0c38\u0c4d\u0c1f\u0c41"\ + "\u0c38\u0c46\u0c2a\u0c4d\u0c1f\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c05\u0c15\u0c4d\u0c1f\u0c4b\u0c2c\u0c30\u0c4d"\ + "\u0c28\u0c35\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c21\u0c3f\u0c38\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + ""] + ::msgcat::mcset te MONTHS_FULL [list \ + "\u0c1c\u0c28\u0c35\u0c30\u0c3f"\ + "\u0c2b\u0c3f\u0c2c\u0c4d\u0c30\u0c35\u0c30\u0c3f"\ + "\u0c2e\u0c3e\u0c30\u0c4d\u0c1a\u0c3f"\ + "\u0c0f\u0c2a\u0c4d\u0c30\u0c3f\u0c32\u0c4d"\ + "\u0c2e\u0c47"\ + "\u0c1c\u0c42\u0c28\u0c4d"\ + "\u0c1c\u0c42\u0c32\u0c48"\ + "\u0c06\u0c17\u0c38\u0c4d\u0c1f\u0c41"\ + "\u0c38\u0c46\u0c2a\u0c4d\u0c1f\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c05\u0c15\u0c4d\u0c1f\u0c4b\u0c2c\u0c30\u0c4d"\ + "\u0c28\u0c35\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c21\u0c3f\u0c38\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + ""] +} diff --git a/shared/package-files/42/42c36250bcb1e409d8f50890c312c3c4e1d60322860b29d6336d943976bae5ef/blob b/shared/package-files/42/42c36250bcb1e409d8f50890c312c3c4e1d60322860b29d6336d943976bae5ef/blob new file mode 100644 index 0000000000000000000000000000000000000000..db8519389e9ff567b11fd9a3bb31ac3d8646fe92 --- /dev/null +++ b/shared/package-files/42/42c36250bcb1e409d8f50890c312c3c4e1d60322860b29d6336d943976bae5ef/blob @@ -0,0 +1,36 @@ +#pragma once + +#include +#include +#include + +namespace at::cuda::detail { + +TORCH_CUDA_CU_API bool maybeOverlappingIndices(const at::TensorBase &t); +using at::native::canUse32BitIndexMath; + +template +TensorInfo +getTensorInfo(const at::TensorBase &t) { + IndexType sz[MAX_TENSORINFO_DIMS]; + IndexType st[MAX_TENSORINFO_DIMS]; + + int dims = t.dim(); + for (int i = 0; i < dims; ++i) { + sz[i] = t.size(i); + st[i] = t.stride(i); + } + + scalar* data_ptr = nullptr; + + if constexpr (std::is_const::value) { + data_ptr = t.const_data_ptr(); + } else { + data_ptr = t.mutable_data_ptr(); + } + + return TensorInfo( + data_ptr, dims, sz, st); +} + +} // namespace at::cuda::detail diff --git a/shared/package-files/42/42c3857585b16db2f8ffd47ba19faa60f473340de8d4fe9320ea7be861605906/blob b/shared/package-files/42/42c3857585b16db2f8ffd47ba19faa60f473340de8d4fe9320ea7be861605906/blob new file mode 100644 index 0000000000000000000000000000000000000000..0aea4c3d43e504dafabc031d7ca9cbe8db46163c Binary files /dev/null and b/shared/package-files/42/42c3857585b16db2f8ffd47ba19faa60f473340de8d4fe9320ea7be861605906/blob differ diff --git a/shared/package-files/42/42c5c2abcc858ac5d3bc6f1f8304158a313ee39db243aa30493a5f3ce3366795/blob b/shared/package-files/42/42c5c2abcc858ac5d3bc6f1f8304158a313ee39db243aa30493a5f3ce3366795/blob new file mode 100644 index 0000000000000000000000000000000000000000..c4a53702a3bc9cf1fb3b48388027a0cb3f608087 --- /dev/null +++ b/shared/package-files/42/42c5c2abcc858ac5d3bc6f1f8304158a313ee39db243aa30493a5f3ce3366795/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42c5c2abcc858ac5d3bc6f1f8304158a313ee39db243aa30493a5f3ce3366795 +size 187349634 diff --git a/shared/package-files/42/42cac34697bceb82cfdf391006d4dc88ab9be6b698cf78b756bb7f55ede47734/blob b/shared/package-files/42/42cac34697bceb82cfdf391006d4dc88ab9be6b698cf78b756bb7f55ede47734/blob new file mode 100644 index 0000000000000000000000000000000000000000..29d1944323fc3e6141b0cc2bac229ae4a82bec35 --- /dev/null +++ b/shared/package-files/42/42cac34697bceb82cfdf391006d4dc88ab9be6b698cf78b756bb7f55ede47734/blob @@ -0,0 +1,283 @@ +import datetime +from unittest.mock import Mock + +import numpy as np + +import matplotlib.pyplot as plt +from matplotlib.path import Path +from matplotlib.table import CustomCell, Table +from matplotlib.testing.decorators import image_comparison, check_figures_equal +from matplotlib.transforms import Bbox +import matplotlib.units as munits + + +def test_non_square(): + # Check that creating a non-square table works + cellcolors = ['b', 'r'] + plt.table(cellColours=cellcolors) + + +@image_comparison(['table_zorder.png'], remove_text=True) +def test_zorder(): + data = [[66386, 174296], + [58230, 381139]] + + colLabels = ('Freeze', 'Wind') + rowLabels = ['%d year' % x for x in (100, 50)] + + cellText = [] + yoff = np.zeros(len(colLabels)) + for row in reversed(data): + yoff += row + cellText.append(['%1.1f' % (x/1000.0) for x in yoff]) + + t = np.linspace(0, 2*np.pi, 100) + plt.plot(t, np.cos(t), lw=4, zorder=2) + + plt.table(cellText=cellText, + rowLabels=rowLabels, + colLabels=colLabels, + loc='center', + zorder=-2, + ) + + plt.table(cellText=cellText, + rowLabels=rowLabels, + colLabels=colLabels, + loc='upper center', + zorder=4, + ) + plt.yticks([]) + + +@image_comparison(['table_labels.png']) +def test_label_colours(): + dim = 3 + + c = np.linspace(0, 1, dim) + colours = plt.cm.RdYlGn(c) + cellText = [['1'] * dim] * dim + + fig = plt.figure() + + ax1 = fig.add_subplot(4, 1, 1) + ax1.axis('off') + ax1.table(cellText=cellText, + rowColours=colours, + loc='best') + + ax2 = fig.add_subplot(4, 1, 2) + ax2.axis('off') + ax2.table(cellText=cellText, + rowColours=colours, + rowLabels=['Header'] * dim, + loc='best') + + ax3 = fig.add_subplot(4, 1, 3) + ax3.axis('off') + ax3.table(cellText=cellText, + colColours=colours, + loc='best') + + ax4 = fig.add_subplot(4, 1, 4) + ax4.axis('off') + ax4.table(cellText=cellText, + colColours=colours, + colLabels=['Header'] * dim, + loc='best') + + +@image_comparison(['table_cell_manipulation.png'], style='mpl20') +def test_diff_cell_table(text_placeholders): + cells = ('horizontal', 'vertical', 'open', 'closed', 'T', 'R', 'B', 'L') + cellText = [['1'] * len(cells)] * 2 + colWidths = [0.1] * len(cells) + + _, axs = plt.subplots(nrows=len(cells), figsize=(4, len(cells)+1), layout='tight') + for ax, cell in zip(axs, cells): + ax.table( + colWidths=colWidths, + cellText=cellText, + loc='center', + edges=cell, + ) + ax.axis('off') + + +def test_customcell(): + types = ('horizontal', 'vertical', 'open', 'closed', 'T', 'R', 'B', 'L') + codes = ( + (Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO, Path.MOVETO), + (Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO), + (Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO), + (Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY), + (Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO), + (Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO, Path.MOVETO), + (Path.MOVETO, Path.LINETO, Path.MOVETO, Path.MOVETO, Path.MOVETO), + (Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.LINETO), + ) + + for t, c in zip(types, codes): + cell = CustomCell((0, 0), visible_edges=t, width=1, height=1) + code = tuple(s for _, s in cell.get_path().iter_segments()) + assert c == code + + +@image_comparison(['table_auto_column.png']) +def test_auto_column(): + fig, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1) + + # iterable list input + ax1.axis('off') + tb1 = ax1.table( + cellText=[['Fit Text', 2], + ['very long long text, Longer text than default', 1]], + rowLabels=["A", "B"], + colLabels=["Col1", "Col2"], + loc="center") + tb1.auto_set_font_size(False) + tb1.set_fontsize(12) + tb1.auto_set_column_width([-1, 0, 1]) + + # iterable tuple input + ax2.axis('off') + tb2 = ax2.table( + cellText=[['Fit Text', 2], + ['very long long text, Longer text than default', 1]], + rowLabels=["A", "B"], + colLabels=["Col1", "Col2"], + loc="center") + tb2.auto_set_font_size(False) + tb2.set_fontsize(12) + tb2.auto_set_column_width((-1, 0, 1)) + + # 3 single inputs + ax3.axis('off') + tb3 = ax3.table( + cellText=[['Fit Text', 2], + ['very long long text, Longer text than default', 1]], + rowLabels=["A", "B"], + colLabels=["Col1", "Col2"], + loc="center") + tb3.auto_set_font_size(False) + tb3.set_fontsize(12) + tb3.auto_set_column_width(-1) + tb3.auto_set_column_width(0) + tb3.auto_set_column_width(1) + + # 4 this used to test non-integer iterable input, which did nothing, but only + # remains to avoid re-generating the test image. + ax4.axis('off') + tb4 = ax4.table( + cellText=[['Fit Text', 2], + ['very long long text, Longer text than default', 1]], + rowLabels=["A", "B"], + colLabels=["Col1", "Col2"], + loc="center") + tb4.auto_set_font_size(False) + tb4.set_fontsize(12) + + +def test_table_cells(): + fig, ax = plt.subplots() + table = Table(ax) + + cell = table.add_cell(1, 2, 1, 1) + assert isinstance(cell, CustomCell) + assert cell is table[1, 2] + + cell2 = CustomCell((0, 0), 1, 2, visible_edges=None) + table[2, 1] = cell2 + assert table[2, 1] is cell2 + + # make sure getitem support has not broken + # properties and setp + table.properties() + plt.setp(table) + + +@check_figures_equal(extensions=["png"]) +def test_table_bbox(fig_test, fig_ref): + data = [[2, 3], + [4, 5]] + + col_labels = ('Foo', 'Bar') + row_labels = ('Ada', 'Bob') + + cell_text = [[f"{x}" for x in row] for row in data] + + ax_list = fig_test.subplots() + ax_list.table(cellText=cell_text, + rowLabels=row_labels, + colLabels=col_labels, + loc='center', + bbox=[0.1, 0.2, 0.8, 0.6] + ) + + ax_bbox = fig_ref.subplots() + ax_bbox.table(cellText=cell_text, + rowLabels=row_labels, + colLabels=col_labels, + loc='center', + bbox=Bbox.from_extents(0.1, 0.2, 0.9, 0.8) + ) + + +@check_figures_equal(extensions=['png']) +def test_table_unit(fig_test, fig_ref): + # test that table doesn't participate in unit machinery, instead uses repr/str + + class FakeUnit: + def __init__(self, thing): + pass + def __repr__(self): + return "Hello" + + fake_convertor = munits.ConversionInterface() + # v, u, a = value, unit, axis + fake_convertor.convert = Mock(side_effect=lambda v, u, a: 0) + # not used, here for completeness + fake_convertor.default_units = Mock(side_effect=lambda v, a: None) + fake_convertor.axisinfo = Mock(side_effect=lambda u, a: munits.AxisInfo()) + + munits.registry[FakeUnit] = fake_convertor + + data = [[FakeUnit("yellow"), FakeUnit(42)], + [FakeUnit(datetime.datetime(1968, 8, 1)), FakeUnit(True)]] + + fig_test.subplots().table(data) + fig_ref.subplots().table([["Hello", "Hello"], ["Hello", "Hello"]]) + fig_test.canvas.draw() + fake_convertor.convert.assert_not_called() + + munits.registry.pop(FakeUnit) + assert not munits.registry.get_converter(FakeUnit) + + +def test_table_dataframe(pd): + # Test if Pandas Data Frame can be passed in cellText + + data = { + 'Letter': ['A', 'B', 'C'], + 'Number': [100, 200, 300] + } + + df = pd.DataFrame(data) + fig, ax = plt.subplots() + table = ax.table(df, loc='center') + + for r, (index, row) in enumerate(df.iterrows()): + for c, col in enumerate(df.columns if r == 0 else row.values): + assert table[r if r == 0 else r+1, c].get_text().get_text() == str(col) + + +def test_table_fontsize(): + # Test that the passed fontsize propagates to cells + tableData = [['a', 1], ['b', 2]] + fig, ax = plt.subplots() + test_fontsize = 20 + t = ax.table(cellText=tableData, loc='top', fontsize=test_fontsize) + cell_fontsize = t[(0, 0)].get_fontsize() + assert cell_fontsize == test_fontsize, f"Actual:{test_fontsize},got:{cell_fontsize}" + cell_fontsize = t[(1, 1)].get_fontsize() + assert cell_fontsize == test_fontsize, f"Actual:{test_fontsize},got:{cell_fontsize}" diff --git a/shared/package-files/42/42cdd0425d166264e7918136a2f4f174b7aee8362758efcea1498bc0d0d9cd2c/blob b/shared/package-files/42/42cdd0425d166264e7918136a2f4f174b7aee8362758efcea1498bc0d0d9cd2c/blob new file mode 100644 index 0000000000000000000000000000000000000000..f39561a1c5035fed52add5e49476d0eea91bdae0 --- /dev/null +++ b/shared/package-files/42/42cdd0425d166264e7918136a2f4f174b7aee8362758efcea1498bc0d0d9cd2c/blob @@ -0,0 +1,300 @@ +"""Tests for useful utilities for higher level polynomial classes. """ + +from sympy.core.mul import Mul +from sympy.core.numbers import (Integer, pi) +from sympy.core.relational import Eq +from sympy.core.singleton import S +from sympy.core.symbol import (Symbol, symbols) +from sympy.functions.elementary.exponential import exp +from sympy.functions.elementary.miscellaneous import sqrt +from sympy.functions.elementary.trigonometric import (cos, sin) +from sympy.integrals.integrals import Integral +from sympy.testing.pytest import raises + +from sympy.polys.polyutils import ( + _nsort, + _sort_gens, + _unify_gens, + _analyze_gens, + _sort_factors, + parallel_dict_from_expr, + dict_from_expr, +) + +from sympy.polys.polyerrors import PolynomialError + +from sympy.polys.domains import ZZ + +x, y, z, p, q, r, s, t, u, v, w = symbols('x,y,z,p,q,r,s,t,u,v,w') +A, B = symbols('A,B', commutative=False) + + +def test__nsort(): + # issue 6137 + r = S('''[3/2 + sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) - 4/sqrt(-7/3 + + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3)) - + 61/(18*(-415/216 + 13*I/12)**(1/3)))/2 - sqrt(-7/3 + 61/(18*(-415/216 + + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3))/2, 3/2 - sqrt(-7/3 + + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + + 13*I/12)**(1/3))/2 - sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) - + 4/sqrt(-7/3 + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + + 13*I/12)**(1/3)) - 61/(18*(-415/216 + 13*I/12)**(1/3)))/2, 3/2 + + sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) + 4/sqrt(-7/3 + + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3)) - + 61/(18*(-415/216 + 13*I/12)**(1/3)))/2 + sqrt(-7/3 + 61/(18*(-415/216 + + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3))/2, 3/2 + sqrt(-7/3 + + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + + 13*I/12)**(1/3))/2 - sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) + + 4/sqrt(-7/3 + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + + 13*I/12)**(1/3)) - 61/(18*(-415/216 + 13*I/12)**(1/3)))/2]''') + ans = [r[1], r[0], r[-1], r[-2]] + assert _nsort(r) == ans + assert len(_nsort(r, separated=True)[0]) == 0 + b, c, a = exp(-1000), exp(-999), exp(-1001) + assert _nsort((b, c, a)) == [a, b, c] + # issue 12560 + a = cos(1)**2 + sin(1)**2 - 1 + assert _nsort([a]) == [a] + + +def test__sort_gens(): + assert _sort_gens([]) == () + + assert _sort_gens([x]) == (x,) + assert _sort_gens([p]) == (p,) + assert _sort_gens([q]) == (q,) + + assert _sort_gens([x, p]) == (x, p) + assert _sort_gens([p, x]) == (x, p) + assert _sort_gens([q, p]) == (p, q) + + assert _sort_gens([q, p, x]) == (x, p, q) + + assert _sort_gens([x, p, q], wrt=x) == (x, p, q) + assert _sort_gens([x, p, q], wrt=p) == (p, x, q) + assert _sort_gens([x, p, q], wrt=q) == (q, x, p) + + assert _sort_gens([x, p, q], wrt='x') == (x, p, q) + assert _sort_gens([x, p, q], wrt='p') == (p, x, q) + assert _sort_gens([x, p, q], wrt='q') == (q, x, p) + + assert _sort_gens([x, p, q], wrt='x,q') == (x, q, p) + assert _sort_gens([x, p, q], wrt='q,x') == (q, x, p) + assert _sort_gens([x, p, q], wrt='p,q') == (p, q, x) + assert _sort_gens([x, p, q], wrt='q,p') == (q, p, x) + + assert _sort_gens([x, p, q], wrt='x, q') == (x, q, p) + assert _sort_gens([x, p, q], wrt='q, x') == (q, x, p) + assert _sort_gens([x, p, q], wrt='p, q') == (p, q, x) + assert _sort_gens([x, p, q], wrt='q, p') == (q, p, x) + + assert _sort_gens([x, p, q], wrt=[x, 'q']) == (x, q, p) + assert _sort_gens([x, p, q], wrt=[q, 'x']) == (q, x, p) + assert _sort_gens([x, p, q], wrt=[p, 'q']) == (p, q, x) + assert _sort_gens([x, p, q], wrt=[q, 'p']) == (q, p, x) + + assert _sort_gens([x, p, q], wrt=['x', 'q']) == (x, q, p) + assert _sort_gens([x, p, q], wrt=['q', 'x']) == (q, x, p) + assert _sort_gens([x, p, q], wrt=['p', 'q']) == (p, q, x) + assert _sort_gens([x, p, q], wrt=['q', 'p']) == (q, p, x) + + assert _sort_gens([x, p, q], sort='x > p > q') == (x, p, q) + assert _sort_gens([x, p, q], sort='p > x > q') == (p, x, q) + assert _sort_gens([x, p, q], sort='p > q > x') == (p, q, x) + + assert _sort_gens([x, p, q], wrt='x', sort='q > p') == (x, q, p) + assert _sort_gens([x, p, q], wrt='p', sort='q > x') == (p, q, x) + assert _sort_gens([x, p, q], wrt='q', sort='p > x') == (q, p, x) + + # https://github.com/sympy/sympy/issues/19353 + n1 = Symbol('\n1') + assert _sort_gens([n1]) == (n1,) + assert _sort_gens([x, n1]) == (x, n1) + + X = symbols('x0,x1,x2,x10,x11,x12,x20,x21,x22') + + assert _sort_gens(X) == X + + +def test__unify_gens(): + assert _unify_gens([], []) == () + + assert _unify_gens([x], [x]) == (x,) + assert _unify_gens([y], [y]) == (y,) + + assert _unify_gens([x, y], [x]) == (x, y) + assert _unify_gens([x], [x, y]) == (x, y) + + assert _unify_gens([x, y], [x, y]) == (x, y) + assert _unify_gens([y, x], [y, x]) == (y, x) + + assert _unify_gens([x], [y]) == (x, y) + assert _unify_gens([y], [x]) == (y, x) + + assert _unify_gens([x], [y, x]) == (y, x) + assert _unify_gens([y, x], [x]) == (y, x) + + assert _unify_gens([x, y, z], [x, y, z]) == (x, y, z) + assert _unify_gens([z, y, x], [x, y, z]) == (z, y, x) + assert _unify_gens([x, y, z], [z, y, x]) == (x, y, z) + assert _unify_gens([z, y, x], [z, y, x]) == (z, y, x) + + assert _unify_gens([x, y, z], [t, x, p, q, z]) == (t, x, y, p, q, z) + + +def test__analyze_gens(): + assert _analyze_gens((x, y, z)) == (x, y, z) + assert _analyze_gens([x, y, z]) == (x, y, z) + + assert _analyze_gens(([x, y, z],)) == (x, y, z) + assert _analyze_gens(((x, y, z),)) == (x, y, z) + + +def test__sort_factors(): + assert _sort_factors([], multiple=True) == [] + assert _sort_factors([], multiple=False) == [] + + F = [[1, 2, 3], [1, 2], [1]] + G = [[1], [1, 2], [1, 2, 3]] + + assert _sort_factors(F, multiple=False) == G + + F = [[1, 2], [1, 2, 3], [1, 2], [1]] + G = [[1], [1, 2], [1, 2], [1, 2, 3]] + + assert _sort_factors(F, multiple=False) == G + + F = [[2, 2], [1, 2, 3], [1, 2], [1]] + G = [[1], [1, 2], [2, 2], [1, 2, 3]] + + assert _sort_factors(F, multiple=False) == G + + F = [([1, 2, 3], 1), ([1, 2], 1), ([1], 1)] + G = [([1], 1), ([1, 2], 1), ([1, 2, 3], 1)] + + assert _sort_factors(F, multiple=True) == G + + F = [([1, 2], 1), ([1, 2, 3], 1), ([1, 2], 1), ([1], 1)] + G = [([1], 1), ([1, 2], 1), ([1, 2], 1), ([1, 2, 3], 1)] + + assert _sort_factors(F, multiple=True) == G + + F = [([2, 2], 1), ([1, 2, 3], 1), ([1, 2], 1), ([1], 1)] + G = [([1], 1), ([1, 2], 1), ([2, 2], 1), ([1, 2, 3], 1)] + + assert _sort_factors(F, multiple=True) == G + + F = [([2, 2], 1), ([1, 2, 3], 1), ([1, 2], 2), ([1], 1)] + G = [([1], 1), ([2, 2], 1), ([1, 2], 2), ([1, 2, 3], 1)] + + assert _sort_factors(F, multiple=True) == G + + +def test__dict_from_expr_if_gens(): + assert dict_from_expr( + Integer(17), gens=(x,)) == ({(0,): Integer(17)}, (x,)) + assert dict_from_expr( + Integer(17), gens=(x, y)) == ({(0, 0): Integer(17)}, (x, y)) + assert dict_from_expr( + Integer(17), gens=(x, y, z)) == ({(0, 0, 0): Integer(17)}, (x, y, z)) + + assert dict_from_expr( + Integer(-17), gens=(x,)) == ({(0,): Integer(-17)}, (x,)) + assert dict_from_expr( + Integer(-17), gens=(x, y)) == ({(0, 0): Integer(-17)}, (x, y)) + assert dict_from_expr(Integer( + -17), gens=(x, y, z)) == ({(0, 0, 0): Integer(-17)}, (x, y, z)) + + assert dict_from_expr( + Integer(17)*x, gens=(x,)) == ({(1,): Integer(17)}, (x,)) + assert dict_from_expr( + Integer(17)*x, gens=(x, y)) == ({(1, 0): Integer(17)}, (x, y)) + assert dict_from_expr(Integer( + 17)*x, gens=(x, y, z)) == ({(1, 0, 0): Integer(17)}, (x, y, z)) + + assert dict_from_expr( + Integer(17)*x**7, gens=(x,)) == ({(7,): Integer(17)}, (x,)) + assert dict_from_expr( + Integer(17)*x**7*y, gens=(x, y)) == ({(7, 1): Integer(17)}, (x, y)) + assert dict_from_expr(Integer(17)*x**7*y*z**12, gens=( + x, y, z)) == ({(7, 1, 12): Integer(17)}, (x, y, z)) + + assert dict_from_expr(x + 2*y + 3*z, gens=(x,)) == \ + ({(1,): Integer(1), (0,): 2*y + 3*z}, (x,)) + assert dict_from_expr(x + 2*y + 3*z, gens=(x, y)) == \ + ({(1, 0): Integer(1), (0, 1): Integer(2), (0, 0): 3*z}, (x, y)) + assert dict_from_expr(x + 2*y + 3*z, gens=(x, y, z)) == \ + ({(1, 0, 0): Integer( + 1), (0, 1, 0): Integer(2), (0, 0, 1): Integer(3)}, (x, y, z)) + + assert dict_from_expr(x*y + 2*x*z + 3*y*z, gens=(x,)) == \ + ({(1,): y + 2*z, (0,): 3*y*z}, (x,)) + assert dict_from_expr(x*y + 2*x*z + 3*y*z, gens=(x, y)) == \ + ({(1, 1): Integer(1), (1, 0): 2*z, (0, 1): 3*z}, (x, y)) + assert dict_from_expr(x*y + 2*x*z + 3*y*z, gens=(x, y, z)) == \ + ({(1, 1, 0): Integer( + 1), (1, 0, 1): Integer(2), (0, 1, 1): Integer(3)}, (x, y, z)) + + assert dict_from_expr(2**y*x, gens=(x,)) == ({(1,): 2**y}, (x,)) + assert dict_from_expr(Integral(x, (x, 1, 2)) + x) == ( + {(0, 1): 1, (1, 0): 1}, (x, Integral(x, (x, 1, 2)))) + raises(PolynomialError, lambda: dict_from_expr(2**y*x, gens=(x, y))) + + +def test__dict_from_expr_no_gens(): + assert dict_from_expr(Integer(17)) == ({(): Integer(17)}, ()) + + assert dict_from_expr(x) == ({(1,): Integer(1)}, (x,)) + assert dict_from_expr(y) == ({(1,): Integer(1)}, (y,)) + + assert dict_from_expr(x*y) == ({(1, 1): Integer(1)}, (x, y)) + assert dict_from_expr( + x + y) == ({(1, 0): Integer(1), (0, 1): Integer(1)}, (x, y)) + + assert dict_from_expr(sqrt(2)) == ({(1,): Integer(1)}, (sqrt(2),)) + assert dict_from_expr(sqrt(2), greedy=False) == ({(): sqrt(2)}, ()) + + assert dict_from_expr(x*y, domain=ZZ[x]) == ({(1,): x}, (y,)) + assert dict_from_expr(x*y, domain=ZZ[y]) == ({(1,): y}, (x,)) + + assert dict_from_expr(3*sqrt( + 2)*pi*x*y, extension=None) == ({(1, 1, 1, 1): 3}, (x, y, pi, sqrt(2))) + assert dict_from_expr(3*sqrt( + 2)*pi*x*y, extension=True) == ({(1, 1, 1): 3*sqrt(2)}, (x, y, pi)) + + assert dict_from_expr(3*sqrt( + 2)*pi*x*y, extension=True) == ({(1, 1, 1): 3*sqrt(2)}, (x, y, pi)) + + f = cos(x)*sin(x) + cos(x)*sin(y) + cos(y)*sin(x) + cos(y)*sin(y) + + assert dict_from_expr(f) == ({(0, 1, 0, 1): 1, (0, 1, 1, 0): 1, + (1, 0, 0, 1): 1, (1, 0, 1, 0): 1}, (cos(x), cos(y), sin(x), sin(y))) + + +def test__parallel_dict_from_expr_if_gens(): + assert parallel_dict_from_expr([x + 2*y + 3*z, Integer(7)], gens=(x,)) == \ + ([{(1,): Integer(1), (0,): 2*y + 3*z}, {(0,): Integer(7)}], (x,)) + + +def test__parallel_dict_from_expr_no_gens(): + assert parallel_dict_from_expr([x*y, Integer(3)]) == \ + ([{(1, 1): Integer(1)}, {(0, 0): Integer(3)}], (x, y)) + assert parallel_dict_from_expr([x*y, 2*z, Integer(3)]) == \ + ([{(1, 1, 0): Integer( + 1)}, {(0, 0, 1): Integer(2)}, {(0, 0, 0): Integer(3)}], (x, y, z)) + assert parallel_dict_from_expr((Mul(x, x**2, evaluate=False),)) == \ + ([{(3,): 1}], (x,)) + + +def test_parallel_dict_from_expr(): + assert parallel_dict_from_expr([Eq(x, 1), Eq( + x**2, 2)]) == ([{(0,): -Integer(1), (1,): Integer(1)}, + {(0,): -Integer(2), (2,): Integer(1)}], (x,)) + raises(PolynomialError, lambda: parallel_dict_from_expr([A*B - B*A])) + + +def test_dict_from_expr(): + assert dict_from_expr(Eq(x, 1)) == \ + ({(0,): -Integer(1), (1,): Integer(1)}, (x,)) + raises(PolynomialError, lambda: dict_from_expr(A*B - B*A)) + raises(PolynomialError, lambda: dict_from_expr(S.true)) diff --git a/shared/package-files/42/42ce594346326e1b3d8cd4fea61c914e6e1264b197112a820eada94d41022609/blob b/shared/package-files/42/42ce594346326e1b3d8cd4fea61c914e6e1264b197112a820eada94d41022609/blob new file mode 100644 index 0000000000000000000000000000000000000000..fd3a1d44caf0941417c7f1b9c9d122e4c77a0336 --- /dev/null +++ b/shared/package-files/42/42ce594346326e1b3d8cd4fea61c914e6e1264b197112a820eada94d41022609/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API empty_strided { + using schema = at::Tensor (c10::SymIntArrayRef, c10::SymIntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::empty_strided") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "empty_strided(SymInt[] size, SymInt[] stride, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor") + static at::Tensor call(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +}; + +struct TORCH_API empty_strided_out { + using schema = at::Tensor & (c10::SymIntArrayRef, c10::SymIntArrayRef, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::empty_strided") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "empty_strided.out(SymInt[] size, SymInt[] stride, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/42/42cf224dd64557e7d427094be7ae18395c17df0bbb849c9bf7ab8f238d7628ff/blob b/shared/package-files/42/42cf224dd64557e7d427094be7ae18395c17df0bbb849c9bf7ab8f238d7628ff/blob new file mode 100644 index 0000000000000000000000000000000000000000..8775c6faa5e7589f7c4d068930067774a9b3b706 --- /dev/null +++ b/shared/package-files/42/42cf224dd64557e7d427094be7ae18395c17df0bbb849c9bf7ab8f238d7628ff/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42cf224dd64557e7d427094be7ae18395c17df0bbb849c9bf7ab8f238d7628ff +size 1245008 diff --git a/shared/package-files/42/42cf7abd3afc1994b25425ae6a6cdc36554c45ad79bedd18f93db2652526fd00/blob b/shared/package-files/42/42cf7abd3afc1994b25425ae6a6cdc36554c45ad79bedd18f93db2652526fd00/blob new file mode 100644 index 0000000000000000000000000000000000000000..605c80483b77fd4efa6f48ab8fd1bc6abd12e5a4 --- /dev/null +++ b/shared/package-files/42/42cf7abd3afc1994b25425ae6a6cdc36554c45ad79bedd18f93db2652526fd00/blob @@ -0,0 +1,82 @@ +from os.path import join, sep, dirname + +from numpy.distutils.misc_util import ( + appendpath, minrelpath, gpaths, get_shared_lib_extension, get_info + ) +from numpy.testing import ( + assert_, assert_equal + ) + +ajoin = lambda *paths: join(*((sep,)+paths)) + +class TestAppendpath: + + def test_1(self): + assert_equal(appendpath('prefix', 'name'), join('prefix', 'name')) + assert_equal(appendpath('/prefix', 'name'), ajoin('prefix', 'name')) + assert_equal(appendpath('/prefix', '/name'), ajoin('prefix', 'name')) + assert_equal(appendpath('prefix', '/name'), join('prefix', 'name')) + + def test_2(self): + assert_equal(appendpath('prefix/sub', 'name'), + join('prefix', 'sub', 'name')) + assert_equal(appendpath('prefix/sub', 'sup/name'), + join('prefix', 'sub', 'sup', 'name')) + assert_equal(appendpath('/prefix/sub', '/prefix/name'), + ajoin('prefix', 'sub', 'name')) + + def test_3(self): + assert_equal(appendpath('/prefix/sub', '/prefix/sup/name'), + ajoin('prefix', 'sub', 'sup', 'name')) + assert_equal(appendpath('/prefix/sub/sub2', '/prefix/sup/sup2/name'), + ajoin('prefix', 'sub', 'sub2', 'sup', 'sup2', 'name')) + assert_equal(appendpath('/prefix/sub/sub2', '/prefix/sub/sup/name'), + ajoin('prefix', 'sub', 'sub2', 'sup', 'name')) + +class TestMinrelpath: + + def test_1(self): + n = lambda path: path.replace('/', sep) + assert_equal(minrelpath(n('aa/bb')), n('aa/bb')) + assert_equal(minrelpath('..'), '..') + assert_equal(minrelpath(n('aa/..')), '') + assert_equal(minrelpath(n('aa/../bb')), 'bb') + assert_equal(minrelpath(n('aa/bb/..')), 'aa') + assert_equal(minrelpath(n('aa/bb/../..')), '') + assert_equal(minrelpath(n('aa/bb/../cc/../dd')), n('aa/dd')) + assert_equal(minrelpath(n('.././..')), n('../..')) + assert_equal(minrelpath(n('aa/bb/.././../dd')), n('dd')) + +class TestGpaths: + + def test_gpaths(self): + local_path = minrelpath(join(dirname(__file__), '..')) + ls = gpaths('command/*.py', local_path) + assert_(join(local_path, 'command', 'build_src.py') in ls, repr(ls)) + f = gpaths('system_info.py', local_path) + assert_(join(local_path, 'system_info.py') == f[0], repr(f)) + +class TestSharedExtension: + + def test_get_shared_lib_extension(self): + import sys + ext = get_shared_lib_extension(is_python_ext=False) + if sys.platform.startswith('linux'): + assert_equal(ext, '.so') + elif sys.platform.startswith('gnukfreebsd'): + assert_equal(ext, '.so') + elif sys.platform.startswith('darwin'): + assert_equal(ext, '.dylib') + elif sys.platform.startswith('win'): + assert_equal(ext, '.dll') + # just check for no crash + assert_(get_shared_lib_extension(is_python_ext=True)) + + +def test_installed_npymath_ini(): + # Regression test for gh-7707. If npymath.ini wasn't installed, then this + # will give an error. + info = get_info('npymath') + + assert isinstance(info, dict) + assert "define_macros" in info diff --git a/shared/package-files/42/42d01cfab3e8728ef13ae932e912e631a7e9ccf2acc6e77d2c4802180121f608/blob b/shared/package-files/42/42d01cfab3e8728ef13ae932e912e631a7e9ccf2acc6e77d2c4802180121f608/blob new file mode 100644 index 0000000000000000000000000000000000000000..527843fe42f0b79eac46802a12d17e5f5b1b222c --- /dev/null +++ b/shared/package-files/42/42d01cfab3e8728ef13ae932e912e631a7e9ccf2acc6e77d2c4802180121f608/blob @@ -0,0 +1,463 @@ +"""This module contains the _EstimatorPrettyPrinter class used in +BaseEstimator.__repr__ for pretty-printing estimators""" + +# Authors: The scikit-learn developers +# SPDX-License-Identifier: BSD-3-Clause + +# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +# 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 Python Software Foundation; +# All Rights Reserved + +# Authors: Fred L. Drake, Jr. (built-in CPython pprint module) +# Nicolas Hug (scikit-learn specific changes) + +# License: PSF License version 2 (see below) + +# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 +# -------------------------------------------- + +# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), +# and the Individual or Organization ("Licensee") accessing and otherwise +# using this software ("Python") in source or binary form and its associated +# documentation. + +# 2. Subject to the terms and conditions of this License Agreement, PSF hereby +# grants Licensee a nonexclusive, royalty-free, world-wide license to +# reproduce, analyze, test, perform and/or display publicly, prepare +# derivative works, distribute, and otherwise use Python alone or in any +# derivative version, provided, however, that PSF's License Agreement and +# PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, +# 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, +# 2017, 2018 Python Software Foundation; All Rights Reserved" are retained in +# Python alone or in any derivative version prepared by Licensee. + +# 3. In the event Licensee prepares a derivative work that is based on or +# incorporates Python or any part thereof, and wants to make the derivative +# work available to others as provided herein, then Licensee hereby agrees to +# include in any such work a brief summary of the changes made to Python. + +# 4. PSF is making Python available to Licensee on an "AS IS" basis. PSF MAKES +# NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT +# NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF +# PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. + +# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY +# INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF +# MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE +# THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +# 6. This License Agreement will automatically terminate upon a material +# breach of its terms and conditions. + +# 7. Nothing in this License Agreement shall be deemed to create any +# relationship of agency, partnership, or joint venture between PSF and +# Licensee. This License Agreement does not grant permission to use PSF +# trademarks or trade name in a trademark sense to endorse or promote products +# or services of Licensee, or any third party. + +# 8. By copying, installing or otherwise using Python, Licensee agrees to be +# bound by the terms and conditions of this License Agreement. + + +# Brief summary of changes to original code: +# - "compact" parameter is supported for dicts, not just lists or tuples +# - estimators have a custom handler, they're not just treated as objects +# - long sequences (lists, tuples, dict items) with more than N elements are +# shortened using ellipsis (', ...') at the end. + +import inspect +import pprint + +from .._config import get_config +from ..base import BaseEstimator +from ._missing import is_scalar_nan + + +class KeyValTuple(tuple): + """Dummy class for correctly rendering key-value tuples from dicts.""" + + def __repr__(self): + # needed for _dispatch[tuple.__repr__] not to be overridden + return super().__repr__() + + +class KeyValTupleParam(KeyValTuple): + """Dummy class for correctly rendering key-value tuples from parameters.""" + + pass + + +def _changed_params(estimator): + """Return dict (param_name: value) of parameters that were given to + estimator with non-default values.""" + + params = estimator.get_params(deep=False) + init_func = getattr(estimator.__init__, "deprecated_original", estimator.__init__) + init_params = inspect.signature(init_func).parameters + init_params = {name: param.default for name, param in init_params.items()} + + def has_changed(k, v): + if k not in init_params: # happens if k is part of a **kwargs + return True + if init_params[k] == inspect._empty: # k has no default value + return True + # try to avoid calling repr on nested estimators + if isinstance(v, BaseEstimator) and v.__class__ != init_params[k].__class__: + return True + # Use repr as a last resort. It may be expensive. + if repr(v) != repr(init_params[k]) and not ( + is_scalar_nan(init_params[k]) and is_scalar_nan(v) + ): + return True + return False + + return {k: v for k, v in params.items() if has_changed(k, v)} + + +class _EstimatorPrettyPrinter(pprint.PrettyPrinter): + """Pretty Printer class for estimator objects. + + This extends the pprint.PrettyPrinter class, because: + - we need estimators to be printed with their parameters, e.g. + Estimator(param1=value1, ...) which is not supported by default. + - the 'compact' parameter of PrettyPrinter is ignored for dicts, which + may lead to very long representations that we want to avoid. + + Quick overview of pprint.PrettyPrinter (see also + https://stackoverflow.com/questions/49565047/pprint-with-hex-numbers): + + - the entry point is the _format() method which calls format() (overridden + here) + - format() directly calls _safe_repr() for a first try at rendering the + object + - _safe_repr formats the whole object recursively, only calling itself, + not caring about line length or anything + - back to _format(), if the output string is too long, _format() then calls + the appropriate _pprint_TYPE() method (e.g. _pprint_list()) depending on + the type of the object. This where the line length and the compact + parameters are taken into account. + - those _pprint_TYPE() methods will internally use the format() method for + rendering the nested objects of an object (e.g. the elements of a list) + + In the end, everything has to be implemented twice: in _safe_repr and in + the custom _pprint_TYPE methods. Unfortunately PrettyPrinter is really not + straightforward to extend (especially when we want a compact output), so + the code is a bit convoluted. + + This class overrides: + - format() to support the changed_only parameter + - _safe_repr to support printing of estimators (for when they fit on a + single line) + - _format_dict_items so that dict are correctly 'compacted' + - _format_items so that ellipsis is used on long lists and tuples + + When estimators cannot be printed on a single line, the builtin _format() + will call _pprint_estimator() because it was registered to do so (see + _dispatch[BaseEstimator.__repr__] = _pprint_estimator). + + both _format_dict_items() and _pprint_estimator() use the + _format_params_or_dict_items() method that will format parameters and + key-value pairs respecting the compact parameter. This method needs another + subroutine _pprint_key_val_tuple() used when a parameter or a key-value + pair is too long to fit on a single line. This subroutine is called in + _format() and is registered as well in the _dispatch dict (just like + _pprint_estimator). We had to create the two classes KeyValTuple and + KeyValTupleParam for this. + """ + + def __init__( + self, + indent=1, + width=80, + depth=None, + stream=None, + *, + compact=False, + indent_at_name=True, + n_max_elements_to_show=None, + ): + super().__init__(indent, width, depth, stream, compact=compact) + self._indent_at_name = indent_at_name + if self._indent_at_name: + self._indent_per_level = 1 # ignore indent param + self._changed_only = get_config()["print_changed_only"] + # Max number of elements in a list, dict, tuple until we start using + # ellipsis. This also affects the number of arguments of an estimators + # (they are treated as dicts) + self.n_max_elements_to_show = n_max_elements_to_show + + def format(self, object, context, maxlevels, level): + return _safe_repr( + object, context, maxlevels, level, changed_only=self._changed_only + ) + + def _pprint_estimator(self, object, stream, indent, allowance, context, level): + stream.write(object.__class__.__name__ + "(") + if self._indent_at_name: + indent += len(object.__class__.__name__) + + if self._changed_only: + params = _changed_params(object) + else: + params = object.get_params(deep=False) + + self._format_params( + sorted(params.items()), stream, indent, allowance + 1, context, level + ) + stream.write(")") + + def _format_dict_items(self, items, stream, indent, allowance, context, level): + return self._format_params_or_dict_items( + items, stream, indent, allowance, context, level, is_dict=True + ) + + def _format_params(self, items, stream, indent, allowance, context, level): + return self._format_params_or_dict_items( + items, stream, indent, allowance, context, level, is_dict=False + ) + + def _format_params_or_dict_items( + self, object, stream, indent, allowance, context, level, is_dict + ): + """Format dict items or parameters respecting the compact=True + parameter. For some reason, the builtin rendering of dict items doesn't + respect compact=True and will use one line per key-value if all cannot + fit in a single line. + Dict items will be rendered as <'key': value> while params will be + rendered as . The implementation is mostly copy/pasting from + the builtin _format_items(). + This also adds ellipsis if the number of items is greater than + self.n_max_elements_to_show. + """ + write = stream.write + indent += self._indent_per_level + delimnl = ",\n" + " " * indent + delim = "" + width = max_width = self._width - indent + 1 + it = iter(object) + try: + next_ent = next(it) + except StopIteration: + return + last = False + n_items = 0 + while not last: + if n_items == self.n_max_elements_to_show: + write(", ...") + break + n_items += 1 + ent = next_ent + try: + next_ent = next(it) + except StopIteration: + last = True + max_width -= allowance + width -= allowance + if self._compact: + k, v = ent + krepr = self._repr(k, context, level) + vrepr = self._repr(v, context, level) + if not is_dict: + krepr = krepr.strip("'") + middle = ": " if is_dict else "=" + rep = krepr + middle + vrepr + w = len(rep) + 2 + if width < w: + width = max_width + if delim: + delim = delimnl + if width >= w: + width -= w + write(delim) + delim = ", " + write(rep) + continue + write(delim) + delim = delimnl + class_ = KeyValTuple if is_dict else KeyValTupleParam + self._format( + class_(ent), stream, indent, allowance if last else 1, context, level + ) + + def _format_items(self, items, stream, indent, allowance, context, level): + """Format the items of an iterable (list, tuple...). Same as the + built-in _format_items, with support for ellipsis if the number of + elements is greater than self.n_max_elements_to_show. + """ + write = stream.write + indent += self._indent_per_level + if self._indent_per_level > 1: + write((self._indent_per_level - 1) * " ") + delimnl = ",\n" + " " * indent + delim = "" + width = max_width = self._width - indent + 1 + it = iter(items) + try: + next_ent = next(it) + except StopIteration: + return + last = False + n_items = 0 + while not last: + if n_items == self.n_max_elements_to_show: + write(", ...") + break + n_items += 1 + ent = next_ent + try: + next_ent = next(it) + except StopIteration: + last = True + max_width -= allowance + width -= allowance + if self._compact: + rep = self._repr(ent, context, level) + w = len(rep) + 2 + if width < w: + width = max_width + if delim: + delim = delimnl + if width >= w: + width -= w + write(delim) + delim = ", " + write(rep) + continue + write(delim) + delim = delimnl + self._format(ent, stream, indent, allowance if last else 1, context, level) + + def _pprint_key_val_tuple(self, object, stream, indent, allowance, context, level): + """Pretty printing for key-value tuples from dict or parameters.""" + k, v = object + rep = self._repr(k, context, level) + if isinstance(object, KeyValTupleParam): + rep = rep.strip("'") + middle = "=" + else: + middle = ": " + stream.write(rep) + stream.write(middle) + self._format( + v, stream, indent + len(rep) + len(middle), allowance, context, level + ) + + # Note: need to copy _dispatch to prevent instances of the builtin + # PrettyPrinter class to call methods of _EstimatorPrettyPrinter (see issue + # 12906) + # mypy error: "Type[PrettyPrinter]" has no attribute "_dispatch" + _dispatch = pprint.PrettyPrinter._dispatch.copy() # type: ignore[attr-defined] + _dispatch[BaseEstimator.__repr__] = _pprint_estimator + _dispatch[KeyValTuple.__repr__] = _pprint_key_val_tuple + + +def _safe_repr(object, context, maxlevels, level, changed_only=False): + """Same as the builtin _safe_repr, with added support for Estimator + objects.""" + typ = type(object) + + if typ in pprint._builtin_scalars: + return repr(object), True, False + + r = getattr(typ, "__repr__", None) + if issubclass(typ, dict) and r is dict.__repr__: + if not object: + return "{}", True, False + objid = id(object) + if maxlevels and level >= maxlevels: + return "{...}", False, objid in context + if objid in context: + return pprint._recursion(object), False, True + context[objid] = 1 + readable = True + recursive = False + components = [] + append = components.append + level += 1 + saferepr = _safe_repr + items = sorted(object.items(), key=pprint._safe_tuple) + for k, v in items: + krepr, kreadable, krecur = saferepr( + k, context, maxlevels, level, changed_only=changed_only + ) + vrepr, vreadable, vrecur = saferepr( + v, context, maxlevels, level, changed_only=changed_only + ) + append("%s: %s" % (krepr, vrepr)) + readable = readable and kreadable and vreadable + if krecur or vrecur: + recursive = True + del context[objid] + return "{%s}" % ", ".join(components), readable, recursive + + if (issubclass(typ, list) and r is list.__repr__) or ( + issubclass(typ, tuple) and r is tuple.__repr__ + ): + if issubclass(typ, list): + if not object: + return "[]", True, False + format = "[%s]" + elif len(object) == 1: + format = "(%s,)" + else: + if not object: + return "()", True, False + format = "(%s)" + objid = id(object) + if maxlevels and level >= maxlevels: + return format % "...", False, objid in context + if objid in context: + return pprint._recursion(object), False, True + context[objid] = 1 + readable = True + recursive = False + components = [] + append = components.append + level += 1 + for o in object: + orepr, oreadable, orecur = _safe_repr( + o, context, maxlevels, level, changed_only=changed_only + ) + append(orepr) + if not oreadable: + readable = False + if orecur: + recursive = True + del context[objid] + return format % ", ".join(components), readable, recursive + + if issubclass(typ, BaseEstimator): + objid = id(object) + if maxlevels and level >= maxlevels: + return f"{typ.__name__}(...)", False, objid in context + if objid in context: + return pprint._recursion(object), False, True + context[objid] = 1 + readable = True + recursive = False + if changed_only: + params = _changed_params(object) + else: + params = object.get_params(deep=False) + components = [] + append = components.append + level += 1 + saferepr = _safe_repr + items = sorted(params.items(), key=pprint._safe_tuple) + for k, v in items: + krepr, kreadable, krecur = saferepr( + k, context, maxlevels, level, changed_only=changed_only + ) + vrepr, vreadable, vrecur = saferepr( + v, context, maxlevels, level, changed_only=changed_only + ) + append("%s=%s" % (krepr.strip("'"), vrepr)) + readable = readable and kreadable and vreadable + if krecur or vrecur: + recursive = True + del context[objid] + return ("%s(%s)" % (typ.__name__, ", ".join(components)), readable, recursive) + + rep = repr(object) + return rep, (rep and not rep.startswith("<")), False diff --git a/shared/package-files/42/42d492d7577ebe456fa9a204789ea8370c844f508aa3242a8e57c1976b133890/blob b/shared/package-files/42/42d492d7577ebe456fa9a204789ea8370c844f508aa3242a8e57c1976b133890/blob new file mode 100644 index 0000000000000000000000000000000000000000..deeac955e65ffaf55838568baa54951efaf2662b --- /dev/null +++ b/shared/package-files/42/42d492d7577ebe456fa9a204789ea8370c844f508aa3242a8e57c1976b133890/blob @@ -0,0 +1,249 @@ +NIST/ITL StRD +Dataset Name: SmLs07 (SmLs07.dat) + + +File Format: ASCII + Certified Values (lines 41 to 47) + Data (lines 61 to 249) + + +Procedure: Analysis of Variance + + +Reference: Simon, Stephen D. and Lesage, James P. (1989). + "Assessing the Accuracy of ANOVA Calculations in + Statistical Software". + Computational Statistics & Data Analysis, 8, pp. 325-332. + + +Data: 1 Factor + 9 Treatments + 21 Replicates/Cell + 189 Observations + 13 Constant Leading Digits + Higher Level of Difficulty + Generated Data + + +Model: 10 Parameters (mu,tau_1, ... , tau_9) + y_{ij} = mu + tau_i + epsilon_{ij} + + + + + + +Certified Values: + +Source of Sums of Mean +Variation df Squares Squares F Statistic + +Between Treatment 8 1.68000000000000E+00 2.10000000000000E-01 2.10000000000000E+01 +Within Treatment 180 1.80000000000000E+00 1.00000000000000E-02 + + Certified R-Squared 4.82758620689655E-01 + + Certified Residual + Standard Deviation 1.00000000000000E-01 + + + + + + + + + + + + +Data: Treatment Response + 1 1000000000000.4 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 1 1000000000000.3 + 1 1000000000000.5 + 2 1000000000000.3 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 2 1000000000000.2 + 2 1000000000000.4 + 3 1000000000000.5 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 3 1000000000000.4 + 3 1000000000000.6 + 4 1000000000000.3 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 4 1000000000000.2 + 4 1000000000000.4 + 5 1000000000000.5 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 5 1000000000000.4 + 5 1000000000000.6 + 6 1000000000000.3 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 6 1000000000000.2 + 6 1000000000000.4 + 7 1000000000000.5 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 7 1000000000000.4 + 7 1000000000000.6 + 8 1000000000000.3 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 8 1000000000000.2 + 8 1000000000000.4 + 9 1000000000000.5 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 + 9 1000000000000.4 + 9 1000000000000.6 diff --git a/shared/package-files/42/42d4c80382381361c362972f737592c3fe26fde04d93e665711bc6a6c22ddd9d/blob b/shared/package-files/42/42d4c80382381361c362972f737592c3fe26fde04d93e665711bc6a6c22ddd9d/blob new file mode 100644 index 0000000000000000000000000000000000000000..54fb21d32b125d3cb780d2c073591bb0a7679d6e --- /dev/null +++ b/shared/package-files/42/42d4c80382381361c362972f737592c3fe26fde04d93e665711bc6a6c22ddd9d/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor _pad_circular(const at::Tensor & self, at::IntArrayRef pad); +TORCH_API at::Tensor _pad_circular_symint(const at::Tensor & self, c10::SymIntArrayRef pad); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/42/42d588123dc7c5de18c7978ddffb380556e29cbfc7c790747c9eb150af7b27fc/blob b/shared/package-files/42/42d588123dc7c5de18c7978ddffb380556e29cbfc7c790747c9eb150af7b27fc/blob new file mode 100644 index 0000000000000000000000000000000000000000..5dcb3d7a1ff8e9862527ecf83b1b38bfd2297d15 --- /dev/null +++ b/shared/package-files/42/42d588123dc7c5de18c7978ddffb380556e29cbfc7c790747c9eb150af7b27fc/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API argmin { + using schema = at::Tensor (const at::Tensor &, c10::optional, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::argmin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "argmin(Tensor self, int? dim=None, bool keepdim=False) -> Tensor") + static at::Tensor call(const at::Tensor & self, c10::optional dim, bool keepdim); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::optional dim, bool keepdim); +}; + +struct TORCH_API argmin_out { + using schema = at::Tensor & (const at::Tensor &, c10::optional, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::argmin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "argmin.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, c10::optional dim, bool keepdim, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::optional dim, bool keepdim, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/42/42d5a4d8d3eec0f0a5d1abf372110273ea9f717d6626723c0d840d495e21c17d/blob b/shared/package-files/42/42d5a4d8d3eec0f0a5d1abf372110273ea9f717d6626723c0d840d495e21c17d/blob new file mode 100644 index 0000000000000000000000000000000000000000..9e04af997bf9e2a61405a51e8de1b763ad2c25ce --- /dev/null +++ b/shared/package-files/42/42d5a4d8d3eec0f0a5d1abf372110273ea9f717d6626723c0d840d495e21c17d/blob @@ -0,0 +1,2561 @@ +""" +Testing numba implementation of the numba dictionary. + +The tests here only check that the numba typing and codegen are working +correctly. Detailed testing of the underlying dictionary operations is done +in test_dictimpl.py. +""" + +import sys +import warnings + +import numpy as np + +from numba import njit, literally +from numba import int32, int64, float32, float64 +from numba import typeof +from numba.typed import Dict, dictobject, List +from numba.typed.typedobjectutils import _sentry_safe_cast +from numba.core.errors import TypingError +from numba.core import types +from numba.tests.support import (TestCase, MemoryLeakMixin, unittest, + override_config, forbid_codegen) +from numba.experimental import jitclass +from numba.extending import overload + + +class TestDictObject(MemoryLeakMixin, TestCase): + def test_dict_bool(self): + """ + Exercise bool(dict) + """ + @njit + def foo(n): + d = dictobject.new_dict(int32, float32) + for i in range(n): + d[i] = i + 1 + return bool(d) + + # Insert nothing + self.assertEqual(foo(n=0), False) + # Insert 1 entry + self.assertEqual(foo(n=1), True) + # Insert 2 entries + self.assertEqual(foo(n=2), True) + # Insert 100 entries + self.assertEqual(foo(n=100), True) + + def test_dict_create(self): + """ + Exercise dictionary creation, insertion and len + """ + @njit + def foo(n): + d = dictobject.new_dict(int32, float32) + for i in range(n): + d[i] = i + 1 + return len(d) + + # Insert nothing + self.assertEqual(foo(n=0), 0) + # Insert 1 entry + self.assertEqual(foo(n=1), 1) + # Insert 2 entries + self.assertEqual(foo(n=2), 2) + # Insert 100 entries + self.assertEqual(foo(n=100), 100) + + def test_dict_get(self): + """ + Exercise dictionary creation, insertion and get + """ + @njit + def foo(n, targets): + d = dictobject.new_dict(int32, float64) + # insertion loop + for i in range(n): + d[i] = i + # retrieval loop + output = [] + for t in targets: + output.append(d.get(t)) + return output + + self.assertEqual(foo(5, [0, 1, 9]), [0, 1, None]) + self.assertEqual(foo(10, [0, 1, 9]), [0, 1, 9]) + self.assertEqual(foo(10, [-1, 9, 1]), [None, 9, 1]) + + def test_dict_get_with_default(self): + """ + Exercise dict.get(k, d) where d is set + """ + @njit + def foo(n, target, default): + d = dictobject.new_dict(int32, float64) + # insertion loop + for i in range(n): + d[i] = i + # retrieval loop + return d.get(target, default) + + self.assertEqual(foo(5, 3, -1), 3) + self.assertEqual(foo(5, 5, -1), -1) + + def test_dict_getitem(self): + """ + Exercise dictionary __getitem__ + """ + @njit + def foo(keys, vals, target): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + + # lookup + return d[target] + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + self.assertEqual(foo(keys, vals, 1), 0.1) + self.assertEqual(foo(keys, vals, 2), 0.2) + self.assertEqual(foo(keys, vals, 3), 0.3) + # check no leak so far + self.assert_no_memory_leak() + # disable leak check for exception test + self.disable_leak_check() + with self.assertRaisesRegex(KeyError, "0"): + foo(keys, vals, 0) + with self.assertRaisesRegex(KeyError, "4"): + foo(keys, vals, 4) + + def test_dict_popitem(self): + """ + Exercise dictionary .popitem + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + + # popitem + return d.popitem() + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + for i in range(1, len(keys)): + self.assertEqual( + foo(keys[:i], vals[:i]), + (keys[i - 1], vals[i - 1]), + ) + + def test_dict_popitem_many(self): + """ + Exercise dictionary .popitem + """ + + @njit + def core(d, npop): + # popitem + keysum, valsum = 0, 0 + for _ in range(npop): + k, v = d.popitem() + keysum += k + valsum -= v + return keysum, valsum + + @njit + def foo(keys, vals, npop): + d = dictobject.new_dict(int32, int32) + # insertion + for k, v in zip(keys, vals): + d[k] = v + + return core(d, npop) + + keys = [1, 2, 3] + vals = [10, 20, 30] + + for i in range(len(keys)): + self.assertEqual( + foo(keys, vals, npop=3), + core.py_func(dict(zip(keys, vals)), npop=3), + ) + + # check no leak so far + self.assert_no_memory_leak() + # disable leak check for exception test + self.disable_leak_check() + + with self.assertRaises(KeyError): + foo(keys, vals, npop=4) + + def test_dict_pop(self): + """ + Exercise dictionary .pop + """ + @njit + def foo(keys, vals, target): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + + # popitem + return d.pop(target, None), len(d) + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual(foo(keys, vals, 1), (0.1, 2)) + self.assertEqual(foo(keys, vals, 2), (0.2, 2)) + self.assertEqual(foo(keys, vals, 3), (0.3, 2)) + self.assertEqual(foo(keys, vals, 0), (None, 3)) + + # check no leak so far + self.assert_no_memory_leak() + # disable leak check for exception test + self.disable_leak_check() + + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # popitem + return d.pop(0) + + with self.assertRaises(KeyError): + foo() + + def test_dict_pop_many(self): + """ + Exercise dictionary .pop + """ + + @njit + def core(d, pops): + total = 0 + for k in pops: + total += k + d.pop(k, 0.123) + len(d) + total *= 2 + return total + + @njit + def foo(keys, vals, pops): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + # popitem + return core(d, pops) + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + pops = [2, 3, 3, 1, 0, 2, 1, 0, -1] + + self.assertEqual( + foo(keys, vals, pops), + core.py_func(dict(zip(keys, vals)), pops), + ) + + def test_dict_delitem(self): + @njit + def foo(keys, vals, target): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + del d[target] + return len(d), d.get(target) + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + self.assertEqual(foo(keys, vals, 1), (2, None)) + self.assertEqual(foo(keys, vals, 2), (2, None)) + self.assertEqual(foo(keys, vals, 3), (2, None)) + # check no leak so far + self.assert_no_memory_leak() + # disable leak check for exception test + self.disable_leak_check() + with self.assertRaises(KeyError): + foo(keys, vals, 0) + + def test_dict_clear(self): + """ + Exercise dict.clear + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + b4 = len(d) + # clear + d.clear() + return b4, len(d) + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + self.assertEqual(foo(keys, vals), (3, 0)) + + def test_dict_items(self): + """ + Exercise dict.items + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + out = [] + for kv in d.items(): + out.append(kv) + return out + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual( + foo(keys, vals), + list(zip(keys, vals)), + ) + + # Test .items() on empty dict + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + out = [] + for kv in d.items(): + out.append(kv) + return out + + self.assertEqual(foo(), []) + + def test_dict_keys(self): + """ + Exercise dict.keys + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + out = [] + for k in d.keys(): + out.append(k) + return out + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual( + foo(keys, vals), + keys, + ) + + def test_dict_keys_len(self): + """ + Exercise len(dict.keys()) + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + return len(d.keys()) + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual( + foo(keys, vals), + len(keys), + ) + + def test_dict_values(self): + """ + Exercise dict.values + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + out = [] + for v in d.values(): + out.append(v) + return out + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual( + foo(keys, vals), + vals, + ) + + def test_dict_values_len(self): + """ + Exercise len(dict.values()) + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + return len(d.values()) + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual( + foo(keys, vals), + len(vals), + ) + + def test_dict_items_len(self): + """ + Exercise len(dict.items()) + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + return len(d.items()) + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + self.assertPreciseEqual( + foo(keys, vals), + len(vals), + ) + + def test_dict_iter(self): + """ + Exercise iter(dict) + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + out = [] + for k in d: + out.append(k) + return out + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual( + foo(keys, vals), + [1, 2, 3] + ) + + def test_dict_contains(self): + """ + Exercise operator.contains + """ + @njit + def foo(keys, vals, checklist): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + out = [] + for k in checklist: + out.append(k in d) + return out + + keys = [1, 2, 3] + vals = [0.1, 0.2, 0.3] + + self.assertEqual( + foo(keys, vals, [2, 3, 4, 1, 0]), + [True, True, False, True, False], + ) + + def test_dict_copy(self): + """ + Exercise dict.copy + """ + @njit + def foo(keys, vals): + d = dictobject.new_dict(int32, float64) + # insertion + for k, v in zip(keys, vals): + d[k] = v + return list(d.copy().items()) + + keys = list(range(20)) + vals = [x + i / 100 for i, x in enumerate(keys)] + out = foo(keys, vals) + self.assertEqual(out, list(zip(keys, vals))) + + def test_dict_setdefault(self): + """ + Exercise dict.setdefault + """ + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + d.setdefault(1, 1.2) # used because key is not in + a = d.get(1) + d[1] = 2.3 + b = d.get(1) + d[2] = 3.4 + d.setdefault(2, 4.5) # not used because key is in + c = d.get(2) + return a, b, c + + self.assertEqual(foo(), (1.2, 2.3, 3.4)) + + def test_dict_equality(self): + """ + Exercise dict.__eq__ and .__ne__ + """ + @njit + def foo(na, nb, fa, fb): + da = dictobject.new_dict(int32, float64) + db = dictobject.new_dict(int32, float64) + for i in range(na): + da[i] = i * fa + for i in range(nb): + db[i] = i * fb + return da == db, da != db + + # Same keys and values + self.assertEqual(foo(10, 10, 3, 3), (True, False)) + # Same keys and diff values + self.assertEqual(foo(10, 10, 3, 3.1), (False, True)) + # LHS has more keys + self.assertEqual(foo(11, 10, 3, 3), (False, True)) + # RHS has more keys + self.assertEqual(foo(10, 11, 3, 3), (False, True)) + + def test_dict_equality_more(self): + """ + Exercise dict.__eq__ + """ + @njit + def foo(ak, av, bk, bv): + # The key-value types are different in the two dictionaries + da = dictobject.new_dict(int32, float64) + db = dictobject.new_dict(int64, float32) + for i in range(len(ak)): + da[ak[i]] = av[i] + for i in range(len(bk)): + db[bk[i]] = bv[i] + return da == db + + # Simple equal case + ak = [1, 2, 3] + av = [2, 3, 4] + bk = [1, 2, 3] + bv = [2, 3, 4] + self.assertTrue(foo(ak, av, bk, bv)) + + # Equal with replacement + ak = [1, 2, 3] + av = [2, 3, 4] + bk = [1, 2, 2, 3] + bv = [2, 1, 3, 4] + self.assertTrue(foo(ak, av, bk, bv)) + + # Diff values + ak = [1, 2, 3] + av = [2, 3, 4] + bk = [1, 2, 3] + bv = [2, 1, 4] + self.assertFalse(foo(ak, av, bk, bv)) + + # Diff keys + ak = [0, 2, 3] + av = [2, 3, 4] + bk = [1, 2, 3] + bv = [2, 3, 4] + self.assertFalse(foo(ak, av, bk, bv)) + + def test_dict_equality_diff_type(self): + """ + Exercise dict.__eq__ + """ + @njit + def foo(na, b): + da = dictobject.new_dict(int32, float64) + for i in range(na): + da[i] = i + return da == b + + # dict != int + self.assertFalse(foo(10, 1)) + # dict != tuple[int] + self.assertFalse(foo(10, (1,))) + + def test_dict_to_from_meminfo(self): + """ + Exercise dictobject.{_as_meminfo, _from_meminfo} + """ + @njit + def make_content(nelem): + for i in range(nelem): + yield i, i + (i + 1) / 100 + + @njit + def boxer(nelem): + d = dictobject.new_dict(int32, float64) + for k, v in make_content(nelem): + d[k] = v + return dictobject._as_meminfo(d) + + dcttype = types.DictType(int32, float64) + + @njit + def unboxer(mi): + d = dictobject._from_meminfo(mi, dcttype) + return list(d.items()) + + mi = boxer(10) + self.assertEqual(mi.refcount, 1) + + got = unboxer(mi) + expected = list(make_content.py_func(10)) + self.assertEqual(got, expected) + + def test_001_cannot_downcast_key(self): + @njit + def foo(n): + d = dictobject.new_dict(int32, float64) + for i in range(n): + d[i] = i + 1 + # bad key type + z = d.get(1j) + return z + + with self.assertRaises(TypingError) as raises: + foo(10) + self.assertIn( + 'cannot safely cast complex128 to int32', + str(raises.exception), + ) + + def test_002_cannot_downcast_default(self): + @njit + def foo(n): + d = dictobject.new_dict(int32, float64) + for i in range(n): + d[i] = i + 1 + # bad default type + z = d.get(2 * n, 1j) + return z + + with self.assertRaises(TypingError) as raises: + foo(10) + self.assertIn( + 'cannot safely cast complex128 to float64', + str(raises.exception), + ) + + def test_003_cannot_downcast_key(self): + @njit + def foo(n): + d = dictobject.new_dict(int32, float64) + for i in range(n): + d[i] = i + 1 + # bad cast!? + z = d.get(2.4) + return z + + # should raise + with self.assertRaises(TypingError) as raises: + foo(10) + self.assertIn( + 'cannot safely cast float64 to int32', + str(raises.exception), + ) + + def test_004_cannot_downcast_key(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # should raise TypingError + d[1j] = 7. + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + 'cannot safely cast complex128 to int32', + str(raises.exception), + ) + + def test_005_cannot_downcast_value(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # should raise TypingError + d[1] = 1j + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + 'cannot safely cast complex128 to float64', + str(raises.exception), + ) + + def test_006_cannot_downcast_key(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # raise TypingError + d[11.5] + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + 'cannot safely cast float64 to int32', + str(raises.exception), + ) + + @unittest.skipUnless(sys.maxsize > 2 ** 32, "64 bit test only") + def test_007_collision_checks(self): + # this checks collisions in real life for 64bit systems + @njit + def foo(v1, v2): + d = dictobject.new_dict(int64, float64) + c1 = np.uint64(2 ** 61 - 1) + c2 = np.uint64(0) + assert hash(c1) == hash(c2) + d[c1] = v1 + d[c2] = v2 + return (d[c1], d[c2]) + + a, b = 10., 20. + x, y = foo(a, b) + self.assertEqual(x, a) + self.assertEqual(y, b) + + def test_008_lifo_popitem(self): + # check that (keys, vals) are LIFO .popitem() + @njit + def foo(n): + d = dictobject.new_dict(int32, float64) + for i in range(n): + d[i] = i + 1 + keys = [] + vals = [] + for i in range(n): + tmp = d.popitem() + keys.append(tmp[0]) + vals.append(tmp[1]) + return keys, vals + + z = 10 + gk, gv = foo(z) + + self.assertEqual(gk, [x for x in reversed(range(z))]) + self.assertEqual(gv, [x + 1 for x in reversed(range(z))]) + + def test_010_cannot_downcast_default(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + d[0] = 6. + d[1] = 7. + # pop'd default must have same type as value + d.pop(11, 12j) + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + "cannot safely cast complex128 to float64", + str(raises.exception), + ) + + def test_011_cannot_downcast_key(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + d[0] = 6. + d[1] = 7. + # pop'd key must have same type as key + d.pop(11j) + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + "cannot safely cast complex128 to int32", + str(raises.exception), + ) + + def test_012_cannot_downcast_key(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + d[0] = 6. + # invalid key type + return 1j in d + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + "cannot safely cast complex128 to int32", + str(raises.exception), + ) + + def test_013_contains_empty_dict(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # contains on empty dict + return 1 in d + + self.assertFalse(foo()) + + def test_014_not_contains_empty_dict(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # not contains empty dict + return 1 not in d + + self.assertTrue(foo()) + + def test_015_dict_clear(self): + @njit + def foo(n): + d = dictobject.new_dict(int32, float64) + for i in range(n): + d[i] = i + 1 + x = len(d) + d.clear() + y = len(d) + return x, y + + m = 10 + self.assertEqual(foo(m), (m, 0)) + + def test_016_cannot_downcast_key(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # key is wrong type + d.setdefault(1j, 12.) + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + "cannot safely cast complex128 to int32", + str(raises.exception), + ) + + def test_017_cannot_downcast_default(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + # default value is wrong type + d.setdefault(1, 12.j) + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + "cannot safely cast complex128 to float64", + str(raises.exception), + ) + + def test_018_keys_iter_are_views(self): + # this is broken somewhere in llvmlite, intent of test is to check if + # keys behaves like a view or not + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + d[11] = 12. + k1 = d.keys() + d[22] = 9. + k2 = d.keys() + rk1 = [x for x in k1] + rk2 = [x for x in k2] + return rk1, rk2 + + a, b = foo() + self.assertEqual(a, b) + self.assertEqual(a, [11, 22]) + + # Not implemented yet + @unittest.expectedFailure + def test_019(self): + # should keys/vals be set-like? + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + d[11] = 12. + d[22] = 9. + k2 = d.keys() & {12, } + return k2 + + print(foo()) + + def test_020_string_key(self): + @njit + def foo(): + d = dictobject.new_dict(types.unicode_type, float64) + d['a'] = 1. + d['b'] = 2. + d['c'] = 3. + d['d'] = 4. + out = [] + for x in d.items(): + out.append(x) + return out, d['a'] + + items, da = foo() + self.assertEqual(items, [('a', 1.), ('b', 2.), ('c', 3.), ('d', 4)]) + self.assertEqual(da, 1.) + + def test_021_long_str_key(self): + @njit + def foo(): + d = dictobject.new_dict(types.unicode_type, float64) + tmp = [] + for i in range(10000): + tmp.append('a') + s = ''.join(tmp) + d[s] = 1. + out = list(d.items()) + return out + self.assertEqual(foo(), [('a' * 10000, 1)]) + + def test_022_references_juggle(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + e = d + d[1] = 12. + e[2] = 14. + e = dictobject.new_dict(int32, float64) + e[1] = 100. + e[2] = 1000. + f = d + d = e + + k1 = [x for x in d.items()] + k2 = [x for x in e.items()] + k3 = [x for x in f.items()] + + return k1, k2, k3 + + k1, k2, k3 = foo() + self.assertEqual(k1, [(1, 100.0), (2, 1000.0)]) + self.assertEqual(k2, [(1, 100.0), (2, 1000.0)]) + self.assertEqual(k3, [(1, 12), (2, 14)]) + + def test_023_closure(self): + @njit + def foo(): + d = dictobject.new_dict(int32, float64) + + def bar(): + d[1] = 12. + d[2] = 14. + bar() + return [x for x in d.keys()] + + self.assertEqual(foo(), [1, 2]) + + def test_024_unicode_getitem_keys(self): + # See issue #6135 + @njit + def foo(): + s = 'a\u1234' + d = {s[0] : 1} + return d['a'] + + self.assertEqual(foo(), foo.py_func()) + + @njit + def foo(): + s = 'abc\u1234' + d = {s[:1] : 1} + return d['a'] + + self.assertEqual(foo(), foo.py_func()) + + def test_issue6570_alignment_padding(self): + # Create a key type that is 12-bytes long on a 8-byte aligned system + # so that the a 4-byte padding is needed. + # If the 4-byte padding is not zero-filled, it will have garbage data + # that affects key matching in the lookup. + keyty = types.Tuple([types.uint64, types.float32]) + + @njit + def foo(): + d = dictobject.new_dict(keyty, float64) + t1 = np.array([3], dtype=np.uint64) + t2 = np.array([5.67], dtype=np.float32) + v1 = np.array([10.23], dtype=np.float32) + d[(t1[0], t2[0])] = v1[0] + return (t1[0], t2[0]) in d + + self.assertTrue(foo()) + + def test_dict_update(self): + """ + Tests dict.update works with various dictionaries. + """ + n = 10 + + def f1(n): + """ + Test update with a regular dictionary. + """ + d1 = {i: i + 1 for i in range(n)} + d2 = {3 * i: i for i in range(n)} + d1.update(d2) + return d1 + + py_func = f1 + cfunc = njit()(f1) + a = py_func(n) + b = cfunc(n) + self.assertEqual(a, b) + + def f2(n): + """ + Test update where one of the dictionaries + is created as a Python literal. + """ + d1 = { + 1: 2, + 3: 4, + 5: 6 + } + d2 = {3 * i: i for i in range(n)} + d1.update(d2) + return d1 + + py_func = f2 + cfunc = njit()(f2) + a = py_func(n) + b = cfunc(n) + self.assertEqual(a, b) + + +class TestDictTypeCasting(TestCase): + def check_good(self, fromty, toty): + _sentry_safe_cast(fromty, toty) + + def check_bad(self, fromty, toty): + with self.assertRaises(TypingError) as raises: + _sentry_safe_cast(fromty, toty) + self.assertIn( + 'cannot safely cast {fromty} to {toty}'.format(**locals()), + str(raises.exception), + ) + + def test_cast_int_to(self): + self.check_good(types.int32, types.float32) + self.check_good(types.int32, types.float64) + self.check_good(types.int32, types.complex128) + self.check_good(types.int64, types.complex128) + self.check_bad(types.int32, types.complex64) + self.check_good(types.int8, types.complex64) + + def test_cast_float_to(self): + self.check_good(types.float32, types.float64) + self.check_good(types.float32, types.complex64) + self.check_good(types.float64, types.complex128) + + def test_cast_bool_to(self): + self.check_good(types.boolean, types.int32) + self.check_good(types.boolean, types.float64) + self.check_good(types.boolean, types.complex128) + + +class TestTypedDict(MemoryLeakMixin, TestCase): + def test_basic(self): + d = Dict.empty(int32, float32) + # len + self.assertEqual(len(d), 0) + # setitems + d[1] = 1 + d[2] = 2.3 + d[3] = 3.4 + self.assertEqual(len(d), 3) + # keys + self.assertEqual(list(d.keys()), [1, 2, 3]) + # values + for x, y in zip(list(d.values()), [1, 2.3, 3.4]): + self.assertAlmostEqual(x, y, places=4) + # getitem + self.assertAlmostEqual(d[1], 1) + self.assertAlmostEqual(d[2], 2.3, places=4) + self.assertAlmostEqual(d[3], 3.4, places=4) + # deltiem + del d[2] + self.assertEqual(len(d), 2) + # get + self.assertIsNone(d.get(2)) + # setdefault + d.setdefault(2, 100) + d.setdefault(3, 200) + self.assertEqual(d[2], 100) + self.assertAlmostEqual(d[3], 3.4, places=4) + # update + d.update({4: 5, 5: 6}) + self.assertAlmostEqual(d[4], 5) + self.assertAlmostEqual(d[5], 6) + # contains + self.assertTrue(4 in d) + # items + pyd = dict(d.items()) + self.assertEqual(len(pyd), len(d)) + # pop + self.assertAlmostEqual(d.pop(4), 5) + # popitem + nelem = len(d) + k, v = d.popitem() + self.assertEqual(len(d), nelem - 1) + self.assertTrue(k not in d) + # __eq__ & copy + copied = d.copy() + self.assertEqual(copied, d) + self.assertEqual(list(copied.items()), list(d.items())) + + def test_copy_from_dict(self): + expect = {k: float(v) for k, v in zip(range(10), range(10, 20))} + nbd = Dict.empty(int32, float64) + for k, v in expect.items(): + nbd[k] = v + got = dict(nbd) + self.assertEqual(got, expect) + + def test_compiled(self): + @njit + def producer(): + d = Dict.empty(int32, float64) + d[1] = 1.23 + return d + + @njit + def consumer(d): + return d[1] + + d = producer() + val = consumer(d) + self.assertEqual(val, 1.23) + + def test_gh7908(self): + d = Dict.empty( + key_type=types.Tuple([types.uint32, + types.uint32]), + value_type=int64) + + d[(1, 1)] = 12345 + self.assertEqual(d[(1, 1)], d.get((1, 1))) + + def check_stringify(self, strfn, prefix=False): + nbd = Dict.empty(int32, int32) + d = {} + nbd[1] = 2 + d[1] = 2 + checker = self.assertIn if prefix else self.assertEqual + checker(strfn(d), strfn(nbd)) + nbd[2] = 3 + d[2] = 3 + checker(strfn(d), strfn(nbd)) + for i in range(10, 20): + nbd[i] = i + 1 + d[i] = i + 1 + checker(strfn(d), strfn(nbd)) + if prefix: + self.assertTrue(strfn(nbd).startswith('DictType')) + + def test_repr(self): + self.check_stringify(repr, prefix=True) + + def test_str(self): + self.check_stringify(str) + + +class DictIterableCtor: + + def test_iterable_type_constructor(self): + # https://docs.python.org/3/library/stdtypes.html#dict + @njit + def func1(a, b): + d = Dict(zip(a, b)) + return d + + @njit + def func2(a_, b): + a = range(3) + return Dict(zip(a, b)) + + @njit + def func3(a_, b): + a = [0, 1, 2] + return Dict(zip(a, b)) + + @njit + def func4(a, b): + c = zip(a, b) + return Dict(zip(a, zip(c, a))) + + @njit + def func5(a, b): + return Dict(zip(zip(a, b), b)) + + @njit + def func6(items): + return Dict(items) + + @njit + def func7(k, v): + return Dict({k: v}) # mapping - not supported + + @njit + def func8(k, v): + d = Dict() + d[k] = v + return d + + def _get_dict(py_dict): + d = Dict() + for k, v in py_dict.items(): + d[k] = v + return d + + vals = ( + (func1, [(0, 1, 2), 'abc'], _get_dict({0: 'a', 1: 'b', 2: 'c'})), + (func2, [(0, 1, 2), 'abc'], _get_dict({0: 'a', 1: 'b', 2: 'c'})), + (func3, [(0, 1, 2), 'abc'], _get_dict({0: 'a', 1: 'b', 2: 'c'})), + (func4, [(0, 1, 2), 'abc'], _get_dict( + {0: ((0, 'a'), 0), 1: ((1, 'b'), 1), 2: ((2, 'c'), 2)})), + (func5, [(0, 1, 2), 'abc'], _get_dict( + {(0, 'a'): 'a', (1, 'b'): 'b', (2, 'c'): 'c'})), + # (func6, [(),], Dict({})), + (func6, [((1, 'a'), (3, 'b')),], _get_dict({1: 'a', 3: 'b'})), + (func1, ['key', _get_dict({1: 'abc'})], _get_dict({'k': 1})), + (func8, ['key', _get_dict({1: 'abc'})], _get_dict( + {'key': _get_dict({1: 'abc'})})), + (func8, ['key', List([1, 2, 3])], _get_dict( + {'key': List([1, 2, 3])})), + ) + + for func, args, expected in vals: + if self.jit_enabled: + got = func(*args) + else: + got = func.py_func(*args) + self.assertPreciseEqual(expected, got) + + +class TestDictIterableCtorJit(TestCase, DictIterableCtor): + + def setUp(self): + self.jit_enabled = True + + def test_exception_no_iterable_arg(self): + @njit + def ctor(): + return Dict(3) + + msg = ".*No implementation of function.*" + with self.assertRaisesRegex(TypingError, msg): + ctor() + + def test_exception_dict_mapping(self): + @njit + def ctor(): + return Dict({1: 2, 3: 4}) + + msg = ".*No implementation of function.*" + with self.assertRaisesRegex(TypingError, msg): + ctor() + + def test_exception_setitem(self): + @njit + def ctor(): + return Dict(((1, 'a'), (2, 'b', 3))) + + msg = ".*No implementation of function.*" + with self.assertRaisesRegex(TypingError, msg): + ctor() + + +class TestDictIterableCtorNoJit(TestCase, DictIterableCtor): + + def setUp(self): + self.jit_enabled = False + + def test_exception_nargs(self): + msg = 'Dict expect at most 1 argument, got 2' + with self.assertRaisesRegex(TypingError, msg): + Dict(1, 2) + + def test_exception_mapping_ctor(self): + msg = r'.*dict\(mapping\) is not supported.*' # noqa: W605 + with self.assertRaisesRegex(TypingError, msg): + Dict({1: 2}) + + def test_exception_non_iterable_arg(self): + msg = '.*object is not iterable.*' + with self.assertRaisesRegex(TypingError, msg): + Dict(3) + + def test_exception_setitem(self): + msg = ".*dictionary update sequence element #1 has length 3.*" + with self.assertRaisesRegex(ValueError, msg): + Dict(((1, 'a'), (2, 'b', 3))) + + +class TestDictRefctTypes(MemoryLeakMixin, TestCase): + + def test_str_key(self): + @njit + def foo(): + d = Dict.empty( + key_type=types.unicode_type, + value_type=types.int32, + ) + d["123"] = 123 + d["321"] = 321 + return d + + d = foo() + self.assertEqual(d['123'], 123) + self.assertEqual(d['321'], 321) + expect = {'123': 123, '321': 321} + self.assertEqual(dict(d), expect) + # Test insert replacement + d['123'] = 231 + expect['123'] = 231 + self.assertEqual(d['123'], 231) + self.assertEqual(dict(d), expect) + # Test dictionary growth + nelem = 100 + for i in range(nelem): + d[str(i)] = i + expect[str(i)] = i + for i in range(nelem): + self.assertEqual(d[str(i)], i) + self.assertEqual(dict(d), expect) + + def test_str_val(self): + @njit + def foo(): + d = Dict.empty( + key_type=types.int32, + value_type=types.unicode_type, + ) + d[123] = "123" + d[321] = "321" + return d + + d = foo() + self.assertEqual(d[123], '123') + self.assertEqual(d[321], '321') + expect = {123: '123', 321: '321'} + self.assertEqual(dict(d), expect) + # Test insert replacement + d[123] = "231" + expect[123] = "231" + self.assertEqual(dict(d), expect) + # Test dictionary growth + nelem = 1 + for i in range(nelem): + d[i] = str(i) + expect[i] = str(i) + for i in range(nelem): + self.assertEqual(d[i], str(i)) + self.assertEqual(dict(d), expect) + + def test_str_key_array_value(self): + np.random.seed(123) + d = Dict.empty( + key_type=types.unicode_type, + value_type=types.float64[:], + ) + expect = [] + expect.append(np.random.random(10)) + d['mass'] = expect[-1] + expect.append(np.random.random(20)) + d['velocity'] = expect[-1] + for i in range(100): + expect.append(np.random.random(i)) + d[str(i)] = expect[-1] + self.assertEqual(len(d), len(expect)) + self.assertPreciseEqual(d['mass'], expect[0]) + self.assertPreciseEqual(d['velocity'], expect[1]) + # Ordering is kept + for got, exp in zip(d.values(), expect): + self.assertPreciseEqual(got, exp) + + # Try deleting + self.assertTrue('mass' in d) + self.assertTrue('velocity' in d) + del d['mass'] + self.assertFalse('mass' in d) + del d['velocity'] + self.assertFalse('velocity' in d) + del expect[0:2] + + for i in range(90): + k, v = d.popitem() + w = expect.pop() + self.assertPreciseEqual(v, w) + + # Trigger a resize + expect.append(np.random.random(10)) + d["last"] = expect[-1] + + # Ordering is kept + for got, exp in zip(d.values(), expect): + self.assertPreciseEqual(got, exp) + + def test_dict_of_dict_int_keyval(self): + def inner_numba_dict(): + d = Dict.empty( + key_type=types.intp, + value_type=types.intp, + ) + return d + + d = Dict.empty( + key_type=types.intp, + value_type=types.DictType(types.intp, types.intp), + ) + + def usecase(d, make_inner_dict): + for i in range(100): + mid = make_inner_dict() + for j in range(i + 1): + mid[j] = j * 10000 + d[i] = mid + return d + + got = usecase(d, inner_numba_dict) + expect = usecase({}, dict) + + self.assertIsInstance(expect, dict) + + self.assertEqual(dict(got), expect) + + # Delete items + for where in [12, 3, 6, 8, 10]: + del got[where] + del expect[where] + self.assertEqual(dict(got), expect) + + def test_dict_of_dict_npm(self): + inner_dict_ty = types.DictType(types.intp, types.intp) + + @njit + def inner_numba_dict(): + d = Dict.empty( + key_type=types.intp, + value_type=types.intp, + ) + return d + + @njit + def foo(count): + d = Dict.empty( + key_type=types.intp, + value_type=inner_dict_ty, + ) + for i in range(count): + d[i] = inner_numba_dict() + for j in range(i + 1): + d[i][j] = j + + return d + + d = foo(100) + ct = 0 + for k, dd in d.items(): + ct += 1 + self.assertEqual(len(dd), k + 1) + for kk, vv in dd.items(): + self.assertEqual(kk, vv) + + self.assertEqual(ct, 100) + + def test_delitem(self): + d = Dict.empty(types.int64, types.unicode_type) + d[1] = 'apple' + + @njit + def foo(x, k): + del x[1] + + foo(d, 1) + self.assertEqual(len(d), 0) + self.assertFalse(d) + + def test_getitem_return_type(self): + # Dict.__getitem__ must return non-optional type. + d = Dict.empty(types.int64, types.int64[:]) + d[1] = np.arange(10, dtype=np.int64) + + @njit + def foo(d): + d[1] += 100 + return d[1] + + foo(d) + # Return type is an array, not optional + retty = foo.nopython_signatures[0].return_type + self.assertIsInstance(retty, types.Array) + self.assertNotIsInstance(retty, types.Optional) + # Value is correctly updated + self.assertPreciseEqual(d[1], np.arange(10, dtype=np.int64) + 100) + + def test_storage_model_mismatch(self): + # https://github.com/numba/numba/issues/4520 + # check for storage model mismatch in refcount ops generation + dct = Dict() + ref = [ + ("a", True, "a"), + ("b", False, "b"), + ("c", False, "c"), + ] + # populate + for x in ref: + dct[x] = x + # test + for i, x in enumerate(ref): + self.assertEqual(dct[x], x) + + +class TestDictForbiddenTypes(TestCase): + def assert_disallow(self, expect, callable): + with self.assertRaises(TypingError) as raises: + callable() + msg = str(raises.exception) + self.assertIn(expect, msg) + + def assert_disallow_key(self, ty): + msg = '{} as key is forbidden'.format(ty) + self.assert_disallow(msg, lambda: Dict.empty(ty, types.intp)) + + @njit + def foo(): + Dict.empty(ty, types.intp) + self.assert_disallow(msg, foo) + + def assert_disallow_value(self, ty): + msg = '{} as value is forbidden'.format(ty) + self.assert_disallow(msg, lambda: Dict.empty(types.intp, ty)) + + @njit + def foo(): + Dict.empty(types.intp, ty) + self.assert_disallow(msg, foo) + + def test_disallow_list(self): + self.assert_disallow_key(types.List(types.intp)) + self.assert_disallow_value(types.List(types.intp)) + + def test_disallow_set(self): + self.assert_disallow_key(types.Set(types.intp)) + self.assert_disallow_value(types.Set(types.intp)) + + +class TestDictInferred(TestCase): + def test_simple_literal(self): + @njit + def foo(): + d = Dict() + d[123] = 321 + return d + + k, v = 123, 321 + d = foo() + self.assertEqual(dict(d), {k: v}) + self.assertEqual(typeof(d).key_type, typeof(k)) + self.assertEqual(typeof(d).value_type, typeof(v)) + + def test_simple_args(self): + @njit + def foo(k, v): + d = Dict() + d[k] = v + return d + + k, v = 123, 321 + d = foo(k, v) + self.assertEqual(dict(d), {k: v}) + self.assertEqual(typeof(d).key_type, typeof(k)) + self.assertEqual(typeof(d).value_type, typeof(v)) + + def test_simple_upcast(self): + @njit + def foo(k, v, w): + d = Dict() + d[k] = v + d[k] = w + return d + + k, v, w = 123, 32.1, 321 + d = foo(k, v, w) + self.assertEqual(dict(d), {k: w}) + self.assertEqual(typeof(d).key_type, typeof(k)) + self.assertEqual(typeof(d).value_type, typeof(v)) + + def test_conflicting_value_type(self): + @njit + def foo(k, v, w): + d = Dict() + d[k] = v + d[k] = w + return d + + k, v, w = 123, 321, 32.1 + with self.assertRaises(TypingError) as raises: + foo(k, v, w) + self.assertIn( + 'cannot safely cast float64 to {}'.format(typeof(v)), + str(raises.exception), + ) + + def test_conflicting_key_type(self): + @njit + def foo(k, h, v): + d = Dict() + d[k] = v + d[h] = v + return d + + k, h, v = 123, 123.1, 321 + with self.assertRaises(TypingError) as raises: + foo(k, h, v) + self.assertIn( + 'cannot safely cast float64 to {}'.format(typeof(v)), + str(raises.exception), + ) + + def test_conflict_key_type_non_number(self): + # Allow non-number types to cast unsafely + @njit + def foo(k1, v1, k2): + d = Dict() + d[k1] = v1 + return d, d[k2] + + # k2 will unsafely downcast typeof(k1) + k1 = (np.int8(1), np.int8(2)) + k2 = (np.int32(1), np.int32(2)) + v1 = np.intp(123) + + with warnings.catch_warnings(record=True) as w: + d, dk2 = foo(k1, v1, k2) + self.assertEqual(len(w), 1) + # Make sure the warning is about unsafe cast + msg = 'unsafe cast from UniTuple(int32 x 2) to UniTuple(int8 x 2)' + self.assertIn(msg, str(w[0])) + + keys = list(d.keys()) + self.assertEqual(keys[0], (1, 2)) + self.assertEqual(dk2, d[(np.int32(1), np.int32(2))]) + + def test_ifelse_filled_both_branches(self): + @njit + def foo(k, v): + d = Dict() + if k: + d[k] = v + else: + d[0xdead] = v + 1 + + return d + + k, v = 123, 321 + d = foo(k, v) + self.assertEqual(dict(d), {k: v}) + k, v = 0, 0 + d = foo(k, v) + self.assertEqual(dict(d), {0xdead: v + 1}) + + def test_ifelse_empty_one_branch(self): + @njit + def foo(k, v): + d = Dict() + if k: + d[k] = v + + return d + + k, v = 123, 321 + d = foo(k, v) + self.assertEqual(dict(d), {k: v}) + k, v = 0, 0 + d = foo(k, v) + self.assertEqual(dict(d), {}) + self.assertEqual(typeof(d).key_type, typeof(k)) + self.assertEqual(typeof(d).value_type, typeof(v)) + + def test_loop(self): + @njit + def foo(ks, vs): + d = Dict() + for k, v in zip(ks, vs): + d[k] = v + return d + + vs = list(range(4)) + ks = list(map(lambda x : x + 100, vs)) + d = foo(ks, vs) + self.assertEqual(dict(d), dict(zip(ks, vs))) + + def test_unused(self): + @njit + def foo(): + d = Dict() + return d + + with self.assertRaises(TypingError) as raises: + foo() + self.assertIn( + "imprecise type", + str(raises.exception) + ) + + def test_define_after_use(self): + @njit + def foo(define): + d = Dict() + ct = len(d) + for k, v in d.items(): + ct += v + + if define: + # This will set the type + d[1] = 2 + return ct, d, len(d) + + ct, d, n = foo(True) + self.assertEqual(ct, 0) + self.assertEqual(n, 1) + self.assertEqual(dict(d), {1: 2}) + + ct, d, n = foo(False) + self.assertEqual(ct, 0) + self.assertEqual(dict(d), {}) + self.assertEqual(n, 0) + + def test_dict_of_dict(self): + @njit + def foo(k1, k2, v): + d = Dict() + z1 = Dict() + z1[k1 + 1] = v + k1 + z2 = Dict() + z2[k2 + 2] = v + k2 + d[k1] = z1 + d[k2] = z2 + return d + + k1, k2, v = 100, 200, 321 + d = foo(k1, k2, v) + self.assertEqual( + dict(d), + { + k1: {k1 + 1: k1 + v}, + k2: {k2 + 2: k2 + v}, + }, + ) + + def test_comprehension_basic(self): + @njit + def foo(): + return {i: 2 * i for i in range(10)} + + self.assertEqual(foo(), foo.py_func()) + + def test_comprehension_basic_mixed_type(self): + @njit + def foo(): + return {i: float(j) for i, j in zip(range(10), range(10, 0, -1))} + + self.assertEqual(foo(), foo.py_func()) + + def test_comprehension_involved(self): + @njit + def foo(): + a = {0: 'A', 1: 'B', 2: 'C'} + return {3 + i: a[i] for i in range(3)} + + self.assertEqual(foo(), foo.py_func()) + + def test_comprehension_fail_mixed_type(self): + @njit + def foo(): + a = {0: 'A', 1: 'B', 2: 1j} + return {3 + i: a[i] for i in range(3)} + + with self.assertRaises(TypingError) as e: + foo() + + excstr = str(e.exception) + self.assertIn("Cannot cast complex128 to unicode_type", excstr) + + +class TestNonCompiledInfer(TestCase): + def test_check_untyped_dict_ops(self): + # Check operation on untyped dictionary + d = Dict() + self.assertFalse(d._typed) + self.assertEqual(len(d), 0) + self.assertEqual(str(d), str({})) + self.assertEqual(list(iter(d)), []) + # Test __getitem__ + with self.assertRaises(KeyError) as raises: + d[1] + self.assertEqual(str(raises.exception), str(KeyError(1))) + # Test __delitem__ + with self.assertRaises(KeyError) as raises: + del d[1] + self.assertEqual(str(raises.exception), str(KeyError(1))) + # Test .pop + with self.assertRaises(KeyError): + d.pop(1) + self.assertEqual(str(raises.exception), str(KeyError(1))) + # Test .pop + self.assertIs(d.pop(1, None), None) + # Test .get + self.assertIs(d.get(1), None) + # Test .popitem + with self.assertRaises(KeyError) as raises: + d.popitem() + self.assertEqual(str(raises.exception), + str(KeyError('dictionary is empty'))) + # Test setdefault(k) + with self.assertRaises(TypeError) as raises: + d.setdefault(1) + self.assertEqual( + str(raises.exception), + str(TypeError('invalid operation on untyped dictionary')), + ) + # Test __contains__ + self.assertFalse(1 in d) + # It's untyped + self.assertFalse(d._typed) + + def test_getitem(self): + # Test __getitem__ + d = Dict() + d[1] = 2 + # It's typed now + self.assertTrue(d._typed) + self.assertEqual(d[1], 2) + + def test_setdefault(self): + # Test setdefault(k, d) + d = Dict() + d.setdefault(1, 2) + # It's typed now + self.assertTrue(d._typed) + self.assertEqual(d[1], 2) + + +@jitclass(spec=[('a', types.intp)]) +class Bag(object): + def __init__(self, a): + self.a = a + + def __hash__(self): + return hash(self.a) + + +class TestDictWithJitclass(TestCase): + def test_jitclass_as_value(self): + @njit + def foo(x): + d = Dict() + d[0] = x + d[1] = Bag(101) + return d + + d = foo(Bag(a=100)) + self.assertEqual(d[0].a, 100) + self.assertEqual(d[1].a, 101) + + +class TestNoJit(TestCase): + """Exercise dictionary creation with JIT disabled. """ + + def test_dict_create_no_jit_using_new_dict(self): + with override_config('DISABLE_JIT', True): + with forbid_codegen(): + d = dictobject.new_dict(int32, float32) + self.assertEqual(type(d), dict) + + def test_dict_create_no_jit_using_Dict(self): + with override_config('DISABLE_JIT', True): + with forbid_codegen(): + d = Dict() + self.assertEqual(type(d), dict) + + def test_dict_create_no_jit_using_empty(self): + with override_config('DISABLE_JIT', True): + with forbid_codegen(): + d = Dict.empty(types.int32, types.float32) + self.assertEqual(type(d), dict) + + +class TestDictIterator(TestCase): + def test_dict_iterator(self): + @njit + def fun1(): + dd = Dict.empty(key_type=types.intp, + value_type=types.intp) + dd[0] = 10 + dd[1] = 20 + dd[2] = 30 + + return list(dd.keys()), list(dd.values()) + + @njit + def fun2(): + dd = Dict.empty(key_type=types.intp, + value_type=types.intp) + dd[4] = 77 + dd[5] = 88 + dd[6] = 99 + + return list(dd.keys()), list(dd.values()) + res1 = fun1() + res2 = fun2() + + self.assertEqual([0,1,2], res1[0]) + self.assertEqual([10,20,30], res1[1]) + self.assertEqual([4,5,6], res2[0]) + self.assertEqual([77,88,99], res2[1]) + + +class TestTypedDictInitialValues(MemoryLeakMixin, TestCase): + """Tests that typed dictionaries carry their initial value if present""" + + def test_homogeneous_and_literal(self): + def bar(d): + ... + + @overload(bar) + def ol_bar(d): + if d.initial_value is None: + return lambda d: literally(d) + self.assertTrue(isinstance(d, types.DictType)) + self.assertEqual(d.initial_value, {'a': 1, 'b': 2, 'c': 3}) + self.assertEqual(hasattr(d, 'literal_value'), False) + return lambda d: d + + @njit + def foo(): + # keys and values all have literal representation + x = {'a': 1, 'b': 2, 'c': 3} + bar(x) + + foo() + + def test_heterogeneous_but_castable_to_homogeneous(self): + def bar(d): + ... + + @overload(bar) + def ol_bar(d): + self.assertTrue(isinstance(d, types.DictType)) + self.assertEqual(d.initial_value, None) + self.assertEqual(hasattr(d, 'literal_value'), False) + return lambda d: d + + @njit + def foo(): + # This dictionary will be typed based on 1j, i.e. complex128 + # as the values are not all literals, there's no "initial_value" + # available irrespective of whether it's possible to rip this + # information out of the bytecode. + x = {'a': 1j, 'b': 2, 'c': 3} + bar(x) + + foo() + + def test_heterogeneous_but_not_castable_to_homogeneous(self): + def bar(d): + ... + + @overload(bar) + def ol_bar(d): + a = {'a': 1, 'b': 2j, 'c': 3} + + def specific_ty(z): + return types.literal(z) if types.maybe_literal(z) else typeof(z) + expected = {types.literal(x): specific_ty(y) for x, y in a.items()} + self.assertTrue(isinstance(d, types.LiteralStrKeyDict)) + self.assertEqual(d.literal_value, expected) + self.assertEqual(hasattr(d, 'initial_value'), False) + return lambda d: d + + @njit + def foo(): + # This dictionary will be typed based on 1, i.e. intp, as the values + # cannot all be cast to this type, but the keys are literal strings + # this is a LiteralStrKey[Dict], there's no initial_value but there + # is a literal_value. + x = {'a': 1, 'b': 2j, 'c': 3} + bar(x) + + foo() + + def test_mutation_not_carried(self): + def bar(d): + ... + + @overload(bar) + def ol_bar(d): + if d.initial_value is None: + return lambda d: literally(d) + self.assertTrue(isinstance(d, types.DictType)) + self.assertEqual(d.initial_value, {'a': 1, 'b': 2, 'c': 3}) + return lambda d: d + + @njit + def foo(): + # This dictionary is mutated, check the initial_value carries + # correctly and is not mutated + x = {'a': 1, 'b': 2, 'c': 3} + x['d'] = 4 + bar(x) + + foo() + + def test_mutation_not_carried_single_function(self): + # this is another pattern for using literally + + @njit + def nop(*args): + pass + + for fn, iv in (nop, None), (literally, {'a': 1, 'b': 2, 'c': 3}): + @njit + def baz(x): + pass + + def bar(z): + pass + + @overload(bar) + def ol_bar(z): + def impl(z): + fn(z) + baz(z) + return impl + + @njit + def foo(): + x = {'a': 1, 'b': 2, 'c': 3} + bar(x) + x['d'] = 4 + return x + + foo() + # baz should be specialised based on literally being invoked and + # the literal/unliteral arriving at the call site + larg = baz.signatures[0][0] + self.assertEqual(larg.initial_value, iv) + + def test_unify_across_function_call(self): + + @njit + def bar(x): + o = {1: 2} + if x: + o = {2: 3} + return o + + @njit + def foo(x): + if x: + d = {3: 4} + else: + d = bar(x) + return d + + e1 = Dict() + e1[3] = 4 + e2 = Dict() + e2[1] = 2 + self.assertEqual(foo(True), e1) + self.assertEqual(foo(False), e2) + + +class TestLiteralStrKeyDict(MemoryLeakMixin, TestCase): + """ Tests for dictionaries with string keys that can map to anything!""" + + def test_basic_const_lowering_boxing(self): + @njit + def foo(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + return (ld['a'], ld['b'], ld['c']) + + self.assertEqual(foo(), (1, 2j, 'd')) + + def test_basic_nonconst_in_scope(self): + @njit + def foo(x): + y = x + 5 + e = True if y > 2 else False + ld = {'a': 1, 'b': 2j, 'c': 'd', 'non_const': e} + return ld['non_const'] + + # Recall that key non_const has a value of a known type, bool, and it's + # value is stuffed in at run time, this is permitted as the dictionary + # is immutable in type + self.assertTrue(foo(34)) + self.assertFalse(foo(-100)) + + def test_basic_nonconst_freevar(self): + e = 5 + + def bar(x): + pass + + @overload(bar) + def ol_bar(x): + self.assertEqual(x.literal_value, + {types.literal('a'): types.literal(1), + types.literal('b'): typeof(2j), + types.literal('c'): types.literal('d'), + types.literal('d'): types.literal(5)}) + + def impl(x): + pass + return impl + + @njit + def foo(): + ld = {'a': 1, 'b': 2j, 'c': 'd', 'd': e} + bar(ld) + + foo() + + def test_literal_value(self): + + def bar(x): + pass + + @overload(bar) + def ol_bar(x): + self.assertEqual(x.literal_value, + {types.literal('a'): types.literal(1), + types.literal('b'): typeof(2j), + types.literal('c'): types.literal('d')}) + + def impl(x): + pass + return impl + + @njit + def foo(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + bar(ld) + + foo() + + def test_list_and_array_as_value(self): + + def bar(x): + pass + + @overload(bar) + def ol_bar(x): + self.assertEqual(x.literal_value, + {types.literal('a'): types.literal(1), + types.literal('b'): + types.List(types.intp, initial_value=[1,2,3]), + types.literal('c'): typeof(np.zeros(5))}) + + def impl(x): + pass + return impl + + @njit + def foo(): + b = [1, 2, 3] + ld = {'a': 1, 'b': b, 'c': np.zeros(5)} + bar(ld) + + foo() + + def test_repeated_key_literal_value(self): + + def bar(x): + pass + + @overload(bar) + def ol_bar(x): + # order is important, 'a' was seen first, but updated later + self.assertEqual(x.literal_value, + {types.literal('a'): types.literal('aaaa'), + types.literal('b'): typeof(2j), + types.literal('c'): types.literal('d')}) + + def impl(x): + pass + return impl + + @njit + def foo(): + ld = {'a': 1, 'a': 10, 'b': 2j, 'c': 'd', 'a': 'aaaa'} # noqa #F601 + bar(ld) + + foo() + + def test_read_only(self): + + def _len(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + return len(ld) + + def static_getitem(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + return ld['b'] + + def contains(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + return 'b' in ld, 'f' in ld + + def copy(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + new = ld.copy() + return ld == new + + rdonlys = (_len, static_getitem, contains, copy) + + for test in rdonlys: + with self.subTest(test.__name__): + self.assertPreciseEqual(njit(test)(), test()) + + def test_mutation_failure(self): + + def setitem(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + ld['a'] = 12 + + def delitem(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + del ld['a'] + + def popitem(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + ld.popitem() + + def pop(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + ld.pop() + + def clear(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + ld.clear() + + def setdefault(): + ld = {'a': 1, 'b': 2j, 'c': 'd'} + ld.setdefault('f', 1) + + illegals = (setitem, delitem, popitem, pop, clear, setdefault) + + for test in illegals: + with self.subTest(test.__name__): + with self.assertRaises(TypingError) as raises: + njit(test)() + expect = "Cannot mutate a literal dictionary" + self.assertIn(expect, str(raises.exception)) + + def test_get(self): + + @njit + def get(x): + ld = {'a': 2j, 'c': 'd'} + return ld.get(x) + + @njit + def getitem(x): + ld = {'a': 2j, 'c': 'd'} + return ld[x] + + for test in (get, getitem): + with self.subTest(test.__name__): + with self.assertRaises(TypingError) as raises: + test('a') + expect = "Cannot get{item}() on a literal dictionary" + self.assertIn(expect, str(raises.exception)) + + def test_dict_keys(self): + + @njit + def foo(): + ld = {'a': 2j, 'c': 'd'} + return [x for x in ld.keys()] + + self.assertEqual(foo(), ['a', 'c']) + + def test_dict_values(self): + + @njit + def foo(): + ld = {'a': 2j, 'c': 'd'} + return ld.values() + + self.assertEqual(foo(), (2j, 'd')) + + def test_dict_items(self): + @njit + def foo(): + ld = {'a': 2j, 'c': 'd', 'f': np.zeros((5))} + return ld.items() + + self.assertPreciseEqual(foo(), + (('a', 2j), ('c', 'd'), ('f', np.zeros((5))))) + + def test_dict_return(self): + + @njit + def foo(): + ld = {'a': 2j, 'c': 'd'} + return ld + + # escaping heterogeneous dictionary is not supported + with self.assertRaises(TypeError) as raises: + foo() + + excstr = str(raises.exception) + self.assertIn("cannot convert native LiteralStrKey", excstr) + + def test_dict_unify(self): + @njit + def foo(x): + if x + 7 > 4: + a = {'a': 2j, 'c': 'd', 'e': np.zeros(4)} + else: + # Note the use of a different literal str for key 'c' + a = {'a': 5j, 'c': 'CAT', 'e': np.zeros((5,))} + return a['c'] + + self.assertEqual(foo(100), 'd') + self.assertEqual(foo(-100), 'CAT') + self.assertEqual(foo(100), foo.py_func(100)) + self.assertEqual(foo(-100), foo.py_func(-100)) + + def test_dict_not_unify(self): + + @njit + def key_mismatch(x): + if x + 7 > 4: + a = {'BAD_KEY': 2j, 'c': 'd', 'e': np.zeros(4)} + else: + a = {'a': 5j, 'c': 'CAT', 'e': np.zeros((5,))} + # prevents inline of return on py310 + py310_defeat1 = 1 # noqa + py310_defeat2 = 2 # noqa + py310_defeat3 = 3 # noqa + py310_defeat4 = 4 # noqa + return a['a'] + + with self.assertRaises(TypingError) as raises: + key_mismatch(100) + + self.assertIn("Cannot unify LiteralStrKey", str(raises.exception)) + + @njit + def value_type_mismatch(x): + if x + 7 > 4: + a = {'a': 2j, 'c': 'd', 'e': np.zeros((4, 3))} + else: + a = {'a': 5j, 'c': 'CAT', 'e': np.zeros((5,))} + # prevents inline of return on py310 + py310_defeat1 = 1 # noqa + py310_defeat2 = 2 # noqa + py310_defeat3 = 3 # noqa + py310_defeat4 = 4 # noqa + return a['a'] + + with self.assertRaises(TypingError) as raises: + value_type_mismatch(100) + + self.assertIn("Cannot unify LiteralStrKey", str(raises.exception)) + + def test_dict_value_coercion(self): + # checks that things coerce or not! + + p = {# safe and no conversion: TypedDict + (np.int32, np.int32): types.DictType, + # safe and convertible: TypedDict + (np.int32, np.int8): types.DictType, + # safe convertible: TypedDict + (np.complex128, np.int32): types.DictType, + # unsafe not convertible: LiteralStrKey + (np.int32, np.complex128): types.LiteralStrKeyDict, + # unsafe not convertible: LiteralStrKey + (np.int32, np.array): types.LiteralStrKeyDict, + # unsafe not convertible: LiteralStrKey + (np.array, np.int32): types.LiteralStrKeyDict, + # unsafe not convertible: LiteralStrKey + (np.int8, np.int32): types.LiteralStrKeyDict, + # unsafe not convertible: LiteralStrKey (issue #6420 case) + (np.int64, np.float64): types.LiteralStrKeyDict,} + + def bar(x): + pass + + for dts, container in p.items(): + @overload(bar) + def ol_bar(x): + self.assertTrue(isinstance(x, container)) + + def impl(x): + pass + return impl + + ty1, ty2 = dts + + @njit + def foo(): + d = {'a': ty1(1), 'b': ty2(2)} + bar(d) + + foo() + + def test_build_map_op_code(self): + # tests building dictionaries via `build_map`, which, for statically + # determinable str key->things cases is just a single key:value + # any other build_map would either end up as being non-const str keys + # or keys of some non-string type and therefore not considered. + def bar(x): + pass + + @overload(bar) + def ol_bar(x): + def impl(x): + pass + return impl + + @njit + def foo(): + a = {'a': {'b1': 10, 'b2': 'string'}} + bar(a) + + foo() + + def test_dict_as_arg(self): + @njit + def bar(fake_kwargs=None): + if fake_kwargs is not None: + # Add 10 to array in key 'd' + fake_kwargs['d'][:] += 10 + + @njit + def foo(): + a = 1 + b = 2j + c = 'string' + d = np.zeros(3) + e = {'a': a, 'b': b, 'c': c, 'd': d} + bar(fake_kwargs=e) + return e['d'] + + np.testing.assert_allclose(foo(), np.ones(3) * 10) + + def test_dict_with_single_literallist_value(self): + #see issue #6094 + @njit + def foo(): + z = {"A": [lambda a: 2 * a, "B"]} + return z["A"][0](5) + + self.assertPreciseEqual(foo(), foo.py_func()) + + def test_tuple_not_in_mro(self): + # Related to #6094, make sure that LiteralStrKey does not inherit from + # types.BaseTuple as this breaks isinstance checks. + def bar(x): + pass + + @overload(bar) + def ol_bar(x): + self.assertFalse(isinstance(x, types.BaseTuple)) + self.assertTrue(isinstance(x, types.LiteralStrKeyDict)) + return lambda x: ... + + @njit + def foo(): + d = {'a': 1, 'b': 'c'} + bar(d) + + foo() + + def test_const_key_not_in_dict(self): + + @njit + def foo(): + a = {'not_a': 2j, 'c': 'd', 'e': np.zeros(4)} + return a['a'] + + with self.assertRaises(TypingError) as raises: + foo() + + self.assertIn("Key 'a' is not in dict.", str(raises.exception)) + + def test_uncommon_identifiers(self): + # Tests uncommon identifiers like numerical values and operators in + # the key fields. See #6518 and #7416. + + # Numerical values in keys + @njit + def foo(): + d = {'0': np.ones(5), '1': 4} + return len(d) + + self.assertPreciseEqual(foo(), foo.py_func()) + + # operators in keys + @njit + def bar(): + d = {'+': np.ones(5), 'x--': 4} + return len(d) + + self.assertPreciseEqual(bar(), bar.py_func()) + + def test_update_error(self): + # Tests that dict.update produces a reasonable + # error with a LiteralStrKeyDict input. + @njit + def foo(): + + d1 = { + 'a': 2, + 'b': 4, + 'c': 'a' + } + d1.update({'x': 3}) + return d1 + + with self.assertRaises(TypingError) as raises: + foo() + + self.assertIn( + "Cannot mutate a literal dictionary", + str(raises.exception) + ) + + +if __name__ == '__main__': + unittest.main() diff --git a/shared/package-files/42/42d63605d5ab56c2171a50524b20f88a452d42825b6f177e5b5e0fff1a138c16/blob b/shared/package-files/42/42d63605d5ab56c2171a50524b20f88a452d42825b6f177e5b5e0fff1a138c16/blob new file mode 100644 index 0000000000000000000000000000000000000000..ac79ac27efeb6d28be355a63c5bb97563b3cb742 --- /dev/null +++ b/shared/package-files/42/42d63605d5ab56c2171a50524b20f88a452d42825b6f177e5b5e0fff1a138c16/blob @@ -0,0 +1,155 @@ +#pragma once + +// Wrap tensor operation outputs as PyObject* + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace torch { +namespace autograd { +namespace utils { + +inline PyObject* wrap(bool value) { + if (value) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } +} + +inline PyObject* wrap(c10::DeviceIndex value) { + return THPUtils_packDeviceIndex(value); +} + +inline PyObject* wrap(int64_t value) { + return THPUtils_packInt64(value); +} + +inline PyObject* wrap(double value) { + return PyFloat_FromDouble(value); +} + +inline PyObject* wrap(c10::complex value) { + // I could probably also use FromComplex with a reinterpret cast, + // but... eh. + return PyComplex_FromDoubles(value.real(), value.imag()); +} + +inline PyObject* wrap(void* value) { + return THPUtils_packInt64(reinterpret_cast(value)); +} + +inline PyObject* wrap(THPDtype* dtype) { + Py_INCREF(dtype); + return (PyObject*)dtype; +} + +inline PyObject* wrap(at::ScalarType scalarType) { + return wrap(getTHPDtype(scalarType)); +} + +inline PyObject* wrap(THPLayout* layout) { + Py_INCREF(layout); + return (PyObject*)layout; +} + +inline PyObject* wrap(at::Layout layout) { + return wrap(getTHPLayout(layout)); +} + +inline PyObject* wrap(at::Tensor tensor) { + return THPVariable_Wrap(Variable(std::move(tensor))); +} + +inline PyObject* wrap(const at::Scalar& scalar) { + return wrap(scalar_to_tensor(scalar)); +} + +inline PyObject* wrap(at::QScheme qscheme) { + auto* thp_qscheme = torch::utils::getTHPQScheme(qscheme); + Py_INCREF(thp_qscheme); + return thp_qscheme; +} + +inline PyObject* wrap(at::TensorList tl) { + auto r = THPObjectPtr{PyTuple_New(tl.size())}; + if (!r) + throw python_error(); + for (const auto i : c10::irange(tl.size())) { + PyTuple_SET_ITEM(r.get(), i, wrap(tl[i])); + } + return r.release(); +} + +inline PyObject* wrap(at::IntArrayRef list) { + auto r = THPObjectPtr{PyTuple_New(list.size())}; + if (!r) + throw python_error(); + for (const auto i : c10::irange(list.size())) { + PyTuple_SET_ITEM(r.get(), i, wrap(list[i])); + } + return r.release(); +} + +inline PyObject* wrap(at::Stream stream) { + return THPStream_Wrap(stream); +} + +namespace detail { +template +void apply_with_idx_impl( + const F& f, + Tuple& t, + std::index_sequence /*indices*/) { + (void)std::initializer_list{(f(std::get(t), Is), 0)...}; +} + +// For tuple(a, b, c), calls f(a, 0), f(b, 1), f(c, 2) +template +void apply_with_idx(const F& f, std::tuple& t) { + apply_with_idx_impl(f, t, std::index_sequence_for{}); +} +} // namespace detail + +template +PyObject* wrap(std::tuple values) { + auto r = THPObjectPtr{PyTuple_New(sizeof...(Ts))}; + if (!r) + throw python_error(); + detail::apply_with_idx( + [&](auto& value, size_t idx) { + PyTuple_SET_ITEM(r.get(), idx, wrap(std::move(value))); + }, + values); + return r.release(); +} + +template +PyObject* wrap(PyTypeObject* type, std::tuple values) { + auto r = THPObjectPtr{PyStructSequence_New(type)}; + if (!r) + throw python_error(); + detail::apply_with_idx( + [&](auto& value, size_t idx) { + PyStructSequence_SET_ITEM(r.get(), idx, wrap(std::move(value))); + }, + values); + return r.release(); +} + +} // namespace utils +} // namespace autograd +} // namespace torch diff --git a/shared/package-files/42/42d681ba4cc7285c44d42ae4d74e1a7c11e3a9c515a7d1c868262b18577a20ae/blob b/shared/package-files/42/42d681ba4cc7285c44d42ae4d74e1a7c11e3a9c515a7d1c868262b18577a20ae/blob new file mode 100644 index 0000000000000000000000000000000000000000..eae1d7f890ba6f6cf89e53e1373bb40ecdde6478 --- /dev/null +++ b/shared/package-files/42/42d681ba4cc7285c44d42ae4d74e1a7c11e3a9c515a7d1c868262b18577a20ae/blob @@ -0,0 +1,289 @@ +""" +Author: Kishan Manani +License: BSD-3 Clause + +An implementation of MSTL [1], an algorithm for time series decomposition when +there are multiple seasonal components. + +This implementation has the following differences with the original algorithm: +- Missing data must be handled outside of this class. +- The algorithm proposed in the paper handles a case when there is no +seasonality. This implementation assumes that there is at least one seasonal +component. + +[1] K. Bandara, R.J. Hyndman, and C. Bergmeir (2021) +MSTL: A Seasonal-Trend Decomposition Algorithm for Time Series with Multiple +Seasonal Patterns +https://arxiv.org/pdf/2107.13462.pdf +""" +from __future__ import annotations + +from typing import TYPE_CHECKING +import warnings + +import numpy as np +import pandas as pd +from scipy.stats import boxcox + +from statsmodels.tsa.seasonal._seasonal import DecomposeResult +from statsmodels.tsa.stl._stl import STL +from statsmodels.tsa.tsatools import freq_to_period + +if TYPE_CHECKING: + from collections.abc import Sequence + + from statsmodels.tools.typing import ArrayLike1D + + +class MSTL: + """ + MSTL(endog, periods=None, windows=None, lmbda=None, iterate=2, + stl_kwargs=None) + + Season-Trend decomposition using LOESS for multiple seasonalities + + .. versionadded:: 0.14.0 + + Parameters + ---------- + endog : array_like + Data to be decomposed. Must be squeezable to 1-d. + periods : int, sequence of int, or None, optional + Periodicity of the seasonal components. If None and endog is a pandas + Series or DataFrame, attempts to determine from endog. If endog is a + ndarray, periods must be provided. + windows : int, sequence of int, or None, optional + Length of the seasonal smoothers for each corresponding period. + Must be an odd integer, and should normally be >= 7 (default). If None + then default values determined using 7 + 4 * np.arange(1, n + 1, 1) + where n is number of seasonal components. + lmbda : float, "auto", or None, optional + The lambda parameter for the Box-Cox transform to be applied to `endog` + prior to decomposition. If None, no transform is applied. If "auto", a + value will be estimated that maximizes the log-likelihood function. + iterate : int, optional + Number of iterations to use to refine the seasonal component. + stl_kwargs : dict, optional + Arguments to pass to STL. + + See Also + -------- + statsmodels.tsa.seasonal.STL + + References + ---------- + .. [1] K. Bandara, R.J. Hyndman, and C. Bergmeir (2021) + MSTL: A Seasonal-Trend Decomposition Algorithm for Time Series with + Multiple Seasonal Patterns. arXiv preprint arXiv:2107.13462. + + Examples + -------- + Start by creating a toy dataset with hourly frequency and multiple seasonal + components. + + >>> import numpy as np + >>> import matplotlib.pyplot as plt + >>> import pandas as pd + >>> pd.plotting.register_matplotlib_converters() + >>> np.random.seed(0) + >>> t = np.arange(1, 1000) + >>> trend = 0.0001 * t ** 2 + 100 + >>> daily_seasonality = 5 * np.sin(2 * np.pi * t / 24) + >>> weekly_seasonality = 10 * np.sin(2 * np.pi * t / (24 * 7)) + >>> noise = np.random.randn(len(t)) + >>> y = trend + daily_seasonality + weekly_seasonality + noise + >>> index = pd.date_range(start='2000-01-01', periods=len(t), freq='h') + >>> data = pd.DataFrame(data=y, index=index) + + Use MSTL to decompose the time series into two seasonal components + with periods 24 (daily seasonality) and 24*7 (weekly seasonality). + + >>> from statsmodels.tsa.seasonal import MSTL + >>> res = MSTL(data, periods=(24, 24*7)).fit() + >>> res.plot() + >>> plt.tight_layout() + >>> plt.show() + + .. plot:: plots/mstl_plot.py + """ + + def __init__( + self, + endog: ArrayLike1D, + *, + periods: int | Sequence[int] | None = None, + windows: int | Sequence[int] | None = None, + lmbda: float | str | None = None, + iterate: int = 2, + stl_kwargs: dict[str, int | bool | None] | None = None, + ): + self.endog = endog + self._y = self._to_1d_array(endog) + self.nobs = self._y.shape[0] + self.lmbda = lmbda + self.est_lmbda = None + self.periods, self.windows = self._process_periods_and_windows(periods, windows) + self.iterate = iterate + self._stl_kwargs = self._remove_overloaded_stl_kwargs( + stl_kwargs or {} + ) + + def fit(self): + """ + Estimate a trend component, multiple seasonal components, and a + residual component. + + Returns + ------- + DecomposeResult + Estimation results. + """ + num_seasons = len(self.periods) + iterate = 1 if num_seasons == 1 else self.iterate + + # Box Cox + if self.lmbda == "auto": + y, lmbda = boxcox(self._y, lmbda=None) + self.est_lmbda = lmbda + elif self.lmbda: + y = boxcox(self._y, lmbda=self.lmbda) + else: + y = self._y + + # Get STL fit params + stl_inner_iter = self._stl_kwargs.pop("inner_iter", None) + stl_outer_iter = self._stl_kwargs.pop("outer_iter", None) + + # Iterate over each seasonal component to extract seasonalities + seasonal = np.zeros(shape=(num_seasons, self.nobs)) + deseas = y + for _ in range(iterate): + for i in range(num_seasons): + deseas = deseas + seasonal[i] + res = STL( + endog=deseas, + period=self.periods[i], + seasonal=self.windows[i], + **self._stl_kwargs, + ).fit(inner_iter=stl_inner_iter, outer_iter=stl_outer_iter) + seasonal[i] = res.seasonal + deseas = deseas - seasonal[i] + + seasonal = np.squeeze(seasonal.T) + trend = res.trend + rw = res.weights + resid = deseas - trend + + # Return pandas if endog is pandas + if isinstance(self.endog, (pd.Series, pd.DataFrame)): + index = self.endog.index + y = pd.Series(y, index=index, name="observed") + trend = pd.Series(trend, index=index, name="trend") + resid = pd.Series(resid, index=index, name="resid") + rw = pd.Series(rw, index=index, name="robust_weight") + cols = [f"seasonal_{period}" for period in self.periods] + if seasonal.ndim == 1: + seasonal = pd.Series(seasonal, index=index, name="seasonal") + else: + seasonal = pd.DataFrame(seasonal, index=index, columns=cols) + + return DecomposeResult(y, seasonal, trend, resid, rw) + + def __str__(self): + return ( + "MSTL(endog," + f" periods={self.periods}," + f" windows={self.windows}," + f" lmbda={self.lmbda}," + f" iterate={self.iterate})" + ) + + def _process_periods_and_windows( + self, + periods: int | Sequence[int] | None, + windows: int | Sequence[int] | None, + ) -> tuple[Sequence[int], Sequence[int]]: + periods = self._process_periods(periods) + + if windows: + windows = self._process_windows(windows, num_seasons=len(periods)) + periods, windows = self._sort_periods_and_windows(periods, windows) + else: + windows = self._process_windows(windows, num_seasons=len(periods)) + periods = sorted(periods) + + if len(periods) != len(windows): + raise ValueError("Periods and windows must have same length") + + # Remove long periods from decomposition + if any(period >= self.nobs / 2 for period in periods): + warnings.warn( + "A period(s) is larger than half the length of time series." + " Removing these period(s).", + UserWarning, + stacklevel=2, + ) + periods = tuple(period for period in periods if period < self.nobs / 2) + windows = windows[: len(periods)] + + return periods, windows + + def _process_periods( + self, periods: int | Sequence[int] | None + ) -> Sequence[int]: + if periods is None: + periods = (self._infer_period(),) + elif isinstance(periods, int): + periods = (periods,) + else: + pass + return periods + + def _process_windows( + self, + windows: int | Sequence[int] | None, + num_seasons: int, + ) -> Sequence[int]: + if windows is None: + windows = self._default_seasonal_windows(num_seasons) + elif isinstance(windows, int): + windows = (windows,) + else: + pass + return windows + + def _infer_period(self) -> int: + freq = None + if isinstance(self.endog, (pd.Series, pd.DataFrame)): + freq = getattr(self.endog.index, "inferred_freq", None) + if freq is None: + raise ValueError("Unable to determine period from endog") + period = freq_to_period(freq) + return period + + @staticmethod + def _sort_periods_and_windows( + periods, windows + ) -> tuple[Sequence[int], Sequence[int]]: + if len(periods) != len(windows): + raise ValueError("Periods and windows must have same length") + periods, windows = zip(*sorted(zip(periods, windows, strict=True)), strict=True) + return periods, windows + + @staticmethod + def _remove_overloaded_stl_kwargs(stl_kwargs: dict) -> dict: + args = ["endog", "period", "seasonal"] + for arg in args: + stl_kwargs.pop(arg, None) + return stl_kwargs + + @staticmethod + def _default_seasonal_windows(n: int) -> Sequence[int]: + return tuple(7 + 4 * i for i in range(1, n + 1)) # See [1] + + @staticmethod + def _to_1d_array(x): + y = np.ascontiguousarray(np.squeeze(np.asarray(x)), dtype=np.double) + if y.ndim != 1: + raise ValueError("y must be a 1d array") + return y diff --git a/shared/package-files/42/42da1341875fc08d545524b8b000a0706149d48cd0bdadc560014dcfa248cb87/blob b/shared/package-files/42/42da1341875fc08d545524b8b000a0706149d48cd0bdadc560014dcfa248cb87/blob new file mode 100644 index 0000000000000000000000000000000000000000..26490a7dfa2409255ddb90695075efc94ed0b4c3 --- /dev/null +++ b/shared/package-files/42/42da1341875fc08d545524b8b000a0706149d48cd0bdadc560014dcfa248cb87/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor linalg_det(const at::Tensor & A); +TORCH_API at::Tensor & linalg_det_out(const at::Tensor & A, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/shared/package-files/42/42da3d2f3062bcbf9a21539595fd54d5b662d43465fc21f620385ac655043e5c/blob b/shared/package-files/42/42da3d2f3062bcbf9a21539595fd54d5b662d43465fc21f620385ac655043e5c/blob new file mode 100644 index 0000000000000000000000000000000000000000..64449b815ebf3be7b31a14224eb3fd368e581758 Binary files /dev/null and b/shared/package-files/42/42da3d2f3062bcbf9a21539595fd54d5b662d43465fc21f620385ac655043e5c/blob differ diff --git a/shared/package-files/42/42db0b14d5b8e638c82fa713a6dcb298b068e8c2f5745ab0fc84993f97c4debe/blob b/shared/package-files/42/42db0b14d5b8e638c82fa713a6dcb298b068e8c2f5745ab0fc84993f97c4debe/blob new file mode 100644 index 0000000000000000000000000000000000000000..ce2ec46460e96b312de7ed2a040d68fa0e0d4db8 --- /dev/null +++ b/shared/package-files/42/42db0b14d5b8e638c82fa713a6dcb298b068e8c2f5745ab0fc84993f97c4debe/blob @@ -0,0 +1,183 @@ +from contextlib import contextmanager +from dataclasses import dataclass +from typing import Any, Callable + +import torch +import torch.fx.traceback as fx_traceback +import torch.utils._pytree as pytree +from torch._ops import HigherOrderOperator +from torch.fx.experimental.proxy_tensor import make_fx +from torch.multiprocessing.reductions import StorageWeakRef + + +@dataclass +class UnsupportedAliasMutationException(RuntimeError): + reason: str + + +def autograd_not_implemented_inner( + operator: HigherOrderOperator, delayed_error: bool, *args: Any, **kwargs: Any +) -> Any: + """If autograd is enabled and any of the arguments require grad this will either + raise an error or return a DelayedError depending on the value of delayed. + + Args: + operator: The HigherOrderOperator to call with the *args and **kwargs with + op_name: The name of the HigherOrderOperator + delayed_error: If True, return a DelayedError instead of raising an error + args: The flattened operands to the HigherOrderOperator + kwargs: The keyword arguments to the HigherOrderOperator + + Raises: + RuntimeError: If autograd is enabled and any of the arguments to the HigherOrderOperator + """ + with torch._C._AutoDispatchBelowAutograd(): + result = operator(*args, **kwargs) + flat_operands = pytree.arg_tree_leaves(*args) + if torch.is_grad_enabled() and any( + f.requires_grad for f in flat_operands if isinstance(f, torch.Tensor) + ): + if delayed_error: + err_fn = torch._C._functions.DelayedError( + f"Autograd not implemented for {str(operator)}", + 1, + ) + + def fake_requires_grad(tensor): + if torch.is_floating_point(tensor) or torch.is_complex(tensor): + tensor = tensor.detach() + tensor.requires_grad = True + return tensor + + return pytree.tree_map_only( + torch.Tensor, lambda x: err_fn(fake_requires_grad(x)), result + ) + else: + raise RuntimeError(f"Autograd not implemented for {str(operator)}") + return result + + +def autograd_not_implemented(op: HigherOrderOperator, deferred_error: bool) -> Callable: + def inner(*args, **kwargs): + return autograd_not_implemented_inner(op, deferred_error, *args, **kwargs) + + return inner + + +def _maybe_run_with_interpreter(fn): + maybe_interpreted_fn = fn + if isinstance(fn, torch.fx.GraphModule) and fx_traceback.has_preserved_node_meta(): + # Running graph with interpreter is needed for propagating the stack_trace + def graph_with_interpreter(*args): + with fx_traceback.preserve_node_meta(): + return torch.fx.Interpreter(fn).run(*args) + + maybe_interpreted_fn = graph_with_interpreter + return maybe_interpreted_fn + + +# We'll use the current decomposition table to make sure operators in subgraphs are +# decomposed properly. +# We also need to maybe run with interpreter for propagating stack_trace +def reenter_make_fx(fn, pre_dispatch=False): + decomp_table = torch.fx.experimental.proxy_tensor.CURRENT_DECOMPOSITION_TABLE + return make_fx( + _maybe_run_with_interpreter(fn), + decomposition_table=decomp_table, + pre_dispatch=pre_dispatch, + ) + + +@contextmanager +def _set_compilation_env(): + _old_is_tracing = torch.fx._symbolic_trace._is_fx_tracing_flag + try: + # We need to turn off the is_fx_tracing_flag. Remove this flag check from dyanmo + # once we are confident fx tracing works with dynamo. + torch.fx._symbolic_trace._is_fx_tracing_flag = False + yield + finally: + torch.fx._symbolic_trace._is_fx_tracing_flag = _old_is_tracing + + +def _has_potential_branch_input_mutation(branch, inputs, pre_dispatch=False): + """ + Dispatch-trace the branch with inputs and check if + producing graph has mutable op on the input. This is + bit restrictive as the branch must be traceable. + """ + try: + gm = make_fx(branch, pre_dispatch=pre_dispatch)(*inputs) + except UnsupportedAliasMutationException: + # this can happen when nested cond_op is + # functionalized + return True + except Exception as e: + raise e + + def _detect_input_mutation(gm): + input_nodes = set() + for node in gm.graph.nodes: + if node.op == "placeholder": + input_nodes.add(node) + if node.op == "call_function": + target = node.target + if ( + isinstance(target, torch._ops.OpOverload) + and target._schema.is_mutable + ): + for arg in node.args: + if arg in input_nodes: + return True + + for _, module in gm.named_children(): + if isinstance(module, torch.fx.GraphModule): + if _detect_input_mutation(module): + return True + + return False + + return _detect_input_mutation(gm) + + +def _has_potential_branch_input_alias(branch, inputs, pre_dispatch=False): + """ + Dispatch-trace the branch with inputs and check if + producing graph has output aliasing the branch input. This is + bit restrictive as the branch must be traceable. + """ + try: + gm = make_fx(branch, pre_dispatch=pre_dispatch)(*inputs) + except UnsupportedAliasMutationException: + # this can happen when nested cond_op is + # functionalized + return True + except Exception as e: + raise e + + def _detect_input_alias(gm): + input_storages = set() + for node in gm.graph.nodes: + # We need to check existence of "val" because we reuse the logic here + # for map operator, where num_mapped_args is a scalar + # and doesn't have a "val" meta. + if node.op == "placeholder" and "val" in node.meta: + input_storages.add(StorageWeakRef(node.meta["val"]._typed_storage())) + if node.op == "output": + + def check_alias(out): + if out is not None and "val" in out.meta: + out_storage = StorageWeakRef(out.meta["val"]._typed_storage()) + return out_storage in input_storages + return False + + if any(pytree.tree_leaves(pytree.tree_map(check_alias, node.args))): + return True + + for _, module in gm.named_children(): + if isinstance(module, torch.fx.GraphModule) and _detect_input_alias(module): + return True + + return False + + return _detect_input_alias(gm) diff --git a/shared/package-files/42/42dc2526048a52f73077103038e2b1296e88b27c7f0ee07ab81a2b61bcf87129/blob b/shared/package-files/42/42dc2526048a52f73077103038e2b1296e88b27c7f0ee07ab81a2b61bcf87129/blob new file mode 100644 index 0000000000000000000000000000000000000000..6dea15ac0bc2474b222762505b50efc0dbe680e5 --- /dev/null +++ b/shared/package-files/42/42dc2526048a52f73077103038e2b1296e88b27c7f0ee07ab81a2b61bcf87129/blob @@ -0,0 +1,1766 @@ +""" +Common type operations. +""" +from __future__ import annotations + +from typing import ( + TYPE_CHECKING, + Any, + Callable, +) +import warnings + +import numpy as np + +from pandas._config import using_string_dtype + +from pandas._libs import ( + Interval, + Period, + algos, + lib, +) +from pandas._libs.tslibs import conversion +from pandas.util._exceptions import find_stack_level + +from pandas.core.dtypes.base import _registry as registry +from pandas.core.dtypes.dtypes import ( + CategoricalDtype, + DatetimeTZDtype, + ExtensionDtype, + IntervalDtype, + PeriodDtype, + SparseDtype, +) +from pandas.core.dtypes.generic import ABCIndex +from pandas.core.dtypes.inference import ( + is_array_like, + is_bool, + is_complex, + is_dataclass, + is_decimal, + is_dict_like, + is_file_like, + is_float, + is_hashable, + is_integer, + is_interval, + is_iterator, + is_list_like, + is_named_tuple, + is_nested_list_like, + is_number, + is_re, + is_re_compilable, + is_scalar, + is_sequence, +) + +if TYPE_CHECKING: + from pandas._typing import ( + ArrayLike, + DtypeObj, + ) + +DT64NS_DTYPE = conversion.DT64NS_DTYPE +TD64NS_DTYPE = conversion.TD64NS_DTYPE +INT64_DTYPE = np.dtype(np.int64) + +# oh the troubles to reduce import time +_is_scipy_sparse = None + +ensure_float64 = algos.ensure_float64 +ensure_int64 = algos.ensure_int64 +ensure_int32 = algos.ensure_int32 +ensure_int16 = algos.ensure_int16 +ensure_int8 = algos.ensure_int8 +ensure_platform_int = algos.ensure_platform_int +ensure_object = algos.ensure_object +ensure_uint64 = algos.ensure_uint64 + + +def ensure_str(value: bytes | Any) -> str: + """ + Ensure that bytes and non-strings get converted into ``str`` objects. + """ + if isinstance(value, bytes): + value = value.decode("utf-8") + elif not isinstance(value, str): + value = str(value) + return value + + +def ensure_python_int(value: int | np.integer) -> int: + """ + Ensure that a value is a python int. + + Parameters + ---------- + value: int or numpy.integer + + Returns + ------- + int + + Raises + ------ + TypeError: if the value isn't an int or can't be converted to one. + """ + if not (is_integer(value) or is_float(value)): + if not is_scalar(value): + raise TypeError( + f"Value needs to be a scalar value, was type {type(value).__name__}" + ) + raise TypeError(f"Wrong type {type(value)} for value {value}") + try: + new_value = int(value) + assert new_value == value + except (TypeError, ValueError, AssertionError) as err: + raise TypeError(f"Wrong type {type(value)} for value {value}") from err + return new_value + + +def classes(*klasses) -> Callable: + """Evaluate if the tipo is a subclass of the klasses.""" + return lambda tipo: issubclass(tipo, klasses) + + +def _classes_and_not_datetimelike(*klasses) -> Callable: + """ + Evaluate if the tipo is a subclass of the klasses + and not a datetimelike. + """ + return lambda tipo: ( + issubclass(tipo, klasses) + and not issubclass(tipo, (np.datetime64, np.timedelta64)) + ) + + +def is_object_dtype(arr_or_dtype) -> bool: + """ + Check whether an array-like or dtype is of the object dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype to check. + + Returns + ------- + boolean + Whether or not the array-like or dtype is of the object dtype. + + Examples + -------- + >>> from pandas.api.types import is_object_dtype + >>> is_object_dtype(object) + True + >>> is_object_dtype(int) + False + >>> is_object_dtype(np.array([], dtype=object)) + True + >>> is_object_dtype(np.array([], dtype=int)) + False + >>> is_object_dtype([1, 2, 3]) + False + """ + return _is_dtype_type(arr_or_dtype, classes(np.object_)) + + +def is_sparse(arr) -> bool: + """ + Check whether an array-like is a 1-D pandas sparse array. + + .. deprecated:: 2.1.0 + Use isinstance(dtype, pd.SparseDtype) instead. + + Check that the one-dimensional array-like is a pandas sparse array. + Returns True if it is a pandas sparse array, not another type of + sparse array. + + Parameters + ---------- + arr : array-like + Array-like to check. + + Returns + ------- + bool + Whether or not the array-like is a pandas sparse array. + + Examples + -------- + Returns `True` if the parameter is a 1-D pandas sparse array. + + >>> from pandas.api.types import is_sparse + >>> is_sparse(pd.arrays.SparseArray([0, 0, 1, 0])) + True + >>> is_sparse(pd.Series(pd.arrays.SparseArray([0, 0, 1, 0]))) + True + + Returns `False` if the parameter is not sparse. + + >>> is_sparse(np.array([0, 0, 1, 0])) + False + >>> is_sparse(pd.Series([0, 1, 0, 0])) + False + + Returns `False` if the parameter is not a pandas sparse array. + + >>> from scipy.sparse import bsr_matrix + >>> is_sparse(bsr_matrix([0, 1, 0, 0])) + False + + Returns `False` if the parameter has more than one dimension. + """ + warnings.warn( + "is_sparse is deprecated and will be removed in a future " + "version. Check `isinstance(dtype, pd.SparseDtype)` instead.", + DeprecationWarning, + stacklevel=2, + ) + + dtype = getattr(arr, "dtype", arr) + return isinstance(dtype, SparseDtype) + + +def is_scipy_sparse(arr) -> bool: + """ + Check whether an array-like is a scipy.sparse.spmatrix instance. + + Parameters + ---------- + arr : array-like + The array-like to check. + + Returns + ------- + boolean + Whether or not the array-like is a scipy.sparse.spmatrix instance. + + Notes + ----- + If scipy is not installed, this function will always return False. + + Examples + -------- + >>> from scipy.sparse import bsr_matrix + >>> is_scipy_sparse(bsr_matrix([1, 2, 3])) + True + >>> is_scipy_sparse(pd.arrays.SparseArray([1, 2, 3])) + False + """ + global _is_scipy_sparse + + if _is_scipy_sparse is None: # pylint: disable=used-before-assignment + try: + from scipy.sparse import issparse as _is_scipy_sparse + except ImportError: + _is_scipy_sparse = lambda _: False + + assert _is_scipy_sparse is not None + return _is_scipy_sparse(arr) + + +def is_datetime64_dtype(arr_or_dtype) -> bool: + """ + Check whether an array-like or dtype is of the datetime64 dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype to check. + + Returns + ------- + boolean + Whether or not the array-like or dtype is of the datetime64 dtype. + + Examples + -------- + >>> from pandas.api.types import is_datetime64_dtype + >>> is_datetime64_dtype(object) + False + >>> is_datetime64_dtype(np.datetime64) + True + >>> is_datetime64_dtype(np.array([], dtype=int)) + False + >>> is_datetime64_dtype(np.array([], dtype=np.datetime64)) + True + >>> is_datetime64_dtype([1, 2, 3]) + False + """ + if isinstance(arr_or_dtype, np.dtype): + # GH#33400 fastpath for dtype object + return arr_or_dtype.kind == "M" + return _is_dtype_type(arr_or_dtype, classes(np.datetime64)) + + +def is_datetime64tz_dtype(arr_or_dtype) -> bool: + """ + Check whether an array-like or dtype is of a DatetimeTZDtype dtype. + + .. deprecated:: 2.1.0 + Use isinstance(dtype, pd.DatetimeTZDtype) instead. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype to check. + + Returns + ------- + boolean + Whether or not the array-like or dtype is of a DatetimeTZDtype dtype. + + Examples + -------- + >>> from pandas.api.types import is_datetime64tz_dtype + >>> is_datetime64tz_dtype(object) + False + >>> is_datetime64tz_dtype([1, 2, 3]) + False + >>> is_datetime64tz_dtype(pd.DatetimeIndex([1, 2, 3])) # tz-naive + False + >>> is_datetime64tz_dtype(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern")) + True + + >>> from pandas.core.dtypes.dtypes import DatetimeTZDtype + >>> dtype = DatetimeTZDtype("ns", tz="US/Eastern") + >>> s = pd.Series([], dtype=dtype) + >>> is_datetime64tz_dtype(dtype) + True + >>> is_datetime64tz_dtype(s) + True + """ + # GH#52607 + warnings.warn( + "is_datetime64tz_dtype is deprecated and will be removed in a future " + "version. Check `isinstance(dtype, pd.DatetimeTZDtype)` instead.", + DeprecationWarning, + stacklevel=2, + ) + if isinstance(arr_or_dtype, DatetimeTZDtype): + # GH#33400 fastpath for dtype object + # GH 34986 + return True + + if arr_or_dtype is None: + return False + return DatetimeTZDtype.is_dtype(arr_or_dtype) + + +def is_timedelta64_dtype(arr_or_dtype) -> bool: + """ + Check whether an array-like or dtype is of the timedelta64 dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype to check. + + Returns + ------- + boolean + Whether or not the array-like or dtype is of the timedelta64 dtype. + + Examples + -------- + >>> from pandas.core.dtypes.common import is_timedelta64_dtype + >>> is_timedelta64_dtype(object) + False + >>> is_timedelta64_dtype(np.timedelta64) + True + >>> is_timedelta64_dtype([1, 2, 3]) + False + >>> is_timedelta64_dtype(pd.Series([], dtype="timedelta64[ns]")) + True + >>> is_timedelta64_dtype('0 days') + False + """ + if isinstance(arr_or_dtype, np.dtype): + # GH#33400 fastpath for dtype object + return arr_or_dtype.kind == "m" + + return _is_dtype_type(arr_or_dtype, classes(np.timedelta64)) + + +def is_period_dtype(arr_or_dtype) -> bool: + """ + Check whether an array-like or dtype is of the Period dtype. + + .. deprecated:: 2.2.0 + Use isinstance(dtype, pd.Period) instead. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype to check. + + Returns + ------- + boolean + Whether or not the array-like or dtype is of the Period dtype. + + Examples + -------- + >>> from pandas.core.dtypes.common import is_period_dtype + >>> is_period_dtype(object) + False + >>> is_period_dtype(pd.PeriodDtype(freq="D")) + True + >>> is_period_dtype([1, 2, 3]) + False + >>> is_period_dtype(pd.Period("2017-01-01")) + False + >>> is_period_dtype(pd.PeriodIndex([], freq="Y")) + True + """ + warnings.warn( + "is_period_dtype is deprecated and will be removed in a future version. " + "Use `isinstance(dtype, pd.PeriodDtype)` instead", + DeprecationWarning, + stacklevel=2, + ) + if isinstance(arr_or_dtype, ExtensionDtype): + # GH#33400 fastpath for dtype object + return arr_or_dtype.type is Period + + if arr_or_dtype is None: + return False + return PeriodDtype.is_dtype(arr_or_dtype) + + +def is_interval_dtype(arr_or_dtype) -> bool: + """ + Check whether an array-like or dtype is of the Interval dtype. + + .. deprecated:: 2.2.0 + Use isinstance(dtype, pd.IntervalDtype) instead. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype to check. + + Returns + ------- + boolean + Whether or not the array-like or dtype is of the Interval dtype. + + Examples + -------- + >>> from pandas.core.dtypes.common import is_interval_dtype + >>> is_interval_dtype(object) + False + >>> is_interval_dtype(pd.IntervalDtype()) + True + >>> is_interval_dtype([1, 2, 3]) + False + >>> + >>> interval = pd.Interval(1, 2, closed="right") + >>> is_interval_dtype(interval) + False + >>> is_interval_dtype(pd.IntervalIndex([interval])) + True + """ + # GH#52607 + warnings.warn( + "is_interval_dtype is deprecated and will be removed in a future version. " + "Use `isinstance(dtype, pd.IntervalDtype)` instead", + DeprecationWarning, + stacklevel=2, + ) + if isinstance(arr_or_dtype, ExtensionDtype): + # GH#33400 fastpath for dtype object + return arr_or_dtype.type is Interval + + if arr_or_dtype is None: + return False + return IntervalDtype.is_dtype(arr_or_dtype) + + +def is_categorical_dtype(arr_or_dtype) -> bool: + """ + Check whether an array-like or dtype is of the Categorical dtype. + + .. deprecated:: 2.2.0 + Use isinstance(dtype, pd.CategoricalDtype) instead. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype to check. + + Returns + ------- + boolean + Whether or not the array-like or dtype is of the Categorical dtype. + + Examples + -------- + >>> from pandas.api.types import is_categorical_dtype + >>> from pandas import CategoricalDtype + >>> is_categorical_dtype(object) + False + >>> is_categorical_dtype(CategoricalDtype()) + True + >>> is_categorical_dtype([1, 2, 3]) + False + >>> is_categorical_dtype(pd.Categorical([1, 2, 3])) + True + >>> is_categorical_dtype(pd.CategoricalIndex([1, 2, 3])) + True + """ + # GH#52527 + warnings.warn( + "is_categorical_dtype is deprecated and will be removed in a future " + "version. Use isinstance(dtype, pd.CategoricalDtype) instead", + DeprecationWarning, + stacklevel=2, + ) + if isinstance(arr_or_dtype, ExtensionDtype): + # GH#33400 fastpath for dtype object + return arr_or_dtype.name == "category" + + if arr_or_dtype is None: + return False + return CategoricalDtype.is_dtype(arr_or_dtype) + + +def is_string_or_object_np_dtype(dtype: np.dtype) -> bool: + """ + Faster alternative to is_string_dtype, assumes we have a np.dtype object. + """ + return dtype == object or dtype.kind in "SU" + + +def is_string_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of the string dtype. + + If an array is passed with an object dtype, the elements must be + inferred as strings. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of the string dtype. + + Examples + -------- + >>> from pandas.api.types import is_string_dtype + >>> is_string_dtype(str) + True + >>> is_string_dtype(object) + True + >>> is_string_dtype(int) + False + >>> is_string_dtype(np.array(['a', 'b'])) + True + >>> is_string_dtype(pd.Series([1, 2])) + False + >>> is_string_dtype(pd.Series([1, 2], dtype=object)) + False + """ + if hasattr(arr_or_dtype, "dtype") and _get_dtype(arr_or_dtype).kind == "O": + return is_all_strings(arr_or_dtype) + + def condition(dtype) -> bool: + if is_string_or_object_np_dtype(dtype): + return True + try: + return dtype == "string" + except TypeError: + return False + + return _is_dtype(arr_or_dtype, condition) + + +def is_dtype_equal(source, target) -> bool: + """ + Check if two dtypes are equal. + + Parameters + ---------- + source : The first dtype to compare + target : The second dtype to compare + + Returns + ------- + boolean + Whether or not the two dtypes are equal. + + Examples + -------- + >>> is_dtype_equal(int, float) + False + >>> is_dtype_equal("int", int) + True + >>> is_dtype_equal(object, "category") + False + >>> is_dtype_equal(CategoricalDtype(), "category") + True + >>> is_dtype_equal(DatetimeTZDtype(tz="UTC"), "datetime64") + False + """ + if isinstance(target, str): + if not isinstance(source, str): + # GH#38516 ensure we get the same behavior from + # is_dtype_equal(CDT, "category") and CDT == "category" + try: + src = _get_dtype(source) + if isinstance(src, ExtensionDtype): + return src == target + except (TypeError, AttributeError, ImportError): + return False + elif isinstance(source, str): + return is_dtype_equal(target, source) + + try: + source = _get_dtype(source) + target = _get_dtype(target) + return source == target + except (TypeError, AttributeError, ImportError): + # invalid comparison + # object == category will hit this + return False + + +def is_integer_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of an integer dtype. + + Unlike in `is_any_int_dtype`, timedelta64 instances will return False. + + The nullable Integer dtypes (e.g. pandas.Int64Dtype) are also considered + as integer by this function. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of an integer dtype and + not an instance of timedelta64. + + Examples + -------- + >>> from pandas.api.types import is_integer_dtype + >>> is_integer_dtype(str) + False + >>> is_integer_dtype(int) + True + >>> is_integer_dtype(float) + False + >>> is_integer_dtype(np.uint64) + True + >>> is_integer_dtype('int8') + True + >>> is_integer_dtype('Int8') + True + >>> is_integer_dtype(pd.Int8Dtype) + True + >>> is_integer_dtype(np.datetime64) + False + >>> is_integer_dtype(np.timedelta64) + False + >>> is_integer_dtype(np.array(['a', 'b'])) + False + >>> is_integer_dtype(pd.Series([1, 2])) + True + >>> is_integer_dtype(np.array([], dtype=np.timedelta64)) + False + >>> is_integer_dtype(pd.Index([1, 2.])) # float + False + """ + return _is_dtype_type( + arr_or_dtype, _classes_and_not_datetimelike(np.integer) + ) or _is_dtype( + arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind in "iu" + ) + + +def is_signed_integer_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of a signed integer dtype. + + Unlike in `is_any_int_dtype`, timedelta64 instances will return False. + + The nullable Integer dtypes (e.g. pandas.Int64Dtype) are also considered + as integer by this function. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of a signed integer dtype + and not an instance of timedelta64. + + Examples + -------- + >>> from pandas.core.dtypes.common import is_signed_integer_dtype + >>> is_signed_integer_dtype(str) + False + >>> is_signed_integer_dtype(int) + True + >>> is_signed_integer_dtype(float) + False + >>> is_signed_integer_dtype(np.uint64) # unsigned + False + >>> is_signed_integer_dtype('int8') + True + >>> is_signed_integer_dtype('Int8') + True + >>> is_signed_integer_dtype(pd.Int8Dtype) + True + >>> is_signed_integer_dtype(np.datetime64) + False + >>> is_signed_integer_dtype(np.timedelta64) + False + >>> is_signed_integer_dtype(np.array(['a', 'b'])) + False + >>> is_signed_integer_dtype(pd.Series([1, 2])) + True + >>> is_signed_integer_dtype(np.array([], dtype=np.timedelta64)) + False + >>> is_signed_integer_dtype(pd.Index([1, 2.])) # float + False + >>> is_signed_integer_dtype(np.array([1, 2], dtype=np.uint32)) # unsigned + False + """ + return _is_dtype_type( + arr_or_dtype, _classes_and_not_datetimelike(np.signedinteger) + ) or _is_dtype( + arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind == "i" + ) + + +def is_unsigned_integer_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of an unsigned integer dtype. + + The nullable Integer dtypes (e.g. pandas.UInt64Dtype) are also + considered as integer by this function. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of an unsigned integer dtype. + + Examples + -------- + >>> from pandas.api.types import is_unsigned_integer_dtype + >>> is_unsigned_integer_dtype(str) + False + >>> is_unsigned_integer_dtype(int) # signed + False + >>> is_unsigned_integer_dtype(float) + False + >>> is_unsigned_integer_dtype(np.uint64) + True + >>> is_unsigned_integer_dtype('uint8') + True + >>> is_unsigned_integer_dtype('UInt8') + True + >>> is_unsigned_integer_dtype(pd.UInt8Dtype) + True + >>> is_unsigned_integer_dtype(np.array(['a', 'b'])) + False + >>> is_unsigned_integer_dtype(pd.Series([1, 2])) # signed + False + >>> is_unsigned_integer_dtype(pd.Index([1, 2.])) # float + False + >>> is_unsigned_integer_dtype(np.array([1, 2], dtype=np.uint32)) + True + """ + return _is_dtype_type( + arr_or_dtype, _classes_and_not_datetimelike(np.unsignedinteger) + ) or _is_dtype( + arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind == "u" + ) + + +def is_int64_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of the int64 dtype. + + .. deprecated:: 2.1.0 + + is_int64_dtype is deprecated and will be removed in a future + version. Use dtype == np.int64 instead. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of the int64 dtype. + + Notes + ----- + Depending on system architecture, the return value of `is_int64_dtype( + int)` will be True if the OS uses 64-bit integers and False if the OS + uses 32-bit integers. + + Examples + -------- + >>> from pandas.api.types import is_int64_dtype + >>> is_int64_dtype(str) # doctest: +SKIP + False + >>> is_int64_dtype(np.int32) # doctest: +SKIP + False + >>> is_int64_dtype(np.int64) # doctest: +SKIP + True + >>> is_int64_dtype('int8') # doctest: +SKIP + False + >>> is_int64_dtype('Int8') # doctest: +SKIP + False + >>> is_int64_dtype(pd.Int64Dtype) # doctest: +SKIP + True + >>> is_int64_dtype(float) # doctest: +SKIP + False + >>> is_int64_dtype(np.uint64) # unsigned # doctest: +SKIP + False + >>> is_int64_dtype(np.array(['a', 'b'])) # doctest: +SKIP + False + >>> is_int64_dtype(np.array([1, 2], dtype=np.int64)) # doctest: +SKIP + True + >>> is_int64_dtype(pd.Index([1, 2.])) # float # doctest: +SKIP + False + >>> is_int64_dtype(np.array([1, 2], dtype=np.uint32)) # unsigned # doctest: +SKIP + False + """ + # GH#52564 + warnings.warn( + "is_int64_dtype is deprecated and will be removed in a future " + "version. Use dtype == np.int64 instead.", + DeprecationWarning, + stacklevel=2, + ) + return _is_dtype_type(arr_or_dtype, classes(np.int64)) + + +def is_datetime64_any_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of the datetime64 dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + bool + Whether or not the array or dtype is of the datetime64 dtype. + + Examples + -------- + >>> from pandas.api.types import is_datetime64_any_dtype + >>> from pandas.core.dtypes.dtypes import DatetimeTZDtype + >>> is_datetime64_any_dtype(str) + False + >>> is_datetime64_any_dtype(int) + False + >>> is_datetime64_any_dtype(np.datetime64) # can be tz-naive + True + >>> is_datetime64_any_dtype(DatetimeTZDtype("ns", "US/Eastern")) + True + >>> is_datetime64_any_dtype(np.array(['a', 'b'])) + False + >>> is_datetime64_any_dtype(np.array([1, 2])) + False + >>> is_datetime64_any_dtype(np.array([], dtype="datetime64[ns]")) + True + >>> is_datetime64_any_dtype(pd.DatetimeIndex([1, 2, 3], dtype="datetime64[ns]")) + True + """ + if isinstance(arr_or_dtype, (np.dtype, ExtensionDtype)): + # GH#33400 fastpath for dtype object + return arr_or_dtype.kind == "M" + + if arr_or_dtype is None: + return False + + try: + tipo = _get_dtype(arr_or_dtype) + except TypeError: + return False + return lib.is_np_dtype(tipo, "M") or isinstance(tipo, DatetimeTZDtype) + + +def is_datetime64_ns_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of the datetime64[ns] dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + bool + Whether or not the array or dtype is of the datetime64[ns] dtype. + + Examples + -------- + >>> from pandas.api.types import is_datetime64_ns_dtype + >>> from pandas.core.dtypes.dtypes import DatetimeTZDtype + >>> is_datetime64_ns_dtype(str) + False + >>> is_datetime64_ns_dtype(int) + False + >>> is_datetime64_ns_dtype(np.datetime64) # no unit + False + >>> is_datetime64_ns_dtype(DatetimeTZDtype("ns", "US/Eastern")) + True + >>> is_datetime64_ns_dtype(np.array(['a', 'b'])) + False + >>> is_datetime64_ns_dtype(np.array([1, 2])) + False + >>> is_datetime64_ns_dtype(np.array([], dtype="datetime64")) # no unit + False + >>> is_datetime64_ns_dtype(np.array([], dtype="datetime64[ps]")) # wrong unit + False + >>> is_datetime64_ns_dtype(pd.DatetimeIndex([1, 2, 3], dtype="datetime64[ns]")) + True + """ + if arr_or_dtype is None: + return False + try: + tipo = _get_dtype(arr_or_dtype) + except TypeError: + return False + return tipo == DT64NS_DTYPE or ( + isinstance(tipo, DatetimeTZDtype) and tipo.unit == "ns" + ) + + +def is_timedelta64_ns_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of the timedelta64[ns] dtype. + + This is a very specific dtype, so generic ones like `np.timedelta64` + will return False if passed into this function. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of the timedelta64[ns] dtype. + + Examples + -------- + >>> from pandas.core.dtypes.common import is_timedelta64_ns_dtype + >>> is_timedelta64_ns_dtype(np.dtype('m8[ns]')) + True + >>> is_timedelta64_ns_dtype(np.dtype('m8[ps]')) # Wrong frequency + False + >>> is_timedelta64_ns_dtype(np.array([1, 2], dtype='m8[ns]')) + True + >>> is_timedelta64_ns_dtype(np.array([1, 2], dtype=np.timedelta64)) + False + """ + return _is_dtype(arr_or_dtype, lambda dtype: dtype == TD64NS_DTYPE) + + +# This exists to silence numpy deprecation warnings, see GH#29553 +def is_numeric_v_string_like(a: ArrayLike, b) -> bool: + """ + Check if we are comparing a string-like object to a numeric ndarray. + NumPy doesn't like to compare such objects, especially numeric arrays + and scalar string-likes. + + Parameters + ---------- + a : array-like, scalar + The first object to check. + b : array-like, scalar + The second object to check. + + Returns + ------- + boolean + Whether we return a comparing a string-like object to a numeric array. + + Examples + -------- + >>> is_numeric_v_string_like(np.array([1]), "foo") + True + >>> is_numeric_v_string_like(np.array([1, 2]), np.array(["foo"])) + True + >>> is_numeric_v_string_like(np.array(["foo"]), np.array([1, 2])) + True + >>> is_numeric_v_string_like(np.array([1]), np.array([2])) + False + >>> is_numeric_v_string_like(np.array(["foo"]), np.array(["foo"])) + False + """ + is_a_array = isinstance(a, np.ndarray) + is_b_array = isinstance(b, np.ndarray) + + is_a_numeric_array = is_a_array and a.dtype.kind in ("u", "i", "f", "c", "b") + is_b_numeric_array = is_b_array and b.dtype.kind in ("u", "i", "f", "c", "b") + is_a_string_array = is_a_array and a.dtype.kind in ("S", "U") + is_b_string_array = is_b_array and b.dtype.kind in ("S", "U") + + is_b_scalar_string_like = not is_b_array and isinstance(b, str) + + return ( + (is_a_numeric_array and is_b_scalar_string_like) + or (is_a_numeric_array and is_b_string_array) + or (is_b_numeric_array and is_a_string_array) + ) + + +def needs_i8_conversion(dtype: DtypeObj | None) -> bool: + """ + Check whether the dtype should be converted to int64. + + Dtype "needs" such a conversion if the dtype is of a datetime-like dtype + + Parameters + ---------- + dtype : np.dtype, ExtensionDtype, or None + + Returns + ------- + boolean + Whether or not the dtype should be converted to int64. + + Examples + -------- + >>> needs_i8_conversion(str) + False + >>> needs_i8_conversion(np.int64) + False + >>> needs_i8_conversion(np.datetime64) + False + >>> needs_i8_conversion(np.dtype(np.datetime64)) + True + >>> needs_i8_conversion(np.array(['a', 'b'])) + False + >>> needs_i8_conversion(pd.Series([1, 2])) + False + >>> needs_i8_conversion(pd.Series([], dtype="timedelta64[ns]")) + False + >>> needs_i8_conversion(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern")) + False + >>> needs_i8_conversion(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern").dtype) + True + """ + if isinstance(dtype, np.dtype): + return dtype.kind in "mM" + return isinstance(dtype, (PeriodDtype, DatetimeTZDtype)) + + +def is_numeric_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of a numeric dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of a numeric dtype. + + Examples + -------- + >>> from pandas.api.types import is_numeric_dtype + >>> is_numeric_dtype(str) + False + >>> is_numeric_dtype(int) + True + >>> is_numeric_dtype(float) + True + >>> is_numeric_dtype(np.uint64) + True + >>> is_numeric_dtype(np.datetime64) + False + >>> is_numeric_dtype(np.timedelta64) + False + >>> is_numeric_dtype(np.array(['a', 'b'])) + False + >>> is_numeric_dtype(pd.Series([1, 2])) + True + >>> is_numeric_dtype(pd.Index([1, 2.])) + True + >>> is_numeric_dtype(np.array([], dtype=np.timedelta64)) + False + """ + return _is_dtype_type( + arr_or_dtype, _classes_and_not_datetimelike(np.number, np.bool_) + ) or _is_dtype( + arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ._is_numeric + ) + + +def is_any_real_numeric_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of a real number dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of a real number dtype. + + Examples + -------- + >>> from pandas.api.types import is_any_real_numeric_dtype + >>> is_any_real_numeric_dtype(int) + True + >>> is_any_real_numeric_dtype(float) + True + >>> is_any_real_numeric_dtype(object) + False + >>> is_any_real_numeric_dtype(str) + False + >>> is_any_real_numeric_dtype(complex(1, 2)) + False + >>> is_any_real_numeric_dtype(bool) + False + """ + return ( + is_numeric_dtype(arr_or_dtype) + and not is_complex_dtype(arr_or_dtype) + and not is_bool_dtype(arr_or_dtype) + ) + + +def is_float_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of a float dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of a float dtype. + + Examples + -------- + >>> from pandas.api.types import is_float_dtype + >>> is_float_dtype(str) + False + >>> is_float_dtype(int) + False + >>> is_float_dtype(float) + True + >>> is_float_dtype(np.array(['a', 'b'])) + False + >>> is_float_dtype(pd.Series([1, 2])) + False + >>> is_float_dtype(pd.Index([1, 2.])) + True + """ + return _is_dtype_type(arr_or_dtype, classes(np.floating)) or _is_dtype( + arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind in "f" + ) + + +def is_bool_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of a boolean dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of a boolean dtype. + + Notes + ----- + An ExtensionArray is considered boolean when the ``_is_boolean`` + attribute is set to True. + + Examples + -------- + >>> from pandas.api.types import is_bool_dtype + >>> is_bool_dtype(str) + False + >>> is_bool_dtype(int) + False + >>> is_bool_dtype(bool) + True + >>> is_bool_dtype(np.bool_) + True + >>> is_bool_dtype(np.array(['a', 'b'])) + False + >>> is_bool_dtype(pd.Series([1, 2])) + False + >>> is_bool_dtype(np.array([True, False])) + True + >>> is_bool_dtype(pd.Categorical([True, False])) + True + >>> is_bool_dtype(pd.arrays.SparseArray([True, False])) + True + """ + if arr_or_dtype is None: + return False + try: + dtype = _get_dtype(arr_or_dtype) + except (TypeError, ValueError): + return False + + if isinstance(dtype, CategoricalDtype): + arr_or_dtype = dtype.categories + # now we use the special definition for Index + + if isinstance(arr_or_dtype, ABCIndex): + # Allow Index[object] that is all-bools or Index["boolean"] + if arr_or_dtype.inferred_type == "boolean": + if not is_bool_dtype(arr_or_dtype.dtype): + # GH#52680 + warnings.warn( + "The behavior of is_bool_dtype with an object-dtype Index " + "of bool objects is deprecated. In a future version, " + "this will return False. Cast the Index to a bool dtype instead.", + DeprecationWarning, + stacklevel=2, + ) + return True + return False + elif isinstance(dtype, ExtensionDtype): + return getattr(dtype, "_is_boolean", False) + + return issubclass(dtype.type, np.bool_) + + +def is_1d_only_ea_dtype(dtype: DtypeObj | None) -> bool: + """ + Analogue to is_extension_array_dtype but excluding DatetimeTZDtype. + """ + return isinstance(dtype, ExtensionDtype) and not dtype._supports_2d + + +def is_extension_array_dtype(arr_or_dtype) -> bool: + """ + Check if an object is a pandas extension array type. + + See the :ref:`Use Guide ` for more. + + Parameters + ---------- + arr_or_dtype : object + For array-like input, the ``.dtype`` attribute will + be extracted. + + Returns + ------- + bool + Whether the `arr_or_dtype` is an extension array type. + + Notes + ----- + This checks whether an object implements the pandas extension + array interface. In pandas, this includes: + + * Categorical + * Sparse + * Interval + * Period + * DatetimeArray + * TimedeltaArray + + Third-party libraries may implement arrays or types satisfying + this interface as well. + + Examples + -------- + >>> from pandas.api.types import is_extension_array_dtype + >>> arr = pd.Categorical(['a', 'b']) + >>> is_extension_array_dtype(arr) + True + >>> is_extension_array_dtype(arr.dtype) + True + + >>> arr = np.array(['a', 'b']) + >>> is_extension_array_dtype(arr.dtype) + False + """ + dtype = getattr(arr_or_dtype, "dtype", arr_or_dtype) + if isinstance(dtype, ExtensionDtype): + return True + elif isinstance(dtype, np.dtype): + return False + else: + try: + with warnings.catch_warnings(): + # pandas_dtype(..) can raise UserWarning for class input + warnings.simplefilter("ignore", UserWarning) + dtype = pandas_dtype(dtype) + except (TypeError, ValueError): + # np.dtype(..) can raise ValueError + return False + return isinstance(dtype, ExtensionDtype) + + +def is_ea_or_datetimelike_dtype(dtype: DtypeObj | None) -> bool: + """ + Check for ExtensionDtype, datetime64 dtype, or timedelta64 dtype. + + Notes + ----- + Checks only for dtype objects, not dtype-castable strings or types. + """ + return isinstance(dtype, ExtensionDtype) or (lib.is_np_dtype(dtype, "mM")) + + +def is_complex_dtype(arr_or_dtype) -> bool: + """ + Check whether the provided array or dtype is of a complex dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array or dtype to check. + + Returns + ------- + boolean + Whether or not the array or dtype is of a complex dtype. + + Examples + -------- + >>> from pandas.api.types import is_complex_dtype + >>> is_complex_dtype(str) + False + >>> is_complex_dtype(int) + False + >>> is_complex_dtype(np.complex128) + True + >>> is_complex_dtype(np.array(['a', 'b'])) + False + >>> is_complex_dtype(pd.Series([1, 2])) + False + >>> is_complex_dtype(np.array([1 + 1j, 5])) + True + """ + return _is_dtype_type(arr_or_dtype, classes(np.complexfloating)) + + +def _is_dtype(arr_or_dtype, condition) -> bool: + """ + Return true if the condition is satisfied for the arr_or_dtype. + + Parameters + ---------- + arr_or_dtype : array-like, str, np.dtype, or ExtensionArrayType + The array-like or dtype object whose dtype we want to extract. + condition : callable[Union[np.dtype, ExtensionDtype]] + + Returns + ------- + bool + + """ + if arr_or_dtype is None: + return False + try: + dtype = _get_dtype(arr_or_dtype) + except (TypeError, ValueError): + return False + return condition(dtype) + + +def _get_dtype(arr_or_dtype) -> DtypeObj: + """ + Get the dtype instance associated with an array + or dtype object. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype object whose dtype we want to extract. + + Returns + ------- + obj_dtype : The extract dtype instance from the + passed in array or dtype object. + + Raises + ------ + TypeError : The passed in object is None. + """ + if arr_or_dtype is None: + raise TypeError("Cannot deduce dtype from null object") + + # fastpath + if isinstance(arr_or_dtype, np.dtype): + return arr_or_dtype + elif isinstance(arr_or_dtype, type): + return np.dtype(arr_or_dtype) + + # if we have an array-like + elif hasattr(arr_or_dtype, "dtype"): + arr_or_dtype = arr_or_dtype.dtype + + return pandas_dtype(arr_or_dtype) + + +def _is_dtype_type(arr_or_dtype, condition) -> bool: + """ + Return true if the condition is satisfied for the arr_or_dtype. + + Parameters + ---------- + arr_or_dtype : array-like or dtype + The array-like or dtype object whose dtype we want to extract. + condition : callable[Union[np.dtype, ExtensionDtypeType]] + + Returns + ------- + bool : if the condition is satisfied for the arr_or_dtype + """ + if arr_or_dtype is None: + return condition(type(None)) + + # fastpath + if isinstance(arr_or_dtype, np.dtype): + return condition(arr_or_dtype.type) + elif isinstance(arr_or_dtype, type): + if issubclass(arr_or_dtype, ExtensionDtype): + arr_or_dtype = arr_or_dtype.type + return condition(np.dtype(arr_or_dtype).type) + + # if we have an array-like + if hasattr(arr_or_dtype, "dtype"): + arr_or_dtype = arr_or_dtype.dtype + + # we are not possibly a dtype + elif is_list_like(arr_or_dtype): + return condition(type(None)) + + try: + tipo = pandas_dtype(arr_or_dtype).type + except (TypeError, ValueError): + if is_scalar(arr_or_dtype): + return condition(type(None)) + + return False + + return condition(tipo) + + +def infer_dtype_from_object(dtype) -> type: + """ + Get a numpy dtype.type-style object for a dtype object. + + This methods also includes handling of the datetime64[ns] and + datetime64[ns, TZ] objects. + + If no dtype can be found, we return ``object``. + + Parameters + ---------- + dtype : dtype, type + The dtype object whose numpy dtype.type-style + object we want to extract. + + Returns + ------- + type + """ + if isinstance(dtype, type) and issubclass(dtype, np.generic): + # Type object from a dtype + + return dtype + elif isinstance(dtype, (np.dtype, ExtensionDtype)): + # dtype object + try: + _validate_date_like_dtype(dtype) + except TypeError: + # Should still pass if we don't have a date-like + pass + if hasattr(dtype, "numpy_dtype"): + # TODO: Implement this properly + # https://github.com/pandas-dev/pandas/issues/52576 + return dtype.numpy_dtype.type + return dtype.type + + try: + dtype = pandas_dtype(dtype) + except TypeError: + pass + + if isinstance(dtype, ExtensionDtype): + return dtype.type + elif isinstance(dtype, str): + # TODO(jreback) + # should deprecate these + if dtype in ["datetimetz", "datetime64tz"]: + return DatetimeTZDtype.type + elif dtype in ["period"]: + raise NotImplementedError + + if dtype in ["datetime", "timedelta"]: + dtype += "64" + try: + return infer_dtype_from_object(getattr(np, dtype)) + except (AttributeError, TypeError): + # Handles cases like _get_dtype(int) i.e., + # Python objects that are valid dtypes + # (unlike user-defined types, in general) + # + # TypeError handles the float16 type code of 'e' + # further handle internal types + pass + + return infer_dtype_from_object(np.dtype(dtype)) + + +def _validate_date_like_dtype(dtype) -> None: + """ + Check whether the dtype is a date-like dtype. Raises an error if invalid. + + Parameters + ---------- + dtype : dtype, type + The dtype to check. + + Raises + ------ + TypeError : The dtype could not be casted to a date-like dtype. + ValueError : The dtype is an illegal date-like dtype (e.g. the + frequency provided is too specific) + """ + try: + typ = np.datetime_data(dtype)[0] + except ValueError as e: + raise TypeError(e) from e + if typ not in ["generic", "ns"]: + raise ValueError( + f"{repr(dtype.name)} is too specific of a frequency, " + f"try passing {repr(dtype.type.__name__)}" + ) + + +def validate_all_hashable(*args, error_name: str | None = None) -> None: + """ + Return None if all args are hashable, else raise a TypeError. + + Parameters + ---------- + *args + Arguments to validate. + error_name : str, optional + The name to use if error + + Raises + ------ + TypeError : If an argument is not hashable + + Returns + ------- + None + """ + if not all(is_hashable(arg) for arg in args): + if error_name: + raise TypeError(f"{error_name} must be a hashable type") + raise TypeError("All elements must be hashable") + + +def pandas_dtype(dtype) -> DtypeObj: + """ + Convert input into a pandas only dtype object or a numpy dtype object. + + Parameters + ---------- + dtype : object to be converted + + Returns + ------- + np.dtype or a pandas dtype + + Raises + ------ + TypeError if not a dtype + + Examples + -------- + >>> pd.api.types.pandas_dtype(int) + dtype('int64') + """ + # short-circuit + if isinstance(dtype, np.ndarray): + return dtype.dtype + elif isinstance(dtype, (np.dtype, ExtensionDtype)): + return dtype + + # builtin aliases + if dtype is str and using_string_dtype(): + from pandas.core.arrays.string_ import StringDtype + + return StringDtype(na_value=np.nan) + + # registered extension types + result = registry.find(dtype) + if result is not None: + if isinstance(result, type): + # GH 31356, GH 54592 + warnings.warn( + f"Instantiating {result.__name__} without any arguments." + f"Pass a {result.__name__} instance to silence this warning.", + UserWarning, + stacklevel=find_stack_level(), + ) + result = result() + return result + + # try a numpy dtype + # raise a consistent TypeError if failed + try: + with warnings.catch_warnings(): + # TODO: warnings.catch_warnings can be removed when numpy>2.3.0 + # is the minimum version + # GH#51523 - Series.astype(np.integer) doesn't show + # numpy deprecation warning of np.integer + # Hence enabling DeprecationWarning + warnings.simplefilter("always", DeprecationWarning) + npdtype = np.dtype(dtype) + except SyntaxError as err: + # np.dtype uses `eval` which can raise SyntaxError + raise TypeError(f"data type '{dtype}' not understood") from err + + # Any invalid dtype (such as pd.Timestamp) should raise an error. + # np.dtype(invalid_type).kind = 0 for such objects. However, this will + # also catch some valid dtypes such as object, np.object_ and 'object' + # which we safeguard against by catching them earlier and returning + # np.dtype(valid_dtype) before this condition is evaluated. + if is_hashable(dtype) and dtype in [ + object, + np.object_, + "object", + "O", + "object_", + ]: + # check hashability to avoid errors/DeprecationWarning when we get + # here and `dtype` is an array + return npdtype + elif npdtype.kind == "O": + raise TypeError(f"dtype '{dtype}' not understood") + + return npdtype + + +def is_all_strings(value: ArrayLike) -> bool: + """ + Check if this is an array of strings that we should try parsing. + + Includes object-dtype ndarray containing all-strings, StringArray, + and Categorical with all-string categories. + Does not include numpy string dtypes. + """ + dtype = value.dtype + + if isinstance(dtype, np.dtype): + if len(value) == 0: + return dtype == np.dtype("object") + else: + return dtype == np.dtype("object") and lib.is_string_array( + np.asarray(value), skipna=False + ) + elif isinstance(dtype, CategoricalDtype): + return dtype.categories.inferred_type == "string" + return dtype == "string" + + +__all__ = [ + "classes", + "DT64NS_DTYPE", + "ensure_float64", + "ensure_python_int", + "ensure_str", + "infer_dtype_from_object", + "INT64_DTYPE", + "is_1d_only_ea_dtype", + "is_all_strings", + "is_any_real_numeric_dtype", + "is_array_like", + "is_bool", + "is_bool_dtype", + "is_categorical_dtype", + "is_complex", + "is_complex_dtype", + "is_dataclass", + "is_datetime64_any_dtype", + "is_datetime64_dtype", + "is_datetime64_ns_dtype", + "is_datetime64tz_dtype", + "is_decimal", + "is_dict_like", + "is_dtype_equal", + "is_ea_or_datetimelike_dtype", + "is_extension_array_dtype", + "is_file_like", + "is_float_dtype", + "is_int64_dtype", + "is_integer_dtype", + "is_interval", + "is_interval_dtype", + "is_iterator", + "is_named_tuple", + "is_nested_list_like", + "is_number", + "is_numeric_dtype", + "is_object_dtype", + "is_period_dtype", + "is_re", + "is_re_compilable", + "is_scipy_sparse", + "is_sequence", + "is_signed_integer_dtype", + "is_sparse", + "is_string_dtype", + "is_string_or_object_np_dtype", + "is_timedelta64_dtype", + "is_timedelta64_ns_dtype", + "is_unsigned_integer_dtype", + "needs_i8_conversion", + "pandas_dtype", + "TD64NS_DTYPE", + "validate_all_hashable", +] diff --git a/shared/package-files/42/42dcd63495f87b4eb7c7757afa379bb55a53f94afd7a5f657d9adf57236e515c/blob b/shared/package-files/42/42dcd63495f87b4eb7c7757afa379bb55a53f94afd7a5f657d9adf57236e515c/blob new file mode 100644 index 0000000000000000000000000000000000000000..a9f853e43069b8e3f8a156a4af2b1198a004230d --- /dev/null +++ b/shared/package-files/42/42dcd63495f87b4eb7c7757afa379bb55a53f94afd7a5f657d9adf57236e515c/blob @@ -0,0 +1,19 @@ +Copyright (c) 2022 Julian Berman + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/shared/package-files/42/42e07e12f5e64ee960e4cb88e1a2c4dc696614d4c62ae9403fe0d05bd4c15d4e/blob b/shared/package-files/42/42e07e12f5e64ee960e4cb88e1a2c4dc696614d4c62ae9403fe0d05bd4c15d4e/blob new file mode 100644 index 0000000000000000000000000000000000000000..4433d76d29636a974159ed67a53423d5702972d1 --- /dev/null +++ b/shared/package-files/42/42e07e12f5e64ee960e4cb88e1a2c4dc696614d4c62ae9403fe0d05bd4c15d4e/blob @@ -0,0 +1,118 @@ +from sympy.core import Integer, Pow, Mod +from sympy import factorint + + +def is_nilpotent_number(n): + """ + Check whether `n` is a nilpotent number. A number `n` is said to be + nilpotent if and only if every finite group of order `n` is nilpotent. + For more information see [1]_. + + Examples + ======== + + >>> from sympy.combinatorics.group_numbers import is_nilpotent_number + >>> from sympy import randprime + >>> is_nilpotent_number(21) + False + >>> is_nilpotent_number(randprime(1, 30)**12) + True + + References + ========== + + .. [1] Pakianathan, J., Shankar, K., *Nilpotent Numbers*, + The American Mathematical Monthly, 107(7), 631-634. + + + """ + if n <= 0 or int(n) != n: + raise ValueError("n must be a positive integer, not %i" % n) + + n = Integer(n) + prime_factors = list(factorint(n).items()) + is_nilpotent = True + for p_j, a_j in prime_factors: + for p_i, a_i in prime_factors: + if any([Mod(Pow(p_i, k), p_j) == 1 for k in range(1, a_i + 1)]): + is_nilpotent = False + break + if not is_nilpotent: + break + + return is_nilpotent + + +def is_abelian_number(n): + """ + Check whether `n` is an abelian number. A number `n` is said to be abelian + if and only if every finite group of order `n` is abelian. For more + information see [1]_. + + Examples + ======== + + >>> from sympy.combinatorics.group_numbers import is_abelian_number + >>> from sympy import randprime + >>> is_abelian_number(4) + True + >>> is_abelian_number(randprime(1, 2000)**2) + True + >>> is_abelian_number(60) + False + + References + ========== + + .. [1] Pakianathan, J., Shankar, K., *Nilpotent Numbers*, + The American Mathematical Monthly, 107(7), 631-634. + + + """ + if n <= 0 or int(n) != n: + raise ValueError("n must be a positive integer, not %i" % n) + + n = Integer(n) + if not is_nilpotent_number(n): + return False + + prime_factors = list(factorint(n).items()) + is_abelian = all(a_i < 3 for p_i, a_i in prime_factors) + return is_abelian + + +def is_cyclic_number(n): + """ + Check whether `n` is a cyclic number. A number `n` is said to be cyclic + if and only if every finite group of order `n` is cyclic. For more + information see [1]_. + + Examples + ======== + + >>> from sympy.combinatorics.group_numbers import is_cyclic_number + >>> from sympy import randprime + >>> is_cyclic_number(15) + True + >>> is_cyclic_number(randprime(1, 2000)**2) + False + >>> is_cyclic_number(4) + False + + References + ========== + + .. [1] Pakianathan, J., Shankar, K., *Nilpotent Numbers*, + The American Mathematical Monthly, 107(7), 631-634. + + """ + if n <= 0 or int(n) != n: + raise ValueError("n must be a positive integer, not %i" % n) + + n = Integer(n) + if not is_nilpotent_number(n): + return False + + prime_factors = list(factorint(n).items()) + is_cyclic = all(a_i < 2 for p_i, a_i in prime_factors) + return is_cyclic diff --git a/shared/package-files/42/42e103b61173d259b3336f85df9ddf0cb94f39202068ac4382738fe9cddf4dce/blob b/shared/package-files/42/42e103b61173d259b3336f85df9ddf0cb94f39202068ac4382738fe9cddf4dce/blob new file mode 100644 index 0000000000000000000000000000000000000000..626dd09bfbf6cfdefb9b9c985bad9b07ced45332 --- /dev/null +++ b/shared/package-files/42/42e103b61173d259b3336f85df9ddf0cb94f39202068ac4382738fe9cddf4dce/blob @@ -0,0 +1,1262 @@ +""" +Test VAR Model +""" +from statsmodels.compat.pandas import ( + QUARTER_END, + _infer_freq_returns_offset, + assert_index_equal, +) +from statsmodels.compat.python import lrange + +from contextlib import nullcontext +from io import BytesIO +from pathlib import Path +import warnings + +import numpy as np +from numpy.testing import assert_allclose, assert_almost_equal, assert_equal +import pandas as pd +import pytest + +from statsmodels.datasets import macrodata +import statsmodels.tools.data as data_util +from statsmodels.tools.sm_exceptions import ValueWarning +from statsmodels.tsa.base.datetools import dates_from_str +from statsmodels.tsa.stattools import acovf +from statsmodels.tsa.vector_ar import util +from statsmodels.tsa.vector_ar.hypothesis_test_results import ( + ErrorBand, + ForecastInterval, +) +from statsmodels.tsa.vector_ar.var_model import VAR, VARProcess, forecast, var_acf + +DECIMAL_12 = 12 +DECIMAL_6 = 6 +DECIMAL_5 = 5 +DECIMAL_4 = 4 +DECIMAL_3 = 3 +DECIMAL_2 = 2 + + +@pytest.fixture +def bivariate_var_data(): + """A bivariate dataset for VAR estimation""" + rs = np.random.RandomState(2382178) + e = rs.standard_normal((252, 2)) + y = np.zeros_like(e) + y[:2] = e[:2] + for i in range(2, 252): + y[i] = 0.2 * y[i - 1] + 0.1 * y[i - 2] + e[i] + return y + + +@pytest.fixture +def bivariate_var_result(bivariate_var_data): + """A bivariate VARResults for reuse""" + mod = VAR(bivariate_var_data) + return mod.fit() + + +class CheckVAR: # FIXME: not inherited, so these tests are never run! + # just so pylint will not complain + res1 = None + res2 = None + + def test_params(self): + assert_almost_equal(self.res1.params, self.res2.params, DECIMAL_3) + + def test_neqs(self): + assert_equal(self.res1.neqs, self.res2.neqs) + + def test_nobs(self): + assert_equal(self.res1.avobs, self.res2.nobs) + + def test_df_eq(self): + assert_equal(self.res1.df_eq, self.res2.df_eq) + + def test_rmse(self): + results = self.res1.results + for i in range(len(results)): + assert_almost_equal( + results[i].mse_resid ** 0.5, + eval("self.res2.rmse_" + str(i + 1)), + DECIMAL_6, + ) + + def test_rsquared(self): + results = self.res1.results + for i in range(len(results)): + assert_almost_equal( + results[i].rsquared, + eval("self.res2.rsquared_" + str(i + 1)), + DECIMAL_3, + ) + + def test_llf(self): + results = self.res1.results + assert_almost_equal(self.res1.llf, self.res2.llf, DECIMAL_2) + for i in range(len(results)): + assert_almost_equal( + results[i].llf, eval("self.res2.llf_" + str(i + 1)), DECIMAL_2 + ) + + def test_aic(self): + assert_almost_equal(self.res1.aic, self.res2.aic) + + def test_bic(self): + assert_almost_equal(self.res1.bic, self.res2.bic) + + def test_hqic(self): + assert_almost_equal(self.res1.hqic, self.res2.hqic) + + def test_fpe(self): + assert_almost_equal(self.res1.fpe, self.res2.fpe) + + def test_detsig(self): + assert_almost_equal(self.res1.detomega, self.res2.detsig) + + def test_bse(self): + assert_almost_equal(self.res1.bse, self.res2.bse, DECIMAL_4) + + +def get_macrodata(): + data = macrodata.load_pandas().data[["realgdp", "realcons", "realinv"]] + data = data.to_records(index=False) + nd = data.view((float, 3), type=np.ndarray) + nd = np.diff(np.log(nd), axis=0) + return nd.ravel().view(data.dtype, type=np.ndarray) + + +def generate_var(): # FIXME: make a test? + import pandas.rpy.common as prp + from rpy2.robjects import r + + r.source("tests/var.R") + return prp.convert_robj(r["result"], use_pandas=False) + + +def write_generate_var(): # FIXME: make a test? + result = generate_var() + np.savez("tests/results/vars_results.npz", **result) + + +class RResults: + """ + Simple interface with results generated by "vars" package in R. + """ + + def __init__(self): + # data = np.load(resultspath + 'vars_results.npz') + from .results.results_var_data import var_results + + data = var_results.__dict__ + + self.names = data["coefs"].dtype.names + self.params = data["coefs"].view((float, len(self.names)), type=np.ndarray) + self.stderr = data["stderr"].view((float, len(self.names)), type=np.ndarray) + + self.irf = data["irf"].item() + self.orth_irf = data["orthirf"].item() + + self.nirfs = int(data["nirfs"][0]) + self.nobs = int(data["obs"][0]) + self.totobs = int(data["totobs"][0]) + + crit = data["crit"].item() + self.aic = crit["aic"][0] + self.sic = self.bic = crit["sic"][0] + self.hqic = crit["hqic"][0] + self.fpe = crit["fpe"][0] + + self.detomega = data["detomega"][0] + self.loglike = data["loglike"][0] + + self.nahead = int(data["nahead"][0]) + self.ma_rep = data["phis"] + + self.causality = data["causality"] + + +class CheckIRF: + ref = None + res = None + irf = None + k = None + + # --------------------------------------------------------------------------- + # IRF tests + + def test_irf_coefs(self): + self._check_irfs(self.irf.irfs, self.ref.irf) + self._check_irfs(self.irf.orth_irfs, self.ref.orth_irf) + + def _check_irfs(self, py_irfs, r_irfs): + for i, name in enumerate(self.res.names): + ref_irfs = r_irfs[name].view((float, self.k), type=np.ndarray) + res_irfs = py_irfs[:, :, i] + assert_almost_equal(ref_irfs, res_irfs) + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_plot_irf(self, close_figures): + self.irf.plot() + self.irf.plot(plot_stderr=False) + + self.irf.plot(impulse=0, response=1) + self.irf.plot(impulse=0) + self.irf.plot(response=0) + + self.irf.plot(orth=True) + self.irf.plot(impulse=0, response=1, orth=True) + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_plot_cum_effects(self, close_figures): + self.irf.plot_cum_effects() + self.irf.plot_cum_effects(plot_stderr=False) + self.irf.plot_cum_effects(impulse=0, response=1) + + self.irf.plot_cum_effects(orth=True) + self.irf.plot_cum_effects(impulse=0, response=1, orth=True) + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_plot_figsizes(self, close_figures): + assert_equal(self.irf.plot().get_size_inches(), (10, 10)) + assert_equal(self.irf.plot(figsize=(14, 10)).get_size_inches(), (14, 10)) + + assert_equal(self.irf.plot_cum_effects().get_size_inches(), (10, 10)) + assert_equal( + self.irf.plot_cum_effects(figsize=(14, 10)).get_size_inches(), + (14, 10), + ) + + +@pytest.mark.smoke +class CheckFEVD: + fevd = None + + # --------------------------------------------------------------------------- + # FEVD tests + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_fevd_plot(self, close_figures): + import matplotlib.pyplot as plt + + assert isinstance(self.fevd.plot(), plt.Figure) + + def test_fevd_repr(self): + assert hasattr(self.fevd, "plot") + assert hasattr(self.fevd, "cov") + + def test_fevd_summary(self): + self.fevd.summary() + + def test_fevd_cov(self): + # test does not crash + # not implemented + with pytest.raises(NotImplementedError): + self.fevd.cov() + + +class TestVARResults(CheckIRF, CheckFEVD): + + def setup_method(self): + self.p = 2 + + self.data = get_macrodata() + self.model = VAR(self.data) + self.names = self.model.endog_names + + self.ref = RResults() + self.k = len(self.ref.names) + self.res = self.model.fit(maxlags=self.p) + + self.irf = self.res.irf(self.ref.nirfs) + self.nahead = self.ref.nahead + + self.fevd = self.res.fevd() + + def test_constructor(self): + # make sure this works with no names + ndarr = self.data.view((float, 3), type=np.ndarray) + model = VAR(ndarr) + model.fit(self.p) + + def test_names(self): + assert_equal(self.model.endog_names, self.ref.names) + + model2 = VAR(self.data) + assert_equal(model2.endog_names, self.ref.names) + + def test_get_eq_index(self): + assert type(self.res.names) is list + + for i, name in enumerate(self.names): + idx = self.res.get_eq_index(i) + idx2 = self.res.get_eq_index(name) + + assert_equal(idx, i) + assert_equal(idx, idx2) + + with pytest.raises(ValueError): + self.res.get_eq_index("foo") + + @pytest.mark.smoke + def test_repr(self): + # just want this to work + str(self.res) + repr(self.res) + + def test_params(self): + assert_almost_equal(self.res.params, self.ref.params, DECIMAL_3) + + @pytest.mark.smoke + def test_cov_params(self): + # do nothing for now + assert isinstance(self.res.cov_params(), np.ndarray) + + @pytest.mark.smoke + def test_cov_ybar(self): + self.res.cov_ybar() + + @pytest.mark.smoke + def test_tstat(self): + assert isinstance(self.res.tvalues, np.ndarray) + + @pytest.mark.smoke + def test_pvalues(self): + assert isinstance(self.res.pvalues, np.ndarray) + + @pytest.mark.smoke + def test_summary(self): + summ = self.res.summary() + assert "Summary of " in str(summ) + + def test_detsig(self): + assert_almost_equal(self.res.detomega, self.ref.detomega) + + def test_aic(self): + assert_almost_equal(self.res.aic, self.ref.aic) + + def test_bic(self): + assert_almost_equal(self.res.bic, self.ref.bic) + + def test_hqic(self): + assert_almost_equal(self.res.hqic, self.ref.hqic) + + def test_fpe(self): + assert_almost_equal(self.res.fpe, self.ref.fpe) + + def test_lagorder_select(self): + ics = ["aic", "fpe", "hqic", "bic"] + + for ic in ics: + # Smoke test + self.model.fit(maxlags=10, ic=ic, verbose=True) + + with pytest.raises(TypeError): + self.model.fit(ic="foo") + + def test_nobs(self): + assert_equal(self.res.nobs, self.ref.nobs) + + def test_stderr(self): + assert_almost_equal(self.res.stderr, self.ref.stderr, DECIMAL_4) + + def test_loglike(self): + assert_almost_equal(self.res.llf, self.ref.loglike) + + def test_ma_rep(self): + ma_rep = self.res.ma_rep(self.nahead) + assert_almost_equal(ma_rep, self.ref.ma_rep) + + # -------------------------------------------------- + # Lots of tests to make sure stuff works...need to check correctness + + def test_causality(self): + causedby = self.ref.causality["causedby"] + + for i, name in enumerate(self.names): + variables = self.names[:i] + self.names[i + 1 :] + result = self.res.test_causality(name, variables, kind="f") + assert_almost_equal(result.pvalue, causedby[i], DECIMAL_4) + + rng = lrange(self.k) + rng.remove(i) + result2 = self.res.test_causality(i, rng, kind="f") + assert_almost_equal(result.pvalue, result2.pvalue, DECIMAL_12) + + # make sure works + result = self.res.test_causality(name, variables, kind="wald") + + # corner cases + _ = self.res.test_causality(self.names[0], self.names[1]) + _ = self.res.test_causality(0, 1) + + with pytest.raises(ValueError): + self.res.test_causality(0, 1, kind="foo") + + def test_causality_no_lags(self): + res = VAR(self.data).fit(maxlags=0) + with pytest.raises(RuntimeError, match="0 lags"): + res.test_causality(0, 1) + + @pytest.mark.smoke + def test_select_order(self): + result = self.model.fit(10, ic="aic", verbose=True) + assert isinstance(result.params, np.ndarray) + result = self.model.fit(10, ic="fpe", verbose=True) + assert isinstance(result.params, np.ndarray) + + # bug + model = VAR(self.model.endog) + model.select_order() + + def test_is_stable(self): + # may not necessarily be true for other datasets + assert self.res.is_stable(verbose=True) + + def test_acf(self): + # test that it works...for now + acfs = self.res.acf(10) + + # defaults to nlags=lag_order + acfs = self.res.acf() + assert len(acfs) == self.p + 1 + + def test_acf_2_lags(self): + c = np.zeros((2, 2, 2)) + c[0] = np.array([[0.2, 0.1], [0.15, 0.15]]) + c[1] = np.array([[0.1, 0.9], [0, 0.1]]) + + acf = var_acf(c, np.eye(2), 3) + + gamma = np.zeros((6, 6)) + gamma[:2, :2] = acf[0] + gamma[2:4, 2:4] = acf[0] + gamma[4:6, 4:6] = acf[0] + gamma[2:4, :2] = acf[1].T + gamma[4:, :2] = acf[2].T + gamma[:2, 2:4] = acf[1] + gamma[:2, 4:] = acf[2] + recovered = np.dot(gamma[:2, 2:], np.linalg.inv(gamma[:4, :4])) + recovered = [recovered[:, 2 * i : 2 * (i + 1)] for i in range(2)] + recovered = np.array(recovered) + assert_allclose(recovered, c, atol=1e-7) + + @pytest.mark.smoke + def test_acorr(self): + acorrs = self.res.acorr(10) + assert acorrs.shape == (11, 3, 3) + + @pytest.mark.smoke + def test_forecast(self): + self.res.forecast(self.res.endog[-5:], 5) + + @pytest.mark.smoke + def test_forecast_interval(self): + y = self.res.endog[: -self.p :] + res = self.res.forecast_interval(y, 5) + assert isinstance(res, ForecastInterval) + point, lower, upper = res + assert point is res.point_forecast + assert lower is res.forc_lower + assert upper is res.forc_upper + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_plot_sim(self, close_figures): + rs = np.random.RandomState(923298321) + self.res.plotsim(steps=100, rng=rs) + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_plot(self, close_figures): + self.res.plot() + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_plot_acorr(self, close_figures): + self.res.plot_acorr() + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_plot_forecast(self, close_figures): + self.res.plot_forecast(5) + + def test_reorder(self): + # manually reorder + data = self.data.view((float, 3), type=np.ndarray) + names = self.names + data2 = np.append( + np.append(data[:, 2, None], data[:, 0, None], axis=1), + data[:, 1, None], + axis=1, + ) + names2 = [] + names2.append(names[2]) + names2.append(names[0]) + names2.append(names[1]) + res2 = VAR(data2).fit(maxlags=self.p) + + # use reorder function + res3 = self.res.reorder(["realinv", "realgdp", "realcons"]) + + # check if the main results match + assert_almost_equal(res2.params, res3.params) + assert_almost_equal(res2.sigma_u, res3.sigma_u) + assert_almost_equal(res2.bic, res3.bic) + assert_almost_equal(res2.stderr, res3.stderr) + + +def test_pickle(): + # Removed from class to allow thread safe testing + fh = BytesIO() + p = 2 + data = get_macrodata() + model = VAR(data) + res = model.fit(maxlags=p) + # test wrapped results load save pickle + del res.model.data.orig_endog + res.save(fh) + fh.seek(0, 0) + res_unpickled = res.__class__.load(fh) + assert type(res_unpickled) is type(res) + + +class E1_Results: + """ + Results from Lütkepohl (2005) using E2 dataset + """ + + def __init__(self): + # Lutkepohl p. 120 results + + # I asked the author about these results and there is probably rounding + # error in the book, so I adjusted these test results to match what is + # coming out of the Python (double-checked) calculations + self.irf_stderr = np.array( + [ + [ + [0.125, 0.546, 0.664], + [0.032, 0.139, 0.169], + [0.026, 0.112, 0.136], + ], + [ + [0.129, 0.547, 0.663], + [0.032, 0.134, 0.163], + [0.026, 0.108, 0.131], + ], + [ + [0.084, 0.385, 0.479], + [0.016, 0.079, 0.095], + [0.016, 0.078, 0.103], + ], + ] + ) + + self.cum_irf_stderr = np.array( + [ + [ + [0.125, 0.546, 0.664], + [0.032, 0.139, 0.169], + [0.026, 0.112, 0.136], + ], + [ + [0.149, 0.631, 0.764], + [0.044, 0.185, 0.224], + [0.033, 0.140, 0.169], + ], + [ + [0.099, 0.468, 0.555], + [0.038, 0.170, 0.205], + [0.033, 0.150, 0.185], + ], + ] + ) + + self.lr_stderr = np.array( + [ + [0.134, 0.645, 0.808], + [0.048, 0.230, 0.288], + [0.043, 0.208, 0.260], + ] + ) + + +basepath = Path(__file__).parent +resultspath = basepath / "results" + + +def get_lutkepohl_data(name="e2"): + path = Path(resultspath).joinpath(f"{name}.dat") + + return util.parse_lutkepohl_data(path) + + +def test_lutkepohl_parse(): + files = [f"e{i:d}" for i in range(1, 7)] + + for f in files: + get_lutkepohl_data(f) + + +class TestVARResultsLutkepohl: + """ + Verify calculations using results from Lütkepohl's book + """ + + @classmethod + def setup_class(cls): + cls.p = 2 + sdata, dates = get_lutkepohl_data("e1") + + data = data_util.struct_to_ndarray(sdata) + adj_data = np.diff(np.log(data), axis=0) + # est = VAR(adj_data, p=2, dates=dates[1:], names=names) + + cls.model = VAR(adj_data[:-16], dates=dates[1:-16], freq=f"B{QUARTER_END}-MAR") + cls.res = cls.model.fit(maxlags=cls.p) + cls.irf = cls.res.irf(10) + cls.lut = E1_Results() + + def test_approx_mse(self): + # 3.5.18, p. 99 + mse2 = ( + np.array( + [ + [25.12, 0.580, 1.300], + [0.580, 1.581, 0.586], + [1.300, 0.586, 1.009], + ] + ) + * 1e-4 + ) + + assert_almost_equal(mse2, self.res.forecast_cov(3)[1], DECIMAL_3) + + def test_irf_stderr(self): + irf_stderr = self.irf.stderr(orth=False) + for i in range(1, 1 + len(self.lut.irf_stderr)): + assert_almost_equal(np.round(irf_stderr[i], 3), self.lut.irf_stderr[i - 1]) + + def test_cum_irf_stderr(self): + stderr = self.irf.cum_effect_stderr(orth=False) + for i in range(1, 1 + len(self.lut.cum_irf_stderr)): + assert_almost_equal(np.round(stderr[i], 3), self.lut.cum_irf_stderr[i - 1]) + + def test_lr_effect_stderr(self): + stderr = self.irf.lr_effect_stderr(orth=False) + orth_stderr = self.irf.lr_effect_stderr(orth=True) + assert orth_stderr.shape == stderr.shape + assert_almost_equal(np.round(stderr, 3), self.lut.lr_stderr) + + +def test_get_trendorder(): + results = {"c": 1, "n": 0, "ct": 2, "ctt": 3} + + for t, trendorder in results.items(): + assert util.get_trendorder(t) == trendorder + + +def test_var_constant(): + # see 2043 + import datetime + + from pandas import DataFrame, DatetimeIndex + + series = np.array([[2.0, 2.0], [1, 2.0], [1, 2.0], [1, 2.0], [1.0, 2.0]]) + data = DataFrame(series) + + d = datetime.datetime.now() + delta = datetime.timedelta(days=1) + index = [] + for _ in range(data.shape[0]): + index.append(d) + d += delta + + data.index = DatetimeIndex(index) + + # with pytest.warns(ValueWarning): # does not silence warning in test output + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=ValueWarning) + model = VAR(data) + with pytest.raises(ValueError): + model.fit(1) + + +def test_var_trend(): + # see 2271 + data = get_macrodata().view((float, 3), type=np.ndarray) + + model = VAR(data) + results = model.fit(4) # , trend = 'c') + irf = results.irf(10) + assert irf.irfs.shape == (11, 3, 3) + + data_nc = data - data.mean(0) + model_nc = VAR(data_nc) + # Fit once with a trend + model_nc.fit(4, trend="n") + with pytest.raises(ValueError): + # Attempt to change the trend + model.fit(4, trend="t") + + +@pytest.mark.parametrize( + "trend,k_trend", [("c", 1), ("ct", 2), ("ctt", 3), ("n", 0)] +) +def test_var_fit_valid_trend(trend, k_trend): + data = get_macrodata().view((float, 3), type=np.ndarray) + results = VAR(data).fit(2, trend=trend) + assert results.k_trend == k_trend + + +def test_var_fit_invalid_trend_raises(): + data = get_macrodata().view((float, 3), type=np.ndarray) + with pytest.raises(ValueError, match="trend"): + VAR(data).fit(2, trend="not-a-trend") + + +def test_irf_trend(): + # test for irf with different trend see #1636 + # this is a rough comparison by adding trend or subtracting mean to data + # to get similar AR coefficients and IRF + data = get_macrodata().view((float, 3), type=np.ndarray) + + model = VAR(data) + results = model.fit(4) # , trend = 'c') + irf = results.irf(10) + + data_nc = data - data.mean(0) + model_nc = VAR(data_nc) + results_nc = model_nc.fit(4, trend="n") + irf_nc = results_nc.irf(10) + + assert_allclose(irf_nc.stderr()[1:4], irf.stderr()[1:4], rtol=0.01) + + trend = 1e-3 * np.arange(len(data)) / (len(data) - 1) + # for pandas version, currently not used, if data is a pd.DataFrame + # data_t = pd.DataFrame(data.values + trend[:,None], index=data.index, columns=data.columns) + data_t = data + trend[:, None] + + model_t = VAR(data_t) + results_t = model_t.fit(4, trend="ct") + irf_t = results_t.irf(10) + + assert_allclose(irf_t.stderr()[1:4], irf.stderr()[1:4], rtol=0.03) + + +class TestVARExtras: + @classmethod + def setup_class(cls): + mdata = macrodata.load_pandas().data + mdata = mdata[["realgdp", "realcons", "realinv"]] + data = mdata.values + data = np.diff(np.log(data), axis=0) * 400 + cls.res0 = VAR(data).fit(maxlags=2) + cls.resl1 = VAR(data).fit(maxlags=1) + cls.data = data + + def test_process(self, close_figures): + res0 = self.res0 + k_ar = res0.k_ar + fc20 = res0.forecast(res0.endog[-k_ar:], 20) + mean_lr = res0.mean() + assert_allclose(mean_lr, fc20[-1], rtol=5e-4) + + ysim = res0.simulate_var(rng=np.random.RandomState(987128)) + assert_allclose(ysim.mean(0), mean_lr, rtol=0.1) + # initialization does not use long run intercept, see #4542 + assert_allclose(ysim[0], res0.intercept, rtol=1e-10) + assert_allclose(ysim[1], res0.intercept, rtol=1e-10) + + data = self.data + resl1 = self.resl1 + y_sim_init = res0.simulate_var(rng=np.random.RandomState(987128), initial_values=data[-k_ar:]) + y_sim_init_2 = res0.simulate_var(rng=np.random.RandomState(987128), initial_values=data[-1]) + assert_allclose(y_sim_init[:k_ar], data[-k_ar:]) + assert_allclose(y_sim_init_2[0], data[-1]) + assert_allclose(y_sim_init_2[k_ar - 1], data[-1]) + + y_sim_init_3 = resl1.simulate_var(rng=np.random.RandomState(987128), initial_values=data[-1]) + assert_allclose(y_sim_init_3[0], data[-1]) + + n_sim = 900 + ysimz = res0.simulate_var(steps=n_sim, offset=np.zeros((n_sim, 3)), rng=np.random.RandomState(987128)) + zero3 = np.zeros(3) + assert_allclose(ysimz.mean(0), zero3, atol=0.4) + # initialization does not use long run intercept, see #4542 + assert_allclose(ysimz[0], zero3, atol=1e-10) + assert_allclose(ysimz[1], zero3, atol=1e-10) + + # check attributes + assert_equal(res0.k_trend, 1) + assert_equal(res0.k_exog_user, 0) + assert_equal(res0.k_exog, 1) + assert_equal(res0.k_ar, 2) + + # Smoke test + res0.irf() + + def test_simulate_var_int_seed_warns_consistently(self): + # GH: simulate_var relied on varsim's internal warn=False, so an + # int/array seed silently used the legacy RandomState behavior + # with no FutureWarning, unlike every other simulate()-style + # method in the library (e.g. MLEResults.simulate). + res0 = self.res0 + with pytest.warns(FutureWarning): + res0.simulate_var(rng=987128) + with warnings.catch_warnings(): + warnings.simplefilter("error") + res0.simulate_var(rng=np.random.RandomState(987128)) + res0.simulate_var(rng=np.random.default_rng(987128)) + + @pytest.mark.thread_unsafe(reason="uses matplotlib") + @pytest.mark.matplotlib + def test_process_plotting(self, close_figures): + # Partially a smoke test + res0 = self.res0 + k_ar = res0.k_ar + fc20 = res0.forecast(res0.endog[-k_ar:], 20) + irf = res0.irf() + + rs = np.random.RandomState(429238921) + res0.plotsim(rng=rs) + res0.plot_acorr() + + fig = res0.plot_forecast(20) + fcp = fig.axes[0].get_children()[1].get_ydata()[-20:] + # Note values are equal, but keep rtol buffer + assert_allclose(fc20[:, 0], fcp, rtol=1e-13) + fcp = fig.axes[1].get_children()[1].get_ydata()[-20:] + assert_allclose(fc20[:, 1], fcp, rtol=1e-13) + fcp = fig.axes[2].get_children()[1].get_ydata()[-20:] + assert_allclose(fc20[:, 2], fcp, rtol=1e-13) + + fig_asym = irf.plot(rng=rs) + fig_mc = irf.plot( + stderr_type="mc", repl=1000, rng=np.random.RandomState(987128) + ) + + for k in range(3): + a = fig_asym.axes[1].get_children()[k].get_ydata() + m = fig_mc.axes[1].get_children()[k].get_ydata() + # use m as desired because it is larger + # a is for some irf much smaller than m + assert_allclose(a, m, atol=0.1, rtol=0.9) + + def test_forecast_cov(self): + # forecast_cov can include parameter uncertainty if contant-only + res = self.res0 + + covfc1 = res.forecast_cov(3) + assert_allclose(covfc1, res.mse(3), rtol=1e-13) + # ignore warning, TODO: assert OutputWarning + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + covfc2 = res.forecast_cov(3, method="auto") + assert_allclose(covfc2, covfc1, rtol=0.05) + # regression test, TODO: replace with verified numbers (Stata) + res_covfc2 = np.array( + [ + [ + [9.45802013, 4.94142038, 37.1999646], + [4.94142038, 7.09273624, 5.66215089], + [37.1999646, 5.66215089, 259.61275869], + ], + [ + [11.30364479, 5.72569141, 49.28744123], + [5.72569141, 7.409761, 10.98164091], + [49.28744123, 10.98164091, 336.4484723], + ], + [ + [12.36188803, 6.44426905, 53.54588026], + [6.44426905, 7.88850029, 13.96382545], + [53.54588026, 13.96382545, 352.19564327], + ], + ] + ) + assert_allclose(covfc2, res_covfc2, atol=1e-6) + + def test_exog(self): + # check that trend and exog are equivalent for basics and varsim + data = self.res0.model.endog + res_lin_trend = VAR(data).fit(maxlags=2, trend="ct") + ex = np.arange(len(data)) + res_lin_trend1 = VAR(data, exog=ex).fit(maxlags=2) + ex2 = np.arange(len(data))[:, None] ** [0, 1] + res_lin_trend2 = VAR(data, exog=ex2).fit(maxlags=2, trend="n") + # TODO: intercept differs by 4e-3, others are < 1e-12 + assert_allclose(res_lin_trend.params, res_lin_trend1.params, rtol=5e-3) + assert_allclose(res_lin_trend.params, res_lin_trend2.params, rtol=5e-3) + assert_allclose(res_lin_trend1.params, res_lin_trend2.params, rtol=1e-10) + + y1 = res_lin_trend.simulate_var(rng=np.random.RandomState(987128)) + y2 = res_lin_trend1.simulate_var(rng=np.random.RandomState(987128)) + y3 = res_lin_trend2.simulate_var(rng=np.random.RandomState(987128)) + assert_allclose(y2.mean(0), y1.mean(0), rtol=1e-12) + assert_allclose(y3.mean(0), y1.mean(0), rtol=1e-12) + assert_allclose(y3.mean(0), y2.mean(0), rtol=1e-12) + + h = 10 + fc1 = res_lin_trend.forecast(res_lin_trend.endog[-2:], h) + exf = np.arange(len(data), len(data) + h) + fc2 = res_lin_trend1.forecast(res_lin_trend1.endog[-2:], h, exog_future=exf) + with pytest.raises(ValueError, match="exog_future only has"): + wrong_exf = np.arange(len(data), len(data) + h // 2) + res_lin_trend1.forecast(res_lin_trend1.endog[-2:], h, exog_future=wrong_exf) + exf2 = exf[:, None] ** [0, 1] + fc3 = res_lin_trend2.forecast(res_lin_trend2.endog[-2:], h, exog_future=exf2) + assert_allclose(fc2, fc1, rtol=1e-12, atol=1e-12) + assert_allclose(fc3, fc1, rtol=1e-12, atol=1e-12) + assert_allclose(fc3, fc2, rtol=1e-12, atol=1e-12) + + fci1 = res_lin_trend.forecast_interval(res_lin_trend.endog[-2:], h) + exf = np.arange(len(data), len(data) + h) + fci2 = res_lin_trend1.forecast_interval( + res_lin_trend1.endog[-2:], h, exog_future=exf + ) + exf2 = exf[:, None] ** [0, 1] + fci3 = res_lin_trend2.forecast_interval( + res_lin_trend2.endog[-2:], h, exog_future=exf2 + ) + for field in ("point_forecast", "forc_lower", "forc_upper"): + assert_allclose( + getattr(fci2, field), getattr(fci1, field), rtol=1e-12, atol=1e-12 + ) + assert_allclose( + getattr(fci3, field), getattr(fci1, field), rtol=1e-12, atol=1e-12 + ) + assert_allclose( + getattr(fci3, field), getattr(fci2, field), rtol=1e-12, atol=1e-12 + ) + + def test_multiple_simulations(self): + res0 = self.res0 + k_ar = res0.k_ar + neqs = res0.neqs + init = self.data[-k_ar:] + + sim1 = res0.simulate_var(rng=np.random.RandomState(987128), steps=10) + sim2 = res0.simulate_var(rng=np.random.RandomState(987128), steps=10, nsimulations=2) + assert_equal(sim2.shape, (2, 10, neqs)) + assert_allclose(sim1, sim2[0]) + + sim2_init = res0.simulate_var( + rng=np.random.RandomState(987128), steps=10, initial_values=init, nsimulations=2 + ) + assert_allclose(sim2_init[0, :k_ar], init) + assert_allclose(sim2_init[1, :k_ar], init) + + +def test_var_cov_params_pandas(bivariate_var_data): + df = pd.DataFrame(bivariate_var_data, columns=["x", "y"]) + mod = VAR(df) + res = mod.fit(2) + cov = res.cov_params() + assert isinstance(cov, pd.DataFrame) + exog_names = ("const", "L1.x", "L1.y", "L2.x", "L2.y") + index = pd.MultiIndex.from_product((exog_names, ("x", "y"))) + assert_index_equal(cov.index, cov.columns) + assert_index_equal(cov.index, index) + + +def test_summaries_exog(): + rs = np.random.RandomState(2182378) + y = rs.standard_normal((500, 6)) + df = pd.DataFrame(y) + cols = [f"endog_{i}" for i in range(2)] + [f"exog_{i}" for i in range(4)] + df.columns = cols + df.index = pd.date_range("1-1-1950", periods=500, freq="MS") + endog = df.iloc[:, :2] + exog = df.iloc[:, 2:] + + res = VAR(endog=endog, exog=exog).fit(maxlags=0) + summ = res.summary().summary + assert "exog_0" in summ + assert "exog_1" in summ + assert "exog_2" in summ + assert "exog_3" in summ + + res = VAR(endog=endog, exog=exog).fit(maxlags=2) + summ = res.summary().summary + assert "exog_0" in summ + assert "exog_1" in summ + assert "exog_2" in summ + assert "exog_3" in summ + + +def test_whiteness_nlag(): + # GH 6686 + rs = np.random.RandomState(233078) + y = rs.standard_normal((200, 2)) + res = VAR(y).fit(maxlags=1, ic=None) + with pytest.raises(ValueError, match="The whiteness test can only"): + res.test_whiteness(1) + + +def test_var_maxlag(): + rs = np.random.RandomState(2382378) + y = rs.standard_normal((22, 10)) + VAR(y).fit(maxlags=None, ic="aic") + with pytest.raises(ValueError, match="maxlags is too large"): + VAR(y).fit(maxlags=8, ic="aic") + + +def test_from_formula(): + with pytest.raises(NotImplementedError): + VAR.from_formula("y ~ x", None) + + +def test_correct_nobs(): + # GH6748 + mdata = macrodata.load_pandas().data + # prepare the dates index + dates = mdata[["year", "quarter"]].astype(int).astype(str) + quarterly = dates["year"] + "Q" + dates["quarter"] + quarterly = dates_from_str(quarterly) + mdata = mdata[["realgdp", "realcons", "realinv"]] + mdata.index = pd.DatetimeIndex(quarterly) + data = np.log(mdata).diff().dropna() + with _infer_freq_returns_offset(): + data.index.freq = data.index.inferred_freq + data_exog = pd.DataFrame(index=data.index) + rs = np.random.RandomState(238971) + data_exog["exovar1"] = rs.normal(size=data_exog.shape[0]) + # make a VAR model + model = VAR(endog=data, exog=data_exog) + results = model.fit(maxlags=1) + irf = results.irf_resim( + orth=False, + repl=100, + steps=10, + rng=np.random.RandomState(1), + burn=100, + cum=False, + ) + assert irf.shape == (100, 11, 3, 3) + + +@pytest.mark.parametrize( + "rng", + [0, np.random.RandomState(0), np.random.default_rng(0)], + ids=["int", "randomstate", "generator"], +) +def test_irf_resim_replications_differ(rng): + # GH: irf_resim re-derived a fresh generator from the raw seed on + # every Monte Carlo iteration instead of advancing a single + # generator, so every replication was identical when an int seed + # (or any freshly-instantiated RandomState/Generator) was used. + rs = np.random.RandomState(3489) + y = rs.standard_normal((60, 2)).cumsum(axis=0) + res = VAR(y).fit(maxlags=1) + warn_cm = pytest.warns(FutureWarning) if isinstance(rng, int) else nullcontext() + with warn_cm: + sim = res.irf_resim(repl=5, steps=3, rng=rng, burn=10) + assert not np.allclose(sim[0], sim[1]) + assert not np.allclose(sim[1], sim[2]) + + +def test_irf_resim_reproducible_with_int_seed(): + rs = np.random.RandomState(3489) + y = rs.standard_normal((60, 2)).cumsum(axis=0) + res = VAR(y).fit(maxlags=1) + with pytest.warns(FutureWarning): + sim1 = res.irf_resim(repl=5, steps=3, rng=0, burn=10) + with pytest.warns(FutureWarning): + sim2 = res.irf_resim(repl=5, steps=3, rng=0, burn=10) + assert_allclose(sim1, sim2) + + +@pytest.mark.slow +def test_irf_err_bands(): + # smoke tests + data = get_macrodata() + model = VAR(data) + results = model.fit(maxlags=2) + irf = results.irf() + # Smoke tests only + rs = np.random.RandomState(2389711) + for res in ( + irf.err_band_sz1(rng=rs), + irf.err_band_sz2(rng=rs), + irf.err_band_sz3(rng=rs), + irf.errband_mc(rng=rs), + irf.cum_errband_mc(rng=rs), + ): + assert isinstance(res, ErrorBand) + assert res[0] is res.lower + assert res[1] is res.upper + + +@pytest.mark.matplotlib +def test_irf_plot_err_bands_kwarg(close_figures): + # test that user can pass precalculated error bands to plot and plot_cum_effects + data = get_macrodata() + model = VAR(data) + results = model.fit(maxlags=2) + irf = results.irf() + + # Precalculate + err_bands = irf.errband_mc(repl=10) + + # Use in plot (bypassing internal calculation) + fig1 = irf.plot(err_bands=err_bands, stderr_type="mc") + assert fig1 is not None + + cum_err_bands = irf.cum_errband_mc(repl=10) + fig2 = irf.plot_cum_effects(err_bands=cum_err_bands, stderr_type="mc") + assert fig2 is not None + + +def test_irf_invalid_stderr_type_raises(bivariate_var_result): + irf = bivariate_var_result.irf() + with pytest.raises(ValueError, match="stderr_type"): + irf.plot(stderr_type="invalid") + with pytest.raises(ValueError, match="stderr_type"): + irf.plot_cum_effects(stderr_type="invalid") + + +def test_0_lag(): + # GH 9412 + rs = np.random.RandomState(20260112) + y = rs.randn(500, 2) + results = VAR(y).fit(maxlags=0, ic="bic", trend="c") + assert results.params.shape == (1, 2) + fcasts = results.forecast(y, steps=5) + assert_allclose(fcasts, np.ones((5, 1)) * results.params) + + +def test_forecast_wrong_shape_params(): + # GH 9412 + rs = np.random.RandomState(233751) + y = rs.rand(300, 2) + mod = VAR(y) + results = mod.fit(maxlags=1, ic="aic", trend="c") + with pytest.raises(ValueError): + forecast(y, results.params, results.params, steps=5) + + +def test_var_model_predict_matches_forecast_and_fittedvalues(): + # VAR.predict(params, start, end, lags, trend) is the model-level + # prediction method exported alongside VARResults.forecast, but every + # existing test exercises forecast() instead, leaving predict() + # completely uncovered. start/end are locations in the full `endog` + # array (length n_totobs), not in the post-lag-adjustment `nobs`, and + # a valid `start` must be in-sample (<= n_totobs - 1) even when + # requesting out-of-sample values via `end`. + dta = macrodata.load_pandas().data + data = dta[["realgdp", "realcons", "realinv"]].pct_change().dropna().to_numpy() + + mod = VAR(data) + res = mod.fit(maxlags=2, trend="c") + lags = res.k_ar + n_totobs = mod.n_totobs + + # In-sample predictions must reproduce the fitted values exactly. + in_sample = mod.predict( + res.params, start=lags, end=n_totobs - 1, lags=lags, trend="c" + ) + assert_allclose(in_sample, res.fittedvalues, atol=1e-12) + + # Out-of-sample predictions must reproduce VARResults.forecast(): the + # last `steps` rows of predict() with a fully in-sample `start` should + # equal a `steps`-ahead forecast from the end of the sample. + steps = 5 + mixed = mod.predict( + res.params, start=n_totobs - 1, end=n_totobs - 1 + steps, + lags=lags, trend="c", + ) + assert mixed.shape == (steps + 1, 3) + assert_allclose(mixed[0], res.fittedvalues[-1], atol=1e-12) + assert_allclose(mixed[1:], res.forecast(data[-lags:], steps), atol=1e-10) + + +def test_sample_acov(bivariate_var_result): + # VARResults.sample_acov was never called by any existing test. Check + # it against an independently hand-computed cross-product + # autocovariance of the (post-presample) endog data, and cross-check + # the diagonal (each column's own autocovariance) against the + # separately-tested univariate acovf function. + res = bivariate_var_result + nlags = 4 + acov = res.sample_acov(nlags=nlags) + assert acov.shape == (nlags + 1, 2, 2) + + x = res.endog[res.k_ar :] + xm = x - x.mean(axis=0) + nobs = xm.shape[0] + expected = np.empty_like(acov) + for lag in range(nlags + 1): + for i in range(2): + for j in range(2): + a = xm[lag:, i] if lag else xm[:, i] + b = xm[: nobs - lag, j] if lag else xm[:, j] + expected[lag, i, j] = np.sum(a * b) / nobs + assert_allclose(acov, expected) + + for col in range(2): + ref = acovf(x[:, col], demean=True, fft=False, nlag=nlags) + assert_allclose(acov[:, col, col], ref) + + +def test_sample_acorr(bivariate_var_result): + # VARResults.sample_acorr was never called by any existing test. Its + # docstring-documented relationship to sample_acov is that it is + # normalized by the lag-0 (co)variances, which is checked exactly here, + # along with the lag-0 self-autocorrelation being 1. + res = bivariate_var_result + nlags = 4 + acov = res.sample_acov(nlags=nlags) + acorr = res.sample_acorr(nlags=nlags) + + sd = np.sqrt(np.diag(acov[0])) + expected = acov / np.outer(sd, sd) + assert_allclose(acorr, expected) + assert_allclose(np.diag(acorr[0]), np.ones(2)) + + +@pytest.mark.thread_unsafe(reason="uses matplotlib") +@pytest.mark.matplotlib +def test_varprocess_plot_acorr(bivariate_var_result, close_figures): + # VARResults defines its own plot_acorr (residual/sample autocorrelation + # of a *fitted* model), which shadows VARProcess.plot_acorr (theoretical + # autocorrelation of a *known* process) for every VARResults instance, + # so `VARResults_instance.plot_acorr()` never runs VARProcess's version. + # Build a plain VARProcess from the fitted coefficients to exercise the + # VARProcess implementation directly, and check the plotted bar heights + # against the already-tested theoretical acorr() output. + res = bivariate_var_result + process = VARProcess(res.coefs, res.coefs_exog, res.sigma_u, names=res.names) + assert type(process).plot_acorr is VARProcess.plot_acorr + + nlags = 4 + fig = process.plot_acorr(nlags=nlags) + expected = process.acorr(nlags=nlags) + k = process.neqs + assert len(fig.axes) == k * k + for idx, ax in enumerate(fig.axes): + i, j = divmod(idx, k) + heights = np.array([seg[1, 1] for seg in ax.collections[0].get_segments()]) + assert_allclose(heights, expected[:, i, j]) + + +@pytest.mark.thread_unsafe(reason="uses matplotlib") +@pytest.mark.matplotlib +def test_plot_sample_acorr(bivariate_var_result, close_figures): + # VARResults.plot_sample_acorr was never called by any existing test. + # Check the plotted bar heights against the independently-verified + # sample_acorr() output (see test_sample_acorr above). + res = bivariate_var_result + nlags = 4 + fig = res.plot_sample_acorr(nlags=nlags) + expected = res.sample_acorr(nlags=nlags) + k = res.neqs + assert len(fig.axes) == k * k + for idx, ax in enumerate(fig.axes): + i, j = divmod(idx, k) + heights = np.array([seg[1, 1] for seg in ax.collections[0].get_segments()]) + assert_allclose(heights, expected[:, i, j]) diff --git a/shared/package-files/42/42e156db357cc2a63b3c3e4f1db50c2507376be7391327e48db969e2e98eca53/blob b/shared/package-files/42/42e156db357cc2a63b3c3e4f1db50c2507376be7391327e48db969e2e98eca53/blob new file mode 100644 index 0000000000000000000000000000000000000000..9d528d34e36845efd44126c087cd15cd81e1e02e --- /dev/null +++ b/shared/package-files/42/42e156db357cc2a63b3c3e4f1db50c2507376be7391327e48db969e2e98eca53/blob @@ -0,0 +1,120 @@ +""" +frozen (immutable) data structures to support MultiIndexing + +These are used for: + +- .names (FrozenList) + +""" +from __future__ import annotations + +from typing import ( + TYPE_CHECKING, + NoReturn, +) + +from pandas.core.base import PandasObject + +from pandas.io.formats.printing import pprint_thing + +if TYPE_CHECKING: + from pandas._typing import Self + + +class FrozenList(PandasObject, list): + """ + Container that doesn't allow setting item *but* + because it's technically hashable, will be used + for lookups, appropriately, etc. + """ + + # Side note: This has to be of type list. Otherwise, + # it messes up PyTables type checks. + + def union(self, other) -> FrozenList: + """ + Returns a FrozenList with other concatenated to the end of self. + + Parameters + ---------- + other : array-like + The array-like whose elements we are concatenating. + + Returns + ------- + FrozenList + The collection difference between self and other. + """ + if isinstance(other, tuple): + other = list(other) + return type(self)(super().__add__(other)) + + def difference(self, other) -> FrozenList: + """ + Returns a FrozenList with elements from other removed from self. + + Parameters + ---------- + other : array-like + The array-like whose elements we are removing self. + + Returns + ------- + FrozenList + The collection difference between self and other. + """ + other = set(other) + temp = [x for x in self if x not in other] + return type(self)(temp) + + # TODO: Consider deprecating these in favor of `union` (xref gh-15506) + # error: Incompatible types in assignment (expression has type + # "Callable[[FrozenList, Any], FrozenList]", base class "list" defined the + # type as overloaded function) + __add__ = __iadd__ = union # type: ignore[assignment] + + def __getitem__(self, n): + if isinstance(n, slice): + return type(self)(super().__getitem__(n)) + return super().__getitem__(n) + + def __radd__(self, other) -> Self: + if isinstance(other, tuple): + other = list(other) + return type(self)(other + list(self)) + + def __eq__(self, other: object) -> bool: + if isinstance(other, (tuple, FrozenList)): + other = list(other) + return super().__eq__(other) + + __req__ = __eq__ + + def __mul__(self, other) -> Self: + return type(self)(super().__mul__(other)) + + __imul__ = __mul__ + + def __reduce__(self): + return type(self), (list(self),) + + # error: Signature of "__hash__" incompatible with supertype "list" + def __hash__(self) -> int: # type: ignore[override] + return hash(tuple(self)) + + def _disabled(self, *args, **kwargs) -> NoReturn: + """ + This method will not function because object is immutable. + """ + raise TypeError(f"'{type(self).__name__}' does not support mutable operations.") + + def __str__(self) -> str: + return pprint_thing(self, quote_strings=True, escape_chars=("\t", "\r", "\n")) + + def __repr__(self) -> str: + return f"{type(self).__name__}({str(self)})" + + __setitem__ = __setslice__ = _disabled # type: ignore[assignment] + __delitem__ = __delslice__ = _disabled + pop = append = extend = _disabled + remove = sort = insert = _disabled # type: ignore[assignment] diff --git a/shared/package-files/42/42e1b603d7452183cad6f657e06331c6020dc000745b0aff08cfdefcafa31fbb/blob b/shared/package-files/42/42e1b603d7452183cad6f657e06331c6020dc000745b0aff08cfdefcafa31fbb/blob new file mode 100644 index 0000000000000000000000000000000000000000..cd36cc9cac05fe011ae72432be72b3540f352579 --- /dev/null +++ b/shared/package-files/42/42e1b603d7452183cad6f657e06331c6020dc000745b0aff08cfdefcafa31fbb/blob @@ -0,0 +1,302 @@ +# Copyright (C) 2014 Anaconda, Inc +# SPDX-License-Identifier: BSD-3-Clause +import json +import logging +import os +import time +from concurrent.futures import Executor +from functools import partial +from os.path import dirname + +from conda.core.index import get_index +from conda_index.index import update_index as _update_index + +from . import conda_interface, utils +from .conda_interface import CondaHTTPError, context, url_path +from .deprecations import deprecated +from .utils import ( + CONDA_PACKAGE_EXTENSION_V1, + CONDA_PACKAGE_EXTENSION_V2, + JSONDecodeError, + get_logger, + on_win, +) + +log = get_logger(__name__) + + +@deprecated("24.3", "24.5") +class DummyExecutor(Executor): + def map(self, func, *iterables): + for iterable in iterables: + for thing in iterable: + yield func(thing) + + +local_index_timestamp = 0 +cached_index = None +local_subdir = "" +local_output_folder = "" +cached_channels = [] +_channel_data = {} +deprecated.constant("24.1", "24.5", "channel_data", _channel_data) + + +# TODO: support for libarchive seems to have broken ability to use multiple threads here. +# The new conda format is so much faster that it more than makes up for it. However, it +# would be nice to fix this at some point. +_MAX_THREADS_DEFAULT = os.cpu_count() or 1 +if on_win: # see https://github.com/python/cpython/commit/8ea0fd85bc67438f679491fae29dfe0a3961900a + _MAX_THREADS_DEFAULT = min(48, _MAX_THREADS_DEFAULT) +deprecated.constant("24.3", "24.5", "MAX_THREADS_DEFAULT", _MAX_THREADS_DEFAULT) +deprecated.constant("24.3", "24.5", "LOCK_TIMEOUT_SECS", 3 * 3600) +deprecated.constant("24.3", "24.5", "LOCKFILE_NAME", ".lock") + +# TODO: this is to make sure that the index doesn't leak tokens. It breaks use of private channels, though. +# os.environ['CONDA_ADD_ANACONDA_TOKEN'] = "false" + + +def get_build_index( + subdir, + bldpkgs_dir, + output_folder=None, + clear_cache=False, + omit_defaults=False, + channel_urls=None, + debug=False, + verbose=True, + locking=None, + timeout=None, +): + """ + Used during package builds to create/get a channel including any local or + newly built packages. This function both updates and gets index data. + """ + global local_index_timestamp + global local_subdir + global local_output_folder + global cached_index + global cached_channels + global _channel_data + mtime = 0 + + channel_urls = list(utils.ensure_list(channel_urls)) + + if not output_folder: + output_folder = dirname(bldpkgs_dir) + + # check file modification time - this is the age of our local index. + index_file = os.path.join(output_folder, subdir, "repodata.json") + if os.path.isfile(index_file): + mtime = os.path.getmtime(index_file) + + if ( + clear_cache + or not os.path.isfile(index_file) + or local_subdir != subdir + or local_output_folder != output_folder + or mtime > local_index_timestamp + or cached_channels != channel_urls + ): + # priority: (local as either croot or output_folder IF NOT EXPLICITLY IN CHANNEL ARGS), + # then channels passed as args (if local in this, it remains in same order), + # then channels from condarc. + urls = list(channel_urls) + + loggers = utils.LoggingContext.default_loggers + [__name__] + if debug: + log_context = partial(utils.LoggingContext, logging.DEBUG, loggers=loggers) + elif verbose: + log_context = partial(utils.LoggingContext, logging.WARN, loggers=loggers) + else: + log_context = partial( + utils.LoggingContext, logging.CRITICAL + 1, loggers=loggers + ) + with log_context(): + # this is where we add the "local" channel. It's a little smarter than conda, because + # conda does not know about our output_folder when it is not the default setting. + if os.path.isdir(output_folder): + local_path = url_path(output_folder) + # replace local with the appropriate real channel. Order is maintained. + urls = [url if url != "local" else local_path for url in urls] + if local_path not in urls: + urls.insert(0, local_path) + _ensure_valid_channel(output_folder, subdir) + _delegated_update_index(output_folder, verbose=debug) + + # replace noarch with native subdir - this ends up building an index with both the + # native content and the noarch content. + + if subdir == "noarch": + subdir = conda_interface.subdir + try: + # get_index() is like conda reading the index, not conda_index + # creating a new index. + cached_index = get_index( + channel_urls=urls, + prepend=not omit_defaults, + use_local=False, + use_cache=context.offline, + platform=subdir, + ) + # HACK: defaults does not have the many subfolders we support. Omit it and + # try again. + except CondaHTTPError: + if "defaults" in urls: + urls.remove("defaults") + cached_index = get_index( + channel_urls=urls, + prepend=omit_defaults, + use_local=False, + use_cache=context.offline, + platform=subdir, + ) + + expanded_channels = {rec.channel for rec in cached_index} + + superchannel = {} + # we need channeldata.json too, as it is a more reliable source of run_exports data + for channel in expanded_channels: + if channel.scheme == "file": + location = channel.location + if utils.on_win: + location = location.lstrip("/") + elif not os.path.isabs(channel.location) and os.path.exists( + os.path.join(os.path.sep, channel.location) + ): + location = os.path.join(os.path.sep, channel.location) + channeldata_file = os.path.join( + location, channel.name, "channeldata.json" + ) + retry = 0 + max_retries = 1 + if os.path.isfile(channeldata_file): + while retry < max_retries: + try: + with open(channeldata_file, "r+") as f: + _channel_data[channel.name] = json.load(f) + break + except (OSError, JSONDecodeError): + time.sleep(0.2) + retry += 1 + else: + # download channeldata.json for url + if not context.offline: + try: + _channel_data[channel.name] = utils.download_channeldata( + channel.base_url + "/channeldata.json" + ) + except CondaHTTPError: + continue + # collapse defaults metachannel back into one superchannel, merging channeldata + if channel.base_url in context.default_channels and _channel_data.get( + channel.name + ): + packages = superchannel.get("packages", {}) + packages.update(_channel_data[channel.name]) + superchannel["packages"] = packages + _channel_data["defaults"] = superchannel + local_index_timestamp = os.path.getmtime(index_file) + local_subdir = subdir + local_output_folder = output_folder + cached_channels = channel_urls + return cached_index, local_index_timestamp, _channel_data + + +def _ensure_valid_channel(local_folder, subdir): + for folder in {subdir, "noarch"}: + path = os.path.join(local_folder, folder) + if not os.path.isdir(path): + os.makedirs(path) + + +def _delegated_update_index( + dir_path, + check_md5=False, + channel_name=None, + patch_generator=None, + threads=1, + verbose=False, + progress=False, + subdirs=None, + warn=True, + current_index_versions=None, + debug=False, +): + """ + update_index as called by conda-build, delegating to standalone conda-index. + Needed to allow update_index calls on single subdir. + """ + # conda-build calls update_index on a single subdir internally, but + # conda-index expects to index every subdir under dir_path + parent_path, dirname = os.path.split(dir_path) + if dirname in utils.DEFAULT_SUBDIRS: + dir_path = parent_path + subdirs = [dirname] + + log_level = logging.DEBUG if debug else logging.INFO if verbose else logging.WARNING + with utils.LoggingContext(log_level): + return _update_index( + dir_path, + check_md5=check_md5, + channel_name=channel_name, + patch_generator=patch_generator, + threads=threads, + verbose=verbose, + progress=progress, + subdirs=subdirs, + warn=warn, + current_index_versions=current_index_versions, + debug=debug, + ) + + +@deprecated( + "24.1.0", "24.5.0", addendum="Use `conda_index._apply_instructions` instead." +) +def _apply_instructions(subdir, repodata, instructions): + repodata.setdefault("removed", []) + utils.merge_or_update_dict( + repodata.get("packages", {}), + instructions.get("packages", {}), + merge=False, + add_missing_keys=False, + ) + # we could have totally separate instructions for .conda than .tar.bz2, but it's easier if we assume + # that a similarly-named .tar.bz2 file is the same content as .conda, and shares fixes + new_pkg_fixes = { + k.replace(CONDA_PACKAGE_EXTENSION_V1, CONDA_PACKAGE_EXTENSION_V2): v + for k, v in instructions.get("packages", {}).items() + } + + utils.merge_or_update_dict( + repodata.get("packages.conda", {}), + new_pkg_fixes, + merge=False, + add_missing_keys=False, + ) + utils.merge_or_update_dict( + repodata.get("packages.conda", {}), + instructions.get("packages.conda", {}), + merge=False, + add_missing_keys=False, + ) + + for fn in instructions.get("revoke", ()): + for key in ("packages", "packages.conda"): + if fn.endswith(CONDA_PACKAGE_EXTENSION_V1) and key == "packages.conda": + fn = fn.replace(CONDA_PACKAGE_EXTENSION_V1, CONDA_PACKAGE_EXTENSION_V2) + if fn in repodata[key]: + repodata[key][fn]["revoked"] = True + repodata[key][fn]["depends"].append("package_has_been_revoked") + + for fn in instructions.get("remove", ()): + for key in ("packages", "packages.conda"): + if fn.endswith(CONDA_PACKAGE_EXTENSION_V1) and key == "packages.conda": + fn = fn.replace(CONDA_PACKAGE_EXTENSION_V1, CONDA_PACKAGE_EXTENSION_V2) + popped = repodata[key].pop(fn, None) + if popped: + repodata["removed"].append(fn) + repodata["removed"].sort() + + return repodata diff --git a/shared/package-files/42/42e1f1dbcd103ae63b87fdaddd232059b36b0bfdcd769ee1647597ad393f8f19/blob b/shared/package-files/42/42e1f1dbcd103ae63b87fdaddd232059b36b0bfdcd769ee1647597ad393f8f19/blob new file mode 100644 index 0000000000000000000000000000000000000000..7fb62745e4e0b9c6e942bac48a5d172592a30a4f --- /dev/null +++ b/shared/package-files/42/42e1f1dbcd103ae63b87fdaddd232059b36b0bfdcd769ee1647597ad393f8f19/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & to_mkldnn_out(at::Tensor & out, const at::Tensor & self, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor & to_mkldnn_outf(const at::Tensor & self, c10::optional dtype, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/42/42e2bd675b98a5cbf43c6944b064f3da3c7addb287d5b82c6641004ca4a5c706/blob b/shared/package-files/42/42e2bd675b98a5cbf43c6944b064f3da3c7addb287d5b82c6641004ca4a5c706/blob new file mode 100644 index 0000000000000000000000000000000000000000..5e6348b5c543a5ecb46c97f713a77a14816f1bcc --- /dev/null +++ b/shared/package-files/42/42e2bd675b98a5cbf43c6944b064f3da3c7addb287d5b82c6641004ca4a5c706/blob @@ -0,0 +1,339 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + + +import json +import os +import signal +import socket +from string import Template +import uuid +from typing import Any, Dict, Optional, Tuple + +import torch.distributed.elastic.timer as timer +from torch.distributed.elastic import events + +from torch.distributed.elastic.agent.server.api import ( + RunResult, + SimpleElasticAgent, + WorkerGroup, + WorkerSpec, + WorkerState, +) +from torch.distributed.elastic.events.api import EventMetadataValue +from torch.distributed.elastic.metrics.api import prof +from torch.distributed.elastic.multiprocessing import PContext, start_processes, LogsSpecs +from torch.distributed.elastic.utils import macros +from torch.distributed.elastic.utils.logging import get_logger + +log = get_logger(__name__) + +__all__ = [ + "LocalElasticAgent", + "TORCHELASTIC_ENABLE_FILE_TIMER", + "TORCHELASTIC_TIMER_FILE", +] + +TORCHELASTIC_ENABLE_FILE_TIMER = "TORCHELASTIC_ENABLE_FILE_TIMER" +TORCHELASTIC_TIMER_FILE = "TORCHELASTIC_TIMER_FILE" + +class LocalElasticAgent(SimpleElasticAgent): + """An implementation of :py:class:`torchelastic.agent.server.ElasticAgent` that handles host-local workers. + + This agent is deployed per host and is configured to spawn ``n`` workers. + When using GPUs, ``n`` maps to the number of GPUs available on the host. + + The local agent does not communicate to other local agents deployed on + other hosts, even if the workers may communicate inter-host. The worker id + is interpreted to be a local process. The agent starts and stops all worker + processes as a single unit. + + + The worker function and argument passed to the worker function must be + python multiprocessing compatible. To pass multiprocessing data structures + to the workers you may create the data structure in the same multiprocessing + context as the specified ``start_method`` and pass it as a function argument. + + The ``exit_barrier_timeout`` specifies the amount of time (in seconds) to wait + for other agents to finish. This acts as a safety net to handle cases where + workers finish at different times, to prevent agents from viewing workers + that finished early as a scale-down event. It is strongly advised that the + user code deal with ensuring that workers are terminated in a synchronous + manner rather than relying on the exit_barrier_timeout. + + A named pipe based watchdog can be enabled in ```LocalElasticAgent``` if an + environment variable ``TORCHELASTIC_ENABLE_FILE_TIMER`` with value 1 has + been defined in the ```LocalElasticAgent``` process. + Optionally, another environment variable ```TORCHELASTIC_TIMER_FILE``` + can be set with a unique file name for the named pipe. If the environment + variable ```TORCHELASTIC_TIMER_FILE``` is not set, ```LocalElasticAgent``` + will internally create a unique file name and set it to the environment + variable ```TORCHELASTIC_TIMER_FILE```, and this environment variable will + be propagated to the worker processes to allow them to connect to the same + named pipe that ```LocalElasticAgent``` uses. + + Logs are written to the specified log directory. Each log line will be by default + prefixed by ``[${role_name}${local_rank}]:`` (e.g. ``[trainer0]: foobar``). + Log prefixes can be customized by passing a `template string + `_ as the + ``log_line_prefix_template`` argument. + The following macros (identifiers) are substituted at runtime: + ``${role_name}, ${local_rank}, ${rank}``. For example, to prefix each log line with + global rank instead of the local rank, set ``log_line_prefix_template = "[${rank}]:``. + + + Example launching function + + :: + + def trainer(args) -> str: + return "do train" + + def main(): + start_method="spawn" + shared_queue= multiprocessing.get_context(start_method).Queue() + spec = WorkerSpec( + role="trainer", + local_world_size=nproc_per_process, + entrypoint=trainer, + args=("foobar",), + ...) + agent = LocalElasticAgent(spec, start_method) + results = agent.run() + + if results.is_failed(): + print("trainer failed") + else: + print(f"rank 0 return value: {results.return_values[0]}") + # prints -> rank 0 return value: do train + + Example launching binary + + :: + + def main(): + spec = WorkerSpec( + role="trainer", + local_world_size=nproc_per_process, + entrypoint="/usr/local/bin/trainer", + args=("--trainer-args", "foobar"), + ...) + agent = LocalElasticAgent(spec) + results = agent.run() + + if not results.is_failed(): + print("binary launches do not have return values") + + """ + + def __init__( + self, + spec: WorkerSpec, + logs_specs: LogsSpecs, + start_method="spawn", + exit_barrier_timeout: float = 300, + log_line_prefix_template: Optional[str] = None, + ): + super().__init__(spec, exit_barrier_timeout) + self._start_method = start_method + self._pcontext: Optional[PContext] = None + self._rdzv_handler = spec.rdzv_handler + self._log_line_prefix_template = log_line_prefix_template + self._worker_watchdog: Optional[timer.FileTimerServer] = None + self._logs_specs = logs_specs + + + def _setup_local_watchdog(self, envs: Dict[int, Dict[str, str]]) -> None: + enable_watchdog_env_name = TORCHELASTIC_ENABLE_FILE_TIMER + watchdog_enabled = os.getenv(enable_watchdog_env_name) + watchdog_file_env_name = TORCHELASTIC_TIMER_FILE + watchdog_file_path = os.getenv(watchdog_file_env_name) + if watchdog_enabled is not None and str(watchdog_enabled) == "1": + if watchdog_file_path is None: + watchdog_file_path = "/tmp/watchdog_timer_" + str(uuid.uuid4()) + log.info("Starting a FileTimerServer with %s ...", watchdog_file_path) + self._worker_watchdog = timer.FileTimerServer( + file_path=watchdog_file_path, + max_interval=0.1, + daemon=True, + log_event=self._log_watchdog_event) + self._worker_watchdog.start() + log.info("FileTimerServer started") + else: + log.info("Environment variable '%s' not found. Do not start FileTimerServer.", enable_watchdog_env_name) + # Propagate the watchdog file env to worker processes + if watchdog_file_path is not None: + for worker_env in envs.values(): + worker_env[watchdog_file_env_name] = watchdog_file_path + + + def _get_fq_hostname(self) -> str: + return socket.getfqdn(socket.gethostname()) + + def _log_watchdog_event( + self, + name: str, + request: Optional[timer.FileTimerRequest], + ) -> None: + wg = self._worker_group + spec = wg.spec + md = { + "watchdog_event": name + } + if request is not None: + md["worker_pid"] = str(request.worker_pid) + md["scope_id"] = request.scope_id + md["expiration_time"] = str(request.expiration_time) + md["signal"] = str(request.signal) + md_str = json.dumps(md) + state = "RUNNING" + metadata: Dict[str, EventMetadataValue] = { + "run_id": spec.rdzv_handler.get_run_id(), + "global_rank": None, + "group_rank": wg.group_rank, + "worker_id": None, + "role": spec.role, + "hostname": self._get_fq_hostname(), + "state": state, + "total_run_time": self._total_execution_time, + "rdzv_backend": spec.rdzv_handler.get_backend(), + "raw_error": None, + "metadata": md_str, + "agent_restarts": spec.max_restarts - self._remaining_restarts, + } + # Note: The 'metadata' field of the Event is converted to a TorchelasticStatusLogEntry later. + # The 'name' field of the Event is NOT used in the TorchelasticStatusLogEntry. + event = events.Event( + name=name, source=events.EventSource.AGENT, metadata=metadata + ) + events.record(event) + + # pyre-fixme[56]: Pyre was not able to infer the type of the decorator + # `torch.distributed.elastic.metrics.prof`. + @prof + def _stop_workers(self, worker_group: WorkerGroup) -> None: + self._shutdown() + + # pyre-fixme[56]: Pyre was not able to infer the type of the decorator + # `torch.distributed.elastic.metrics.prof`. + @prof + def _start_workers(self, worker_group: WorkerGroup) -> Dict[int, Any]: + spec = worker_group.spec + store = worker_group.store + assert store is not None + master_addr, master_port = super()._get_master_addr_port(store) + restart_count = spec.max_restarts - self._remaining_restarts + + use_agent_store = spec.rdzv_handler.get_backend() == "static" + + args: Dict[int, Tuple] = {} + envs: Dict[int, Dict[str, str]] = {} + log_line_prefixes: Optional[Dict[int, str]] = {} if self._log_line_prefix_template else None + for worker in worker_group.workers: + local_rank = worker.local_rank + worker_env = { + "LOCAL_RANK": str(local_rank), + "RANK": str(worker.global_rank), + "GROUP_RANK": str(worker_group.group_rank), + "ROLE_RANK": str(worker.role_rank), + "ROLE_NAME": spec.role, + "LOCAL_WORLD_SIZE": str(spec.local_world_size), + "WORLD_SIZE": str(worker.world_size), + "GROUP_WORLD_SIZE": str(worker_group.group_world_size), + "ROLE_WORLD_SIZE": str(worker.role_world_size), + "MASTER_ADDR": master_addr, + "MASTER_PORT": str(master_port), + "TORCHELASTIC_RESTART_COUNT": str(restart_count), + "TORCHELASTIC_MAX_RESTARTS": str(spec.max_restarts), + "TORCHELASTIC_RUN_ID": spec.rdzv_handler.get_run_id(), + "TORCHELASTIC_USE_AGENT_STORE": str(use_agent_store), + "TORCH_NCCL_ASYNC_ERROR_HANDLING": os.getenv( + "TORCH_NCCL_ASYNC_ERROR_HANDLING", str(1) + ), + } + if "OMP_NUM_THREADS" in os.environ: + worker_env["OMP_NUM_THREADS"] = os.environ["OMP_NUM_THREADS"] + + + if self._log_line_prefix_template: + log_line_prefix = Template(self._log_line_prefix_template).safe_substitute( + role_name=spec.role, + rank=worker.global_rank, + local_rank=local_rank,) + log_line_prefixes[local_rank] = log_line_prefix + + envs[local_rank] = worker_env + worker_args = list(spec.args) + worker_args = macros.substitute(worker_args, str(local_rank)) + args[local_rank] = tuple(worker_args) + + self._setup_local_watchdog(envs=envs) + + assert spec.entrypoint is not None + assert self._logs_specs is not None + self._pcontext = start_processes( + name=spec.role, + entrypoint=spec.entrypoint, + args=args, + envs=envs, + logs_specs=self._logs_specs, + log_line_prefixes=log_line_prefixes, + start_method=self._start_method, + ) + + return self._pcontext.pids() + + def _shutdown(self, death_sig: signal.Signals = signal.SIGTERM) -> None: + if self._worker_watchdog is not None: + self._worker_watchdog.stop() + self._worker_watchdog = None + if self._pcontext: + self._pcontext.close(death_sig) + if self._rdzv_handler: + self._rdzv_handler.shutdown() + + # pyre-fixme[56]: Pyre was not able to infer the type of the decorator + # `torch.distributed.elastic.metrics.prof`. + @prof + def _monitor_workers(self, worker_group: WorkerGroup) -> RunResult: + role = worker_group.spec.role + worker_pids = {w.id for w in worker_group.workers} + assert self._pcontext is not None + pc_pids = set(self._pcontext.pids().values()) + if worker_pids != pc_pids: + log.error( + "[%s] worker pids do not match process_context pids." + " Expected: %s, actual: %s", + role, worker_pids, pc_pids + ) + return RunResult(state=WorkerState.UNKNOWN) + + result = self._pcontext.wait(0) + if result: + if result.is_failed(): + # map local rank failure to global rank + worker_failures = {} + for local_rank, failure in result.failures.items(): + worker = worker_group.workers[local_rank] + worker_failures[worker.global_rank] = failure + return RunResult( + state=WorkerState.FAILED, + failures=worker_failures, + ) + else: + # copy ret_val_queue into a map with a global ranks + workers_ret_vals = {} + for local_rank, ret_val in result.return_values.items(): + worker = worker_group.workers[local_rank] + workers_ret_vals[worker.global_rank] = ret_val + return RunResult( + state=WorkerState.SUCCEEDED, + return_values=workers_ret_vals, + ) + else: + return RunResult(state=WorkerState.HEALTHY) diff --git a/shared/package-files/42/42e30058795056e3ff3b46b3389b7e3c1d45647497a4afdc7c6ca0886a9fb7c8/blob b/shared/package-files/42/42e30058795056e3ff3b46b3389b7e3c1d45647497a4afdc7c6ca0886a9fb7c8/blob new file mode 100644 index 0000000000000000000000000000000000000000..b776b6bc01406706a473afc1c5ddcd9d993aaa4a --- /dev/null +++ b/shared/package-files/42/42e30058795056e3ff3b46b3389b7e3c1d45647497a4afdc7c6ca0886a9fb7c8/blob @@ -0,0 +1,137 @@ +from inspect import Parameter, signature +from unittest import TestCase + +from ...traitlets import HasTraits, Int, Unicode +from ..decorators import signature_has_traits + + +class TestExpandSignature(TestCase): + def test_no_init(self): + @signature_has_traits + class Foo(HasTraits): + number1 = Int() + number2 = Int() + value = Unicode("Hello") + + parameters = signature(Foo).parameters + parameter_names = list(parameters) + + self.assertIs(parameters["args"].kind, Parameter.VAR_POSITIONAL) + self.assertEqual("args", parameter_names[0]) + + self.assertIs(parameters["number1"].kind, Parameter.KEYWORD_ONLY) + self.assertIs(parameters["number2"].kind, Parameter.KEYWORD_ONLY) + self.assertIs(parameters["value"].kind, Parameter.KEYWORD_ONLY) + + self.assertIs(parameters["kwargs"].kind, Parameter.VAR_KEYWORD) + self.assertEqual("kwargs", parameter_names[-1]) + + f = Foo(number1=32, value="World") + self.assertEqual(f.number1, 32) + self.assertEqual(f.number2, 0) + self.assertEqual(f.value, "World") + + def test_partial_init(self): + @signature_has_traits + class Foo(HasTraits): + number1 = Int() + number2 = Int() + value = Unicode("Hello") + + def __init__(self, arg1, **kwargs): + self.arg1 = arg1 + + super().__init__(**kwargs) + + parameters = signature(Foo).parameters + parameter_names = list(parameters) + + self.assertIs(parameters["arg1"].kind, Parameter.POSITIONAL_OR_KEYWORD) + self.assertEqual("arg1", parameter_names[0]) + + self.assertIs(parameters["number1"].kind, Parameter.KEYWORD_ONLY) + self.assertIs(parameters["number2"].kind, Parameter.KEYWORD_ONLY) + self.assertIs(parameters["value"].kind, Parameter.KEYWORD_ONLY) + + self.assertIs(parameters["kwargs"].kind, Parameter.VAR_KEYWORD) + self.assertEqual("kwargs", parameter_names[-1]) + + f = Foo(1, number1=32, value="World") + self.assertEqual(f.arg1, 1) + self.assertEqual(f.number1, 32) + self.assertEqual(f.number2, 0) + self.assertEqual(f.value, "World") + + def test_duplicate_init(self): + @signature_has_traits + class Foo(HasTraits): + number1 = Int() + number2 = Int() + + def __init__(self, number1, **kwargs): + self.test = number1 + + super().__init__(number1=number1, **kwargs) + + parameters = signature(Foo).parameters + parameter_names = list(parameters) + + self.assertListEqual(parameter_names, ["number1", "number2", "kwargs"]) + + f = Foo(number1=32, number2=36) + self.assertEqual(f.test, 32) + self.assertEqual(f.number1, 32) + self.assertEqual(f.number2, 36) + + def test_full_init(self): + @signature_has_traits + class Foo(HasTraits): + number1 = Int() + number2 = Int() + value = Unicode("Hello") + + def __init__(self, arg1, arg2=None, *pos_args, **kw_args): + self.arg1 = arg1 + self.arg2 = arg2 + self.pos_args = pos_args + self.kw_args = kw_args + + super().__init__(*pos_args, **kw_args) + + parameters = signature(Foo).parameters + parameter_names = list(parameters) + + self.assertIs(parameters["arg1"].kind, Parameter.POSITIONAL_OR_KEYWORD) + self.assertEqual("arg1", parameter_names[0]) + + self.assertIs(parameters["arg2"].kind, Parameter.POSITIONAL_OR_KEYWORD) + self.assertEqual("arg2", parameter_names[1]) + + self.assertIs(parameters["pos_args"].kind, Parameter.VAR_POSITIONAL) + self.assertEqual("pos_args", parameter_names[2]) + + self.assertIs(parameters["number1"].kind, Parameter.KEYWORD_ONLY) + self.assertIs(parameters["number2"].kind, Parameter.KEYWORD_ONLY) + self.assertIs(parameters["value"].kind, Parameter.KEYWORD_ONLY) + + self.assertIs(parameters["kw_args"].kind, Parameter.VAR_KEYWORD) + self.assertEqual("kw_args", parameter_names[-1]) + + f = Foo(1, 3, 45, "hey", number1=32, value="World") + self.assertEqual(f.arg1, 1) + self.assertEqual(f.arg2, 3) + self.assertTupleEqual(f.pos_args, (45, "hey")) + self.assertEqual(f.number1, 32) + self.assertEqual(f.number2, 0) + self.assertEqual(f.value, "World") + + def test_no_kwargs(self): + with self.assertRaises(RuntimeError): + + @signature_has_traits + class Foo(HasTraits): + number1 = Int() + number2 = Int() + + def __init__(self, arg1, arg2=None): + pass diff --git a/shared/package-files/42/42e4dd584e1c8776a7ce7e27ba34a85df5f8676eb7c9f52bf34b429673b44162/blob b/shared/package-files/42/42e4dd584e1c8776a7ce7e27ba34a85df5f8676eb7c9f52bf34b429673b44162/blob new file mode 100644 index 0000000000000000000000000000000000000000..a231c416add126a7b00c2b136fd48c340259234d --- /dev/null +++ b/shared/package-files/42/42e4dd584e1c8776a7ce7e27ba34a85df5f8676eb7c9f52bf34b429673b44162/blob @@ -0,0 +1,82 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_foreach_sub.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] +inline ::std::vector _foreach_sub(at::TensorList self, const at::Scalar & scalar) { + return at::_ops::_foreach_sub_Scalar::call(self, scalar); +} + +// aten::_foreach_sub_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () +inline void _foreach_sub_(at::TensorList self, const at::Scalar & scalar) { + return at::_ops::_foreach_sub__Scalar::call(self, scalar); +} + +// aten::_foreach_sub.List(Tensor[] self, Tensor[] other, *, Scalar alpha=1) -> Tensor[] +inline ::std::vector _foreach_sub(at::TensorList self, at::TensorList other, const at::Scalar & alpha=1) { + return at::_ops::_foreach_sub_List::call(self, other, alpha); +} + +// aten::_foreach_sub_.List(Tensor(a!)[] self, Tensor[] other, *, Scalar alpha=1) -> () +inline void _foreach_sub_(at::TensorList self, at::TensorList other, const at::Scalar & alpha=1) { + return at::_ops::_foreach_sub__List::call(self, other, alpha); +} + +// aten::_foreach_sub.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] +inline ::std::vector _foreach_sub(at::TensorList self, at::ArrayRef scalars) { + return at::_ops::_foreach_sub_ScalarList::call(self, scalars); +} + +// aten::_foreach_sub_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () +inline void _foreach_sub_(at::TensorList self, at::ArrayRef scalars) { + return at::_ops::_foreach_sub__ScalarList::call(self, scalars); +} + +// aten::_foreach_sub.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () +inline void _foreach_sub_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) { + return at::_ops::_foreach_sub_Scalar_out::call(self, scalar, out); +} +// aten::_foreach_sub.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () +inline void _foreach_sub_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) { + return at::_ops::_foreach_sub_Scalar_out::call(self, scalar, out); +} + +// aten::_foreach_sub.List_out(Tensor[] self, Tensor[] other, *, Scalar alpha=1, Tensor(a!)[] out) -> () +inline void _foreach_sub_out(at::TensorList out, at::TensorList self, at::TensorList other, const at::Scalar & alpha=1) { + return at::_ops::_foreach_sub_List_out::call(self, other, alpha, out); +} +// aten::_foreach_sub.List_out(Tensor[] self, Tensor[] other, *, Scalar alpha=1, Tensor(a!)[] out) -> () +inline void _foreach_sub_outf(at::TensorList self, at::TensorList other, const at::Scalar & alpha, at::TensorList out) { + return at::_ops::_foreach_sub_List_out::call(self, other, alpha, out); +} + +// aten::_foreach_sub.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () +inline void _foreach_sub_out(at::TensorList out, at::TensorList self, at::ArrayRef scalars) { + return at::_ops::_foreach_sub_ScalarList_out::call(self, scalars, out); +} +// aten::_foreach_sub.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () +inline void _foreach_sub_outf(at::TensorList self, at::ArrayRef scalars, at::TensorList out) { + return at::_ops::_foreach_sub_ScalarList_out::call(self, scalars, out); +} + +} diff --git a/shared/package-files/42/42e55a3d0ba570d2e0e05977d4bc3e3bcf4be3629c95808aebc9f9195cb43cd4/blob b/shared/package-files/42/42e55a3d0ba570d2e0e05977d4bc3e3bcf4be3629c95808aebc9f9195cb43cd4/blob new file mode 100644 index 0000000000000000000000000000000000000000..a1f360089a547bb4c81ef7a43884823ba4734227 --- /dev/null +++ b/shared/package-files/42/42e55a3d0ba570d2e0e05977d4bc3e3bcf4be3629c95808aebc9f9195cb43cd4/blob @@ -0,0 +1,72 @@ +from numpy.testing import ( + assert_raises, + assert_warns, + assert_, + assert_equal, + IS_WASM, +) +from numpy.compat import pickle + +import pytest +import sys +import subprocess +import textwrap +from importlib import reload + + +def test_numpy_reloading(): + # gh-7844. Also check that relevant globals retain their identity. + import numpy as np + import numpy._globals + + _NoValue = np._NoValue + VisibleDeprecationWarning = np.VisibleDeprecationWarning + ModuleDeprecationWarning = np.ModuleDeprecationWarning + + with assert_warns(UserWarning): + reload(np) + assert_(_NoValue is np._NoValue) + assert_(ModuleDeprecationWarning is np.ModuleDeprecationWarning) + assert_(VisibleDeprecationWarning is np.VisibleDeprecationWarning) + + assert_raises(RuntimeError, reload, numpy._globals) + with assert_warns(UserWarning): + reload(np) + assert_(_NoValue is np._NoValue) + assert_(ModuleDeprecationWarning is np.ModuleDeprecationWarning) + assert_(VisibleDeprecationWarning is np.VisibleDeprecationWarning) + +def test_novalue(): + import numpy as np + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + assert_equal(repr(np._NoValue), '') + assert_(pickle.loads(pickle.dumps(np._NoValue, + protocol=proto)) is np._NoValue) + + +@pytest.mark.skipif(IS_WASM, reason="can't start subprocess") +def test_full_reimport(): + """At the time of writing this, it is *not* truly supported, but + apparently enough users rely on it, for it to be an annoying change + when it started failing previously. + """ + # Test within a new process, to ensure that we do not mess with the + # global state during the test run (could lead to cryptic test failures). + # This is generally unsafe, especially, since we also reload the C-modules. + code = textwrap.dedent(r""" + import sys + from pytest import warns + import numpy as np + + for k in list(sys.modules.keys()): + if "numpy" in k: + del sys.modules[k] + + with warns(UserWarning): + import numpy as np + """) + p = subprocess.run([sys.executable, '-c', code], capture_output=True) + if p.returncode: + raise AssertionError( + f"Non-zero return code: {p.returncode!r}\n\n{p.stderr.decode()}" + ) diff --git a/shared/package-files/42/42e84870dc8a9da9212423d343fcba88ee4c2ac5ea327caab04ee93e9bb924a4/blob b/shared/package-files/42/42e84870dc8a9da9212423d343fcba88ee4c2ac5ea327caab04ee93e9bb924a4/blob new file mode 100644 index 0000000000000000000000000000000000000000..51d08709bd68574ea5d1eded6b6f981703955f39 --- /dev/null +++ b/shared/package-files/42/42e84870dc8a9da9212423d343fcba88ee4c2ac5ea327caab04ee93e9bb924a4/blob @@ -0,0 +1,5 @@ +from . import spark # noqa: D104 + +__all__ = [ + "spark", +] diff --git a/shared/package-files/42/42eb542adaf7e46099e224b61f5593cccc1ad2302f2f4a6b712f36527b60af99/blob b/shared/package-files/42/42eb542adaf7e46099e224b61f5593cccc1ad2302f2f4a6b712f36527b60af99/blob new file mode 100644 index 0000000000000000000000000000000000000000..a4b10ca67c2a8d32b59b809c77144578c8cc4a53 --- /dev/null +++ b/shared/package-files/42/42eb542adaf7e46099e224b61f5593cccc1ad2302f2f4a6b712f36527b60af99/blob @@ -0,0 +1,62 @@ +from sympy.core import S, symbols +from sympy.matrices import eye, ones, Matrix, ShapeError +from sympy.matrices.expressions import ( + Identity, MatrixExpr, MatrixSymbol, Determinant, + det, per, ZeroMatrix, Transpose, + Permanent +) +from sympy.matrices.expressions.special import OneMatrix +from sympy.testing.pytest import raises +from sympy.assumptions.ask import Q +from sympy.assumptions.refine import refine + +n = symbols('n', integer=True) +A = MatrixSymbol('A', n, n) +B = MatrixSymbol('B', n, n) +C = MatrixSymbol('C', 3, 4) + + +def test_det(): + assert isinstance(Determinant(A), Determinant) + assert not isinstance(Determinant(A), MatrixExpr) + raises(ShapeError, lambda: Determinant(C)) + assert det(eye(3)) == 1 + assert det(Matrix(3, 3, [1, 3, 2, 4, 1, 3, 2, 5, 2])) == 17 + _ = A / det(A) # Make sure this is possible + + raises(TypeError, lambda: Determinant(S.One)) + + assert Determinant(A).arg is A + +def test_eval_determinant(): + assert det(Identity(n)) == 1 + assert det(ZeroMatrix(n, n)) == 0 + assert det(OneMatrix(n, n)) == Determinant(OneMatrix(n, n)) + assert det(OneMatrix(1, 1)) == 1 + assert det(OneMatrix(2, 2)) == 0 + assert det(Transpose(A)) == det(A) + + +def test_refine(): + assert refine(det(A), Q.orthogonal(A)) == 1 + assert refine(det(A), Q.singular(A)) == 0 + assert refine(det(A), Q.unit_triangular(A)) == 1 + assert refine(det(A), Q.normal(A)) == det(A) + + +def test_commutative(): + det_a = Determinant(A) + det_b = Determinant(B) + assert det_a.is_commutative + assert det_b.is_commutative + assert det_a * det_b == det_b * det_a + +def test_permanent(): + assert isinstance(Permanent(A), Permanent) + assert not isinstance(Permanent(A), MatrixExpr) + assert isinstance(Permanent(C), Permanent) + assert Permanent(ones(3, 3)).doit() == 6 + _ = C / per(C) + assert per(Matrix(3, 3, [1, 3, 2, 4, 1, 3, 2, 5, 2])) == 103 + raises(TypeError, lambda: Permanent(S.One)) + assert Permanent(A).arg is A diff --git a/shared/package-files/42/42ed0ec8075cb22ecab386e638cf77fda3ab7c9d376a6b92866d91a8a2dc23f9/blob b/shared/package-files/42/42ed0ec8075cb22ecab386e638cf77fda3ab7c9d376a6b92866d91a8a2dc23f9/blob new file mode 100644 index 0000000000000000000000000000000000000000..fe9167f80f33edb9dc1d897e0a2053a6eee6deee --- /dev/null +++ b/shared/package-files/42/42ed0ec8075cb22ecab386e638cf77fda3ab7c9d376a6b92866d91a8a2dc23f9/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API ::std::tuple topk(const at::Tensor & self, int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true); +TORCH_API ::std::tuple topk_symint(const at::Tensor & self, c10::SymInt k, int64_t dim=-1, bool largest=true, bool sorted=true); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/shared/package-files/42/42f000b687c0a80e2841a62fc4dd602bb4097fa4c6ac8dd3a98e5f1e36cfdb4d/blob b/shared/package-files/42/42f000b687c0a80e2841a62fc4dd602bb4097fa4c6ac8dd3a98e5f1e36cfdb4d/blob new file mode 100644 index 0000000000000000000000000000000000000000..09f979d5e54fe6f5d85cf29edb158e271a6092fc --- /dev/null +++ b/shared/package-files/42/42f000b687c0a80e2841a62fc4dd602bb4097fa4c6ac8dd3a98e5f1e36cfdb4d/blob @@ -0,0 +1,161 @@ +from sympy.core.symbol import symbols +from sympy.physics.mechanics import Point, ReferenceFrame, Dyadic, RigidBody +from sympy.physics.mechanics import dynamicsymbols, outer, inertia +from sympy.physics.mechanics import inertia_of_point_mass +from sympy.core.backend import expand, zeros, _simplify_matrix + +from sympy.testing.pytest import raises, warns_deprecated_sympy + + +def test_rigidbody(): + m, m2, v1, v2, v3, omega = symbols('m m2 v1 v2 v3 omega') + A = ReferenceFrame('A') + A2 = ReferenceFrame('A2') + P = Point('P') + P2 = Point('P2') + I = Dyadic(0) + I2 = Dyadic(0) + B = RigidBody('B', P, A, m, (I, P)) + assert B.mass == m + assert B.frame == A + assert B.masscenter == P + assert B.inertia == (I, B.masscenter) + + B.mass = m2 + B.frame = A2 + B.masscenter = P2 + B.inertia = (I2, B.masscenter) + raises(TypeError, lambda: RigidBody(P, P, A, m, (I, P))) + raises(TypeError, lambda: RigidBody('B', P, P, m, (I, P))) + raises(TypeError, lambda: RigidBody('B', P, A, m, (P, P))) + raises(TypeError, lambda: RigidBody('B', P, A, m, (I, I))) + assert B.__str__() == 'B' + assert B.mass == m2 + assert B.frame == A2 + assert B.masscenter == P2 + assert B.inertia == (I2, B.masscenter) + assert B.masscenter == P2 + assert B.inertia == (I2, B.masscenter) + + # Testing linear momentum function assuming A2 is the inertial frame + N = ReferenceFrame('N') + P2.set_vel(N, v1 * N.x + v2 * N.y + v3 * N.z) + assert B.linear_momentum(N) == m2 * (v1 * N.x + v2 * N.y + v3 * N.z) + + +def test_rigidbody2(): + M, v, r, omega, g, h = dynamicsymbols('M v r omega g h') + N = ReferenceFrame('N') + b = ReferenceFrame('b') + b.set_ang_vel(N, omega * b.x) + P = Point('P') + I = outer(b.x, b.x) + Inertia_tuple = (I, P) + B = RigidBody('B', P, b, M, Inertia_tuple) + P.set_vel(N, v * b.x) + assert B.angular_momentum(P, N) == omega * b.x + O = Point('O') + O.set_vel(N, v * b.x) + P.set_pos(O, r * b.y) + assert B.angular_momentum(O, N) == omega * b.x - M*v*r*b.z + B.potential_energy = M * g * h + assert B.potential_energy == M * g * h + assert expand(2 * B.kinetic_energy(N)) == omega**2 + M * v**2 + +def test_rigidbody3(): + q1, q2, q3, q4 = dynamicsymbols('q1:5') + p1, p2, p3 = symbols('p1:4') + m = symbols('m') + + A = ReferenceFrame('A') + B = A.orientnew('B', 'axis', [q1, A.x]) + O = Point('O') + O.set_vel(A, q2*A.x + q3*A.y + q4*A.z) + P = O.locatenew('P', p1*B.x + p2*B.y + p3*B.z) + P.v2pt_theory(O, A, B) + I = outer(B.x, B.x) + + rb1 = RigidBody('rb1', P, B, m, (I, P)) + # I_S/O = I_S/S* + I_S*/O + rb2 = RigidBody('rb2', P, B, m, + (I + inertia_of_point_mass(m, P.pos_from(O), B), O)) + + assert rb1.central_inertia == rb2.central_inertia + assert rb1.angular_momentum(O, A) == rb2.angular_momentum(O, A) + + +def test_pendulum_angular_momentum(): + """Consider a pendulum of length OA = 2a, of mass m as a rigid body of + center of mass G (OG = a) which turn around (O,z). The angle between the + reference frame R and the rod is q. The inertia of the body is I = + (G,0,ma^2/3,ma^2/3). """ + + m, a = symbols('m, a') + q = dynamicsymbols('q') + + R = ReferenceFrame('R') + R1 = R.orientnew('R1', 'Axis', [q, R.z]) + R1.set_ang_vel(R, q.diff() * R.z) + + I = inertia(R1, 0, m * a**2 / 3, m * a**2 / 3) + + O = Point('O') + + A = O.locatenew('A', 2*a * R1.x) + G = O.locatenew('G', a * R1.x) + + S = RigidBody('S', G, R1, m, (I, G)) + + O.set_vel(R, 0) + A.v2pt_theory(O, R, R1) + G.v2pt_theory(O, R, R1) + + assert (4 * m * a**2 / 3 * q.diff() * R.z - + S.angular_momentum(O, R).express(R)) == 0 + + +def test_rigidbody_inertia(): + N = ReferenceFrame('N') + m, Ix, Iy, Iz, a, b = symbols('m, I_x, I_y, I_z, a, b') + Io = inertia(N, Ix, Iy, Iz) + o = Point('o') + p = o.locatenew('p', a * N.x + b * N.y) + R = RigidBody('R', o, N, m, (Io, p)) + I_check = inertia(N, Ix - b ** 2 * m, Iy - a ** 2 * m, + Iz - m * (a ** 2 + b ** 2), m * a * b) + assert R.inertia == (Io, p) + assert R.central_inertia == I_check + R.central_inertia = Io + assert R.inertia == (Io, o) + assert R.central_inertia == Io + R.inertia = (Io, p) + assert R.inertia == (Io, p) + assert R.central_inertia == I_check + + +def test_parallel_axis(): + N = ReferenceFrame('N') + m, Ix, Iy, Iz, a, b = symbols('m, I_x, I_y, I_z, a, b') + Io = inertia(N, Ix, Iy, Iz) + o = Point('o') + p = o.locatenew('p', a * N.x + b * N.y) + R = RigidBody('R', o, N, m, (Io, o)) + Ip = R.parallel_axis(p) + Ip_expected = inertia(N, Ix + m * b**2, Iy + m * a**2, + Iz + m * (a**2 + b**2), ixy=-m * a * b) + assert Ip == Ip_expected + # Reference frame from which the parallel axis is viewed should not matter + A = ReferenceFrame('A') + A.orient_axis(N, N.z, 1) + assert _simplify_matrix( + (R.parallel_axis(p, A) - Ip_expected).to_matrix(A)) == zeros(3, 3) + + +def test_deprecated_set_potential_energy(): + m, g, h = symbols('m g h') + A = ReferenceFrame('A') + P = Point('P') + I = Dyadic(0) + B = RigidBody('B', P, A, m, (I, P)) + with warns_deprecated_sympy(): + B.set_potential_energy(m*g*h) diff --git a/shared/package-files/42/42f09fd2390233783b7c0d6bcefec807ca2763f72214b3dac92be4050f7968e3/blob b/shared/package-files/42/42f09fd2390233783b7c0d6bcefec807ca2763f72214b3dac92be4050f7968e3/blob new file mode 100644 index 0000000000000000000000000000000000000000..67e139c88f602794453e32826ae6c82f3fd5f44d --- /dev/null +++ b/shared/package-files/42/42f09fd2390233783b7c0d6bcefec807ca2763f72214b3dac92be4050f7968e3/blob @@ -0,0 +1,15 @@ +import codecs +from typing import Tuple + +class IncrementalEncoder(codecs.IncrementalEncoder): + def encode(self, input: str, final: bool = ...) -> bytes: ... + +class IncrementalDecoder(codecs.BufferedIncrementalDecoder): + def _buffer_decode(self, input: bytes, errors: str, final: bool) -> Tuple[str, int]: ... + +class StreamWriter(codecs.StreamWriter): ... +class StreamReader(codecs.StreamReader): ... + +def getregentry() -> codecs.CodecInfo: ... +def encode(input: str, errors: str = ...) -> bytes: ... +def decode(input: bytes, errors: str = ...) -> str: ... diff --git a/shared/package-files/42/42f7e5afd878ad80b0f68f08dd1820921751ab1bdabf5ca2a2afc9784521d93e/blob b/shared/package-files/42/42f7e5afd878ad80b0f68f08dd1820921751ab1bdabf5ca2a2afc9784521d93e/blob new file mode 100644 index 0000000000000000000000000000000000000000..4df30f7f4a8a79984ca6de521ac058bd30fd8faf --- /dev/null +++ b/shared/package-files/42/42f7e5afd878ad80b0f68f08dd1820921751ab1bdabf5ca2a2afc9784521d93e/blob @@ -0,0 +1,418 @@ +""" +For compatibility with numpy libraries, pandas functions or methods have to +accept '*args' and '**kwargs' parameters to accommodate numpy arguments that +are not actually used or respected in the pandas implementation. + +To ensure that users do not abuse these parameters, validation is performed in +'validators.py' to make sure that any extra parameters passed correspond ONLY +to those in the numpy signature. Part of that validation includes whether or +not the user attempted to pass in non-default values for these extraneous +parameters. As we want to discourage users from relying on these parameters +when calling the pandas implementation, we want them only to pass in the +default values for these parameters. + +This module provides a set of commonly used default arguments for functions and +methods that are spread throughout the codebase. This module will make it +easier to adjust to future upstream changes in the analogous numpy signatures. +""" +from __future__ import annotations + +from typing import ( + TYPE_CHECKING, + Any, + TypeVar, + cast, + overload, +) + +import numpy as np +from numpy import ndarray + +from pandas._libs.lib import ( + is_bool, + is_integer, +) +from pandas.errors import UnsupportedFunctionCall +from pandas.util._validators import ( + validate_args, + validate_args_and_kwargs, + validate_kwargs, +) + +if TYPE_CHECKING: + from pandas._typing import ( + Axis, + AxisInt, + ) + + AxisNoneT = TypeVar("AxisNoneT", Axis, None) + + +class CompatValidator: + def __init__( + self, + defaults, + fname=None, + method: str | None = None, + max_fname_arg_count=None, + ) -> None: + self.fname = fname + self.method = method + self.defaults = defaults + self.max_fname_arg_count = max_fname_arg_count + + def __call__( + self, + args, + kwargs, + fname=None, + max_fname_arg_count=None, + method: str | None = None, + ) -> None: + if not args and not kwargs: + return None + + fname = self.fname if fname is None else fname + max_fname_arg_count = ( + self.max_fname_arg_count + if max_fname_arg_count is None + else max_fname_arg_count + ) + method = self.method if method is None else method + + if method == "args": + validate_args(fname, args, max_fname_arg_count, self.defaults) + elif method == "kwargs": + validate_kwargs(fname, kwargs, self.defaults) + elif method == "both": + validate_args_and_kwargs( + fname, args, kwargs, max_fname_arg_count, self.defaults + ) + else: + raise ValueError(f"invalid validation method '{method}'") + + +ARGMINMAX_DEFAULTS = {"out": None} +validate_argmin = CompatValidator( + ARGMINMAX_DEFAULTS, fname="argmin", method="both", max_fname_arg_count=1 +) +validate_argmax = CompatValidator( + ARGMINMAX_DEFAULTS, fname="argmax", method="both", max_fname_arg_count=1 +) + + +def process_skipna(skipna: bool | ndarray | None, args) -> tuple[bool, Any]: + if isinstance(skipna, ndarray) or skipna is None: + args = (skipna,) + args + skipna = True + + return skipna, args + + +def validate_argmin_with_skipna(skipna: bool | ndarray | None, args, kwargs) -> bool: + """ + If 'Series.argmin' is called via the 'numpy' library, the third parameter + in its signature is 'out', which takes either an ndarray or 'None', so + check if the 'skipna' parameter is either an instance of ndarray or is + None, since 'skipna' itself should be a boolean + """ + skipna, args = process_skipna(skipna, args) + validate_argmin(args, kwargs) + return skipna + + +def validate_argmax_with_skipna(skipna: bool | ndarray | None, args, kwargs) -> bool: + """ + If 'Series.argmax' is called via the 'numpy' library, the third parameter + in its signature is 'out', which takes either an ndarray or 'None', so + check if the 'skipna' parameter is either an instance of ndarray or is + None, since 'skipna' itself should be a boolean + """ + skipna, args = process_skipna(skipna, args) + validate_argmax(args, kwargs) + return skipna + + +ARGSORT_DEFAULTS: dict[str, int | str | None] = {} +ARGSORT_DEFAULTS["axis"] = -1 +ARGSORT_DEFAULTS["kind"] = "quicksort" +ARGSORT_DEFAULTS["order"] = None +ARGSORT_DEFAULTS["kind"] = None +ARGSORT_DEFAULTS["stable"] = None + + +validate_argsort = CompatValidator( + ARGSORT_DEFAULTS, fname="argsort", max_fname_arg_count=0, method="both" +) + +# two different signatures of argsort, this second validation for when the +# `kind` param is supported +ARGSORT_DEFAULTS_KIND: dict[str, int | None] = {} +ARGSORT_DEFAULTS_KIND["axis"] = -1 +ARGSORT_DEFAULTS_KIND["order"] = None +ARGSORT_DEFAULTS_KIND["stable"] = None +validate_argsort_kind = CompatValidator( + ARGSORT_DEFAULTS_KIND, fname="argsort", max_fname_arg_count=0, method="both" +) + + +def validate_argsort_with_ascending(ascending: bool | int | None, args, kwargs) -> bool: + """ + If 'Categorical.argsort' is called via the 'numpy' library, the first + parameter in its signature is 'axis', which takes either an integer or + 'None', so check if the 'ascending' parameter has either integer type or is + None, since 'ascending' itself should be a boolean + """ + if is_integer(ascending) or ascending is None: + args = (ascending,) + args + ascending = True + + validate_argsort_kind(args, kwargs, max_fname_arg_count=3) + ascending = cast(bool, ascending) + return ascending + + +CLIP_DEFAULTS: dict[str, Any] = {"out": None} +validate_clip = CompatValidator( + CLIP_DEFAULTS, fname="clip", method="both", max_fname_arg_count=3 +) + + +@overload +def validate_clip_with_axis(axis: ndarray, args, kwargs) -> None: + ... + + +@overload +def validate_clip_with_axis(axis: AxisNoneT, args, kwargs) -> AxisNoneT: + ... + + +def validate_clip_with_axis( + axis: ndarray | AxisNoneT, args, kwargs +) -> AxisNoneT | None: + """ + If 'NDFrame.clip' is called via the numpy library, the third parameter in + its signature is 'out', which can takes an ndarray, so check if the 'axis' + parameter is an instance of ndarray, since 'axis' itself should either be + an integer or None + """ + if isinstance(axis, ndarray): + args = (axis,) + args + # error: Incompatible types in assignment (expression has type "None", + # variable has type "Union[ndarray[Any, Any], str, int]") + axis = None # type: ignore[assignment] + + validate_clip(args, kwargs) + # error: Incompatible return value type (got "Union[ndarray[Any, Any], + # str, int]", expected "Union[str, int, None]") + return axis # type: ignore[return-value] + + +CUM_FUNC_DEFAULTS: dict[str, Any] = {} +CUM_FUNC_DEFAULTS["dtype"] = None +CUM_FUNC_DEFAULTS["out"] = None +validate_cum_func = CompatValidator( + CUM_FUNC_DEFAULTS, method="both", max_fname_arg_count=1 +) +validate_cumsum = CompatValidator( + CUM_FUNC_DEFAULTS, fname="cumsum", method="both", max_fname_arg_count=1 +) + + +def validate_cum_func_with_skipna(skipna: bool, args, kwargs, name) -> bool: + """ + If this function is called via the 'numpy' library, the third parameter in + its signature is 'dtype', which takes either a 'numpy' dtype or 'None', so + check if the 'skipna' parameter is a boolean or not + """ + if not is_bool(skipna): + args = (skipna,) + args + skipna = True + elif isinstance(skipna, np.bool_): + skipna = bool(skipna) + + validate_cum_func(args, kwargs, fname=name) + return skipna + + +ALLANY_DEFAULTS: dict[str, bool | None] = {} +ALLANY_DEFAULTS["dtype"] = None +ALLANY_DEFAULTS["out"] = None +ALLANY_DEFAULTS["keepdims"] = False +ALLANY_DEFAULTS["axis"] = None +validate_all = CompatValidator( + ALLANY_DEFAULTS, fname="all", method="both", max_fname_arg_count=1 +) +validate_any = CompatValidator( + ALLANY_DEFAULTS, fname="any", method="both", max_fname_arg_count=1 +) + +LOGICAL_FUNC_DEFAULTS = {"out": None, "keepdims": False} +validate_logical_func = CompatValidator(LOGICAL_FUNC_DEFAULTS, method="kwargs") + +MINMAX_DEFAULTS = {"axis": None, "dtype": None, "out": None, "keepdims": False} +validate_min = CompatValidator( + MINMAX_DEFAULTS, fname="min", method="both", max_fname_arg_count=1 +) +validate_max = CompatValidator( + MINMAX_DEFAULTS, fname="max", method="both", max_fname_arg_count=1 +) + +RESHAPE_DEFAULTS: dict[str, str] = {"order": "C"} +validate_reshape = CompatValidator( + RESHAPE_DEFAULTS, fname="reshape", method="both", max_fname_arg_count=1 +) + +REPEAT_DEFAULTS: dict[str, Any] = {"axis": None} +validate_repeat = CompatValidator( + REPEAT_DEFAULTS, fname="repeat", method="both", max_fname_arg_count=1 +) + +ROUND_DEFAULTS: dict[str, Any] = {"out": None} +validate_round = CompatValidator( + ROUND_DEFAULTS, fname="round", method="both", max_fname_arg_count=1 +) + +SORT_DEFAULTS: dict[str, int | str | None] = {} +SORT_DEFAULTS["axis"] = -1 +SORT_DEFAULTS["kind"] = "quicksort" +SORT_DEFAULTS["order"] = None +validate_sort = CompatValidator(SORT_DEFAULTS, fname="sort", method="kwargs") + +STAT_FUNC_DEFAULTS: dict[str, Any | None] = {} +STAT_FUNC_DEFAULTS["dtype"] = None +STAT_FUNC_DEFAULTS["out"] = None + +SUM_DEFAULTS = STAT_FUNC_DEFAULTS.copy() +SUM_DEFAULTS["axis"] = None +SUM_DEFAULTS["keepdims"] = False +SUM_DEFAULTS["initial"] = None + +PROD_DEFAULTS = SUM_DEFAULTS.copy() + +MEAN_DEFAULTS = SUM_DEFAULTS.copy() + +MEDIAN_DEFAULTS = STAT_FUNC_DEFAULTS.copy() +MEDIAN_DEFAULTS["overwrite_input"] = False +MEDIAN_DEFAULTS["keepdims"] = False + +STAT_FUNC_DEFAULTS["keepdims"] = False + +validate_stat_func = CompatValidator(STAT_FUNC_DEFAULTS, method="kwargs") +validate_sum = CompatValidator( + SUM_DEFAULTS, fname="sum", method="both", max_fname_arg_count=1 +) +validate_prod = CompatValidator( + PROD_DEFAULTS, fname="prod", method="both", max_fname_arg_count=1 +) +validate_mean = CompatValidator( + MEAN_DEFAULTS, fname="mean", method="both", max_fname_arg_count=1 +) +validate_median = CompatValidator( + MEDIAN_DEFAULTS, fname="median", method="both", max_fname_arg_count=1 +) + +STAT_DDOF_FUNC_DEFAULTS: dict[str, bool | None] = {} +STAT_DDOF_FUNC_DEFAULTS["dtype"] = None +STAT_DDOF_FUNC_DEFAULTS["out"] = None +STAT_DDOF_FUNC_DEFAULTS["keepdims"] = False +validate_stat_ddof_func = CompatValidator(STAT_DDOF_FUNC_DEFAULTS, method="kwargs") + +TAKE_DEFAULTS: dict[str, str | None] = {} +TAKE_DEFAULTS["out"] = None +TAKE_DEFAULTS["mode"] = "raise" +validate_take = CompatValidator(TAKE_DEFAULTS, fname="take", method="kwargs") + + +def validate_take_with_convert(convert: ndarray | bool | None, args, kwargs) -> bool: + """ + If this function is called via the 'numpy' library, the third parameter in + its signature is 'axis', which takes either an ndarray or 'None', so check + if the 'convert' parameter is either an instance of ndarray or is None + """ + if isinstance(convert, ndarray) or convert is None: + args = (convert,) + args + convert = True + + validate_take(args, kwargs, max_fname_arg_count=3, method="both") + return convert + + +TRANSPOSE_DEFAULTS = {"axes": None} +validate_transpose = CompatValidator( + TRANSPOSE_DEFAULTS, fname="transpose", method="both", max_fname_arg_count=0 +) + + +def validate_groupby_func(name: str, args, kwargs, allowed=None) -> None: + """ + 'args' and 'kwargs' should be empty, except for allowed kwargs because all + of their necessary parameters are explicitly listed in the function + signature + """ + if allowed is None: + allowed = [] + + kwargs = set(kwargs) - set(allowed) + + if len(args) + len(kwargs) > 0: + raise UnsupportedFunctionCall( + "numpy operations are not valid with groupby. " + f"Use .groupby(...).{name}() instead" + ) + + +RESAMPLER_NUMPY_OPS = ("min", "max", "sum", "prod", "mean", "std", "var") + + +def validate_resampler_func(method: str, args, kwargs) -> None: + """ + 'args' and 'kwargs' should be empty because all of their necessary + parameters are explicitly listed in the function signature + """ + if len(args) + len(kwargs) > 0: + if method in RESAMPLER_NUMPY_OPS: + raise UnsupportedFunctionCall( + "numpy operations are not valid with resample. " + f"Use .resample(...).{method}() instead" + ) + raise TypeError("too many arguments passed in") + + +def validate_minmax_axis(axis: AxisInt | None, ndim: int = 1) -> None: + """ + Ensure that the axis argument passed to min, max, argmin, or argmax is zero + or None, as otherwise it will be incorrectly ignored. + + Parameters + ---------- + axis : int or None + ndim : int, default 1 + + Raises + ------ + ValueError + """ + if axis is None: + return + if axis >= ndim or (axis < 0 and ndim + axis < 0): + raise ValueError(f"`axis` must be fewer than the number of dimensions ({ndim})") + + +_validation_funcs = { + "median": validate_median, + "mean": validate_mean, + "min": validate_min, + "max": validate_max, + "sum": validate_sum, + "prod": validate_prod, +} + + +def validate_func(fname, args, kwargs) -> None: + if fname not in _validation_funcs: + return validate_stat_func(args, kwargs, fname=fname) + + validation_func = _validation_funcs[fname] + return validation_func(args, kwargs) diff --git a/shared/package-files/42/42f97ab4072f12a69b0c4eaacae39f46937103fb4414e0544e64f0cb31c31fe9/blob b/shared/package-files/42/42f97ab4072f12a69b0c4eaacae39f46937103fb4414e0544e64f0cb31c31fe9/blob new file mode 100644 index 0000000000000000000000000000000000000000..ac588206869144b4839496f694fd94744967f26a --- /dev/null +++ b/shared/package-files/42/42f97ab4072f12a69b0c4eaacae39f46937103fb4414e0544e64f0cb31c31fe9/blob @@ -0,0 +1,74 @@ +"""All minimum dependencies for scikit-learn.""" + +# Authors: The scikit-learn developers +# SPDX-License-Identifier: BSD-3-Clause + +import argparse +from collections import defaultdict + +# scipy and cython should by in sync with pyproject.toml +NUMPY_MIN_VERSION = "1.22.0" +SCIPY_MIN_VERSION = "1.8.0" +JOBLIB_MIN_VERSION = "1.2.0" +THREADPOOLCTL_MIN_VERSION = "3.1.0" +PYTEST_MIN_VERSION = "7.1.2" +CYTHON_MIN_VERSION = "3.0.10" + + +# 'build' and 'install' is included to have structured metadata for CI. +# It will NOT be included in setup's extras_require +# The values are (version_spec, comma separated tags) +dependent_packages = { + "numpy": (NUMPY_MIN_VERSION, "build, install"), + "scipy": (SCIPY_MIN_VERSION, "build, install"), + "joblib": (JOBLIB_MIN_VERSION, "install"), + "threadpoolctl": (THREADPOOLCTL_MIN_VERSION, "install"), + "cython": (CYTHON_MIN_VERSION, "build"), + "meson-python": ("0.17.1", "build"), + "matplotlib": ("3.5.0", "benchmark, docs, examples, tests"), + "scikit-image": ("0.19.0", "docs, examples, tests"), + "pandas": ("1.4.0", "benchmark, docs, examples, tests"), + "seaborn": ("0.9.0", "docs, examples"), + "memory_profiler": ("0.57.0", "benchmark, docs"), + "pytest": (PYTEST_MIN_VERSION, "tests"), + "pytest-cov": ("2.9.0", "tests"), + "ruff": ("0.11.7", "tests"), + "mypy": ("1.15", "tests"), + "pyamg": ("4.2.1", "tests"), + "polars": ("0.20.30", "docs, tests"), + "pyarrow": ("12.0.0", "tests"), + "sphinx": ("7.3.7", "docs"), + "sphinx-copybutton": ("0.5.2", "docs"), + "sphinx-gallery": ("0.17.1", "docs"), + "numpydoc": ("1.2.0", "docs, tests"), + "Pillow": ("8.4.0", "docs"), + "pooch": ("1.6.0", "docs, examples, tests"), + "sphinx-prompt": ("1.4.0", "docs"), + "sphinxext-opengraph": ("0.9.1", "docs"), + "plotly": ("5.14.0", "docs, examples"), + "sphinxcontrib-sass": ("0.3.4", "docs"), + "sphinx-remove-toctrees": ("1.0.0.post1", "docs"), + "sphinx-design": ("0.6.0", "docs"), + "pydata-sphinx-theme": ("0.15.3", "docs"), + "towncrier": ("24.8.0", "docs"), + # XXX: Pin conda-lock to the latest released version (needs manual update + # from time to time) + "conda-lock": ("3.0.1", "maintenance"), +} + + +# create inverse mapping for setuptools +tag_to_packages: dict = defaultdict(list) +for package, (min_version, extras) in dependent_packages.items(): + for extra in extras.split(", "): + tag_to_packages[extra].append("{}>={}".format(package, min_version)) + + +# Used by CI to get the min dependencies +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Get min dependencies for a package") + + parser.add_argument("package", choices=dependent_packages) + args = parser.parse_args() + min_version = dependent_packages[args.package][0] + print(min_version) diff --git a/shared/package-files/42/42fba68e0e7e6bfe47a6e23233933cb905159b0a240b24881382913f3946de75/blob b/shared/package-files/42/42fba68e0e7e6bfe47a6e23233933cb905159b0a240b24881382913f3946de75/blob new file mode 100644 index 0000000000000000000000000000000000000000..b11869b9faca4348ab05119894cf572e2f9e3ebc --- /dev/null +++ b/shared/package-files/42/42fba68e0e7e6bfe47a6e23233933cb905159b0a240b24881382913f3946de75/blob @@ -0,0 +1,163 @@ +""" +Tests for Results.predict +""" + +from statsmodels.compat.pandas import testing as pdt + +import numpy as np +from numpy.testing import assert_allclose, assert_equal +import pandas as pd +import pytest + +from statsmodels.genmod.generalized_linear_model import GLM +from statsmodels.regression.linear_model import OLS + + +class CheckPredictReturns: + + def test_2d(self): + res = self.res + data = self.data + + fitted = res.fittedvalues.iloc[1:10:2] + + pred = res.predict(data.iloc[1:10:2]) + pdt.assert_index_equal(pred.index, fitted.index) + assert_allclose(pred.values, fitted.values, rtol=1e-13) + + # plain dict + xd = dict(zip(data.columns, data.iloc[1:10:2].values.T, strict=True)) + with pytest.warns(DeprecationWarning, match="Using"): + pred = res.predict(xd) + assert_equal(pred.index, np.arange(len(pred))) + assert_allclose(pred.values, fitted.values, rtol=1e-13) + + def test_1d(self): + # one observation + res = self.res + data = self.data + + pred = res.predict(data.iloc[:1]) + pdt.assert_index_equal(pred.index, data.iloc[:1].index) + fv = np.asarray(res.fittedvalues) + assert_allclose(pred.values, fv[0], rtol=1e-13) + + fittedm = res.fittedvalues.mean() + xmean = data.mean() + pred = res.predict(xmean.to_frame().T) + assert_equal(pred.index, np.arange(1)) + assert_allclose(pred, fittedm, rtol=1e-13) + + # Series + pred = res.predict(data.mean()) + assert_equal(pred.index, np.arange(1)) + assert_allclose(pred.values, fittedm, rtol=1e-13) + + # dict with scalar value (is plain dict) + # Note: this warns about dropped nan, even though there are None -FIXED + with pytest.warns(DeprecationWarning, match="Using"): + pred = res.predict(data.mean().to_dict()) + assert_equal(pred.index, np.arange(1)) + assert_allclose(pred.values, fittedm, rtol=1e-13) + + def test_without_formula(self): + res = self.res + data = self.data + fitted = res.fittedvalues.iloc[1:10:2] + + # plain numpy array + pred = res.predict(res.model.exog[1:10:2], transform=False) + assert_allclose(pred, fitted.values, rtol=1e-13) + + # pandas DataFrame + x = pd.DataFrame( + res.model.exog[1:10:2], + index=data.index[1:10:2], + columns=res.model.exog_names, + ) + pred = res.predict(x) + pdt.assert_index_equal(pred.index, fitted.index) + assert_allclose(pred.values, fitted.values, rtol=1e-13) + + # one observation - 1-D + pred = res.predict(res.model.exog[1], transform=False) + assert_allclose(pred, fitted.values[0], rtol=1e-13) + + # one observation - pd.Series + pred = res.predict(x.iloc[0]) + pdt.assert_index_equal(pred.index, fitted.index[:1]) + assert_allclose(pred.values[0], fitted.values[0], rtol=1e-13) + + +class TestPredictOLS(CheckPredictReturns): + + @classmethod + def setup_class(cls): + nobs = 30 + rs = np.random.RandomState(987128) + x = rs.randn(nobs, 3) + y = x.sum(1) + rs.randn(nobs) + index = [f"obs{i:02d}" for i in range(nobs)] + # add one extra column to check that it does not matter + cls.data = pd.DataFrame( + np.round(np.column_stack((y, x)), 4), + columns="y var1 var2 var3".split(), + index=index, + ) + + cls.res = OLS.from_formula("y ~ var1 + var2", data=cls.data).fit() + + +class TestPredictGLM(CheckPredictReturns): + + @classmethod + def setup_class(cls): + nobs = 30 + rs = np.random.RandomState(987128) + x = rs.randn(nobs, 3) + y = x.sum(1) + rs.randn(nobs) + index = [f"obs{i:02d}" for i in range(nobs)] + # add one extra column to check that it does not matter + cls.data = pd.DataFrame( + np.round(np.column_stack((y, x)), 4), + columns="y var1 var2 var3".split(), + index=index, + ) + + cls.res = GLM.from_formula("y ~ var1 + var2", data=cls.data).fit() + + def test_predict_offset(self): + res = self.res + data = self.data + + fitted = res.fittedvalues.iloc[1:10:2] + offset = np.arange(len(fitted)) + fitted = fitted + offset + + pred = res.predict(data.iloc[1:10:2], offset=offset) + pdt.assert_index_equal(pred.index, fitted.index) + assert_allclose(pred.values, fitted.values, rtol=1e-13) + + # plain dict + xd = dict(zip(data.columns, data.iloc[1:10:2].values.T, strict=True)) + with pytest.warns(DeprecationWarning, match="Using"): + pred = res.predict(xd, offset=offset) + assert_equal(pred.index, np.arange(len(pred))) + assert_allclose(pred.values, fitted.values, rtol=1e-13) + + # offset as pandas.Series + data2 = data.iloc[1:10:2].copy() + data2["offset"] = offset + pred = res.predict(data2, offset=data2["offset"]) + pdt.assert_index_equal(pred.index, fitted.index) + assert_allclose(pred.values, fitted.values, rtol=1e-13) + + # check nan in exog is ok, preserves index matching offset length + data2 = data.iloc[1:10:2].copy() + data2["offset"] = offset + data2.iloc[0, 1] = np.nan + pred = res.predict(data2, offset=data2["offset"]) + pdt.assert_index_equal(pred.index, fitted.index) + fitted_nan = fitted.copy() + fitted_nan.iloc[0] = np.nan + assert_allclose(pred.values, fitted_nan.values, rtol=1e-13) diff --git a/shared/package-files/42/42fcb70306b8ad483fa2649d7c9b13891b2b841e26d294f53da322da488c6254/blob b/shared/package-files/42/42fcb70306b8ad483fa2649d7c9b13891b2b841e26d294f53da322da488c6254/blob new file mode 100644 index 0000000000000000000000000000000000000000..62fc630b175ab26ced7c345b1e8cc4d88f7cd478 --- /dev/null +++ b/shared/package-files/42/42fcb70306b8ad483fa2649d7c9b13891b2b841e26d294f53da322da488c6254/blob @@ -0,0 +1,383 @@ +# +# ttk::treeview widget bindings and utilities. +# + +namespace eval ttk::treeview { + variable State + + # Enter/Leave/Motion + # + set State(activeWidget) {} + set State(activeHeading) {} + + # Press/drag/release: + # + set State(pressMode) none + set State(pressX) 0 + + # For pressMode == "resize" + set State(resizeColumn) #0 + + # For pressmode == "heading" + set State(heading) {} +} + +### Widget bindings. +# + +bind Treeview { ttk::treeview::Motion %W %x %y } +bind Treeview { #nothing } +bind Treeview { ttk::treeview::ActivateHeading {} {}} +bind Treeview { ttk::treeview::Press %W %x %y } +bind Treeview { ttk::treeview::DoubleClick %W %x %y } +bind Treeview { ttk::treeview::Release %W %x %y } +bind Treeview { ttk::treeview::Drag %W %x %y } +bind Treeview { ttk::treeview::Keynav %W up } +bind Treeview { ttk::treeview::Keynav %W down } +bind Treeview { ttk::treeview::Keynav %W right } +bind Treeview { ttk::treeview::Keynav %W left } +bind Treeview { %W yview scroll -1 pages } +bind Treeview { %W yview scroll 1 pages } +bind Treeview { ttk::treeview::ToggleFocus %W } +bind Treeview { ttk::treeview::ToggleFocus %W } + +bind Treeview \ + { ttk::treeview::Select %W %x %y extend } +bind Treeview <> \ + { ttk::treeview::Select %W %x %y toggle } + +ttk::copyBindings TtkScrollable Treeview + +### Binding procedures. +# + +## Keynav -- Keyboard navigation +# +# @@@ TODO: verify/rewrite up and down code. +# +proc ttk::treeview::Keynav {w dir} { + set focus [$w focus] + if {$focus eq ""} { return } + + switch -- $dir { + up { + if {[set up [$w prev $focus]] eq ""} { + set focus [$w parent $focus] + } else { + while {[$w item $up -open] && [llength [$w children $up]]} { + set up [lindex [$w children $up] end] + } + set focus $up + } + } + down { + if {[$w item $focus -open] && [llength [$w children $focus]]} { + set focus [lindex [$w children $focus] 0] + } else { + set up $focus + while {$up ne "" && [set down [$w next $up]] eq ""} { + set up [$w parent $up] + } + set focus $down + } + } + left { + if {[$w item $focus -open] && [llength [$w children $focus]]} { + CloseItem $w $focus + } else { + set focus [$w parent $focus] + } + } + right { + OpenItem $w $focus + } + } + + if {$focus != {}} { + SelectOp $w $focus choose + } +} + +## Motion -- pointer motion binding. +# Sets cursor, active element ... +# +proc ttk::treeview::Motion {w x y} { + variable State + + ttk::saveCursor $w State(userConfCursor) [ttk::cursor hresize] + + set cursor $State(userConfCursor) + set activeHeading {} + + switch -- [$w identify region $x $y] { + separator { set cursor hresize } + heading { set activeHeading [$w identify column $x $y] } + } + + ttk::setCursor $w $cursor + ActivateHeading $w $activeHeading +} + +## ActivateHeading -- track active heading element +# +proc ttk::treeview::ActivateHeading {w heading} { + variable State + + if {$w != $State(activeWidget) || $heading != $State(activeHeading)} { + if {[winfo exists $State(activeWidget)] && $State(activeHeading) != {}} { + # It may happen that $State(activeHeading) no longer corresponds + # to an existing display column. This happens for instance when + # changing -displaycolumns in a bound script when this change + # triggers a event. A proc checking if the display column + # $State(activeHeading) is really still present or not could be + # written but it would need to check several special cases: + # a. -displaycolumns "#all" or being an explicit columns list + # b. column #0 display is not governed by the -displaycolumn + # list but by the value of the -show option + # --> Let's rather catch the following line. + catch {$State(activeWidget) heading $State(activeHeading) state !active} + } + if {$heading != {}} { + $w heading $heading state active + } + set State(activeHeading) $heading + set State(activeWidget) $w + } +} + +## Select $w $x $y $selectop +# Binding procedure for selection operations. +# See "Selection modes", below. +# +proc ttk::treeview::Select {w x y op} { + if {[set item [$w identify row $x $y]] ne "" } { + SelectOp $w $item $op + } +} + +## DoubleClick -- Double-Button-1 binding. +# +proc ttk::treeview::DoubleClick {w x y} { + if {[set row [$w identify row $x $y]] ne ""} { + Toggle $w $row + } else { + Press $w $x $y ;# perform single-click action + } +} + +## Press -- Button binding. +# +proc ttk::treeview::Press {w x y} { + focus $w + switch -- [$w identify region $x $y] { + nothing { } + heading { heading.press $w $x $y } + separator { resize.press $w $x $y } + tree - + cell { + set item [$w identify item $x $y] + SelectOp $w $item choose + switch -glob -- [$w identify element $x $y] { + *indicator - + *disclosure { Toggle $w $item } + } + } + } +} + +## Drag -- B1-Motion binding +# +proc ttk::treeview::Drag {w x y} { + variable State + switch $State(pressMode) { + resize { resize.drag $w $x } + heading { heading.drag $w $x $y } + } +} + +proc ttk::treeview::Release {w x y} { + variable State + switch $State(pressMode) { + resize { resize.release $w $x } + heading { heading.release $w } + } + set State(pressMode) none + Motion $w $x $y +} + +### Interactive column resizing. +# +proc ttk::treeview::resize.press {w x y} { + variable State + set State(pressMode) "resize" + set State(resizeColumn) [$w identify column $x $y] +} + +proc ttk::treeview::resize.drag {w x} { + variable State + $w drag $State(resizeColumn) $x +} + +proc ttk::treeview::resize.release {w x} { + $w drop +} + +### Heading activation. +# + +proc ttk::treeview::heading.press {w x y} { + variable State + set column [$w identify column $x $y] + set State(pressMode) "heading" + set State(heading) $column + $w heading $column state pressed +} + +proc ttk::treeview::heading.drag {w x y} { + variable State + if { [$w identify region $x $y] eq "heading" + && [$w identify column $x $y] eq $State(heading) + } { + $w heading $State(heading) state pressed + } else { + $w heading $State(heading) state !pressed + } +} + +proc ttk::treeview::heading.release {w} { + variable State + if {[lsearch -exact [$w heading $State(heading) state] pressed] >= 0} { + after 0 [$w heading $State(heading) -command] + } + $w heading $State(heading) state !pressed +} + +### Selection modes. +# + +## SelectOp $w $item [ choose | extend | toggle ] -- +# Dispatch to appropriate selection operation +# depending on current value of -selectmode. +# +proc ttk::treeview::SelectOp {w item op} { + select.$op.[$w cget -selectmode] $w $item +} + +## -selectmode none: +# +proc ttk::treeview::select.choose.none {w item} { $w focus $item; $w see $item } +proc ttk::treeview::select.toggle.none {w item} { $w focus $item; $w see $item } +proc ttk::treeview::select.extend.none {w item} { $w focus $item; $w see $item } + +## -selectmode browse: +# +proc ttk::treeview::select.choose.browse {w item} { BrowseTo $w $item } +proc ttk::treeview::select.toggle.browse {w item} { BrowseTo $w $item } +proc ttk::treeview::select.extend.browse {w item} { BrowseTo $w $item } + +## -selectmode multiple: +# +proc ttk::treeview::select.choose.extended {w item} { + BrowseTo $w $item +} +proc ttk::treeview::select.toggle.extended {w item} { + $w selection toggle [list $item] +} +proc ttk::treeview::select.extend.extended {w item} { + if {[set anchor [$w focus]] ne ""} { + $w selection set [between $w $anchor $item] + } else { + BrowseTo $w $item + } +} + +### Tree structure utilities. +# + +## between $tv $item1 $item2 -- +# Returns a list of all items between $item1 and $item2, +# in preorder traversal order. $item1 and $item2 may be +# in either order. +# +# NOTES: +# This routine is O(N) in the size of the tree. +# There's probably a way to do this that's O(N) in the number +# of items returned, but I'm not clever enough to figure it out. +# +proc ttk::treeview::between {tv item1 item2} { + variable between [list] + variable selectingBetween 0 + ScanBetween $tv $item1 $item2 {} + return $between +} + +## ScanBetween -- +# Recursive worker routine for ttk::treeview::between +# +proc ttk::treeview::ScanBetween {tv item1 item2 item} { + variable between + variable selectingBetween + + if {$item eq $item1 || $item eq $item2} { + lappend between $item + set selectingBetween [expr {!$selectingBetween}] + } elseif {$selectingBetween} { + lappend between $item + } + foreach child [$tv children $item] { + ScanBetween $tv $item1 $item2 $child + } +} + +### User interaction utilities. +# + +## OpenItem, CloseItem -- Set the open state of an item, generate event +# + +proc ttk::treeview::OpenItem {w item} { + $w focus $item + event generate $w <> + $w item $item -open true +} + +proc ttk::treeview::CloseItem {w item} { + $w item $item -open false + $w focus $item + event generate $w <> +} + +## Toggle -- toggle opened/closed state of item +# +proc ttk::treeview::Toggle {w item} { + # don't allow toggling on indicators that + # are not present in front of leaf items + if {[$w children $item] == {}} { + return + } + # not a leaf, toggle! + if {[$w item $item -open]} { + CloseItem $w $item + } else { + OpenItem $w $item + } +} + +## ToggleFocus -- toggle opened/closed state of focus item +# +proc ttk::treeview::ToggleFocus {w} { + set item [$w focus] + if {$item ne ""} { + Toggle $w $item + } +} + +## BrowseTo -- navigate to specified item; set focus and selection +# +proc ttk::treeview::BrowseTo {w item} { + $w see $item + $w focus $item + $w selection set [list $item] +} + +#*EOF* diff --git a/shared/package-files/42/42fe1c5d7c3b28141613cf367208f4923437c21d6fa55d68ac9dafd898f1af65/blob b/shared/package-files/42/42fe1c5d7c3b28141613cf367208f4923437c21d6fa55d68ac9dafd898f1af65/blob new file mode 100644 index 0000000000000000000000000000000000000000..0a8e350a334bbee29b155fb9944c6831460d973e Binary files /dev/null and b/shared/package-files/42/42fe1c5d7c3b28141613cf367208f4923437c21d6fa55d68ac9dafd898f1af65/blob differ diff --git a/shared/package-files/43/4301b2b74b67badba8bb6e664b4bb62e34600d3608ea884cd9c6d9f877ba3ace/blob b/shared/package-files/43/4301b2b74b67badba8bb6e664b4bb62e34600d3608ea884cd9c6d9f877ba3ace/blob new file mode 100644 index 0000000000000000000000000000000000000000..57694becc49b2028f17eac819b80a225ac010795 --- /dev/null +++ b/shared/package-files/43/4301b2b74b67badba8bb6e664b4bb62e34600d3608ea884cd9c6d9f877ba3ace/blob @@ -0,0 +1,112 @@ +import numpy as np +import scipy.special as sc +import pytest +from numpy.testing import assert_allclose, assert_array_equal, suppress_warnings + + +class TestBdtr: + def test(self): + val = sc.bdtr(0, 1, 0.5) + assert_allclose(val, 0.5) + + def test_sum_is_one(self): + val = sc.bdtr([0, 1, 2], 2, 0.5) + assert_array_equal(val, [0.25, 0.75, 1.0]) + + def test_rounding(self): + double_val = sc.bdtr([0.1, 1.1, 2.1], 2, 0.5) + int_val = sc.bdtr([0, 1, 2], 2, 0.5) + assert_array_equal(double_val, int_val) + + @pytest.mark.parametrize('k, n, p', [ + (np.inf, 2, 0.5), + (1.0, np.inf, 0.5), + (1.0, 2, np.inf) + ]) + def test_inf(self, k, n, p): + with suppress_warnings() as sup: + sup.filter(DeprecationWarning) + val = sc.bdtr(k, n, p) + assert np.isnan(val) + + def test_domain(self): + val = sc.bdtr(-1.1, 1, 0.5) + assert np.isnan(val) + + +class TestBdtrc: + def test_value(self): + val = sc.bdtrc(0, 1, 0.5) + assert_allclose(val, 0.5) + + def test_sum_is_one(self): + val = sc.bdtrc([0, 1, 2], 2, 0.5) + assert_array_equal(val, [0.75, 0.25, 0.0]) + + def test_rounding(self): + double_val = sc.bdtrc([0.1, 1.1, 2.1], 2, 0.5) + int_val = sc.bdtrc([0, 1, 2], 2, 0.5) + assert_array_equal(double_val, int_val) + + @pytest.mark.parametrize('k, n, p', [ + (np.inf, 2, 0.5), + (1.0, np.inf, 0.5), + (1.0, 2, np.inf) + ]) + def test_inf(self, k, n, p): + with suppress_warnings() as sup: + sup.filter(DeprecationWarning) + val = sc.bdtrc(k, n, p) + assert np.isnan(val) + + def test_domain(self): + val = sc.bdtrc(-1.1, 1, 0.5) + val2 = sc.bdtrc(2.1, 1, 0.5) + assert np.isnan(val2) + assert_allclose(val, 1.0) + + def test_bdtr_bdtrc_sum_to_one(self): + bdtr_vals = sc.bdtr([0, 1, 2], 2, 0.5) + bdtrc_vals = sc.bdtrc([0, 1, 2], 2, 0.5) + vals = bdtr_vals + bdtrc_vals + assert_allclose(vals, [1.0, 1.0, 1.0]) + + +class TestBdtri: + def test_value(self): + val = sc.bdtri(0, 1, 0.5) + assert_allclose(val, 0.5) + + def test_sum_is_one(self): + val = sc.bdtri([0, 1], 2, 0.5) + actual = np.asarray([1 - 1/np.sqrt(2), 1/np.sqrt(2)]) + assert_allclose(val, actual) + + def test_rounding(self): + double_val = sc.bdtri([0.1, 1.1], 2, 0.5) + int_val = sc.bdtri([0, 1], 2, 0.5) + assert_allclose(double_val, int_val) + + @pytest.mark.parametrize('k, n, p', [ + (np.inf, 2, 0.5), + (1.0, np.inf, 0.5), + (1.0, 2, np.inf) + ]) + def test_inf(self, k, n, p): + with suppress_warnings() as sup: + sup.filter(DeprecationWarning) + val = sc.bdtri(k, n, p) + assert np.isnan(val) + + @pytest.mark.parametrize('k, n, p', [ + (-1.1, 1, 0.5), + (2.1, 1, 0.5) + ]) + def test_domain(self, k, n, p): + val = sc.bdtri(k, n, p) + assert np.isnan(val) + + def test_bdtr_bdtri_roundtrip(self): + bdtr_vals = sc.bdtr([0, 1, 2], 2, 0.5) + roundtrip_vals = sc.bdtri([0, 1, 2], 2, bdtr_vals) + assert_allclose(roundtrip_vals, [0.5, 0.5, np.nan]) diff --git a/shared/package-files/43/430247c7d47bd0b166713b8a8cb705ade7f40bde1921a7e90f7522b5d528edbb/blob b/shared/package-files/43/430247c7d47bd0b166713b8a8cb705ade7f40bde1921a7e90f7522b5d528edbb/blob new file mode 100644 index 0000000000000000000000000000000000000000..468897e957bb1ebcff5d66863de0b29543ca4fd2 --- /dev/null +++ b/shared/package-files/43/430247c7d47bd0b166713b8a8cb705ade7f40bde1921a7e90f7522b5d528edbb/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor resize_as_sparse(const at::Tensor & self, const at::Tensor & the_template); +TORCH_API const at::Tensor & resize_as_sparse_out(const at::Tensor & out, const at::Tensor & self, const at::Tensor & the_template); +TORCH_API const at::Tensor & resize_as_sparse_outf(const at::Tensor & self, const at::Tensor & the_template, const at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/43/4303dddc93afa2dd629e950461ec6163793f355a193f5ef18a3c086cc68011e7/blob b/shared/package-files/43/4303dddc93afa2dd629e950461ec6163793f355a193f5ef18a3c086cc68011e7/blob new file mode 100644 index 0000000000000000000000000000000000000000..fb1f207ed3d9c0824fc27325aec4677730d27bf3 Binary files /dev/null and b/shared/package-files/43/4303dddc93afa2dd629e950461ec6163793f355a193f5ef18a3c086cc68011e7/blob differ diff --git a/shared/package-files/43/4305da1ea25c27fce08bd14001b76fd54fe42a0724bbd5168c76680a56eda5be/blob b/shared/package-files/43/4305da1ea25c27fce08bd14001b76fd54fe42a0724bbd5168c76680a56eda5be/blob new file mode 100644 index 0000000000000000000000000000000000000000..f092050d881db65ec25e1cebbc34921500b60eca --- /dev/null +++ b/shared/package-files/43/4305da1ea25c27fce08bd14001b76fd54fe42a0724bbd5168c76680a56eda5be/blob @@ -0,0 +1,169 @@ +# Grammar for Python + +# NOTE WELL: You should also follow all the steps listed at +# https://devguide.python.org/grammar/ + +# Start symbols for the grammar: +# single_input is a single interactive statement; +# file_input is a module or sequence of commands read from an input file; +# eval_input is the input for the eval() functions. +# NB: compound_stmt in single_input is followed by extra NEWLINE! +single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE +file_input: stmt* ENDMARKER +eval_input: testlist NEWLINE* ENDMARKER + +decorator: '@' namedexpr_test NEWLINE +decorators: decorator+ +decorated: decorators (classdef | funcdef | async_funcdef) + +async_funcdef: 'async' funcdef +funcdef: 'def' NAME parameters ['->' test] ':' suite + +parameters: '(' [typedargslist] ')' +typedargslist: ( + (tfpdef ['=' test] (',' tfpdef ['=' test])* ',' '/' [',' [ tfpdef ['=' test] ( + ',' tfpdef ['=' test])* ([',' [ + '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] + | '**' tfpdef [',']]]) + | '*' [tfpdef] (',' tfpdef ['=' test])* ([',' ['**' tfpdef [',']]]) + | '**' tfpdef [',']]] ) +| (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' [ + '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] + | '**' tfpdef [',']]] + | '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] + | '**' tfpdef [',']) +) +tfpdef: NAME [':' test] +varargslist: vfpdef ['=' test ](',' vfpdef ['=' test])* ',' '/' [',' [ (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' [ + '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] + | '**' vfpdef [',']]] + | '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] + | '**' vfpdef [',']) ]] | (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' [ + '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] + | '**' vfpdef [',']]] + | '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] + | '**' vfpdef [','] +) +vfpdef: NAME + +stmt: simple_stmt | compound_stmt | NEWLINE +simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE +small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | + import_stmt | global_stmt | nonlocal_stmt | assert_stmt) +expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | + ('=' (yield_expr|testlist_star_expr))*) +annassign: ':' test ['=' (yield_expr|testlist_star_expr)] +testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] +augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | + '<<=' | '>>=' | '**=' | '//=') +# For normal and annotated assignments, additional restrictions enforced by the interpreter +del_stmt: 'del' exprlist +pass_stmt: 'pass' +flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt +break_stmt: 'break' +continue_stmt: 'continue' +return_stmt: 'return' [testlist_star_expr] +yield_stmt: yield_expr +raise_stmt: 'raise' [test ['from' test]] +import_stmt: import_name | import_from +import_name: 'import' dotted_as_names +# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS +import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) + 'import' ('*' | '(' import_as_names ')' | import_as_names)) +import_as_name: NAME ['as' NAME] +dotted_as_name: dotted_name ['as' NAME] +import_as_names: import_as_name (',' import_as_name)* [','] +dotted_as_names: dotted_as_name (',' dotted_as_name)* +dotted_name: NAME ('.' NAME)* +global_stmt: 'global' NAME (',' NAME)* +nonlocal_stmt: 'nonlocal' NAME (',' NAME)* +assert_stmt: 'assert' test [',' test] + +compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt +async_stmt: 'async' (funcdef | with_stmt | for_stmt) +if_stmt: 'if' namedexpr_test ':' suite ('elif' namedexpr_test ':' suite)* ['else' ':' suite] +while_stmt: 'while' namedexpr_test ':' suite ['else' ':' suite] +for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] +try_stmt: ('try' ':' suite + ((except_clause ':' suite)+ + ['else' ':' suite] + ['finally' ':' suite] | + 'finally' ':' suite)) +with_stmt: 'with' with_item (',' with_item)* ':' suite +with_item: test ['as' expr] +# NB compile.c makes sure that the default except clause is last +except_clause: 'except' [test ['as' NAME]] +suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT + +namedexpr_test: test [':=' test] +test: or_test ['if' or_test 'else' test] | lambdef +lambdef: 'lambda' [varargslist] ':' test +or_test: and_test ('or' and_test)* +and_test: not_test ('and' not_test)* +not_test: 'not' not_test | comparison +comparison: expr (comp_op expr)* +# <> isn't actually a valid comparison operator in Python. It's here for the +# sake of a __future__ import described in PEP 401 (which really works :-) +comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' +star_expr: '*' expr +expr: xor_expr ('|' xor_expr)* +xor_expr: and_expr ('^' and_expr)* +and_expr: shift_expr ('&' shift_expr)* +shift_expr: arith_expr (('<<'|'>>') arith_expr)* +arith_expr: term (('+'|'-') term)* +term: factor (('*'|'@'|'/'|'%'|'//') factor)* +factor: ('+'|'-'|'~') factor | power +power: atom_expr ['**' factor] +atom_expr: ['await'] atom trailer* +atom: ('(' [yield_expr|testlist_comp] ')' | + '[' [testlist_comp] ']' | + '{' [dictorsetmaker] '}' | + NAME | NUMBER | strings | '...' | 'None' | 'True' | 'False') +testlist_comp: (namedexpr_test|star_expr) ( comp_for | (',' (namedexpr_test|star_expr))* [','] ) +trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME +subscriptlist: subscript (',' subscript)* [','] +subscript: test [':=' test] | [test] ':' [test] [sliceop] +sliceop: ':' [test] +exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] +testlist: test (',' test)* [','] +dictorsetmaker: ( ((test ':' test | '**' expr) + (comp_for | (',' (test ':' test | '**' expr))* [','])) | + ((test [':=' test] | star_expr) + (comp_for | (',' (test [':=' test] | star_expr))* [','])) ) + +classdef: 'class' NAME ['(' [arglist] ')'] ':' suite + +arglist: argument (',' argument)* [','] + +# The reason that keywords are test nodes instead of NAME is that using NAME +# results in an ambiguity. ast.c makes sure it's a NAME. +# "test '=' test" is really "keyword '=' test", but we have no such token. +# These need to be in a single rule to avoid grammar that is ambiguous +# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, +# we explicitly match '*' here, too, to give it proper precedence. +# Illegal combinations and orderings are blocked in ast.c: +# multiple (test comp_for) arguments are blocked; keyword unpackings +# that precede iterable unpackings are blocked; etc. +argument: ( test [comp_for] | + test ':=' test | + test '=' test | + '**' test | + '*' test ) + +comp_iter: comp_for | comp_if +sync_comp_for: 'for' exprlist 'in' or_test [comp_iter] +comp_for: ['async'] sync_comp_for +comp_if: 'if' or_test [comp_iter] + +# not used in grammar, but may appear in "node" passed from Parser to Compiler +encoding_decl: NAME + +yield_expr: 'yield' [yield_arg] +yield_arg: 'from' test | testlist_star_expr + +strings: (STRING | fstring)+ +fstring: FSTRING_START fstring_content* FSTRING_END +fstring_content: FSTRING_STRING | fstring_expr +fstring_conversion: '!' NAME +fstring_expr: '{' (testlist_comp | yield_expr) ['='] [ fstring_conversion ] [ fstring_format_spec ] '}' +fstring_format_spec: ':' fstring_content* diff --git a/shared/package-files/43/4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba/blob b/shared/package-files/43/4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba/blob new file mode 100644 index 0000000000000000000000000000000000000000..febe411355d6be3be8b60bd8c845479451149d6f --- /dev/null +++ b/shared/package-files/43/4308932872acbf4a674312a45a49b870e48026e3dfedc878ee2f512ddf2f30ba/blob @@ -0,0 +1,557 @@ +# Copyright (C) 2002-2007 Python Software Foundation +# Contact: email-sig@python.org + +"""Email address parsing code. + +Lifted directly from rfc822.py. This should eventually be rewritten. +""" + +__all__ = [ + 'mktime_tz', + 'parsedate', + 'parsedate_tz', + 'quote', + ] + +import time, calendar + +SPACE = ' ' +EMPTYSTRING = '' +COMMASPACE = ', ' + +# Parse a date field +_monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', + 'aug', 'sep', 'oct', 'nov', 'dec', + 'january', 'february', 'march', 'april', 'may', 'june', 'july', + 'august', 'september', 'october', 'november', 'december'] + +_daynames = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'] + +# The timezone table does not include the military time zones defined +# in RFC822, other than Z. According to RFC1123, the description in +# RFC822 gets the signs wrong, so we can't rely on any such time +# zones. RFC1123 recommends that numeric timezone indicators be used +# instead of timezone names. + +_timezones = {'UT':0, 'UTC':0, 'GMT':0, 'Z':0, + 'AST': -400, 'ADT': -300, # Atlantic (used in Canada) + 'EST': -500, 'EDT': -400, # Eastern + 'CST': -600, 'CDT': -500, # Central + 'MST': -700, 'MDT': -600, # Mountain + 'PST': -800, 'PDT': -700 # Pacific + } + + +def parsedate_tz(data): + """Convert a date string to a time tuple. + + Accounts for military timezones. + """ + res = _parsedate_tz(data) + if not res: + return + if res[9] is None: + res[9] = 0 + return tuple(res) + +def _parsedate_tz(data): + """Convert date to extended time tuple. + + The last (additional) element is the time zone offset in seconds, except if + the timezone was specified as -0000. In that case the last element is + None. This indicates a UTC timestamp that explicitly declaims knowledge of + the source timezone, as opposed to a +0000 timestamp that indicates the + source timezone really was UTC. + + """ + if not data: + return None + data = data.split() + if not data: # This happens for whitespace-only input. + return None + # The FWS after the comma after the day-of-week is optional, so search and + # adjust for this. + if data[0].endswith(',') or data[0].lower() in _daynames: + # There's a dayname here. Skip it + del data[0] + else: + i = data[0].rfind(',') + if i >= 0: + data[0] = data[0][i+1:] + if len(data) == 3: # RFC 850 date, deprecated + stuff = data[0].split('-') + if len(stuff) == 3: + data = stuff + data[1:] + if len(data) == 4: + s = data[3] + i = s.find('+') + if i == -1: + i = s.find('-') + if i > 0: + data[3:] = [s[:i], s[i:]] + else: + data.append('') # Dummy tz + if len(data) < 5: + return None + data = data[:5] + [dd, mm, yy, tm, tz] = data + if not (dd and mm and yy): + return None + mm = mm.lower() + if mm not in _monthnames: + dd, mm = mm, dd.lower() + if mm not in _monthnames: + return None + mm = _monthnames.index(mm) + 1 + if mm > 12: + mm -= 12 + if dd[-1] == ',': + dd = dd[:-1] + i = yy.find(':') + if i > 0: + yy, tm = tm, yy + if yy[-1] == ',': + yy = yy[:-1] + if not yy: + return None + if not yy[0].isdigit(): + yy, tz = tz, yy + if tm[-1] == ',': + tm = tm[:-1] + tm = tm.split(':') + if len(tm) == 2: + [thh, tmm] = tm + tss = '0' + elif len(tm) == 3: + [thh, tmm, tss] = tm + elif len(tm) == 1 and '.' in tm[0]: + # Some non-compliant MUAs use '.' to separate time elements. + tm = tm[0].split('.') + if len(tm) == 2: + [thh, tmm] = tm + tss = 0 + elif len(tm) == 3: + [thh, tmm, tss] = tm + else: + return None + else: + return None + try: + yy = int(yy) + dd = int(dd) + thh = int(thh) + tmm = int(tmm) + tss = int(tss) + except ValueError: + return None + # Check for a yy specified in two-digit format, then convert it to the + # appropriate four-digit format, according to the POSIX standard. RFC 822 + # calls for a two-digit yy, but RFC 2822 (which obsoletes RFC 822) + # mandates a 4-digit yy. For more information, see the documentation for + # the time module. + if yy < 100: + # The year is between 1969 and 1999 (inclusive). + if yy > 68: + yy += 1900 + # The year is between 2000 and 2068 (inclusive). + else: + yy += 2000 + tzoffset = None + tz = tz.upper() + if tz in _timezones: + tzoffset = _timezones[tz] + else: + try: + tzoffset = int(tz) + except ValueError: + pass + if tzoffset==0 and tz.startswith('-'): + tzoffset = None + # Convert a timezone offset into seconds ; -0500 -> -18000 + if tzoffset: + if tzoffset < 0: + tzsign = -1 + tzoffset = -tzoffset + else: + tzsign = 1 + tzoffset = tzsign * ( (tzoffset//100)*3600 + (tzoffset % 100)*60) + # Daylight Saving Time flag is set to -1, since DST is unknown. + return [yy, mm, dd, thh, tmm, tss, 0, 1, -1, tzoffset] + + +def parsedate(data): + """Convert a time string to a time tuple.""" + t = parsedate_tz(data) + if isinstance(t, tuple): + return t[:9] + else: + return t + + +def mktime_tz(data): + """Turn a 10-tuple as returned by parsedate_tz() into a POSIX timestamp.""" + if data[9] is None: + # No zone info, so localtime is better assumption than GMT + return time.mktime(data[:8] + (-1,)) + else: + t = calendar.timegm(data) + return t - data[9] + + +def quote(str): + """Prepare string to be used in a quoted string. + + Turns backslash and double quote characters into quoted pairs. These + are the only characters that need to be quoted inside a quoted string. + Does not add the surrounding double quotes. + """ + return str.replace('\\', '\\\\').replace('"', '\\"') + + +class AddrlistClass: + """Address parser class by Ben Escoto. + + To understand what this class does, it helps to have a copy of RFC 2822 in + front of you. + + Note: this class interface is deprecated and may be removed in the future. + Use email.utils.AddressList instead. + """ + + def __init__(self, field): + """Initialize a new instance. + + `field' is an unparsed address header field, containing + one or more addresses. + """ + self.specials = '()<>@,:;.\"[]' + self.pos = 0 + self.LWS = ' \t' + self.CR = '\r\n' + self.FWS = self.LWS + self.CR + self.atomends = self.specials + self.LWS + self.CR + # Note that RFC 2822 now specifies `.' as obs-phrase, meaning that it + # is obsolete syntax. RFC 2822 requires that we recognize obsolete + # syntax, so allow dots in phrases. + self.phraseends = self.atomends.replace('.', '') + self.field = field + self.commentlist = [] + + def gotonext(self): + """Skip white space and extract comments.""" + wslist = [] + while self.pos < len(self.field): + if self.field[self.pos] in self.LWS + '\n\r': + if self.field[self.pos] not in '\n\r': + wslist.append(self.field[self.pos]) + self.pos += 1 + elif self.field[self.pos] == '(': + self.commentlist.append(self.getcomment()) + else: + break + return EMPTYSTRING.join(wslist) + + def getaddrlist(self): + """Parse all addresses. + + Returns a list containing all of the addresses. + """ + result = [] + while self.pos < len(self.field): + ad = self.getaddress() + if ad: + result += ad + else: + result.append(('', '')) + return result + + def getaddress(self): + """Parse the next address.""" + self.commentlist = [] + self.gotonext() + + oldpos = self.pos + oldcl = self.commentlist + plist = self.getphraselist() + + self.gotonext() + returnlist = [] + + if self.pos >= len(self.field): + # Bad email address technically, no domain. + if plist: + returnlist = [(SPACE.join(self.commentlist), plist[0])] + + elif self.field[self.pos] in '.@': + # email address is just an addrspec + # this isn't very efficient since we start over + self.pos = oldpos + self.commentlist = oldcl + addrspec = self.getaddrspec() + returnlist = [(SPACE.join(self.commentlist), addrspec)] + + elif self.field[self.pos] == ':': + # address is a group + returnlist = [] + + fieldlen = len(self.field) + self.pos += 1 + while self.pos < len(self.field): + self.gotonext() + if self.pos < fieldlen and self.field[self.pos] == ';': + self.pos += 1 + break + returnlist = returnlist + self.getaddress() + + elif self.field[self.pos] == '<': + # Address is a phrase then a route addr + routeaddr = self.getrouteaddr() + + if self.commentlist: + returnlist = [(SPACE.join(plist) + ' (' + + ' '.join(self.commentlist) + ')', routeaddr)] + else: + returnlist = [(SPACE.join(plist), routeaddr)] + + else: + if plist: + returnlist = [(SPACE.join(self.commentlist), plist[0])] + elif self.field[self.pos] in self.specials: + self.pos += 1 + + self.gotonext() + if self.pos < len(self.field) and self.field[self.pos] == ',': + self.pos += 1 + return returnlist + + def getrouteaddr(self): + """Parse a route address (Return-path value). + + This method just skips all the route stuff and returns the addrspec. + """ + if self.field[self.pos] != '<': + return + + expectroute = False + self.pos += 1 + self.gotonext() + adlist = '' + while self.pos < len(self.field): + if expectroute: + self.getdomain() + expectroute = False + elif self.field[self.pos] == '>': + self.pos += 1 + break + elif self.field[self.pos] == '@': + self.pos += 1 + expectroute = True + elif self.field[self.pos] == ':': + self.pos += 1 + else: + adlist = self.getaddrspec() + self.pos += 1 + break + self.gotonext() + + return adlist + + def getaddrspec(self): + """Parse an RFC 2822 addr-spec.""" + aslist = [] + + self.gotonext() + while self.pos < len(self.field): + preserve_ws = True + if self.field[self.pos] == '.': + if aslist and not aslist[-1].strip(): + aslist.pop() + aslist.append('.') + self.pos += 1 + preserve_ws = False + elif self.field[self.pos] == '"': + aslist.append('"%s"' % quote(self.getquote())) + elif self.field[self.pos] in self.atomends: + if aslist and not aslist[-1].strip(): + aslist.pop() + break + else: + aslist.append(self.getatom()) + ws = self.gotonext() + if preserve_ws and ws: + aslist.append(ws) + + if self.pos >= len(self.field) or self.field[self.pos] != '@': + return EMPTYSTRING.join(aslist) + + aslist.append('@') + self.pos += 1 + self.gotonext() + domain = self.getdomain() + if not domain: + # Invalid domain, return an empty address instead of returning a + # local part to denote failed parsing. + return EMPTYSTRING + return EMPTYSTRING.join(aslist) + domain + + def getdomain(self): + """Get the complete domain name from an address.""" + sdlist = [] + while self.pos < len(self.field): + if self.field[self.pos] in self.LWS: + self.pos += 1 + elif self.field[self.pos] == '(': + self.commentlist.append(self.getcomment()) + elif self.field[self.pos] == '[': + sdlist.append(self.getdomainliteral()) + elif self.field[self.pos] == '.': + self.pos += 1 + sdlist.append('.') + elif self.field[self.pos] == '@': + # bpo-34155: Don't parse domains with two `@` like + # `a@malicious.org@important.com`. + return EMPTYSTRING + elif self.field[self.pos] in self.atomends: + break + else: + sdlist.append(self.getatom()) + return EMPTYSTRING.join(sdlist) + + def getdelimited(self, beginchar, endchars, allowcomments=True): + """Parse a header fragment delimited by special characters. + + `beginchar' is the start character for the fragment. + If self is not looking at an instance of `beginchar' then + getdelimited returns the empty string. + + `endchars' is a sequence of allowable end-delimiting characters. + Parsing stops when one of these is encountered. + + If `allowcomments' is non-zero, embedded RFC 2822 comments are allowed + within the parsed fragment. + """ + if self.field[self.pos] != beginchar: + return '' + + slist = [''] + quote = False + self.pos += 1 + while self.pos < len(self.field): + if quote: + slist.append(self.field[self.pos]) + quote = False + elif self.field[self.pos] in endchars: + self.pos += 1 + break + elif allowcomments and self.field[self.pos] == '(': + slist.append(self.getcomment()) + continue # have already advanced pos from getcomment + elif self.field[self.pos] == '\\': + quote = True + else: + slist.append(self.field[self.pos]) + self.pos += 1 + + return EMPTYSTRING.join(slist) + + def getquote(self): + """Get a quote-delimited fragment from self's field.""" + return self.getdelimited('"', '"\r', False) + + def getcomment(self): + """Get a parenthesis-delimited fragment from self's field.""" + return self.getdelimited('(', ')\r', True) + + def getdomainliteral(self): + """Parse an RFC 2822 domain-literal.""" + return '[%s]' % self.getdelimited('[', ']\r', False) + + def getatom(self, atomends=None): + """Parse an RFC 2822 atom. + + Optional atomends specifies a different set of end token delimiters + (the default is to use self.atomends). This is used e.g. in + getphraselist() since phrase endings must not include the `.' (which + is legal in phrases).""" + atomlist = [''] + if atomends is None: + atomends = self.atomends + + while self.pos < len(self.field): + if self.field[self.pos] in atomends: + break + else: + atomlist.append(self.field[self.pos]) + self.pos += 1 + + return EMPTYSTRING.join(atomlist) + + def getphraselist(self): + """Parse a sequence of RFC 2822 phrases. + + A phrase is a sequence of words, which are in turn either RFC 2822 + atoms or quoted-strings. Phrases are canonicalized by squeezing all + runs of continuous whitespace into one space. + """ + plist = [] + + while self.pos < len(self.field): + if self.field[self.pos] in self.FWS: + self.pos += 1 + elif self.field[self.pos] == '"': + plist.append(self.getquote()) + elif self.field[self.pos] == '(': + self.commentlist.append(self.getcomment()) + elif self.field[self.pos] in self.phraseends: + break + else: + plist.append(self.getatom(self.phraseends)) + + return plist + +class AddressList(AddrlistClass): + """An AddressList encapsulates a list of parsed RFC 2822 addresses.""" + def __init__(self, field): + AddrlistClass.__init__(self, field) + if field: + self.addresslist = self.getaddrlist() + else: + self.addresslist = [] + + def __len__(self): + return len(self.addresslist) + + def __add__(self, other): + # Set union + newaddr = AddressList(None) + newaddr.addresslist = self.addresslist[:] + for x in other.addresslist: + if not x in self.addresslist: + newaddr.addresslist.append(x) + return newaddr + + def __iadd__(self, other): + # Set union, in-place + for x in other.addresslist: + if not x in self.addresslist: + self.addresslist.append(x) + return self + + def __sub__(self, other): + # Set difference + newaddr = AddressList(None) + for x in self.addresslist: + if not x in other.addresslist: + newaddr.addresslist.append(x) + return newaddr + + def __isub__(self, other): + # Set difference, in-place + for x in other.addresslist: + if x in self.addresslist: + self.addresslist.remove(x) + return self + + def __getitem__(self, index): + # Make indexing, slices, and 'in' work + return self.addresslist[index] diff --git a/shared/package-files/43/430b5906edc100485661bc85a0d0f65da121f101ccadb258208bb22062e9dafd/blob b/shared/package-files/43/430b5906edc100485661bc85a0d0f65da121f101ccadb258208bb22062e9dafd/blob new file mode 100644 index 0000000000000000000000000000000000000000..09ba769a34421f1fcbd18a1e3d08b12c5d95c6ad Binary files /dev/null and b/shared/package-files/43/430b5906edc100485661bc85a0d0f65da121f101ccadb258208bb22062e9dafd/blob differ diff --git a/shared/package-files/43/430d155c8246464c3a6624b3bed47428589698fbb223dc715e00e5fe5ddc1e67/blob b/shared/package-files/43/430d155c8246464c3a6624b3bed47428589698fbb223dc715e00e5fe5ddc1e67/blob new file mode 100644 index 0000000000000000000000000000000000000000..b6d2d666a5f709c8eaf9a5b9c130953371e8df2f --- /dev/null +++ b/shared/package-files/43/430d155c8246464c3a6624b3bed47428589698fbb223dc715e00e5fe5ddc1e67/blob @@ -0,0 +1,175 @@ +""" + pygments.lexers.promql + ~~~~~~~~~~~~~~~~~~~~~~ + + Lexer for Prometheus Query Language. + + :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +from pygments.lexer import RegexLexer, bygroups, default, words +from pygments.token import Comment, Keyword, Name, Number, Operator, \ + Punctuation, String, Whitespace + +__all__ = ["PromQLLexer"] + + +class PromQLLexer(RegexLexer): + """ + For PromQL queries. + + For details about the grammar see: + https://github.com/prometheus/prometheus/tree/master/promql/parser + + .. versionadded: 2.7 + """ + + name = "PromQL" + url = 'https://prometheus.io/docs/prometheus/latest/querying/basics/' + aliases = ["promql"] + filenames = ["*.promql"] + + base_keywords = ( + words( + ( + "bool", + "by", + "group_left", + "group_right", + "ignoring", + "offset", + "on", + "without", + ), + suffix=r"\b", + ), + Keyword, + ) + + aggregator_keywords = ( + words( + ( + "sum", + "min", + "max", + "avg", + "group", + "stddev", + "stdvar", + "count", + "count_values", + "bottomk", + "topk", + "quantile", + ), + suffix=r"\b", + ), + Keyword, + ) + + function_keywords = ( + words( + ( + "abs", + "absent", + "absent_over_time", + "avg_over_time", + "ceil", + "changes", + "clamp_max", + "clamp_min", + "count_over_time", + "day_of_month", + "day_of_week", + "days_in_month", + "delta", + "deriv", + "exp", + "floor", + "histogram_quantile", + "holt_winters", + "hour", + "idelta", + "increase", + "irate", + "label_join", + "label_replace", + "ln", + "log10", + "log2", + "max_over_time", + "min_over_time", + "minute", + "month", + "predict_linear", + "quantile_over_time", + "rate", + "resets", + "round", + "scalar", + "sort", + "sort_desc", + "sqrt", + "stddev_over_time", + "stdvar_over_time", + "sum_over_time", + "time", + "timestamp", + "vector", + "year", + ), + suffix=r"\b", + ), + Keyword.Reserved, + ) + + tokens = { + "root": [ + (r"\n", Whitespace), + (r"\s+", Whitespace), + (r",", Punctuation), + # Keywords + base_keywords, + aggregator_keywords, + function_keywords, + # Offsets + (r"[1-9][0-9]*[smhdwy]", String), + # Numbers + (r"-?[0-9]+\.[0-9]+", Number.Float), + (r"-?[0-9]+", Number.Integer), + # Comments + (r"#.*?$", Comment.Single), + # Operators + (r"(\+|\-|\*|\/|\%|\^)", Operator), + (r"==|!=|>=|<=|<|>", Operator), + (r"and|or|unless", Operator.Word), + # Metrics + (r"[_a-zA-Z][a-zA-Z0-9_]+", Name.Variable), + # Params + (r'(["\'])(.*?)(["\'])', bygroups(Punctuation, String, Punctuation)), + # Other states + (r"\(", Operator, "function"), + (r"\)", Operator), + (r"\{", Punctuation, "labels"), + (r"\[", Punctuation, "range"), + ], + "labels": [ + (r"\}", Punctuation, "#pop"), + (r"\n", Whitespace), + (r"\s+", Whitespace), + (r",", Punctuation), + (r'([_a-zA-Z][a-zA-Z0-9_]*?)(\s*?)(=~|!=|=|!~)(\s*?)("|\')(.*?)("|\')', + bygroups(Name.Label, Whitespace, Operator, Whitespace, + Punctuation, String, Punctuation)), + ], + "range": [ + (r"\]", Punctuation, "#pop"), + (r"[1-9][0-9]*[smhdwy]", String), + ], + "function": [ + (r"\)", Operator, "#pop"), + (r"\(", Operator, "#push"), + default("#pop"), + ], + } diff --git a/shared/package-files/43/430fa71f7c5b5bf9dd708163d6f4ecbab4b4eec2e28ee4e3c9c20e89f7811b26/blob b/shared/package-files/43/430fa71f7c5b5bf9dd708163d6f4ecbab4b4eec2e28ee4e3c9c20e89f7811b26/blob new file mode 100644 index 0000000000000000000000000000000000000000..bc12284944621bc524d9255462ea422b89f0443a --- /dev/null +++ b/shared/package-files/43/430fa71f7c5b5bf9dd708163d6f4ecbab4b4eec2e28ee4e3c9c20e89f7811b26/blob @@ -0,0 +1,39 @@ +# Copyright (C) 2012 Anaconda, Inc +# SPDX-License-Identifier: BSD-3-Clause +from logging import getLogger + +from ..base.context import context +from ..common.compat import on_win +from ..exceptions import ArgumentError + +log = getLogger(__name__) + + +def execute(args, parser): + from ..base.constants import COMPATIBLE_SHELLS + from ..core.initialize import initialize, initialize_dev, install + + if args.install: + return install(context.conda_prefix) + + if args.all: + selected_shells = COMPATIBLE_SHELLS + else: + selected_shells = tuple(args.shells) + + if args.dev: + if len(selected_shells) != 1: + raise ArgumentError("--dev can only handle one shell at a time right now") + return initialize_dev(selected_shells[0]) + + else: + for_user = args.user and not args.system + anaconda_prompt = on_win and args.anaconda_prompt + return initialize( + context.conda_prefix, + selected_shells, + for_user, + args.system, + anaconda_prompt, + args.reverse, + ) diff --git a/shared/package-files/43/43100d30c34d2eb13e03cb4a808748d14681b69c6fdc2f2e7ae97bf23513609a/blob b/shared/package-files/43/43100d30c34d2eb13e03cb4a808748d14681b69c6fdc2f2e7ae97bf23513609a/blob new file mode 100644 index 0000000000000000000000000000000000000000..cad508da5e39a003429542399e4f5c4bc22fdad5 --- /dev/null +++ b/shared/package-files/43/43100d30c34d2eb13e03cb4a808748d14681b69c6fdc2f2e7ae97bf23513609a/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:43100d30c34d2eb13e03cb4a808748d14681b69c6fdc2f2e7ae97bf23513609a +size 5214600 diff --git a/shared/package-files/43/431039e07e889a8e707abbe85e82018894782a4ee065c634c7d1ab9ac38b2186/blob b/shared/package-files/43/431039e07e889a8e707abbe85e82018894782a4ee065c634c7d1ab9ac38b2186/blob new file mode 100644 index 0000000000000000000000000000000000000000..05336f0bd7eb67f86e10327774f48f420b5ac559 Binary files /dev/null and b/shared/package-files/43/431039e07e889a8e707abbe85e82018894782a4ee065c634c7d1ab9ac38b2186/blob differ diff --git a/shared/package-files/43/4311fbd18d0d0f19ebd0b7c906a372ebb739a1e30fd86150c359d7acb2049877/blob b/shared/package-files/43/4311fbd18d0d0f19ebd0b7c906a372ebb739a1e30fd86150c359d7acb2049877/blob new file mode 100644 index 0000000000000000000000000000000000000000..0934c4330d857c7c4b0ca62b76ca723e59996c71 --- /dev/null +++ b/shared/package-files/43/4311fbd18d0d0f19ebd0b7c906a372ebb739a1e30fd86150c359d7acb2049877/blob @@ -0,0 +1,348 @@ +from collections.abc import Hashable +from types import GeneratorType + +from functools import wraps +from ..deprecations import deprecated + + +# TODO: spend time filling out functionality and make these more robust + + +@deprecated("23.3", "23.9", addendum="Use `functools.lru_cache` instead.") +def memoize(func): + """ + Decorator to cause a function to cache it's results for each combination of + inputs and return the cached result on subsequent calls. Does not support + named arguments or arg values that are not hashable. + + >>> @memoize + ... def foo(x): + ... print('running function with', x) + ... return x+3 + ... + >>> foo(10) + running function with 10 + 13 + >>> foo(10) + 13 + >>> foo(11) + running function with 11 + 14 + >>> @memoize + ... def range_tuple(limit): + ... print('running function') + ... return tuple(i for i in range(limit)) + ... + >>> range_tuple(3) + running function + (0, 1, 2) + >>> range_tuple(3) + (0, 1, 2) + >>> @memoize + ... def range_iter(limit): + ... print('running function') + ... return (i for i in range(limit)) + ... + >>> range_iter(3) + Traceback (most recent call last): + TypeError: Can't memoize a generator or non-hashable object! + """ + func._result_cache = {} # pylint: disable-msg=W0212 + + @wraps(func) + def _memoized_func(*args, **kwargs): + key = (args, tuple(sorted(kwargs.items()))) + if key in func._result_cache: # pylint: disable-msg=W0212 + return func._result_cache[key] # pylint: disable-msg=W0212 + else: + result = func(*args, **kwargs) + if isinstance(result, GeneratorType) or not isinstance(result, Hashable): + raise TypeError("Can't memoize a generator or non-hashable object!") + func._result_cache[key] = result # pylint: disable-msg=W0212 + return result + + return _memoized_func + + +def memoizemethod(method): + """ + Decorator to cause a method to cache it's results in self for each + combination of inputs and return the cached result on subsequent calls. + Does not support named arguments or arg values that are not hashable. + + >>> class Foo (object): + ... @memoizemethod + ... def foo(self, x, y=0): + ... print('running method with', x, y) + ... return x + y + 3 + ... + >>> foo1 = Foo() + >>> foo2 = Foo() + >>> foo1.foo(10) + running method with 10 0 + 13 + >>> foo1.foo(10) + 13 + >>> foo2.foo(11, y=7) + running method with 11 7 + 21 + >>> foo2.foo(11) + running method with 11 0 + 14 + >>> foo2.foo(11, y=7) + 21 + >>> class Foo (object): + ... def __init__(self, lower): + ... self.lower = lower + ... @memoizemethod + ... def range_tuple(self, upper): + ... print('running function') + ... return tuple(i for i in range(self.lower, upper)) + ... @memoizemethod + ... def range_iter(self, upper): + ... print('running function') + ... return (i for i in range(self.lower, upper)) + ... + >>> foo = Foo(3) + >>> foo.range_tuple(6) + running function + (3, 4, 5) + >>> foo.range_tuple(7) + running function + (3, 4, 5, 6) + >>> foo.range_tuple(6) + (3, 4, 5) + >>> foo.range_iter(6) + Traceback (most recent call last): + TypeError: Can't memoize a generator or non-hashable object! + """ + + @wraps(method) + def _wrapper(self, *args, **kwargs): + # NOTE: a __dict__ check is performed here rather than using the + # built-in hasattr function because hasattr will look up to an object's + # class if the attr is not directly found in the object's dict. That's + # bad for this if the class itself has a memoized classmethod for + # example that has been called before the memoized instance method, + # then the instance method will use the class's result cache, causing + # its results to be globally stored rather than on a per instance + # basis. + if '_memoized_results' not in self.__dict__: + self._memoized_results = {} + memoized_results = self._memoized_results + + key = (method.__name__, args, tuple(sorted(kwargs.items()))) + if key in memoized_results: + return memoized_results[key] + else: + try: + result = method(self, *args, **kwargs) + except KeyError as e: + if '__wrapped__' in str(e): + result = None # is this the right thing to do? happened during py3 conversion + else: + raise + if isinstance(result, GeneratorType) or not isinstance(result, Hashable): + raise TypeError("Can't memoize a generator or non-hashable object!") + return memoized_results.setdefault(key, result) + + return _wrapper + + +# class memoizemethod(object): +# """cache the return value of a method +# +# This class is meant to be used as a decorator of methods. The return value +# from a given method invocation will be cached on the instance whose method +# was invoked. All arguments passed to a method decorated with memoize must +# be hashable. +# +# If a memoized method is invoked directly on its class the result will not +# be cached. Instead the method will be invoked like a static method: +# class Obj(object): +# @memoize +# def add_to(self, arg): +# return self + arg +# Obj.add_to(1) # not enough arguments +# Obj.add_to(1, 2) # returns 3, result is not cached +# """ +# def __init__(self, func): +# self.func = func +# def __get__(self, obj, objtype=None): +# if obj is None: +# return self.func +# return partial(self, obj) +# def __call__(self, *args, **kw): +# obj = args[0] +# try: +# cache = obj.__cache +# except AttributeError: +# cache = obj.__cache = {} +# key = (self.func, args[1:], frozenset(kw.items())) +# try: +# res = cache[key] +# except KeyError: +# res = cache[key] = self.func(*args, **kw) +# return res + + +def clear_memoized_methods(obj, *method_names): + """ + Clear the memoized method or @memoizedproperty results for the given + method names from the given object. + + >>> v = [0] + >>> def inc(): + ... v[0] += 1 + ... return v[0] + ... + >>> class Foo(object): + ... @memoizemethod + ... def foo(self): + ... return inc() + ... @memoizedproperty + ... def g(self): + ... return inc() + ... + >>> f = Foo() + >>> f.foo(), f.foo() + (1, 1) + >>> clear_memoized_methods(f, 'foo') + >>> (f.foo(), f.foo(), f.g, f.g) + (2, 2, 3, 3) + >>> (f.foo(), f.foo(), f.g, f.g) + (2, 2, 3, 3) + >>> clear_memoized_methods(f, 'g', 'no_problem_if_undefined') + >>> f.g, f.foo(), f.g + (4, 2, 4) + >>> f.foo() + 2 + """ + for key in list(getattr(obj, '_memoized_results', {}).keys()): + # key[0] is the method name + if key[0] in method_names: + del obj._memoized_results[key] + + property_dict = obj._cache_ + for prop in method_names: + inner_attname = '__%s' % prop + if inner_attname in property_dict: + del property_dict[inner_attname] + + +def memoizedproperty(func): + """ + Decorator to cause a method to cache it's results in self for each + combination of inputs and return the cached result on subsequent calls. + Does not support named arguments or arg values that are not hashable. + + >>> class Foo (object): + ... _x = 1 + ... @memoizedproperty + ... def foo(self): + ... self._x += 1 + ... print('updating and returning {0}'.format(self._x)) + ... return self._x + ... + >>> foo1 = Foo() + >>> foo2 = Foo() + >>> foo1.foo + updating and returning 2 + 2 + >>> foo1.foo + 2 + >>> foo2.foo + updating and returning 2 + 2 + >>> foo1.foo + 2 + """ + inner_attname = '__%s' % func.__name__ + + def new_fget(self): + if not hasattr(self, '_cache_'): + self._cache_ = {} + cache = self._cache_ + if inner_attname not in cache: + cache[inner_attname] = func(self) + return cache[inner_attname] + + return property(new_fget) + + +# def memoized_property(fget): +# """ +# Return a property attribute for new-style classes that only calls its getter on the first +# access. The result is stored and on subsequent accesses is returned, preventing the need to +# call the getter any more. +# Example:: +# >>> class C(object): +# ... load_name_count = 0 +# ... @memoized_property +# ... def name(self): +# ... "name's docstring" +# ... self.load_name_count += 1 +# ... return "the name" +# >>> c = C() +# >>> c.load_name_count +# 0 +# >>> c.name +# "the name" +# >>> c.load_name_count +# 1 +# >>> c.name +# "the name" +# >>> c.load_name_count +# 1 +# """ +# attr_name = '_{0}'.format(fget.__name__) +# +# @wraps(fget) +# def fget_memoized(self): +# if not hasattr(self, attr_name): +# setattr(self, attr_name, fget(self)) +# return getattr(self, attr_name) +# +# return property(fget_memoized) + + +class classproperty: # pylint: disable=C0103 + # from celery.five + + def __init__(self, getter=None, setter=None): + if getter is not None and not isinstance(getter, classmethod): + getter = classmethod(getter) + if setter is not None and not isinstance(setter, classmethod): + setter = classmethod(setter) + self.__get = getter + self.__set = setter + + info = getter.__get__(object) # just need the info attrs. + self.__doc__ = info.__doc__ + self.__name__ = info.__name__ + self.__module__ = info.__module__ + + def __get__(self, obj, type_=None): + if obj and type_ is None: + type_ = obj.__class__ + return self.__get.__get__(obj, type_)() + + def __set__(self, obj, value): + if obj is None: + return self + return self.__set.__get__(obj)(value) + + def setter(self, setter): + return self.__class__(self.__get, setter) + +# memoize & clear: +# class method +# function +# classproperty +# property +# staticproperty? +# memoizefunction +# memoizemethod +# memoizedproperty +# +# diff --git a/shared/package-files/43/4312af0a14da44f8f4a2fbf176b7ebde93b31311087f9b2f0f0c5113b7a71178/blob b/shared/package-files/43/4312af0a14da44f8f4a2fbf176b7ebde93b31311087f9b2f0f0c5113b7a71178/blob new file mode 100644 index 0000000000000000000000000000000000000000..8d06cb236269d00ed20a27297b59fa816338e79a --- /dev/null +++ b/shared/package-files/43/4312af0a14da44f8f4a2fbf176b7ebde93b31311087f9b2f0f0c5113b7a71178/blob @@ -0,0 +1,479 @@ +""" +Axislines includes modified implementation of the Axes class. The +biggest difference is that the artists responsible for drawing the axis spine, +ticks, ticklabels and axis labels are separated out from Matplotlib's Axis +class. Originally, this change was motivated to support curvilinear +grid. Here are a few reasons that I came up with a new axes class: + +* "top" and "bottom" x-axis (or "left" and "right" y-axis) can have + different ticks (tick locations and labels). This is not possible + with the current Matplotlib, although some twin axes trick can help. + +* Curvilinear grid. + +* angled ticks. + +In the new axes class, xaxis and yaxis is set to not visible by +default, and new set of artist (AxisArtist) are defined to draw axis +line, ticks, ticklabels and axis label. Axes.axis attribute serves as +a dictionary of these artists, i.e., ax.axis["left"] is a AxisArtist +instance responsible to draw left y-axis. The default Axes.axis contains +"bottom", "left", "top" and "right". + +AxisArtist can be considered as a container artist and has the following +children artists which will draw ticks, labels, etc. + +* line +* major_ticks, major_ticklabels +* minor_ticks, minor_ticklabels +* offsetText +* label + +Note that these are separate artists from `matplotlib.axis.Axis`, thus most +tick-related functions in Matplotlib won't work. For example, color and +markerwidth of the ``ax.axis["bottom"].major_ticks`` will follow those of +Axes.xaxis unless explicitly specified. + +In addition to AxisArtist, the Axes will have *gridlines* attribute, +which obviously draws grid lines. The gridlines needs to be separated +from the axis as some gridlines can never pass any axis. +""" + +import numpy as np + +import matplotlib as mpl +from matplotlib import _api +import matplotlib.axes as maxes +from matplotlib.path import Path +from mpl_toolkits.axes_grid1 import mpl_axes +from .axisline_style import AxislineStyle # noqa +from .axis_artist import AxisArtist, GridlinesCollection + + +class _AxisArtistHelperBase: + """ + Base class for axis helper. + + Subclasses should define the methods listed below. The *axes* + argument will be the ``.axes`` attribute of the caller artist. :: + + # Construct the spine. + + def get_line_transform(self, axes): + return transform + + def get_line(self, axes): + return path + + # Construct the label. + + def get_axislabel_transform(self, axes): + return transform + + def get_axislabel_pos_angle(self, axes): + return (x, y), angle + + # Construct the ticks. + + def get_tick_transform(self, axes): + return transform + + def get_tick_iterators(self, axes): + # A pair of iterables (one for major ticks, one for minor ticks) + # that yield (tick_position, tick_angle, tick_label). + return iter_major, iter_minor + """ + + def __init__(self, nth_coord): + self.nth_coord = nth_coord + + def update_lim(self, axes): + pass + + def get_nth_coord(self): + return self.nth_coord + + def _to_xy(self, values, const): + """ + Create a (*values.shape, 2)-shape array representing (x, y) pairs. + + The other coordinate is filled with the constant *const*. + + Example:: + + >>> self.nth_coord = 0 + >>> self._to_xy([1, 2, 3], const=0) + array([[1, 0], + [2, 0], + [3, 0]]) + """ + if self.nth_coord == 0: + return np.stack(np.broadcast_arrays(values, const), axis=-1) + elif self.nth_coord == 1: + return np.stack(np.broadcast_arrays(const, values), axis=-1) + else: + raise ValueError("Unexpected nth_coord") + + +class _FixedAxisArtistHelperBase(_AxisArtistHelperBase): + """Helper class for a fixed (in the axes coordinate) axis.""" + + @_api.delete_parameter("3.9", "nth_coord") + def __init__(self, loc, nth_coord=None): + """``nth_coord = 0``: x-axis; ``nth_coord = 1``: y-axis.""" + super().__init__(_api.check_getitem( + {"bottom": 0, "top": 0, "left": 1, "right": 1}, loc=loc)) + self._loc = loc + self._pos = {"bottom": 0, "top": 1, "left": 0, "right": 1}[loc] + # axis line in transAxes + self._path = Path(self._to_xy((0, 1), const=self._pos)) + + # LINE + + def get_line(self, axes): + return self._path + + def get_line_transform(self, axes): + return axes.transAxes + + # LABEL + + def get_axislabel_transform(self, axes): + return axes.transAxes + + def get_axislabel_pos_angle(self, axes): + """ + Return the label reference position in transAxes. + + get_label_transform() returns a transform of (transAxes+offset) + """ + return dict(left=((0., 0.5), 90), # (position, angle_tangent) + right=((1., 0.5), 90), + bottom=((0.5, 0.), 0), + top=((0.5, 1.), 0))[self._loc] + + # TICK + + def get_tick_transform(self, axes): + return [axes.get_xaxis_transform(), axes.get_yaxis_transform()][self.nth_coord] + + +class _FloatingAxisArtistHelperBase(_AxisArtistHelperBase): + def __init__(self, nth_coord, value): + self._value = value + super().__init__(nth_coord) + + def get_line(self, axes): + raise RuntimeError("get_line method should be defined by the derived class") + + +class FixedAxisArtistHelperRectilinear(_FixedAxisArtistHelperBase): + + @_api.delete_parameter("3.9", "nth_coord") + def __init__(self, axes, loc, nth_coord=None): + """ + nth_coord = along which coordinate value varies + in 2D, nth_coord = 0 -> x axis, nth_coord = 1 -> y axis + """ + super().__init__(loc) + self.axis = [axes.xaxis, axes.yaxis][self.nth_coord] + + # TICK + + def get_tick_iterators(self, axes): + """tick_loc, tick_angle, tick_label""" + angle_normal, angle_tangent = {0: (90, 0), 1: (0, 90)}[self.nth_coord] + + major = self.axis.major + major_locs = major.locator() + major_labels = major.formatter.format_ticks(major_locs) + + minor = self.axis.minor + minor_locs = minor.locator() + minor_labels = minor.formatter.format_ticks(minor_locs) + + tick_to_axes = self.get_tick_transform(axes) - axes.transAxes + + def _f(locs, labels): + for loc, label in zip(locs, labels): + c = self._to_xy(loc, const=self._pos) + # check if the tick point is inside axes + c2 = tick_to_axes.transform(c) + if mpl.transforms._interval_contains_close((0, 1), c2[self.nth_coord]): + yield c, angle_normal, angle_tangent, label + + return _f(major_locs, major_labels), _f(minor_locs, minor_labels) + + +class FloatingAxisArtistHelperRectilinear(_FloatingAxisArtistHelperBase): + + def __init__(self, axes, nth_coord, + passingthrough_point, axis_direction="bottom"): + super().__init__(nth_coord, passingthrough_point) + self._axis_direction = axis_direction + self.axis = [axes.xaxis, axes.yaxis][self.nth_coord] + + def get_line(self, axes): + fixed_coord = 1 - self.nth_coord + data_to_axes = axes.transData - axes.transAxes + p = data_to_axes.transform([self._value, self._value]) + return Path(self._to_xy((0, 1), const=p[fixed_coord])) + + def get_line_transform(self, axes): + return axes.transAxes + + def get_axislabel_transform(self, axes): + return axes.transAxes + + def get_axislabel_pos_angle(self, axes): + """ + Return the label reference position in transAxes. + + get_label_transform() returns a transform of (transAxes+offset) + """ + angle = [0, 90][self.nth_coord] + fixed_coord = 1 - self.nth_coord + data_to_axes = axes.transData - axes.transAxes + p = data_to_axes.transform([self._value, self._value]) + verts = self._to_xy(0.5, const=p[fixed_coord]) + return (verts, angle) if 0 <= verts[fixed_coord] <= 1 else (None, None) + + def get_tick_transform(self, axes): + return axes.transData + + def get_tick_iterators(self, axes): + """tick_loc, tick_angle, tick_label""" + angle_normal, angle_tangent = {0: (90, 0), 1: (0, 90)}[self.nth_coord] + + major = self.axis.major + major_locs = major.locator() + major_labels = major.formatter.format_ticks(major_locs) + + minor = self.axis.minor + minor_locs = minor.locator() + minor_labels = minor.formatter.format_ticks(minor_locs) + + data_to_axes = axes.transData - axes.transAxes + + def _f(locs, labels): + for loc, label in zip(locs, labels): + c = self._to_xy(loc, const=self._value) + c1, c2 = data_to_axes.transform(c) + if 0 <= c1 <= 1 and 0 <= c2 <= 1: + yield c, angle_normal, angle_tangent, label + + return _f(major_locs, major_labels), _f(minor_locs, minor_labels) + + +class AxisArtistHelper: # Backcompat. + Fixed = _FixedAxisArtistHelperBase + Floating = _FloatingAxisArtistHelperBase + + +class AxisArtistHelperRectlinear: # Backcompat. + Fixed = FixedAxisArtistHelperRectilinear + Floating = FloatingAxisArtistHelperRectilinear + + +class GridHelperBase: + + def __init__(self): + self._old_limits = None + super().__init__() + + def update_lim(self, axes): + x1, x2 = axes.get_xlim() + y1, y2 = axes.get_ylim() + if self._old_limits != (x1, x2, y1, y2): + self._update_grid(x1, y1, x2, y2) + self._old_limits = (x1, x2, y1, y2) + + def _update_grid(self, x1, y1, x2, y2): + """Cache relevant computations when the axes limits have changed.""" + + def get_gridlines(self, which, axis): + """ + Return list of grid lines as a list of paths (list of points). + + Parameters + ---------- + which : {"both", "major", "minor"} + axis : {"both", "x", "y"} + """ + return [] + + +class GridHelperRectlinear(GridHelperBase): + + def __init__(self, axes): + super().__init__() + self.axes = axes + + @_api.delete_parameter( + "3.9", "nth_coord", addendum="'nth_coord' is now inferred from 'loc'.") + def new_fixed_axis( + self, loc, nth_coord=None, axis_direction=None, offset=None, axes=None): + if axes is None: + _api.warn_external( + "'new_fixed_axis' explicitly requires the axes keyword.") + axes = self.axes + if axis_direction is None: + axis_direction = loc + return AxisArtist(axes, FixedAxisArtistHelperRectilinear(axes, loc), + offset=offset, axis_direction=axis_direction) + + def new_floating_axis(self, nth_coord, value, axis_direction="bottom", axes=None): + if axes is None: + _api.warn_external( + "'new_floating_axis' explicitly requires the axes keyword.") + axes = self.axes + helper = FloatingAxisArtistHelperRectilinear( + axes, nth_coord, value, axis_direction) + axisline = AxisArtist(axes, helper, axis_direction=axis_direction) + axisline.line.set_clip_on(True) + axisline.line.set_clip_box(axisline.axes.bbox) + return axisline + + def get_gridlines(self, which="major", axis="both"): + """ + Return list of gridline coordinates in data coordinates. + + Parameters + ---------- + which : {"both", "major", "minor"} + axis : {"both", "x", "y"} + """ + _api.check_in_list(["both", "major", "minor"], which=which) + _api.check_in_list(["both", "x", "y"], axis=axis) + gridlines = [] + + if axis in ("both", "x"): + locs = [] + y1, y2 = self.axes.get_ylim() + if which in ("both", "major"): + locs.extend(self.axes.xaxis.major.locator()) + if which in ("both", "minor"): + locs.extend(self.axes.xaxis.minor.locator()) + gridlines.extend([[x, x], [y1, y2]] for x in locs) + + if axis in ("both", "y"): + x1, x2 = self.axes.get_xlim() + locs = [] + if self.axes.yaxis._major_tick_kw["gridOn"]: + locs.extend(self.axes.yaxis.major.locator()) + if self.axes.yaxis._minor_tick_kw["gridOn"]: + locs.extend(self.axes.yaxis.minor.locator()) + gridlines.extend([[x1, x2], [y, y]] for y in locs) + + return gridlines + + +class Axes(maxes.Axes): + + def __init__(self, *args, grid_helper=None, **kwargs): + self._axisline_on = True + self._grid_helper = grid_helper if grid_helper else GridHelperRectlinear(self) + super().__init__(*args, **kwargs) + self.toggle_axisline(True) + + def toggle_axisline(self, b=None): + if b is None: + b = not self._axisline_on + if b: + self._axisline_on = True + self.spines[:].set_visible(False) + self.xaxis.set_visible(False) + self.yaxis.set_visible(False) + else: + self._axisline_on = False + self.spines[:].set_visible(True) + self.xaxis.set_visible(True) + self.yaxis.set_visible(True) + + @property + def axis(self): + return self._axislines + + def clear(self): + # docstring inherited + + # Init gridlines before clear() as clear() calls grid(). + self.gridlines = gridlines = GridlinesCollection( + [], + colors=mpl.rcParams['grid.color'], + linestyles=mpl.rcParams['grid.linestyle'], + linewidths=mpl.rcParams['grid.linewidth']) + self._set_artist_props(gridlines) + gridlines.set_grid_helper(self.get_grid_helper()) + + super().clear() + + # clip_path is set after Axes.clear(): that's when a patch is created. + gridlines.set_clip_path(self.axes.patch) + + # Init axis artists. + self._axislines = mpl_axes.Axes.AxisDict(self) + new_fixed_axis = self.get_grid_helper().new_fixed_axis + self._axislines.update({ + loc: new_fixed_axis(loc=loc, axes=self, axis_direction=loc) + for loc in ["bottom", "top", "left", "right"]}) + for axisline in [self._axislines["top"], self._axislines["right"]]: + axisline.label.set_visible(False) + axisline.major_ticklabels.set_visible(False) + axisline.minor_ticklabels.set_visible(False) + + def get_grid_helper(self): + return self._grid_helper + + def grid(self, visible=None, which='major', axis="both", **kwargs): + """ + Toggle the gridlines, and optionally set the properties of the lines. + """ + # There are some discrepancies in the behavior of grid() between + # axes_grid and Matplotlib, because axes_grid explicitly sets the + # visibility of the gridlines. + super().grid(visible, which=which, axis=axis, **kwargs) + if not self._axisline_on: + return + if visible is None: + visible = (self.axes.xaxis._minor_tick_kw["gridOn"] + or self.axes.xaxis._major_tick_kw["gridOn"] + or self.axes.yaxis._minor_tick_kw["gridOn"] + or self.axes.yaxis._major_tick_kw["gridOn"]) + self.gridlines.set(which=which, axis=axis, visible=visible) + self.gridlines.set(**kwargs) + + def get_children(self): + if self._axisline_on: + children = [*self._axislines.values(), self.gridlines] + else: + children = [] + children.extend(super().get_children()) + return children + + def new_fixed_axis(self, loc, offset=None): + return self.get_grid_helper().new_fixed_axis(loc, offset=offset, axes=self) + + def new_floating_axis(self, nth_coord, value, axis_direction="bottom"): + return self.get_grid_helper().new_floating_axis( + nth_coord, value, axis_direction=axis_direction, axes=self) + + +class AxesZero(Axes): + + def clear(self): + super().clear() + new_floating_axis = self.get_grid_helper().new_floating_axis + self._axislines.update( + xzero=new_floating_axis( + nth_coord=0, value=0., axis_direction="bottom", axes=self), + yzero=new_floating_axis( + nth_coord=1, value=0., axis_direction="left", axes=self), + ) + for k in ["xzero", "yzero"]: + self._axislines[k].line.set_clip_path(self.patch) + self._axislines[k].set_visible(False) + + +Subplot = Axes +SubplotZero = AxesZero diff --git a/shared/package-files/43/43153707e1effd1b2811c3064bdfb5e37e2e828b8bdb2802eb82eae8582f88d3/blob b/shared/package-files/43/43153707e1effd1b2811c3064bdfb5e37e2e828b8bdb2802eb82eae8582f88d3/blob new file mode 100644 index 0000000000000000000000000000000000000000..34302e93667394d616692a6a4603e6d0be67d211 --- /dev/null +++ b/shared/package-files/43/43153707e1effd1b2811c3064bdfb5e37e2e828b8bdb2802eb82eae8582f88d3/blob @@ -0,0 +1,42 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include +#include +#include +#include + +#include "arrow/csv/options.h" +#include "arrow/python/common.h" +#include "arrow/util/macros.h" + +namespace arrow { +namespace py { +namespace csv { + +using PyInvalidRowCallback = std::function<::arrow::csv::InvalidRowResult( + PyObject*, const ::arrow::csv::InvalidRow&)>; + +ARROW_PYTHON_EXPORT +::arrow::csv::InvalidRowHandler MakeInvalidRowHandler(PyInvalidRowCallback, + PyObject* handler); + +} // namespace csv +} // namespace py +} // namespace arrow diff --git a/shared/package-files/43/43174a95a284e9c2762eda1ca0b6a6afb4768a17ce16532379169783a3737f8c/blob b/shared/package-files/43/43174a95a284e9c2762eda1ca0b6a6afb4768a17ce16532379169783a3737f8c/blob new file mode 100644 index 0000000000000000000000000000000000000000..4240778ecb5c87e57b70823b4f1b6a495663ca6a --- /dev/null +++ b/shared/package-files/43/43174a95a284e9c2762eda1ca0b6a6afb4768a17ce16532379169783a3737f8c/blob @@ -0,0 +1,9 @@ +libdir=/opt/conda/lib +includedir=/opt/conda/include + +Name: gtest +Description: GoogleTest (without main() function) +Version: 1.11.0 +URL: https://github.com/google/googletest +Libs: -L${libdir} -lgtest -lpthread +Cflags: -I${includedir} -DGTEST_HAS_PTHREAD=1 diff --git a/shared/package-files/43/431963e89066e2898960ad425fc02dee17d5d6503b4eb6b13196fe1b005b6a93/blob b/shared/package-files/43/431963e89066e2898960ad425fc02dee17d5d6503b4eb6b13196fe1b005b6a93/blob new file mode 100644 index 0000000000000000000000000000000000000000..baae27176dc89777a16c69944b096195dd0aa83b --- /dev/null +++ b/shared/package-files/43/431963e89066e2898960ad425fc02dee17d5d6503b4eb6b13196fe1b005b6a93/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API row_indices_copy { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::row_indices_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "row_indices_copy(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API row_indices_copy_out { + using schema = at::Tensor & (const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::row_indices_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "row_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/43/431d26bbaeedad684782899327ae73bc67c89325ab6ad9caa59f1c09c4b4461c/blob b/shared/package-files/43/431d26bbaeedad684782899327ae73bc67c89325ab6ad9caa59f1c09c4b4461c/blob new file mode 100644 index 0000000000000000000000000000000000000000..caee23e50b40484c91aab65ea8ccce0db45bd305 --- /dev/null +++ b/shared/package-files/43/431d26bbaeedad684782899327ae73bc67c89325ab6ad9caa59f1c09c4b4461c/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor expand(const at::Tensor & self, at::IntArrayRef size, bool implicit=false); +TORCH_API at::Tensor expand_symint(const at::Tensor & self, c10::SymIntArrayRef size, bool implicit=false); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/43/431da8ad2b99ad48c955607a7910844d1c14bcc2f004dabbbc388f9120c504ef/bootstrap_utils.py b/shared/package-files/43/431da8ad2b99ad48c955607a7910844d1c14bcc2f004dabbbc388f9120c504ef/bootstrap_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..39f8b9eb930bcd1106ee6779676413258e65278b --- /dev/null +++ b/shared/package-files/43/431da8ad2b99ad48c955607a7910844d1c14bcc2f004dabbbc388f9120c504ef/bootstrap_utils.py @@ -0,0 +1,138 @@ +from pathlib import Path +from typing import Any, Dict, Iterable, List, Optional, Sequence + +import numpy as np +from scipy.stats import bootstrap +import yaml + + +DEFAULT_CONFIDENCE_LEVEL = 0.999 +DEFAULT_N_RESAMPLES = 20000 + + +def load_yaml_results(path: str) -> Dict[str, Any]: + path_obj = Path(path) + if path_obj.suffix not in {".yaml", ".yml"}: + raise ValueError( + f"Unsupported results format: {path_obj.suffix}; expected a YAML rerank_eval file." + ) + with path_obj.open("r") as f: + return yaml.safe_load(f) + + +def _as_float_array(values: Iterable[float], metric_name: str) -> np.ndarray: + array = np.asarray(list(values), dtype=float) + if array.size == 0: + raise ValueError(f"No samples available for {metric_name}.") + return array + + +def bootstrap_mean( + values: Iterable[float], + *, + confidence_level: float = DEFAULT_CONFIDENCE_LEVEL, + n_resamples: int = DEFAULT_N_RESAMPLES, + random_state: Optional[int] = 1, + metric_name: str = "metric", +) -> Dict[str, float]: + samples = _as_float_array(values, metric_name) + res = bootstrap( + (samples,), + np.mean, + confidence_level=confidence_level, + n_resamples=n_resamples, + random_state=random_state, + ) + return { + "mean": float(np.mean(samples)), + "ci_low": float(res.confidence_interval.low), + "ci_high": float(res.confidence_interval.high), + "n": int(samples.size), + } + + +def hit_samples_from_individuals( + individuals: Sequence[Dict[str, Any]], + k: int, + metrics: Optional[Dict[str, float]] = None, +) -> List[float]: + key = f"top_{k}" + samples = [float(entry[key]) for entry in individuals if key in entry] + if samples: + return samples + + if metrics is None: + raise ValueError(f"Missing per-entry {key} samples and aggregate metrics.") + + metric_key = f"hit_rate_at_{k}" + if metric_key not in metrics: + raise ValueError(f"Missing {metric_key} in aggregate metrics.") + + num_hits = int(round(float(metrics[metric_key]) * len(individuals))) + return [1.0] * num_hits + [0.0] * (len(individuals) - num_hits) + + +def similarity_samples_from_individuals(individuals: Sequence[Dict[str, Any]]) -> List[float]: + return [ + 1.0 - float(entry["true_dist"]) + for entry in individuals + if "true_dist" in entry and entry["true_dist"] is not None + ] + + +def numeric_samples_from_individuals( + individuals: Sequence[Dict[str, Any]], + key: str, +) -> List[float]: + return [ + float(entry[key]) + for entry in individuals + if key in entry and entry[key] is not None + ] + + +def summarize_rerank_bootstrap( + data: Dict[str, Any], + *, + dist_fn: str, + confidence_level: float = DEFAULT_CONFIDENCE_LEVEL, + n_resamples: int = DEFAULT_N_RESAMPLES, + random_state: Optional[int] = 1, +) -> Dict[str, Dict[str, float]]: + individuals = data.get("individuals", []) + metrics = data.get("metrics", {}) + if not individuals: + raise ValueError("No individuals found in rerank_eval results.") + + summaries = {} + sim = similarity_samples_from_individuals(individuals) + if sim: + summaries[f"{dist_fn}_similarity"] = bootstrap_mean( + sim, + confidence_level=confidence_level, + n_resamples=n_resamples, + random_state=random_state, + metric_name=f"{dist_fn} similarity", + ) + + for k in (1, 5, 20): + samples = hit_samples_from_individuals(individuals, k, metrics) + summaries[f"top_{k}"] = bootstrap_mean( + samples, + confidence_level=confidence_level, + n_resamples=n_resamples, + random_state=random_state, + metric_name=f"top {k}", + ) + + mces_samples = numeric_samples_from_individuals(individuals, "top_1_mces") + if mces_samples: + summaries["top_1_mces"] = bootstrap_mean( + mces_samples, + confidence_level=confidence_level, + n_resamples=n_resamples, + random_state=random_state, + metric_name="top-1 MCES", + ) + + return summaries diff --git a/shared/package-files/43/431f8002db4b53ecc500f00f0e346990f0fb0fe70cf1d28d1af0a71ca055303a/blob b/shared/package-files/43/431f8002db4b53ecc500f00f0e346990f0fb0fe70cf1d28d1af0a71ca055303a/blob new file mode 100644 index 0000000000000000000000000000000000000000..6f15173f29e02994ee983a3e9895d52918e045fc --- /dev/null +++ b/shared/package-files/43/431f8002db4b53ecc500f00f0e346990f0fb0fe70cf1d28d1af0a71ca055303a/blob @@ -0,0 +1,130 @@ +# Copyright (C) 2014 Anaconda, Inc +# SPDX-License-Identifier: BSD-3-Clause +from __future__ import annotations + +import re +import subprocess +from functools import lru_cache +from os.path import basename +from pathlib import Path +from typing import TYPE_CHECKING + +from ..conda_interface import untracked +from ..utils import on_linux, on_mac +from .macho import otool +from .pyldd import codefile_class, inspect_linkages, machofile + +if TYPE_CHECKING: + import os + from typing import Iterable + + from conda.models.records import PrefixRecord + +LDD_RE = re.compile(r"\s*(.*?)\s*=>\s*(.*?)\s*\(.*\)") +LDD_NOT_FOUND_RE = re.compile(r"\s*(.*?)\s*=>\s*not found") + + +def ldd(path): + "thin wrapper around ldd" + lines = subprocess.check_output(["ldd", path]).decode("utf-8").splitlines() + res = [] + for line in lines: + if "=>" not in line: + continue + + assert line[0] == "\t", (path, line) + m = LDD_RE.match(line) + if m: + res.append(m.groups()) + continue + m = LDD_NOT_FOUND_RE.match(line) + if m: + res.append((m.group(1), "not found")) + continue + if "ld-linux" in line: + continue + raise RuntimeError("Unexpected output from ldd: %s" % line) + + return res + + +def get_linkages( + obj_files: Iterable[str], + prefix: str | os.PathLike | Path, + sysroot, +) -> dict[str, list[tuple[str, str]]]: + return _get_linkages(tuple(obj_files), Path(prefix), sysroot) + + +@lru_cache(maxsize=None) +def _get_linkages( + obj_files: tuple[str], + prefix: Path, + sysroot, +) -> dict[str, list[tuple[str, str]]]: + linkages = {} + for file in obj_files: + # Detect the filetype to emulate what the system-native tool does. + path = prefix / file + if codefile_class(path) == machofile: + resolve_filenames = False + recurse = False + else: + resolve_filenames = True + recurse = True + ldd_emulate = [ + (basename(link), link) + for link in inspect_linkages( + path, + resolve_filenames=resolve_filenames, + sysroot=sysroot, + recurse=recurse, + ) + ] + + try: + if on_linux: + ldd_computed = ldd(path) + elif on_mac: + ldd_computed = [ + (basename(link["name"]), link["name"]) for link in otool(path) + ] + except: + # ldd quite often fails on foreign architectures, fallback to + ldd_computed = ldd_emulate + + if set(ldd_computed) != set(ldd_emulate): + print("WARNING: pyldd disagrees with ldd/otool. This will not cause any") + print("WARNING: problems for this build, but please file a bug at:") + print("WARNING: https://github.com/conda/conda-build") + print(f"WARNING: and (if possible) attach file {path}") + print("WARNING:") + print(" ldd/otool gives:") + print(" " + "\n ".join(map(str, ldd_computed))) + print(" pyldd gives:") + print(" " + "\n ".join(map(str, ldd_emulate))) + print(f"Diffs\n{set(ldd_computed) - set(ldd_emulate)}") + print(f"Diffs\n{set(ldd_emulate) - set(ldd_computed)}") + + linkages[file] = ldd_computed + return linkages + + +@lru_cache(maxsize=None) +def get_package_obj_files( + prec: PrefixRecord, prefix: str | os.PathLike | Path +) -> list[str]: + return [ + file + for file in prec["files"] + if codefile_class(Path(prefix, file), skip_symlinks=True) + ] + + +@lru_cache(maxsize=None) +def get_untracked_obj_files(prefix: str | os.PathLike | Path) -> list[str]: + return [ + file + for file in untracked(str(prefix)) + if codefile_class(Path(prefix, file), skip_symlinks=True) + ] diff --git a/shared/package-files/43/432048e096a91b1777dba8e023153a5ec40c73f986fb7679f11080c184942608/blob b/shared/package-files/43/432048e096a91b1777dba8e023153a5ec40c73f986fb7679f11080c184942608/blob new file mode 100644 index 0000000000000000000000000000000000000000..f436c941f3f95b66788d249ddc885acd305bf499 --- /dev/null +++ b/shared/package-files/43/432048e096a91b1777dba8e023153a5ec40c73f986fb7679f11080c184942608/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & linalg_matrix_exp_out(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor linalg_matrix_exp(const at::Tensor & self); +} // namespace native +} // namespace at diff --git a/shared/package-files/43/4320d52271eff309c04dbb5b6c3531203ba465835b8d37510b887fb147a1bd33/blob b/shared/package-files/43/4320d52271eff309c04dbb5b6c3531203ba465835b8d37510b887fb147a1bd33/blob new file mode 100644 index 0000000000000000000000000000000000000000..5f93eabdc2b5d8cea145ebc8399ccc3e2c5a7816 --- /dev/null +++ b/shared/package-files/43/4320d52271eff309c04dbb5b6c3531203ba465835b8d37510b887fb147a1bd33/blob @@ -0,0 +1,248 @@ +import collections +from typing import Any, Dict, Union + +import torch +from torch._export.verifier import SpecViolationError +from torch._guards import detect_fake_mode +from torch.export.exported_program import ( + ArgumentSpec, + CustomObjArgument, + ExportGraphSignature, + InputKind, + InputSpec, + TensorArgument, +) + + +class ConstantAttrMap(collections.abc.MutableMapping): + """A mapping class that understands how to use module constants (tensors and + ScriptObjects) as keys. We store tensors normally, but ScriptObjects are + stored by hash, because different torch.ScriptObjects can point to the same + underlying value (but we guarantee that they will `hash()` to the same value + if that's the case). + """ + + def __init__(self): + # Underlying dict that we use to implement this mapping. + self._constant_attrs: Dict[Union[int, torch.Tensor], Any] = {} + # Map from the hash(ScriptObject) to the ScriptObject itself. Used for + # APIs like `__iter__` that should look like they're returning the + # original ScriptObjects. + self._script_object_map: Dict[int, torch.ScriptObject] = {} + + def __getitem__(self, key: Union[torch.Tensor, torch.ScriptObject]) -> Any: + real_key = hash(key) if isinstance(key, torch.ScriptObject) else key + assert isinstance(real_key, (int, torch.Tensor)) + return self._constant_attrs[real_key] + + def __setitem__( + self, key: Union[torch.Tensor, torch.ScriptObject], value: Any + ) -> None: + if isinstance(key, torch.ScriptObject): + self._constant_attrs[hash(key)] = value + self._script_object_map[hash(key)] = key + elif isinstance(key, torch.Tensor): + self._constant_attrs[key] = value + else: + raise TypeError( + f"Expected key to be a tensor or ScriptObject, got {type(key)}" + ) + + def __delitem__(self, key): + real_key = hash(key) if isinstance(key, torch.ScriptObject) else key + + del self._constant_attrs[real_key] + + def __iter__(self): + for key in self._constant_attrs: + if isinstance(key, int): + yield self._script_object_map[key] + else: + yield key + + def __len__(self): + return len(self._constant_attrs) + + def __contains__(self, key: object) -> bool: + real_key = hash(key) if isinstance(key, torch.ScriptObject) else key + return real_key in self._constant_attrs + + +def get_constant_fqn(node: torch.fx.Node, constant_name: str) -> str: + # The FQN of the constant tensor in the state dict should + # correspond to the module where the constant tensor was + # originally used. + parent_fqn = list(node.meta["nn_module_stack"].values())[-1][0] + if len(parent_fqn) > 0: + return f"{parent_fqn}.{constant_name}" + else: + return constant_name + + +def lift_constants_pass( + gm: torch.fx.GraphModule, + graph_signature: ExportGraphSignature, + constant_attrs: ConstantAttrMap, +) -> Dict[str, Union[torch.Tensor, torch._C.ScriptObject]]: + """ + Takes a graph module, graph signature, and modifies them implace to lift any + constants (tensors or custom classes) as inputs to the graph. Returns a + dictionary of names to constants. + + Arguments: + gm (torch.fx.GraphModule): The graph module containing the graph and constants to lift. + graph_signature (ExportGraphSignature): This graph signature will be + mutated to add additional CONSTANT_TENSOR and CUSTOM_OBJ inputs. + constant_attrs (ConstantAttr): A mapping from a constant value to its + fully-qualified path in `gm`. This is used to maintain consistent + location of constants between the original module and the exported + version. + + Returns: + A dictionary of fqn => constant value. + """ + all_constants: Dict[str, Union[torch.Tensor, torch._C.ScriptObject]] = {} + + inputs = graph_signature.input_specs + num_custom_obj = sum( + input_specs.kind == InputKind.CUSTOM_OBJ for input_specs in inputs + ) + num_tensor_constants = sum( + input_specs.kind == InputKind.CONSTANT_TENSOR for input_specs in inputs + ) + + fake_mode = detect_fake_mode( + tuple(node.meta["val"] for node in gm.graph.nodes if node.op == "placeholder") + ) + + first_user_input_loc, first_user_input = 0, None + for node in gm.graph.nodes: + if node.op == "placeholder" and node.name in graph_signature.user_inputs: + first_user_input = node + break + first_user_input_loc += 1 + + lifted_objs = ConstantAttrMap() + for node in gm.graph.nodes: + if node.op == "get_attr": + constant_val = getattr(gm, node.target) + if constant_val in lifted_objs: + # We already lifted this constant elsewhere. Just rewrite uses + # of this get_attr to point to the already-existing placeholder + # node. + const_placeholder_node = lifted_objs[constant_val] + node.replace_all_uses_with(const_placeholder_node) + gm.graph.erase_node(node) + continue + + # For ScriptObject and Tensor constants: + # First check if the constant was an attribute on some module by + # consulting `constant_attrs` map. If it is, use the fqn that keeps + # its location consistent with the eager module. + # + # If it's not in the `constant_attrs` map, that means it's an inline + # constant (e.g. x + torch.tensor(0)), and thus did not have a + # specific location in the eager module. In that case, just generate + # some name and attach it to the module in which it was used. + if isinstance(constant_val, torch.ScriptObject): + constant_kind = InputKind.CUSTOM_OBJ + constant_fqn = constant_attrs.get(constant_val) + if constant_fqn is not None: + _, _, constant_name = constant_fqn.rpartition(".") + else: + constant_name = f"_lifted_custom_obj{num_custom_obj}" + constant_fqn = get_constant_fqn(node, constant_name) + num_custom_obj += 1 + elif isinstance(constant_val, torch.Tensor): + constant_kind = InputKind.CONSTANT_TENSOR + constant_fqn = constant_attrs.get(constant_val) + if constant_fqn is not None: + _, _, constant_name = constant_fqn.rpartition(".") + else: + constant_name = f"_lifted_tensor_constant{num_tensor_constants}" + constant_fqn = get_constant_fqn(node, constant_name) + num_tensor_constants += 1 + elif isinstance(constant_val, torch.fx.GraphModule): + continue + elif "LoweredBackendModule" in type(constant_val).__name__: + continue + else: + raise SpecViolationError( + f"getattr node {node} referencing unsupported type {type(constant_val)}" + ) + + with gm.graph.inserting_before(first_user_input): + # Insert the constant node before the first user input + const_placeholder_node = gm.graph.placeholder(constant_name) + # match target name with its node name in case there is name collision + # and suffix is added to node name in fx + const_placeholder_node.target = const_placeholder_node.name + + for k, v in node.meta.items(): + const_placeholder_node.meta[k] = v + + input_spec_arg: ArgumentSpec + if isinstance(constant_val, torch.Tensor): + if fake_mode is not None: + const_placeholder_node.meta["val"] = fake_mode.from_tensor( + constant_val, static_shapes=True + ) + const_placeholder_node.meta["val"].constant = constant_val + else: + const_placeholder_node.meta["val"] = constant_val + input_spec_arg = TensorArgument(name=const_placeholder_node.name) + elif isinstance(constant_val, torch._C.ScriptObject): + class_fqn = constant_val._type().qualified_name() # type: ignore[attr-defined] + const_placeholder_node.meta["val"] = CustomObjArgument( + constant_fqn, class_fqn + ) + input_spec_arg = CustomObjArgument( + name=const_placeholder_node.name, class_fqn=class_fqn + ) + else: + raise SpecViolationError( + f"tried to lift unsupported type {type(constant_val)} from node {node.format_node()}" + ) + + lifted_objs[constant_val] = const_placeholder_node + node.replace_all_uses_with(const_placeholder_node) + gm.graph.erase_node(node) + + # Add the constant as a buffer to the graph signature + graph_signature.input_specs.insert( + first_user_input_loc, + InputSpec( + kind=constant_kind, + arg=input_spec_arg, + target=constant_fqn, + ), + ) + all_constants[constant_fqn] = constant_val + first_user_input_loc += 1 + + return all_constants + + +def rewrite_script_object_meta( + gm: torch.fx.GraphModule, +) -> Dict[str, Union[torch.Tensor, torch.ScriptObject]]: + """When tracing, we produce a graph with an actual ScriptObject in the + meta["val"]. Eventually we want to change this behavior, when FakeMode infra + for ScriptObjects lands. + + For now, we rewrie meta["val"] to be a placeholder CustomObjArgument + """ + constants: Dict[str, Union[torch.Tensor, torch._C.ScriptObject]] = {} + for node in gm.graph.nodes: + if "val" not in node.meta or not isinstance( + node.meta["val"], torch.ScriptObject + ): + continue + + old_meta = node.meta["val"] + class_fqn = old_meta._type().qualified_name() # type: ignore[attr-defined] + new_meta = CustomObjArgument(node.name, class_fqn) + constants[node.name] = old_meta + node.meta["val"] = new_meta + + return constants diff --git a/shared/package-files/43/43219de1f312f36d004db3fc62006dbbb6d248ad3da70e5166496c3c9f097f46/blob b/shared/package-files/43/43219de1f312f36d004db3fc62006dbbb6d248ad3da70e5166496c3c9f097f46/blob new file mode 100644 index 0000000000000000000000000000000000000000..064423c4494850f2ad8f43fb00a956be21fcb95e --- /dev/null +++ b/shared/package-files/43/43219de1f312f36d004db3fc62006dbbb6d248ad3da70e5166496c3c9f097f46/blob @@ -0,0 +1,136 @@ +import os +import re +from pathlib import Path +from typing import Optional, Tuple, Union + +import torch +from torch.utils.data import Dataset +from torchaudio._internal import download_url_to_file +from torchaudio.datasets.utils import _extract_tar, _load_waveform + + +URL = "https://speech.fit.vutbr.cz/files/quesst14Database.tgz" +SAMPLE_RATE = 8000 +_CHECKSUM = "4f869e06bc066bbe9c5dde31dbd3909a0870d70291110ebbb38878dcbc2fc5e4" +_LANGUAGES = [ + "albanian", + "basque", + "czech", + "nnenglish", + "romanian", + "slovak", +] + + +class QUESST14(Dataset): + """*QUESST14* :cite:`Mir2015QUESST2014EQ` dataset. + + Args: + root (str or Path): Root directory where the dataset's top level directory is found + subset (str): Subset of the dataset to use. Options: [``"docs"``, ``"dev"``, ``"eval"``]. + language (str or None, optional): Language to get dataset for. + Options: [``None``, ``albanian``, ``basque``, ``czech``, ``nnenglish``, ``romanian``, ``slovak``]. + If ``None``, dataset consists of all languages. (default: ``"nnenglish"``) + download (bool, optional): Whether to download the dataset if it is not found at root path. + (default: ``False``) + """ + + def __init__( + self, + root: Union[str, Path], + subset: str, + language: Optional[str] = "nnenglish", + download: bool = False, + ) -> None: + if subset not in ["docs", "dev", "eval"]: + raise ValueError("`subset` must be one of ['docs', 'dev', 'eval']") + + if language is not None and language not in _LANGUAGES: + raise ValueError(f"`language` must be None or one of {str(_LANGUAGES)}") + + # Get string representation of 'root' + root = os.fspath(root) + + basename = os.path.basename(URL) + archive = os.path.join(root, basename) + + basename = basename.rsplit(".", 2)[0] + self._path = os.path.join(root, basename) + + if not os.path.isdir(self._path): + if not os.path.isfile(archive): + if not download: + raise RuntimeError("Dataset not found. Please use `download=True` to download") + download_url_to_file(URL, archive, hash_prefix=_CHECKSUM) + _extract_tar(archive, root) + + if subset == "docs": + self.data = filter_audio_paths(self._path, language, "language_key_utterances.lst") + elif subset == "dev": + self.data = filter_audio_paths(self._path, language, "language_key_dev.lst") + elif subset == "eval": + self.data = filter_audio_paths(self._path, language, "language_key_eval.lst") + + def get_metadata(self, n: int) -> Tuple[str, int, str]: + """Get metadata for the n-th sample from the dataset. Returns filepath instead of waveform, + but otherwise returns the same fields as :py:func:`__getitem__`. + + Args: + n (int): The index of the sample to be loaded + + Returns: + Tuple of the following items; + + str: + Path to audio + int: + Sample rate + str: + File name + """ + audio_path = self.data[n] + relpath = os.path.relpath(audio_path, self._path) + return relpath, SAMPLE_RATE, audio_path.with_suffix("").name + + def __getitem__(self, n: int) -> Tuple[torch.Tensor, int, str]: + """Load the n-th sample from the dataset. + + Args: + n (int): The index of the sample to be loaded + + Returns: + Tuple of the following items; + + Tensor: + Waveform + int: + Sample rate + str: + File name + """ + metadata = self.get_metadata(n) + waveform = _load_waveform(self._path, metadata[0], metadata[1]) + return (waveform,) + metadata[1:] + + def __len__(self) -> int: + return len(self.data) + + +def filter_audio_paths( + path: str, + language: str, + lst_name: str, +): + """Extract audio paths for the given language.""" + audio_paths = [] + + path = Path(path) + with open(path / "scoring" / lst_name) as f: + for line in f: + audio_path, lang = line.strip().split() + if language is not None and lang != language: + continue + audio_path = re.sub(r"^.*?\/", "", audio_path) + audio_paths.append(path / audio_path) + + return audio_paths diff --git a/shared/package-files/43/4321b12a7a530da1b15b0f5dbbfdbeb8bb30b3d26277c123f4eb56f7010e4340/blob b/shared/package-files/43/4321b12a7a530da1b15b0f5dbbfdbeb8bb30b3d26277c123f4eb56f7010e4340/blob new file mode 100644 index 0000000000000000000000000000000000000000..8b20f115a4d00ccf8ae2e1d171104d69e166149f Binary files /dev/null and b/shared/package-files/43/4321b12a7a530da1b15b0f5dbbfdbeb8bb30b3d26277c123f4eb56f7010e4340/blob differ diff --git a/shared/package-files/43/43261fe01347495b3c2e06da1cb0cdb3fdac1f097fa3879a3eee893454a97ff2/blob b/shared/package-files/43/43261fe01347495b3c2e06da1cb0cdb3fdac1f097fa3879a3eee893454a97ff2/blob new file mode 100644 index 0000000000000000000000000000000000000000..c9b2ff90823a5809d877fb68c10494a38ab183b1 Binary files /dev/null and b/shared/package-files/43/43261fe01347495b3c2e06da1cb0cdb3fdac1f097fa3879a3eee893454a97ff2/blob differ diff --git a/shared/package-files/43/4326c0947fb5deeba0324690ef91c80a959da3bbb3e974958890c61236cbf07a/blob b/shared/package-files/43/4326c0947fb5deeba0324690ef91c80a959da3bbb3e974958890c61236cbf07a/blob new file mode 100644 index 0000000000000000000000000000000000000000..0b7d7832dd4d31db9a6df005d8011a7706f3f756 --- /dev/null +++ b/shared/package-files/43/4326c0947fb5deeba0324690ef91c80a959da3bbb3e974958890c61236cbf07a/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API special_polygamma { + using schema = at::Tensor (int64_t, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::special_polygamma") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "special_polygamma(int n, Tensor self) -> Tensor") + static at::Tensor call(int64_t n, const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, int64_t n, const at::Tensor & self); +}; + +struct TORCH_API special_polygamma_out { + using schema = at::Tensor & (int64_t, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::special_polygamma") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "special_polygamma.out(int n, Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(int64_t n, const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, int64_t n, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/43/432742fb8212c983085960981155d9441aa0a2ebfb4bc706ed2ab6db6c0d93c0/blob b/shared/package-files/43/432742fb8212c983085960981155d9441aa0a2ebfb4bc706ed2ab6db6c0d93c0/blob new file mode 100644 index 0000000000000000000000000000000000000000..47ba1c54803159de8ce209b701597f1a1bc0f3fa --- /dev/null +++ b/shared/package-files/43/432742fb8212c983085960981155d9441aa0a2ebfb4bc706ed2ab6db6c0d93c0/blob @@ -0,0 +1,79 @@ +# +# The Python Imaging Library. +# $Id$ +# +# XV Thumbnail file handler by Charles E. "Gene" Cash +# (gcash@magicnet.net) +# +# see xvcolor.c and xvbrowse.c in the sources to John Bradley's XV, +# available from ftp://ftp.cis.upenn.edu/pub/xv/ +# +# history: +# 98-08-15 cec created (b/w only) +# 98-12-09 cec added color palette +# 98-12-28 fl added to PIL (with only a few very minor modifications) +# +# To do: +# FIXME: make save work (this requires quantization support) +# +from __future__ import annotations + +from . import Image, ImageFile, ImagePalette +from ._binary import o8 + +_MAGIC = b"P7 332" + +# standard color palette for thumbnails (RGB332) +PALETTE = b"" +for r in range(8): + for g in range(8): + for b in range(4): + PALETTE = PALETTE + ( + o8((r * 255) // 7) + o8((g * 255) // 7) + o8((b * 255) // 3) + ) + + +def _accept(prefix): + return prefix[:6] == _MAGIC + + +## +# Image plugin for XV thumbnail images. + + +class XVThumbImageFile(ImageFile.ImageFile): + format = "XVThumb" + format_description = "XV thumbnail image" + + def _open(self): + # check magic + if not _accept(self.fp.read(6)): + msg = "not an XV thumbnail file" + raise SyntaxError(msg) + + # Skip to beginning of next line + self.fp.readline() + + # skip info comments + while True: + s = self.fp.readline() + if not s: + msg = "Unexpected EOF reading XV thumbnail file" + raise SyntaxError(msg) + if s[0] != 35: # ie. when not a comment: '#' + break + + # parse header line (already read) + s = s.strip().split() + + self._mode = "P" + self._size = int(s[0]), int(s[1]) + + self.palette = ImagePalette.raw("RGB", PALETTE) + + self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), (self.mode, 0, 1))] + + +# -------------------------------------------------------------------- + +Image.register_open(XVThumbImageFile.format, XVThumbImageFile, _accept) diff --git a/shared/package-files/43/432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541/blob b/shared/package-files/43/432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541/blob new file mode 100644 index 0000000000000000000000000000000000000000..22f4d716ac9764ee18005b9b852946d614152375 --- /dev/null +++ b/shared/package-files/43/432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541/blob @@ -0,0 +1,101 @@ +from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Sequence + +if TYPE_CHECKING: + from pip._vendor.rich.console import ConsoleRenderable + +from . import get_console +from .segment import Segment +from .terminal_theme import DEFAULT_TERMINAL_THEME + +if TYPE_CHECKING: + from pip._vendor.rich.console import ConsoleRenderable + +JUPYTER_HTML_FORMAT = """\ +
{code}
+""" + + +class JupyterRenderable: + """A shim to write html to Jupyter notebook.""" + + def __init__(self, html: str, text: str) -> None: + self.html = html + self.text = text + + def _repr_mimebundle_( + self, include: Sequence[str], exclude: Sequence[str], **kwargs: Any + ) -> Dict[str, str]: + data = {"text/plain": self.text, "text/html": self.html} + if include: + data = {k: v for (k, v) in data.items() if k in include} + if exclude: + data = {k: v for (k, v) in data.items() if k not in exclude} + return data + + +class JupyterMixin: + """Add to an Rich renderable to make it render in Jupyter notebook.""" + + __slots__ = () + + def _repr_mimebundle_( + self: "ConsoleRenderable", + include: Sequence[str], + exclude: Sequence[str], + **kwargs: Any, + ) -> Dict[str, str]: + console = get_console() + segments = list(console.render(self, console.options)) + html = _render_segments(segments) + text = console._render_buffer(segments) + data = {"text/plain": text, "text/html": html} + if include: + data = {k: v for (k, v) in data.items() if k in include} + if exclude: + data = {k: v for (k, v) in data.items() if k not in exclude} + return data + + +def _render_segments(segments: Iterable[Segment]) -> str: + def escape(text: str) -> str: + """Escape html.""" + return text.replace("&", "&").replace("<", "<").replace(">", ">") + + fragments: List[str] = [] + append_fragment = fragments.append + theme = DEFAULT_TERMINAL_THEME + for text, style, control in Segment.simplify(segments): + if control: + continue + text = escape(text) + if style: + rule = style.get_html_style(theme) + text = f'{text}' if rule else text + if style.link: + text = f'{text}' + append_fragment(text) + + code = "".join(fragments) + html = JUPYTER_HTML_FORMAT.format(code=code) + + return html + + +def display(segments: Iterable[Segment], text: str) -> None: + """Render segments to Jupyter.""" + html = _render_segments(segments) + jupyter_renderable = JupyterRenderable(html, text) + try: + from IPython.display import display as ipython_display + + ipython_display(jupyter_renderable) + except ModuleNotFoundError: + # Handle the case where the Console has force_jupyter=True, + # but IPython is not installed. + pass + + +def print(*args: Any, **kwargs: Any) -> None: + """Proxy for Console print.""" + console = get_console() + return console.print(*args, **kwargs) diff --git a/shared/package-files/43/432a6581ec57b7774039ae13eac07cb4850a9c3506368613b96b7a09976b6d9e/blob b/shared/package-files/43/432a6581ec57b7774039ae13eac07cb4850a9c3506368613b96b7a09976b6d9e/blob new file mode 100644 index 0000000000000000000000000000000000000000..2d749a1878b16c88e5251f633f122f65c4ff84ac --- /dev/null +++ b/shared/package-files/43/432a6581ec57b7774039ae13eac07cb4850a9c3506368613b96b7a09976b6d9e/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_softmax_backward_data(Tensor grad_output, Tensor output, int dim, ScalarType input_dtype) -> Tensor +inline at::Tensor _softmax_backward_data(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { + return at::_ops::_softmax_backward_data::call(grad_output, output, dim, input_dtype); +} + +// aten::_softmax_backward_data.out(Tensor grad_output, Tensor output, int dim, ScalarType input_dtype, *, Tensor(a!) grad_input) -> Tensor(a!) +inline at::Tensor & _softmax_backward_data_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { + return at::_ops::_softmax_backward_data_out::call(grad_output, output, dim, input_dtype, grad_input); +} +// aten::_softmax_backward_data.out(Tensor grad_output, Tensor output, int dim, ScalarType input_dtype, *, Tensor(a!) grad_input) -> Tensor(a!) +inline at::Tensor & _softmax_backward_data_outf(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype, at::Tensor & grad_input) { + return at::_ops::_softmax_backward_data_out::call(grad_output, output, dim, input_dtype, grad_input); +} + +} diff --git a/shared/package-files/43/432c3d4b02dc1e1bf3fddce2fab00ab175580321052cdce8321bc242f4ba7a8e/blob b/shared/package-files/43/432c3d4b02dc1e1bf3fddce2fab00ab175580321052cdce8321bc242f4ba7a8e/blob new file mode 100644 index 0000000000000000000000000000000000000000..6aa6371779b0efbad18e63d0f906403e9581df07 --- /dev/null +++ b/shared/package-files/43/432c3d4b02dc1e1bf3fddce2fab00ab175580321052cdce8321bc242f4ba7a8e/blob @@ -0,0 +1,1845 @@ +# coding: utf-8 + +import datetime +import base64 +import binascii +import sys +import types +import warnings +from collections.abc import Hashable, MutableSequence, MutableMapping + +# fmt: off +from ruamel.yaml.error import (MarkedYAMLError, MarkedYAMLFutureWarning, + MantissaNoDotYAML1_1Warning) +from ruamel.yaml.nodes import * # NOQA +from ruamel.yaml.nodes import (SequenceNode, MappingNode, ScalarNode) +from ruamel.yaml.compat import (_F, builtins_module, # NOQA + nprint, nprintf, version_tnf) +from ruamel.yaml.compat import ordereddict + +from ruamel.yaml.comments import * # NOQA +from ruamel.yaml.comments import (CommentedMap, CommentedOrderedMap, CommentedSet, + CommentedKeySeq, CommentedSeq, TaggedScalar, + CommentedKeyMap, + C_KEY_PRE, C_KEY_EOL, C_KEY_POST, + C_VALUE_PRE, C_VALUE_EOL, C_VALUE_POST, + ) +from ruamel.yaml.scalarstring import (SingleQuotedScalarString, DoubleQuotedScalarString, + LiteralScalarString, FoldedScalarString, + PlainScalarString, ScalarString,) +from ruamel.yaml.scalarint import ScalarInt, BinaryInt, OctalInt, HexInt, HexCapsInt +from ruamel.yaml.scalarfloat import ScalarFloat +from ruamel.yaml.scalarbool import ScalarBoolean +from ruamel.yaml.timestamp import TimeStamp +from ruamel.yaml.util import timestamp_regexp, create_timestamp + +if False: # MYPY + from typing import Any, Dict, List, Set, Generator, Union, Optional # NOQA + + +__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor', + 'ConstructorError', 'RoundTripConstructor'] +# fmt: on + + +class ConstructorError(MarkedYAMLError): + pass + + +class DuplicateKeyFutureWarning(MarkedYAMLFutureWarning): + pass + + +class DuplicateKeyError(MarkedYAMLError): + pass + + +class BaseConstructor: + + yaml_constructors = {} # type: Dict[Any, Any] + yaml_multi_constructors = {} # type: Dict[Any, Any] + + def __init__(self, preserve_quotes=None, loader=None): + # type: (Optional[bool], Any) -> None + self.loader = loader + if self.loader is not None and getattr(self.loader, '_constructor', None) is None: + self.loader._constructor = self + self.loader = loader + self.yaml_base_dict_type = dict + self.yaml_base_list_type = list + self.constructed_objects = {} # type: Dict[Any, Any] + self.recursive_objects = {} # type: Dict[Any, Any] + self.state_generators = [] # type: List[Any] + self.deep_construct = False + self._preserve_quotes = preserve_quotes + self.allow_duplicate_keys = version_tnf((0, 15, 1), (0, 16)) + + @property + def composer(self): + # type: () -> Any + if hasattr(self.loader, 'typ'): + return self.loader.composer + try: + return self.loader._composer + except AttributeError: + sys.stdout.write('slt {}\n'.format(type(self))) + sys.stdout.write('slc {}\n'.format(self.loader._composer)) + sys.stdout.write('{}\n'.format(dir(self))) + raise + + @property + def resolver(self): + # type: () -> Any + if hasattr(self.loader, 'typ'): + return self.loader.resolver + return self.loader._resolver + + @property + def scanner(self): + # type: () -> Any + # needed to get to the expanded comments + if hasattr(self.loader, 'typ'): + return self.loader.scanner + return self.loader._scanner + + def check_data(self): + # type: () -> Any + # If there are more documents available? + return self.composer.check_node() + + def get_data(self): + # type: () -> Any + # Construct and return the next document. + if self.composer.check_node(): + return self.construct_document(self.composer.get_node()) + + def get_single_data(self): + # type: () -> Any + # Ensure that the stream contains a single document and construct it. + node = self.composer.get_single_node() + if node is not None: + return self.construct_document(node) + return None + + def construct_document(self, node): + # type: (Any) -> Any + data = self.construct_object(node) + while bool(self.state_generators): + state_generators = self.state_generators + self.state_generators = [] + for generator in state_generators: + for _dummy in generator: + pass + self.constructed_objects = {} + self.recursive_objects = {} + self.deep_construct = False + return data + + def construct_object(self, node, deep=False): + # type: (Any, bool) -> Any + """deep is True when creating an object/mapping recursively, + in that case want the underlying elements available during construction + """ + if node in self.constructed_objects: + return self.constructed_objects[node] + if deep: + old_deep = self.deep_construct + self.deep_construct = True + if node in self.recursive_objects: + return self.recursive_objects[node] + # raise ConstructorError( + # None, None, 'found unconstructable recursive node', node.start_mark + # ) + self.recursive_objects[node] = None + data = self.construct_non_recursive_object(node) + + self.constructed_objects[node] = data + del self.recursive_objects[node] + if deep: + self.deep_construct = old_deep + return data + + def construct_non_recursive_object(self, node, tag=None): + # type: (Any, Optional[str]) -> Any + constructor = None # type: Any + tag_suffix = None + if tag is None: + tag = node.tag + if tag in self.yaml_constructors: + constructor = self.yaml_constructors[tag] + else: + for tag_prefix in self.yaml_multi_constructors: + if tag.startswith(tag_prefix): + tag_suffix = tag[len(tag_prefix) :] + constructor = self.yaml_multi_constructors[tag_prefix] + break + else: + if None in self.yaml_multi_constructors: + tag_suffix = tag + constructor = self.yaml_multi_constructors[None] + elif None in self.yaml_constructors: + constructor = self.yaml_constructors[None] + elif isinstance(node, ScalarNode): + constructor = self.__class__.construct_scalar + elif isinstance(node, SequenceNode): + constructor = self.__class__.construct_sequence + elif isinstance(node, MappingNode): + constructor = self.__class__.construct_mapping + if tag_suffix is None: + data = constructor(self, node) + else: + data = constructor(self, tag_suffix, node) + if isinstance(data, types.GeneratorType): + generator = data + data = next(generator) + if self.deep_construct: + for _dummy in generator: + pass + else: + self.state_generators.append(generator) + return data + + def construct_scalar(self, node): + # type: (Any) -> Any + if not isinstance(node, ScalarNode): + raise ConstructorError( + None, + None, + _F('expected a scalar node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + return node.value + + def construct_sequence(self, node, deep=False): + # type: (Any, bool) -> Any + """deep is True when creating an object/mapping recursively, + in that case want the underlying elements available during construction + """ + if not isinstance(node, SequenceNode): + raise ConstructorError( + None, + None, + _F('expected a sequence node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + return [self.construct_object(child, deep=deep) for child in node.value] + + def construct_mapping(self, node, deep=False): + # type: (Any, bool) -> Any + """deep is True when creating an object/mapping recursively, + in that case want the underlying elements available during construction + """ + if not isinstance(node, MappingNode): + raise ConstructorError( + None, + None, + _F('expected a mapping node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + total_mapping = self.yaml_base_dict_type() + if getattr(node, 'merge', None) is not None: + todo = [(node.merge, False), (node.value, False)] + else: + todo = [(node.value, True)] + for values, check in todo: + mapping = self.yaml_base_dict_type() # type: Dict[Any, Any] + for key_node, value_node in values: + # keys can be list -> deep + key = self.construct_object(key_node, deep=True) + # lists are not hashable, but tuples are + if not isinstance(key, Hashable): + if isinstance(key, list): + key = tuple(key) + if not isinstance(key, Hashable): + raise ConstructorError( + 'while constructing a mapping', + node.start_mark, + 'found unhashable key', + key_node.start_mark, + ) + + value = self.construct_object(value_node, deep=deep) + if check: + if self.check_mapping_key(node, key_node, mapping, key, value): + mapping[key] = value + else: + mapping[key] = value + total_mapping.update(mapping) + return total_mapping + + def check_mapping_key(self, node, key_node, mapping, key, value): + # type: (Any, Any, Any, Any, Any) -> bool + """return True if key is unique""" + if key in mapping: + if not self.allow_duplicate_keys: + mk = mapping.get(key) + args = [ + 'while constructing a mapping', + node.start_mark, + 'found duplicate key "{}" with value "{}" ' + '(original value: "{}")'.format(key, value, mk), + key_node.start_mark, + """ + To suppress this check see: + http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys + """, + """\ + Duplicate keys will become an error in future releases, and are errors + by default when using the new API. + """, + ] + if self.allow_duplicate_keys is None: + warnings.warn(DuplicateKeyFutureWarning(*args)) + else: + raise DuplicateKeyError(*args) + return False + return True + + def check_set_key(self, node, key_node, setting, key): + # type: (Any, Any, Any, Any, Any) -> None + if key in setting: + if not self.allow_duplicate_keys: + args = [ + 'while constructing a set', + node.start_mark, + 'found duplicate key "{}"'.format(key), + key_node.start_mark, + """ + To suppress this check see: + http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys + """, + """\ + Duplicate keys will become an error in future releases, and are errors + by default when using the new API. + """, + ] + if self.allow_duplicate_keys is None: + warnings.warn(DuplicateKeyFutureWarning(*args)) + else: + raise DuplicateKeyError(*args) + + def construct_pairs(self, node, deep=False): + # type: (Any, bool) -> Any + if not isinstance(node, MappingNode): + raise ConstructorError( + None, + None, + _F('expected a mapping node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + pairs = [] + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + value = self.construct_object(value_node, deep=deep) + pairs.append((key, value)) + return pairs + + @classmethod + def add_constructor(cls, tag, constructor): + # type: (Any, Any) -> None + if 'yaml_constructors' not in cls.__dict__: + cls.yaml_constructors = cls.yaml_constructors.copy() + cls.yaml_constructors[tag] = constructor + + @classmethod + def add_multi_constructor(cls, tag_prefix, multi_constructor): + # type: (Any, Any) -> None + if 'yaml_multi_constructors' not in cls.__dict__: + cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy() + cls.yaml_multi_constructors[tag_prefix] = multi_constructor + + +class SafeConstructor(BaseConstructor): + def construct_scalar(self, node): + # type: (Any) -> Any + if isinstance(node, MappingNode): + for key_node, value_node in node.value: + if key_node.tag == 'tag:yaml.org,2002:value': + return self.construct_scalar(value_node) + return BaseConstructor.construct_scalar(self, node) + + def flatten_mapping(self, node): + # type: (Any) -> Any + """ + This implements the merge key feature http://yaml.org/type/merge.html + by inserting keys from the merge dict/list of dicts if not yet + available in this node + """ + merge = [] # type: List[Any] + index = 0 + while index < len(node.value): + key_node, value_node = node.value[index] + if key_node.tag == 'tag:yaml.org,2002:merge': + if merge: # double << key + if self.allow_duplicate_keys: + del node.value[index] + index += 1 + continue + args = [ + 'while constructing a mapping', + node.start_mark, + 'found duplicate key "{}"'.format(key_node.value), + key_node.start_mark, + """ + To suppress this check see: + http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys + """, + """\ + Duplicate keys will become an error in future releases, and are errors + by default when using the new API. + """, + ] + if self.allow_duplicate_keys is None: + warnings.warn(DuplicateKeyFutureWarning(*args)) + else: + raise DuplicateKeyError(*args) + del node.value[index] + if isinstance(value_node, MappingNode): + self.flatten_mapping(value_node) + merge.extend(value_node.value) + elif isinstance(value_node, SequenceNode): + submerge = [] + for subnode in value_node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError( + 'while constructing a mapping', + node.start_mark, + _F( + 'expected a mapping for merging, but found {subnode_id!s}', + subnode_id=subnode.id, + ), + subnode.start_mark, + ) + self.flatten_mapping(subnode) + submerge.append(subnode.value) + submerge.reverse() + for value in submerge: + merge.extend(value) + else: + raise ConstructorError( + 'while constructing a mapping', + node.start_mark, + _F( + 'expected a mapping or list of mappings for merging, ' + 'but found {value_node_id!s}', + value_node_id=value_node.id, + ), + value_node.start_mark, + ) + elif key_node.tag == 'tag:yaml.org,2002:value': + key_node.tag = 'tag:yaml.org,2002:str' + index += 1 + else: + index += 1 + if bool(merge): + node.merge = merge # separate merge keys to be able to update without duplicate + node.value = merge + node.value + + def construct_mapping(self, node, deep=False): + # type: (Any, bool) -> Any + """deep is True when creating an object/mapping recursively, + in that case want the underlying elements available during construction + """ + if isinstance(node, MappingNode): + self.flatten_mapping(node) + return BaseConstructor.construct_mapping(self, node, deep=deep) + + def construct_yaml_null(self, node): + # type: (Any) -> Any + self.construct_scalar(node) + return None + + # YAML 1.2 spec doesn't mention yes/no etc any more, 1.1 does + bool_values = { + 'yes': True, + 'no': False, + 'y': True, + 'n': False, + 'true': True, + 'false': False, + 'on': True, + 'off': False, + } + + def construct_yaml_bool(self, node): + # type: (Any) -> bool + value = self.construct_scalar(node) + return self.bool_values[value.lower()] + + def construct_yaml_int(self, node): + # type: (Any) -> int + value_s = self.construct_scalar(node) + value_s = value_s.replace('_', "") + sign = +1 + if value_s[0] == '-': + sign = -1 + if value_s[0] in '+-': + value_s = value_s[1:] + if value_s == '0': + return 0 + elif value_s.startswith('0b'): + return sign * int(value_s[2:], 2) + elif value_s.startswith('0x'): + return sign * int(value_s[2:], 16) + elif value_s.startswith('0o'): + return sign * int(value_s[2:], 8) + elif self.resolver.processing_version == (1, 1) and value_s[0] == '0': + return sign * int(value_s, 8) + elif self.resolver.processing_version == (1, 1) and ':' in value_s: + digits = [int(part) for part in value_s.split(':')] + digits.reverse() + base = 1 + value = 0 + for digit in digits: + value += digit * base + base *= 60 + return sign * value + else: + return sign * int(value_s) + + inf_value = 1e300 + while inf_value != inf_value * inf_value: + inf_value *= inf_value + nan_value = -inf_value / inf_value # Trying to make a quiet NaN (like C99). + + def construct_yaml_float(self, node): + # type: (Any) -> float + value_so = self.construct_scalar(node) + value_s = value_so.replace('_', "").lower() + sign = +1 + if value_s[0] == '-': + sign = -1 + if value_s[0] in '+-': + value_s = value_s[1:] + if value_s == '.inf': + return sign * self.inf_value + elif value_s == '.nan': + return self.nan_value + elif self.resolver.processing_version != (1, 2) and ':' in value_s: + digits = [float(part) for part in value_s.split(':')] + digits.reverse() + base = 1 + value = 0.0 + for digit in digits: + value += digit * base + base *= 60 + return sign * value + else: + if self.resolver.processing_version != (1, 2) and 'e' in value_s: + # value_s is lower case independent of input + mantissa, exponent = value_s.split('e') + if '.' not in mantissa: + warnings.warn(MantissaNoDotYAML1_1Warning(node, value_so)) + return sign * float(value_s) + + def construct_yaml_binary(self, node): + # type: (Any) -> Any + try: + value = self.construct_scalar(node).encode('ascii') + except UnicodeEncodeError as exc: + raise ConstructorError( + None, + None, + _F('failed to convert base64 data into ascii: {exc!s}', exc=exc), + node.start_mark, + ) + try: + return base64.decodebytes(value) + except binascii.Error as exc: + raise ConstructorError( + None, + None, + _F('failed to decode base64 data: {exc!s}', exc=exc), + node.start_mark, + ) + + timestamp_regexp = timestamp_regexp # moved to util 0.17.17 + + def construct_yaml_timestamp(self, node, values=None): + # type: (Any, Any) -> Any + if values is None: + try: + match = self.timestamp_regexp.match(node.value) + except TypeError: + match = None + if match is None: + raise ConstructorError( + None, + None, + 'failed to construct timestamp from "{}"'.format(node.value), + node.start_mark, + ) + values = match.groupdict() + return create_timestamp(**values) + + def construct_yaml_omap(self, node): + # type: (Any) -> Any + # Note: we do now check for duplicate keys + omap = ordereddict() + yield omap + if not isinstance(node, SequenceNode): + raise ConstructorError( + 'while constructing an ordered map', + node.start_mark, + _F('expected a sequence, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError( + 'while constructing an ordered map', + node.start_mark, + _F( + 'expected a mapping of length 1, but found {subnode_id!s}', + subnode_id=subnode.id, + ), + subnode.start_mark, + ) + if len(subnode.value) != 1: + raise ConstructorError( + 'while constructing an ordered map', + node.start_mark, + _F( + 'expected a single mapping item, but found {len_subnode_val:d} items', + len_subnode_val=len(subnode.value), + ), + subnode.start_mark, + ) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + assert key not in omap + value = self.construct_object(value_node) + omap[key] = value + + def construct_yaml_pairs(self, node): + # type: (Any) -> Any + # Note: the same code as `construct_yaml_omap`. + pairs = [] # type: List[Any] + yield pairs + if not isinstance(node, SequenceNode): + raise ConstructorError( + 'while constructing pairs', + node.start_mark, + _F('expected a sequence, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError( + 'while constructing pairs', + node.start_mark, + _F( + 'expected a mapping of length 1, but found {subnode_id!s}', + subnode_id=subnode.id, + ), + subnode.start_mark, + ) + if len(subnode.value) != 1: + raise ConstructorError( + 'while constructing pairs', + node.start_mark, + _F( + 'expected a single mapping item, but found {len_subnode_val:d} items', + len_subnode_val=len(subnode.value), + ), + subnode.start_mark, + ) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + pairs.append((key, value)) + + def construct_yaml_set(self, node): + # type: (Any) -> Any + data = set() # type: Set[Any] + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_str(self, node): + # type: (Any) -> Any + value = self.construct_scalar(node) + return value + + def construct_yaml_seq(self, node): + # type: (Any) -> Any + data = self.yaml_base_list_type() # type: List[Any] + yield data + data.extend(self.construct_sequence(node)) + + def construct_yaml_map(self, node): + # type: (Any) -> Any + data = self.yaml_base_dict_type() # type: Dict[Any, Any] + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_object(self, node, cls): + # type: (Any, Any) -> Any + data = cls.__new__(cls) + yield data + if hasattr(data, '__setstate__'): + state = self.construct_mapping(node, deep=True) + data.__setstate__(state) + else: + state = self.construct_mapping(node) + data.__dict__.update(state) + + def construct_undefined(self, node): + # type: (Any) -> None + raise ConstructorError( + None, + None, + _F( + 'could not determine a constructor for the tag {node_tag!r}', node_tag=node.tag + ), + node.start_mark, + ) + + +SafeConstructor.add_constructor('tag:yaml.org,2002:null', SafeConstructor.construct_yaml_null) + +SafeConstructor.add_constructor('tag:yaml.org,2002:bool', SafeConstructor.construct_yaml_bool) + +SafeConstructor.add_constructor('tag:yaml.org,2002:int', SafeConstructor.construct_yaml_int) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:float', SafeConstructor.construct_yaml_float +) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:binary', SafeConstructor.construct_yaml_binary +) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:timestamp', SafeConstructor.construct_yaml_timestamp +) + +SafeConstructor.add_constructor('tag:yaml.org,2002:omap', SafeConstructor.construct_yaml_omap) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:pairs', SafeConstructor.construct_yaml_pairs +) + +SafeConstructor.add_constructor('tag:yaml.org,2002:set', SafeConstructor.construct_yaml_set) + +SafeConstructor.add_constructor('tag:yaml.org,2002:str', SafeConstructor.construct_yaml_str) + +SafeConstructor.add_constructor('tag:yaml.org,2002:seq', SafeConstructor.construct_yaml_seq) + +SafeConstructor.add_constructor('tag:yaml.org,2002:map', SafeConstructor.construct_yaml_map) + +SafeConstructor.add_constructor(None, SafeConstructor.construct_undefined) + + +class Constructor(SafeConstructor): + def construct_python_str(self, node): + # type: (Any) -> Any + return self.construct_scalar(node) + + def construct_python_unicode(self, node): + # type: (Any) -> Any + return self.construct_scalar(node) + + def construct_python_bytes(self, node): + # type: (Any) -> Any + try: + value = self.construct_scalar(node).encode('ascii') + except UnicodeEncodeError as exc: + raise ConstructorError( + None, + None, + _F('failed to convert base64 data into ascii: {exc!s}', exc=exc), + node.start_mark, + ) + try: + return base64.decodebytes(value) + except binascii.Error as exc: + raise ConstructorError( + None, + None, + _F('failed to decode base64 data: {exc!s}', exc=exc), + node.start_mark, + ) + + def construct_python_long(self, node): + # type: (Any) -> int + val = self.construct_yaml_int(node) + return val + + def construct_python_complex(self, node): + # type: (Any) -> Any + return complex(self.construct_scalar(node)) + + def construct_python_tuple(self, node): + # type: (Any) -> Any + return tuple(self.construct_sequence(node)) + + def find_python_module(self, name, mark): + # type: (Any, Any) -> Any + if not name: + raise ConstructorError( + 'while constructing a Python module', + mark, + 'expected non-empty name appended to the tag', + mark, + ) + try: + __import__(name) + except ImportError as exc: + raise ConstructorError( + 'while constructing a Python module', + mark, + _F('cannot find module {name!r} ({exc!s})', name=name, exc=exc), + mark, + ) + return sys.modules[name] + + def find_python_name(self, name, mark): + # type: (Any, Any) -> Any + if not name: + raise ConstructorError( + 'while constructing a Python object', + mark, + 'expected non-empty name appended to the tag', + mark, + ) + if '.' in name: + lname = name.split('.') + lmodule_name = lname + lobject_name = [] # type: List[Any] + while len(lmodule_name) > 1: + lobject_name.insert(0, lmodule_name.pop()) + module_name = '.'.join(lmodule_name) + try: + __import__(module_name) + # object_name = '.'.join(object_name) + break + except ImportError: + continue + else: + module_name = builtins_module + lobject_name = [name] + try: + __import__(module_name) + except ImportError as exc: + raise ConstructorError( + 'while constructing a Python object', + mark, + _F( + 'cannot find module {module_name!r} ({exc!s})', + module_name=module_name, + exc=exc, + ), + mark, + ) + module = sys.modules[module_name] + object_name = '.'.join(lobject_name) + obj = module + while lobject_name: + if not hasattr(obj, lobject_name[0]): + + raise ConstructorError( + 'while constructing a Python object', + mark, + _F( + 'cannot find {object_name!r} in the module {module_name!r}', + object_name=object_name, + module_name=module.__name__, + ), + mark, + ) + obj = getattr(obj, lobject_name.pop(0)) + return obj + + def construct_python_name(self, suffix, node): + # type: (Any, Any) -> Any + value = self.construct_scalar(node) + if value: + raise ConstructorError( + 'while constructing a Python name', + node.start_mark, + _F('expected the empty value, but found {value!r}', value=value), + node.start_mark, + ) + return self.find_python_name(suffix, node.start_mark) + + def construct_python_module(self, suffix, node): + # type: (Any, Any) -> Any + value = self.construct_scalar(node) + if value: + raise ConstructorError( + 'while constructing a Python module', + node.start_mark, + _F('expected the empty value, but found {value!r}', value=value), + node.start_mark, + ) + return self.find_python_module(suffix, node.start_mark) + + def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False): + # type: (Any, Any, Any, Any, bool) -> Any + if not args: + args = [] + if not kwds: + kwds = {} + cls = self.find_python_name(suffix, node.start_mark) + if newobj and isinstance(cls, type): + return cls.__new__(cls, *args, **kwds) + else: + return cls(*args, **kwds) + + def set_python_instance_state(self, instance, state): + # type: (Any, Any) -> None + if hasattr(instance, '__setstate__'): + instance.__setstate__(state) + else: + slotstate = {} # type: Dict[Any, Any] + if isinstance(state, tuple) and len(state) == 2: + state, slotstate = state + if hasattr(instance, '__dict__'): + instance.__dict__.update(state) + elif state: + slotstate.update(state) + for key, value in slotstate.items(): + setattr(instance, key, value) + + def construct_python_object(self, suffix, node): + # type: (Any, Any) -> Any + # Format: + # !!python/object:module.name { ... state ... } + instance = self.make_python_instance(suffix, node, newobj=True) + self.recursive_objects[node] = instance + yield instance + deep = hasattr(instance, '__setstate__') + state = self.construct_mapping(node, deep=deep) + self.set_python_instance_state(instance, state) + + def construct_python_object_apply(self, suffix, node, newobj=False): + # type: (Any, Any, bool) -> Any + # Format: + # !!python/object/apply # (or !!python/object/new) + # args: [ ... arguments ... ] + # kwds: { ... keywords ... } + # state: ... state ... + # listitems: [ ... listitems ... ] + # dictitems: { ... dictitems ... } + # or short format: + # !!python/object/apply [ ... arguments ... ] + # The difference between !!python/object/apply and !!python/object/new + # is how an object is created, check make_python_instance for details. + if isinstance(node, SequenceNode): + args = self.construct_sequence(node, deep=True) + kwds = {} # type: Dict[Any, Any] + state = {} # type: Dict[Any, Any] + listitems = [] # type: List[Any] + dictitems = {} # type: Dict[Any, Any] + else: + value = self.construct_mapping(node, deep=True) + args = value.get('args', []) + kwds = value.get('kwds', {}) + state = value.get('state', {}) + listitems = value.get('listitems', []) + dictitems = value.get('dictitems', {}) + instance = self.make_python_instance(suffix, node, args, kwds, newobj) + if bool(state): + self.set_python_instance_state(instance, state) + if bool(listitems): + instance.extend(listitems) + if bool(dictitems): + for key in dictitems: + instance[key] = dictitems[key] + return instance + + def construct_python_object_new(self, suffix, node): + # type: (Any, Any) -> Any + return self.construct_python_object_apply(suffix, node, newobj=True) + + +Constructor.add_constructor('tag:yaml.org,2002:python/none', Constructor.construct_yaml_null) + +Constructor.add_constructor('tag:yaml.org,2002:python/bool', Constructor.construct_yaml_bool) + +Constructor.add_constructor('tag:yaml.org,2002:python/str', Constructor.construct_python_str) + +Constructor.add_constructor( + 'tag:yaml.org,2002:python/unicode', Constructor.construct_python_unicode +) + +Constructor.add_constructor( + 'tag:yaml.org,2002:python/bytes', Constructor.construct_python_bytes +) + +Constructor.add_constructor('tag:yaml.org,2002:python/int', Constructor.construct_yaml_int) + +Constructor.add_constructor('tag:yaml.org,2002:python/long', Constructor.construct_python_long) + +Constructor.add_constructor('tag:yaml.org,2002:python/float', Constructor.construct_yaml_float) + +Constructor.add_constructor( + 'tag:yaml.org,2002:python/complex', Constructor.construct_python_complex +) + +Constructor.add_constructor('tag:yaml.org,2002:python/list', Constructor.construct_yaml_seq) + +Constructor.add_constructor( + 'tag:yaml.org,2002:python/tuple', Constructor.construct_python_tuple +) + +Constructor.add_constructor('tag:yaml.org,2002:python/dict', Constructor.construct_yaml_map) + +Constructor.add_multi_constructor( + 'tag:yaml.org,2002:python/name:', Constructor.construct_python_name +) + +Constructor.add_multi_constructor( + 'tag:yaml.org,2002:python/module:', Constructor.construct_python_module +) + +Constructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object:', Constructor.construct_python_object +) + +Constructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object/apply:', Constructor.construct_python_object_apply +) + +Constructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object/new:', Constructor.construct_python_object_new +) + + +class RoundTripConstructor(SafeConstructor): + """need to store the comments on the node itself, + as well as on the items + """ + + def comment(self, idx): + # type: (Any) -> Any + assert self.loader.comment_handling is not None + x = self.scanner.comments[idx] + x.set_assigned() + return x + + def comments(self, list_of_comments, idx=None): + # type: (Any, Optional[Any]) -> Any + # hand in the comment and optional pre, eol, post segment + if list_of_comments is None: + return [] + if idx is not None: + if list_of_comments[idx] is None: + return [] + list_of_comments = list_of_comments[idx] + for x in list_of_comments: + yield self.comment(x) + + def construct_scalar(self, node): + # type: (Any) -> Any + if not isinstance(node, ScalarNode): + raise ConstructorError( + None, + None, + _F('expected a scalar node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + + if node.style == '|' and isinstance(node.value, str): + lss = LiteralScalarString(node.value, anchor=node.anchor) + if self.loader and self.loader.comment_handling is None: + if node.comment and node.comment[1]: + lss.comment = node.comment[1][0] # type: ignore + else: + # NEWCMNT + if node.comment is not None and node.comment[1]: + # nprintf('>>>>nc1', node.comment) + # EOL comment after | + lss.comment = self.comment(node.comment[1][0]) # type: ignore + return lss + if node.style == '>' and isinstance(node.value, str): + fold_positions = [] # type: List[int] + idx = -1 + while True: + idx = node.value.find('\a', idx + 1) + if idx < 0: + break + fold_positions.append(idx - len(fold_positions)) + fss = FoldedScalarString(node.value.replace('\a', ''), anchor=node.anchor) + if self.loader and self.loader.comment_handling is None: + if node.comment and node.comment[1]: + fss.comment = node.comment[1][0] # type: ignore + else: + # NEWCMNT + if node.comment is not None and node.comment[1]: + # nprintf('>>>>nc2', node.comment) + # EOL comment after > + fss.comment = self.comment(node.comment[1][0]) # type: ignore + if fold_positions: + fss.fold_pos = fold_positions # type: ignore + return fss + elif bool(self._preserve_quotes) and isinstance(node.value, str): + if node.style == "'": + return SingleQuotedScalarString(node.value, anchor=node.anchor) + if node.style == '"': + return DoubleQuotedScalarString(node.value, anchor=node.anchor) + if node.anchor: + return PlainScalarString(node.value, anchor=node.anchor) + return node.value + + def construct_yaml_int(self, node): + # type: (Any) -> Any + width = None # type: Any + value_su = self.construct_scalar(node) + try: + sx = value_su.rstrip('_') + underscore = [len(sx) - sx.rindex('_') - 1, False, False] # type: Any + except ValueError: + underscore = None + except IndexError: + underscore = None + value_s = value_su.replace('_', "") + sign = +1 + if value_s[0] == '-': + sign = -1 + if value_s[0] in '+-': + value_s = value_s[1:] + if value_s == '0': + return 0 + elif value_s.startswith('0b'): + if self.resolver.processing_version > (1, 1) and value_s[2] == '0': + width = len(value_s[2:]) + if underscore is not None: + underscore[1] = value_su[2] == '_' + underscore[2] = len(value_su[2:]) > 1 and value_su[-1] == '_' + return BinaryInt( + sign * int(value_s[2:], 2), + width=width, + underscore=underscore, + anchor=node.anchor, + ) + elif value_s.startswith('0x'): + # default to lower-case if no a-fA-F in string + if self.resolver.processing_version > (1, 1) and value_s[2] == '0': + width = len(value_s[2:]) + hex_fun = HexInt # type: Any + for ch in value_s[2:]: + if ch in 'ABCDEF': # first non-digit is capital + hex_fun = HexCapsInt + break + if ch in 'abcdef': + break + if underscore is not None: + underscore[1] = value_su[2] == '_' + underscore[2] = len(value_su[2:]) > 1 and value_su[-1] == '_' + return hex_fun( + sign * int(value_s[2:], 16), + width=width, + underscore=underscore, + anchor=node.anchor, + ) + elif value_s.startswith('0o'): + if self.resolver.processing_version > (1, 1) and value_s[2] == '0': + width = len(value_s[2:]) + if underscore is not None: + underscore[1] = value_su[2] == '_' + underscore[2] = len(value_su[2:]) > 1 and value_su[-1] == '_' + return OctalInt( + sign * int(value_s[2:], 8), + width=width, + underscore=underscore, + anchor=node.anchor, + ) + elif self.resolver.processing_version != (1, 2) and value_s[0] == '0': + return sign * int(value_s, 8) + elif self.resolver.processing_version != (1, 2) and ':' in value_s: + digits = [int(part) for part in value_s.split(':')] + digits.reverse() + base = 1 + value = 0 + for digit in digits: + value += digit * base + base *= 60 + return sign * value + elif self.resolver.processing_version > (1, 1) and value_s[0] == '0': + # not an octal, an integer with leading zero(s) + if underscore is not None: + # cannot have a leading underscore + underscore[2] = len(value_su) > 1 and value_su[-1] == '_' + return ScalarInt(sign * int(value_s), width=len(value_s), underscore=underscore) + elif underscore: + # cannot have a leading underscore + underscore[2] = len(value_su) > 1 and value_su[-1] == '_' + return ScalarInt( + sign * int(value_s), width=None, underscore=underscore, anchor=node.anchor + ) + elif node.anchor: + return ScalarInt(sign * int(value_s), width=None, anchor=node.anchor) + else: + return sign * int(value_s) + + def construct_yaml_float(self, node): + # type: (Any) -> Any + def leading_zeros(v): + # type: (Any) -> int + lead0 = 0 + idx = 0 + while idx < len(v) and v[idx] in '0.': + if v[idx] == '0': + lead0 += 1 + idx += 1 + return lead0 + + # underscore = None + m_sign = False # type: Any + value_so = self.construct_scalar(node) + value_s = value_so.replace('_', "").lower() + sign = +1 + if value_s[0] == '-': + sign = -1 + if value_s[0] in '+-': + m_sign = value_s[0] + value_s = value_s[1:] + if value_s == '.inf': + return sign * self.inf_value + if value_s == '.nan': + return self.nan_value + if self.resolver.processing_version != (1, 2) and ':' in value_s: + digits = [float(part) for part in value_s.split(':')] + digits.reverse() + base = 1 + value = 0.0 + for digit in digits: + value += digit * base + base *= 60 + return sign * value + if 'e' in value_s: + try: + mantissa, exponent = value_so.split('e') + exp = 'e' + except ValueError: + mantissa, exponent = value_so.split('E') + exp = 'E' + if self.resolver.processing_version != (1, 2): + # value_s is lower case independent of input + if '.' not in mantissa: + warnings.warn(MantissaNoDotYAML1_1Warning(node, value_so)) + lead0 = leading_zeros(mantissa) + width = len(mantissa) + prec = mantissa.find('.') + if m_sign: + width -= 1 + e_width = len(exponent) + e_sign = exponent[0] in '+-' + # nprint('sf', width, prec, m_sign, exp, e_width, e_sign) + return ScalarFloat( + sign * float(value_s), + width=width, + prec=prec, + m_sign=m_sign, + m_lead0=lead0, + exp=exp, + e_width=e_width, + e_sign=e_sign, + anchor=node.anchor, + ) + width = len(value_so) + prec = value_so.index('.') # you can use index, this would not be float without dot + lead0 = leading_zeros(value_so) + return ScalarFloat( + sign * float(value_s), + width=width, + prec=prec, + m_sign=m_sign, + m_lead0=lead0, + anchor=node.anchor, + ) + + def construct_yaml_str(self, node): + # type: (Any) -> Any + value = self.construct_scalar(node) + if isinstance(value, ScalarString): + return value + return value + + def construct_rt_sequence(self, node, seqtyp, deep=False): + # type: (Any, Any, bool) -> Any + if not isinstance(node, SequenceNode): + raise ConstructorError( + None, + None, + _F('expected a sequence node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + ret_val = [] + if self.loader and self.loader.comment_handling is None: + if node.comment: + seqtyp._yaml_add_comment(node.comment[:2]) + if len(node.comment) > 2: + # this happens e.g. if you have a sequence element that is a flow-style + # mapping and that has no EOL comment but a following commentline or + # empty line + seqtyp.yaml_end_comment_extend(node.comment[2], clear=True) + else: + # NEWCMNT + if node.comment: + nprintf('nc3', node.comment) + if node.anchor: + from ruamel.yaml.serializer import templated_id + + if not templated_id(node.anchor): + seqtyp.yaml_set_anchor(node.anchor) + for idx, child in enumerate(node.value): + if child.comment: + seqtyp._yaml_add_comment(child.comment, key=idx) + child.comment = None # if moved to sequence remove from child + ret_val.append(self.construct_object(child, deep=deep)) + seqtyp._yaml_set_idx_line_col( + idx, [child.start_mark.line, child.start_mark.column] + ) + return ret_val + + def flatten_mapping(self, node): + # type: (Any) -> Any + """ + This implements the merge key feature http://yaml.org/type/merge.html + by inserting keys from the merge dict/list of dicts if not yet + available in this node + """ + + def constructed(value_node): + # type: (Any) -> Any + # If the contents of a merge are defined within the + # merge marker, then they won't have been constructed + # yet. But if they were already constructed, we need to use + # the existing object. + if value_node in self.constructed_objects: + value = self.constructed_objects[value_node] + else: + value = self.construct_object(value_node, deep=False) + return value + + # merge = [] + merge_map_list = [] # type: List[Any] + index = 0 + while index < len(node.value): + key_node, value_node = node.value[index] + if key_node.tag == 'tag:yaml.org,2002:merge': + if merge_map_list: # double << key + if self.allow_duplicate_keys: + del node.value[index] + index += 1 + continue + args = [ + 'while constructing a mapping', + node.start_mark, + 'found duplicate key "{}"'.format(key_node.value), + key_node.start_mark, + """ + To suppress this check see: + http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys + """, + """\ + Duplicate keys will become an error in future releases, and are errors + by default when using the new API. + """, + ] + if self.allow_duplicate_keys is None: + warnings.warn(DuplicateKeyFutureWarning(*args)) + else: + raise DuplicateKeyError(*args) + del node.value[index] + if isinstance(value_node, MappingNode): + merge_map_list.append((index, constructed(value_node))) + # self.flatten_mapping(value_node) + # merge.extend(value_node.value) + elif isinstance(value_node, SequenceNode): + # submerge = [] + for subnode in value_node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError( + 'while constructing a mapping', + node.start_mark, + _F( + 'expected a mapping for merging, but found {subnode_id!s}', + subnode_id=subnode.id, + ), + subnode.start_mark, + ) + merge_map_list.append((index, constructed(subnode))) + # self.flatten_mapping(subnode) + # submerge.append(subnode.value) + # submerge.reverse() + # for value in submerge: + # merge.extend(value) + else: + raise ConstructorError( + 'while constructing a mapping', + node.start_mark, + _F( + 'expected a mapping or list of mappings for merging, ' + 'but found {value_node_id!s}', + value_node_id=value_node.id, + ), + value_node.start_mark, + ) + elif key_node.tag == 'tag:yaml.org,2002:value': + key_node.tag = 'tag:yaml.org,2002:str' + index += 1 + else: + index += 1 + return merge_map_list + # if merge: + # node.value = merge + node.value + + def _sentinel(self): + # type: () -> None + pass + + def construct_mapping(self, node, maptyp, deep=False): # type: ignore + # type: (Any, Any, bool) -> Any + if not isinstance(node, MappingNode): + raise ConstructorError( + None, + None, + _F('expected a mapping node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + merge_map = self.flatten_mapping(node) + # mapping = {} + if self.loader and self.loader.comment_handling is None: + if node.comment: + maptyp._yaml_add_comment(node.comment[:2]) + if len(node.comment) > 2: + maptyp.yaml_end_comment_extend(node.comment[2], clear=True) + else: + # NEWCMNT + if node.comment: + # nprintf('nc4', node.comment, node.start_mark) + if maptyp.ca.pre is None: + maptyp.ca.pre = [] + for cmnt in self.comments(node.comment, 0): + maptyp.ca.pre.append(cmnt) + if node.anchor: + from ruamel.yaml.serializer import templated_id + + if not templated_id(node.anchor): + maptyp.yaml_set_anchor(node.anchor) + last_key, last_value = None, self._sentinel + for key_node, value_node in node.value: + # keys can be list -> deep + key = self.construct_object(key_node, deep=True) + # lists are not hashable, but tuples are + if not isinstance(key, Hashable): + if isinstance(key, MutableSequence): + key_s = CommentedKeySeq(key) + if key_node.flow_style is True: + key_s.fa.set_flow_style() + elif key_node.flow_style is False: + key_s.fa.set_block_style() + key = key_s + elif isinstance(key, MutableMapping): + key_m = CommentedKeyMap(key) + if key_node.flow_style is True: + key_m.fa.set_flow_style() + elif key_node.flow_style is False: + key_m.fa.set_block_style() + key = key_m + if not isinstance(key, Hashable): + raise ConstructorError( + 'while constructing a mapping', + node.start_mark, + 'found unhashable key', + key_node.start_mark, + ) + value = self.construct_object(value_node, deep=deep) + if self.check_mapping_key(node, key_node, maptyp, key, value): + if self.loader and self.loader.comment_handling is None: + if key_node.comment and len(key_node.comment) > 4 and key_node.comment[4]: + if last_value is None: + key_node.comment[0] = key_node.comment.pop(4) + maptyp._yaml_add_comment(key_node.comment, value=last_key) + else: + key_node.comment[2] = key_node.comment.pop(4) + maptyp._yaml_add_comment(key_node.comment, key=key) + key_node.comment = None + if key_node.comment: + maptyp._yaml_add_comment(key_node.comment, key=key) + if value_node.comment: + maptyp._yaml_add_comment(value_node.comment, value=key) + else: + # NEWCMNT + if key_node.comment: + nprintf('nc5a', key, key_node.comment) + if key_node.comment[0]: + maptyp.ca.set(key, C_KEY_PRE, key_node.comment[0]) + if key_node.comment[1]: + maptyp.ca.set(key, C_KEY_EOL, key_node.comment[1]) + if key_node.comment[2]: + maptyp.ca.set(key, C_KEY_POST, key_node.comment[2]) + if value_node.comment: + nprintf('nc5b', key, value_node.comment) + if value_node.comment[0]: + maptyp.ca.set(key, C_VALUE_PRE, value_node.comment[0]) + if value_node.comment[1]: + maptyp.ca.set(key, C_VALUE_EOL, value_node.comment[1]) + if value_node.comment[2]: + maptyp.ca.set(key, C_VALUE_POST, value_node.comment[2]) + maptyp._yaml_set_kv_line_col( + key, + [ + key_node.start_mark.line, + key_node.start_mark.column, + value_node.start_mark.line, + value_node.start_mark.column, + ], + ) + maptyp[key] = value + last_key, last_value = key, value # could use indexing + # do this last, or <<: before a key will prevent insertion in instances + # of collections.OrderedDict (as they have no __contains__ + if merge_map: + maptyp.add_yaml_merge(merge_map) + + def construct_setting(self, node, typ, deep=False): + # type: (Any, Any, bool) -> Any + if not isinstance(node, MappingNode): + raise ConstructorError( + None, + None, + _F('expected a mapping node, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + if self.loader and self.loader.comment_handling is None: + if node.comment: + typ._yaml_add_comment(node.comment[:2]) + if len(node.comment) > 2: + typ.yaml_end_comment_extend(node.comment[2], clear=True) + else: + # NEWCMNT + if node.comment: + nprintf('nc6', node.comment) + if node.anchor: + from ruamel.yaml.serializer import templated_id + + if not templated_id(node.anchor): + typ.yaml_set_anchor(node.anchor) + for key_node, value_node in node.value: + # keys can be list -> deep + key = self.construct_object(key_node, deep=True) + # lists are not hashable, but tuples are + if not isinstance(key, Hashable): + if isinstance(key, list): + key = tuple(key) + if not isinstance(key, Hashable): + raise ConstructorError( + 'while constructing a mapping', + node.start_mark, + 'found unhashable key', + key_node.start_mark, + ) + # construct but should be null + value = self.construct_object(value_node, deep=deep) # NOQA + self.check_set_key(node, key_node, typ, key) + if self.loader and self.loader.comment_handling is None: + if key_node.comment: + typ._yaml_add_comment(key_node.comment, key=key) + if value_node.comment: + typ._yaml_add_comment(value_node.comment, value=key) + else: + # NEWCMNT + if key_node.comment: + nprintf('nc7a', key_node.comment) + if value_node.comment: + nprintf('nc7b', value_node.comment) + typ.add(key) + + def construct_yaml_seq(self, node): + # type: (Any) -> Any + data = CommentedSeq() + data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) + # if node.comment: + # data._yaml_add_comment(node.comment) + yield data + data.extend(self.construct_rt_sequence(node, data)) + self.set_collection_style(data, node) + + def construct_yaml_map(self, node): + # type: (Any) -> Any + data = CommentedMap() + data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) + yield data + self.construct_mapping(node, data, deep=True) + self.set_collection_style(data, node) + + def set_collection_style(self, data, node): + # type: (Any, Any) -> None + if len(data) == 0: + return + if node.flow_style is True: + data.fa.set_flow_style() + elif node.flow_style is False: + data.fa.set_block_style() + + def construct_yaml_object(self, node, cls): + # type: (Any, Any) -> Any + data = cls.__new__(cls) + yield data + if hasattr(data, '__setstate__'): + state = SafeConstructor.construct_mapping(self, node, deep=True) + data.__setstate__(state) + else: + state = SafeConstructor.construct_mapping(self, node) + if hasattr(data, '__attrs_attrs__'): # issue 394 + data.__init__(**state) + else: + data.__dict__.update(state) + if node.anchor: + from ruamel.yaml.serializer import templated_id + from ruamel.yaml.anchor import Anchor + + if not templated_id(node.anchor): + if not hasattr(data, Anchor.attrib): + a = Anchor() + setattr(data, Anchor.attrib, a) + else: + a = getattr(data, Anchor.attrib) + a.value = node.anchor + + def construct_yaml_omap(self, node): + # type: (Any) -> Any + # Note: we do now check for duplicate keys + omap = CommentedOrderedMap() + omap._yaml_set_line_col(node.start_mark.line, node.start_mark.column) + if node.flow_style is True: + omap.fa.set_flow_style() + elif node.flow_style is False: + omap.fa.set_block_style() + yield omap + if self.loader and self.loader.comment_handling is None: + if node.comment: + omap._yaml_add_comment(node.comment[:2]) + if len(node.comment) > 2: + omap.yaml_end_comment_extend(node.comment[2], clear=True) + else: + # NEWCMNT + if node.comment: + nprintf('nc8', node.comment) + if not isinstance(node, SequenceNode): + raise ConstructorError( + 'while constructing an ordered map', + node.start_mark, + _F('expected a sequence, but found {node_id!s}', node_id=node.id), + node.start_mark, + ) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError( + 'while constructing an ordered map', + node.start_mark, + _F( + 'expected a mapping of length 1, but found {subnode_id!s}', + subnode_id=subnode.id, + ), + subnode.start_mark, + ) + if len(subnode.value) != 1: + raise ConstructorError( + 'while constructing an ordered map', + node.start_mark, + _F( + 'expected a single mapping item, but found {len_subnode_val:d} items', + len_subnode_val=len(subnode.value), + ), + subnode.start_mark, + ) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + assert key not in omap + value = self.construct_object(value_node) + if self.loader and self.loader.comment_handling is None: + if key_node.comment: + omap._yaml_add_comment(key_node.comment, key=key) + if subnode.comment: + omap._yaml_add_comment(subnode.comment, key=key) + if value_node.comment: + omap._yaml_add_comment(value_node.comment, value=key) + else: + # NEWCMNT + if key_node.comment: + nprintf('nc9a', key_node.comment) + if subnode.comment: + nprintf('nc9b', subnode.comment) + if value_node.comment: + nprintf('nc9c', value_node.comment) + omap[key] = value + + def construct_yaml_set(self, node): + # type: (Any) -> Any + data = CommentedSet() + data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) + yield data + self.construct_setting(node, data) + + def construct_undefined(self, node): + # type: (Any) -> Any + try: + if isinstance(node, MappingNode): + data = CommentedMap() + data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) + if node.flow_style is True: + data.fa.set_flow_style() + elif node.flow_style is False: + data.fa.set_block_style() + data.yaml_set_tag(node.tag) + yield data + if node.anchor: + from ruamel.yaml.serializer import templated_id + + if not templated_id(node.anchor): + data.yaml_set_anchor(node.anchor) + self.construct_mapping(node, data) + return + elif isinstance(node, ScalarNode): + data2 = TaggedScalar() + data2.value = self.construct_scalar(node) + data2.style = node.style + data2.yaml_set_tag(node.tag) + yield data2 + if node.anchor: + from ruamel.yaml.serializer import templated_id + + if not templated_id(node.anchor): + data2.yaml_set_anchor(node.anchor, always_dump=True) + return + elif isinstance(node, SequenceNode): + data3 = CommentedSeq() + data3._yaml_set_line_col(node.start_mark.line, node.start_mark.column) + if node.flow_style is True: + data3.fa.set_flow_style() + elif node.flow_style is False: + data3.fa.set_block_style() + data3.yaml_set_tag(node.tag) + yield data3 + if node.anchor: + from ruamel.yaml.serializer import templated_id + + if not templated_id(node.anchor): + data3.yaml_set_anchor(node.anchor) + data3.extend(self.construct_sequence(node)) + return + except: # NOQA + pass + raise ConstructorError( + None, + None, + _F( + 'could not determine a constructor for the tag {node_tag!r}', node_tag=node.tag + ), + node.start_mark, + ) + + def construct_yaml_timestamp(self, node, values=None): + # type: (Any, Any) -> Any + try: + match = self.timestamp_regexp.match(node.value) + except TypeError: + match = None + if match is None: + raise ConstructorError( + None, + None, + 'failed to construct timestamp from "{}"'.format(node.value), + node.start_mark, + ) + values = match.groupdict() + if not values['hour']: + return create_timestamp(**values) + # return SafeConstructor.construct_yaml_timestamp(self, node, values) + for part in ['t', 'tz_sign', 'tz_hour', 'tz_minute']: + if values[part]: + break + else: + return create_timestamp(**values) + # return SafeConstructor.construct_yaml_timestamp(self, node, values) + dd = create_timestamp(**values) # this has delta applied + delta = None + if values['tz_sign']: + tz_hour = int(values['tz_hour']) + minutes = values['tz_minute'] + tz_minute = int(minutes) if minutes else 0 + delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) + if values['tz_sign'] == '-': + delta = -delta + # should check for None and solve issue 366 should be tzinfo=delta) + data = TimeStamp( + dd.year, dd.month, dd.day, dd.hour, dd.minute, dd.second, dd.microsecond + ) + if delta: + data._yaml['delta'] = delta + tz = values['tz_sign'] + values['tz_hour'] + if values['tz_minute']: + tz += ':' + values['tz_minute'] + data._yaml['tz'] = tz + else: + if values['tz']: # no delta + data._yaml['tz'] = values['tz'] + + if values['t']: + data._yaml['t'] = True + return data + + def construct_yaml_bool(self, node): + # type: (Any) -> Any + b = SafeConstructor.construct_yaml_bool(self, node) + if node.anchor: + return ScalarBoolean(b, anchor=node.anchor) + return b + + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:null', RoundTripConstructor.construct_yaml_null +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:bool', RoundTripConstructor.construct_yaml_bool +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:int', RoundTripConstructor.construct_yaml_int +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:float', RoundTripConstructor.construct_yaml_float +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:binary', RoundTripConstructor.construct_yaml_binary +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:timestamp', RoundTripConstructor.construct_yaml_timestamp +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:omap', RoundTripConstructor.construct_yaml_omap +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:pairs', RoundTripConstructor.construct_yaml_pairs +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:set', RoundTripConstructor.construct_yaml_set +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:str', RoundTripConstructor.construct_yaml_str +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:seq', RoundTripConstructor.construct_yaml_seq +) + +RoundTripConstructor.add_constructor( + 'tag:yaml.org,2002:map', RoundTripConstructor.construct_yaml_map +) + +RoundTripConstructor.add_constructor(None, RoundTripConstructor.construct_undefined) diff --git a/shared/package-files/43/432c8f3f76370e8dc77cbb441ce61d2d42901c15d7f52d231dde6e26f042fc28/blob b/shared/package-files/43/432c8f3f76370e8dc77cbb441ce61d2d42901c15d7f52d231dde6e26f042fc28/blob new file mode 100644 index 0000000000000000000000000000000000000000..97ef38184c76c52c142e55fe0107aa8dea2c8eb4 Binary files /dev/null and b/shared/package-files/43/432c8f3f76370e8dc77cbb441ce61d2d42901c15d7f52d231dde6e26f042fc28/blob differ diff --git a/shared/package-files/43/432d1f2df98a3f5d33db80534f27fc35244805a529f58f4297c1d12ad68b5930/blob b/shared/package-files/43/432d1f2df98a3f5d33db80534f27fc35244805a529f58f4297c1d12ad68b5930/blob new file mode 100644 index 0000000000000000000000000000000000000000..fd3b8952b4bbb3d8c7d173f1ce81e22da07b0f99 --- /dev/null +++ b/shared/package-files/43/432d1f2df98a3f5d33db80534f27fc35244805a529f58f4297c1d12ad68b5930/blob @@ -0,0 +1,89 @@ +from numba import jit +import unittest +import numpy as np +import copy +from numba.tests.support import MemoryLeakMixin + + +class TestChainedAssign(MemoryLeakMixin, unittest.TestCase): + def test_chain1(self): + from numba.tests.chained_assign_usecases import chain1 + args = [ + [np.arange(2)], + [np.arange(4, dtype=np.double)], + ] + self._test_template(chain1, args) + + def test_chain2(self): + from numba.tests.chained_assign_usecases import chain2 + args = [ + [3], + [3.0], + ] + self._test_template(chain2, args) + + def test_unpack1(self): + from numba.tests.chained_assign_usecases import unpack1 + args = [ + [1, 3.0], + [1.0, 3], + ] + self._test_template(unpack1, args) + + def test_unpack2(self): + from numba.tests.chained_assign_usecases import unpack2 + args = [ + [np.array([2]), np.array([4.0])], + [np.array([2.0]), np.array([4])], + ] + self._test_template(unpack2, args) + + def test_chain3(self): + from numba.tests.chained_assign_usecases import chain3 + args = [ + [np.array([0]), np.array([1.5])], + [np.array([0.5]), np.array([1])], + ] + self._test_template(chain3, args) + + def test_unpack3(self): + from numba.tests.chained_assign_usecases import unpack3 + args = [ + [np.array([1])], + [np.array([1.0])], + ] + self._test_template(unpack3, args) + + def test_unpack4(self): + from numba.tests.chained_assign_usecases import unpack4 + args = [ + [np.array([1])], + [np.array([1.0])], + ] + self._test_template(unpack4, args) + + def test_unpack5(self): + from numba.tests.chained_assign_usecases import unpack5 + args = [ + [np.array([2])], + [np.array([2.0])], + ] + self._test_template(unpack5, args) + + def test_unpack6(self): + from numba.tests.chained_assign_usecases import unpack6 + args1 = 3.0, 2 + args2 = 3.0, 2.0 + self._test_template(unpack6, [args1, args2]) + + def _test_template(self, pyfunc, argcases): + cfunc = jit(pyfunc) + for args in argcases: + a1 = copy.deepcopy(args) + a2 = copy.deepcopy(args) + np.testing.assert_allclose(pyfunc(*a1), cfunc(*a2)) + + +if __name__ == '__main__': + unittest.main() + diff --git a/shared/package-files/43/432dfbcfbbfa7758cb38777aef36d1bb6d5d80be859a5d6b4ddee3e0997536c3/blob b/shared/package-files/43/432dfbcfbbfa7758cb38777aef36d1bb6d5d80be859a5d6b4ddee3e0997536c3/blob new file mode 100644 index 0000000000000000000000000000000000000000..11b5a479f3785241a00313a85ead1405b2f673cd --- /dev/null +++ b/shared/package-files/43/432dfbcfbbfa7758cb38777aef36d1bb6d5d80be859a5d6b4ddee3e0997536c3/blob @@ -0,0 +1,380 @@ +import json +import math +from abc import ABC, abstractmethod +from dataclasses import dataclass +from functools import partial +from typing import Callable, List, Tuple + +import torch +import torchaudio +from torchaudio._internal import module_utils +from torchaudio.models import emformer_rnnt_base, RNNT, RNNTBeamSearch + + +__all__ = [] + +_decibel = 2 * 20 * math.log10(torch.iinfo(torch.int16).max) +_gain = pow(10, 0.05 * _decibel) + + +def _piecewise_linear_log(x): + x[x > math.e] = torch.log(x[x > math.e]) + x[x <= math.e] = x[x <= math.e] / math.e + return x + + +class _FunctionalModule(torch.nn.Module): + def __init__(self, functional): + super().__init__() + self.functional = functional + + def forward(self, input): + return self.functional(input) + + +class _GlobalStatsNormalization(torch.nn.Module): + def __init__(self, global_stats_path): + super().__init__() + + with open(global_stats_path) as f: + blob = json.loads(f.read()) + + self.register_buffer("mean", torch.tensor(blob["mean"])) + self.register_buffer("invstddev", torch.tensor(blob["invstddev"])) + + def forward(self, input): + return (input - self.mean) * self.invstddev + + +class _FeatureExtractor(ABC): + @abstractmethod + def __call__(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + """Generates features and length output from the given input tensor. + + Args: + input (torch.Tensor): input tensor. + + Returns: + (torch.Tensor, torch.Tensor): + torch.Tensor: + Features, with shape `(length, *)`. + torch.Tensor: + Length, with shape `(1,)`. + """ + + +class _TokenProcessor(ABC): + @abstractmethod + def __call__(self, tokens: List[int], **kwargs) -> str: + """Decodes given list of tokens to text sequence. + + Args: + tokens (List[int]): list of tokens to decode. + + Returns: + str: + Decoded text sequence. + """ + + +class _ModuleFeatureExtractor(torch.nn.Module, _FeatureExtractor): + """``torch.nn.Module``-based feature extraction pipeline. + + Args: + pipeline (torch.nn.Module): module that implements feature extraction logic. + """ + + def __init__(self, pipeline: torch.nn.Module) -> None: + super().__init__() + self.pipeline = pipeline + + def forward(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + """Generates features and length output from the given input tensor. + + Args: + input (torch.Tensor): input tensor. + + Returns: + (torch.Tensor, torch.Tensor): + torch.Tensor: + Features, with shape `(length, *)`. + torch.Tensor: + Length, with shape `(1,)`. + """ + features = self.pipeline(input) + length = torch.tensor([features.shape[0]]) + return features, length + + +class _SentencePieceTokenProcessor(_TokenProcessor): + """SentencePiece-model-based token processor. + + Args: + sp_model_path (str): path to SentencePiece model. + """ + + def __init__(self, sp_model_path: str) -> None: + if not module_utils.is_module_available("sentencepiece"): + raise RuntimeError("SentencePiece is not available. Please install it.") + + import sentencepiece as spm + + self.sp_model = spm.SentencePieceProcessor(model_file=sp_model_path) + self.post_process_remove_list = { + self.sp_model.unk_id(), + self.sp_model.eos_id(), + self.sp_model.pad_id(), + } + + def __call__(self, tokens: List[int], lstrip: bool = True) -> str: + """Decodes given list of tokens to text sequence. + + Args: + tokens (List[int]): list of tokens to decode. + lstrip (bool, optional): if ``True``, returns text sequence with leading whitespace + removed. (Default: ``True``). + + Returns: + str: + Decoded text sequence. + """ + filtered_hypo_tokens = [ + token_index for token_index in tokens[1:] if token_index not in self.post_process_remove_list + ] + output_string = "".join(self.sp_model.id_to_piece(filtered_hypo_tokens)).replace("\u2581", " ") + + if lstrip: + return output_string.lstrip() + else: + return output_string + + +@dataclass +class RNNTBundle: + """Dataclass that bundles components for performing automatic speech recognition (ASR, speech-to-text) + inference with an RNN-T model. + + More specifically, the class provides methods that produce the featurization pipeline, + decoder wrapping the specified RNN-T model, and output token post-processor that together + constitute a complete end-to-end ASR inference pipeline that produces a text sequence + given a raw waveform. + + It can support non-streaming (full-context) inference as well as streaming inference. + + Users should not directly instantiate objects of this class; rather, users should use the + instances (representing pre-trained models) that exist within the module, + e.g. :data:`torchaudio.pipelines.EMFORMER_RNNT_BASE_LIBRISPEECH`. + + Example + >>> import torchaudio + >>> from torchaudio.pipelines import EMFORMER_RNNT_BASE_LIBRISPEECH + >>> import torch + >>> + >>> # Non-streaming inference. + >>> # Build feature extractor, decoder with RNN-T model, and token processor. + >>> feature_extractor = EMFORMER_RNNT_BASE_LIBRISPEECH.get_feature_extractor() + 100%|███████████████████████████████| 3.81k/3.81k [00:00<00:00, 4.22MB/s] + >>> decoder = EMFORMER_RNNT_BASE_LIBRISPEECH.get_decoder() + Downloading: "https://download.pytorch.org/torchaudio/models/emformer_rnnt_base_librispeech.pt" + 100%|███████████████████████████████| 293M/293M [00:07<00:00, 42.1MB/s] + >>> token_processor = EMFORMER_RNNT_BASE_LIBRISPEECH.get_token_processor() + 100%|███████████████████████████████| 295k/295k [00:00<00:00, 25.4MB/s] + >>> + >>> # Instantiate LibriSpeech dataset; retrieve waveform for first sample. + >>> dataset = torchaudio.datasets.LIBRISPEECH("/home/librispeech", url="test-clean") + >>> waveform = next(iter(dataset))[0].squeeze() + >>> + >>> with torch.no_grad(): + >>> # Produce mel-scale spectrogram features. + >>> features, length = feature_extractor(waveform) + >>> + >>> # Generate top-10 hypotheses. + >>> hypotheses = decoder(features, length, 10) + >>> + >>> # For top hypothesis, convert predicted tokens to text. + >>> text = token_processor(hypotheses[0][0]) + >>> print(text) + he hoped there would be stew for dinner turnips and carrots and bruised potatoes and fat mutton pieces to [...] + >>> + >>> + >>> # Streaming inference. + >>> hop_length = EMFORMER_RNNT_BASE_LIBRISPEECH.hop_length + >>> num_samples_segment = EMFORMER_RNNT_BASE_LIBRISPEECH.segment_length * hop_length + >>> num_samples_segment_right_context = ( + >>> num_samples_segment + EMFORMER_RNNT_BASE_LIBRISPEECH.right_context_length * hop_length + >>> ) + >>> + >>> # Build streaming inference feature extractor. + >>> streaming_feature_extractor = EMFORMER_RNNT_BASE_LIBRISPEECH.get_streaming_feature_extractor() + >>> + >>> # Process same waveform as before, this time sequentially across overlapping segments + >>> # to simulate streaming inference. Note the usage of ``streaming_feature_extractor`` and ``decoder.infer``. + >>> state, hypothesis = None, None + >>> for idx in range(0, len(waveform), num_samples_segment): + >>> segment = waveform[idx: idx + num_samples_segment_right_context] + >>> segment = torch.nn.functional.pad(segment, (0, num_samples_segment_right_context - len(segment))) + >>> with torch.no_grad(): + >>> features, length = streaming_feature_extractor(segment) + >>> hypotheses, state = decoder.infer(features, length, 10, state=state, hypothesis=hypothesis) + >>> hypothesis = hypotheses[0] + >>> transcript = token_processor(hypothesis[0]) + >>> if transcript: + >>> print(transcript, end=" ", flush=True) + he hoped there would be stew for dinner turn ips and car rots and bru 'd oes and fat mut ton pieces to [...] + """ + + class FeatureExtractor(_FeatureExtractor): + """Interface of the feature extraction part of RNN-T pipeline""" + + class TokenProcessor(_TokenProcessor): + """Interface of the token processor part of RNN-T pipeline""" + + _rnnt_path: str + _rnnt_factory_func: Callable[[], RNNT] + _global_stats_path: str + _sp_model_path: str + _right_padding: int + _blank: int + _sample_rate: int + _n_fft: int + _n_mels: int + _hop_length: int + _segment_length: int + _right_context_length: int + + def _get_model(self) -> RNNT: + model = self._rnnt_factory_func() + path = torchaudio.utils.download_asset(self._rnnt_path) + state_dict = torch.load(path) + model.load_state_dict(state_dict) + model.eval() + return model + + @property + def sample_rate(self) -> int: + """Sample rate (in cycles per second) of input waveforms. + + :type: int + """ + return self._sample_rate + + @property + def n_fft(self) -> int: + """Size of FFT window to use. + + :type: int + """ + return self._n_fft + + @property + def n_mels(self) -> int: + """Number of mel spectrogram features to extract from input waveforms. + + :type: int + """ + return self._n_mels + + @property + def hop_length(self) -> int: + """Number of samples between successive frames in input expected by model. + + :type: int + """ + return self._hop_length + + @property + def segment_length(self) -> int: + """Number of frames in segment in input expected by model. + + :type: int + """ + return self._segment_length + + @property + def right_context_length(self) -> int: + """Number of frames in right contextual block in input expected by model. + + :type: int + """ + return self._right_context_length + + def get_decoder(self) -> RNNTBeamSearch: + """Constructs RNN-T decoder. + + Returns: + RNNTBeamSearch + """ + model = self._get_model() + return RNNTBeamSearch(model, self._blank) + + def get_feature_extractor(self) -> FeatureExtractor: + """Constructs feature extractor for non-streaming (full-context) ASR. + + Returns: + FeatureExtractor + """ + local_path = torchaudio.utils.download_asset(self._global_stats_path) + return _ModuleFeatureExtractor( + torch.nn.Sequential( + torchaudio.transforms.MelSpectrogram( + sample_rate=self.sample_rate, n_fft=self.n_fft, n_mels=self.n_mels, hop_length=self.hop_length + ), + _FunctionalModule(lambda x: x.transpose(1, 0)), + _FunctionalModule(lambda x: _piecewise_linear_log(x * _gain)), + _GlobalStatsNormalization(local_path), + _FunctionalModule(lambda x: torch.nn.functional.pad(x, (0, 0, 0, self._right_padding))), + ) + ) + + def get_streaming_feature_extractor(self) -> FeatureExtractor: + """Constructs feature extractor for streaming (simultaneous) ASR. + + Returns: + FeatureExtractor + """ + local_path = torchaudio.utils.download_asset(self._global_stats_path) + return _ModuleFeatureExtractor( + torch.nn.Sequential( + torchaudio.transforms.MelSpectrogram( + sample_rate=self.sample_rate, n_fft=self.n_fft, n_mels=self.n_mels, hop_length=self.hop_length + ), + _FunctionalModule(lambda x: x.transpose(1, 0)), + _FunctionalModule(lambda x: _piecewise_linear_log(x * _gain)), + _GlobalStatsNormalization(local_path), + ) + ) + + def get_token_processor(self) -> TokenProcessor: + """Constructs token processor. + + Returns: + TokenProcessor + """ + local_path = torchaudio.utils.download_asset(self._sp_model_path) + return _SentencePieceTokenProcessor(local_path) + + +EMFORMER_RNNT_BASE_LIBRISPEECH = RNNTBundle( + _rnnt_path="models/emformer_rnnt_base_librispeech.pt", + _rnnt_factory_func=partial(emformer_rnnt_base, num_symbols=4097), + _global_stats_path="pipeline-assets/global_stats_rnnt_librispeech.json", + _sp_model_path="pipeline-assets/spm_bpe_4096_librispeech.model", + _right_padding=4, + _blank=4096, + _sample_rate=16000, + _n_fft=400, + _n_mels=80, + _hop_length=160, + _segment_length=16, + _right_context_length=4, +) +EMFORMER_RNNT_BASE_LIBRISPEECH.__doc__ = """ASR pipeline based on Emformer-RNNT, +pretrained on *LibriSpeech* dataset :cite:`7178964`, +capable of performing both streaming and non-streaming inference. + +The underlying model is constructed by :py:func:`torchaudio.models.emformer_rnnt_base` +and utilizes weights trained on LibriSpeech using training script ``train.py`` +`here `__ with default arguments. + +Please refer to :py:class:`RNNTBundle` for usage instructions. +""" diff --git a/shared/package-files/43/43306f7300abebb050136b978957142a7bdb7645decc24d82477c36b65c37b53/blob b/shared/package-files/43/43306f7300abebb050136b978957142a7bdb7645decc24d82477c36b65c37b53/blob new file mode 100644 index 0000000000000000000000000000000000000000..9c40758f8cffb7532dc9260f5ebe30ad9c78f96b --- /dev/null +++ b/shared/package-files/43/43306f7300abebb050136b978957142a7bdb7645decc24d82477c36b65c37b53/blob @@ -0,0 +1,265 @@ +"""Algorithms for finding the lowest common ancestor of trees and DAGs.""" +from collections import defaultdict +from collections.abc import Mapping, Set +from itertools import combinations_with_replacement + +import networkx as nx +from networkx.utils import UnionFind, arbitrary_element, not_implemented_for + +__all__ = [ + "all_pairs_lowest_common_ancestor", + "tree_all_pairs_lowest_common_ancestor", + "lowest_common_ancestor", +] + + +@not_implemented_for("undirected") +def all_pairs_lowest_common_ancestor(G, pairs=None): + """Return the lowest common ancestor of all pairs or the provided pairs + + Parameters + ---------- + G : NetworkX directed graph + + pairs : iterable of pairs of nodes, optional (default: all pairs) + The pairs of nodes of interest. + If None, will find the LCA of all pairs of nodes. + + Yields + ------ + ((node1, node2), lca) : 2-tuple + Where lca is least common ancestor of node1 and node2. + Note that for the default case, the order of the node pair is not considered, + e.g. you will not get both ``(a, b)`` and ``(b, a)`` + + Raises + ------ + NetworkXPointlessConcept + If `G` is null. + NetworkXError + If `G` is not a DAG. + + Examples + -------- + The default behavior is to yield the lowest common ancestor for all + possible combinations of nodes in `G`, including self-pairings: + + >>> G = nx.DiGraph([(0, 1), (0, 3), (1, 2)]) + >>> dict(nx.all_pairs_lowest_common_ancestor(G)) + {(0, 0): 0, (0, 1): 0, (0, 3): 0, (0, 2): 0, (1, 1): 1, (1, 3): 0, (1, 2): 1, (3, 3): 3, (3, 2): 0, (2, 2): 2} + + The pairs argument can be used to limit the output to only the + specified node pairings: + + >>> dict(nx.all_pairs_lowest_common_ancestor(G, pairs=[(1, 2), (2, 3)])) + {(1, 2): 1, (2, 3): 0} + + Notes + ----- + Only defined on non-null directed acyclic graphs. + + See Also + -------- + lowest_common_ancestor + """ + if not nx.is_directed_acyclic_graph(G): + raise nx.NetworkXError("LCA only defined on directed acyclic graphs.") + if len(G) == 0: + raise nx.NetworkXPointlessConcept("LCA meaningless on null graphs.") + + if pairs is None: + pairs = combinations_with_replacement(G, 2) + else: + # Convert iterator to iterable, if necessary. Trim duplicates. + pairs = dict.fromkeys(pairs) + # Verify that each of the nodes in the provided pairs is in G + nodeset = set(G) + for pair in pairs: + if set(pair) - nodeset: + raise nx.NodeNotFound( + f"Node(s) {set(pair) - nodeset} from pair {pair} not in G." + ) + + # Once input validation is done, construct the generator + def generate_lca_from_pairs(G, pairs): + ancestor_cache = {} + + for v, w in pairs: + if v not in ancestor_cache: + ancestor_cache[v] = nx.ancestors(G, v) + ancestor_cache[v].add(v) + if w not in ancestor_cache: + ancestor_cache[w] = nx.ancestors(G, w) + ancestor_cache[w].add(w) + + common_ancestors = ancestor_cache[v] & ancestor_cache[w] + + if common_ancestors: + common_ancestor = next(iter(common_ancestors)) + while True: + successor = None + for lower_ancestor in G.successors(common_ancestor): + if lower_ancestor in common_ancestors: + successor = lower_ancestor + break + if successor is None: + break + common_ancestor = successor + yield ((v, w), common_ancestor) + + return generate_lca_from_pairs(G, pairs) + + +@not_implemented_for("undirected") +def lowest_common_ancestor(G, node1, node2, default=None): + """Compute the lowest common ancestor of the given pair of nodes. + + Parameters + ---------- + G : NetworkX directed graph + + node1, node2 : nodes in the graph. + + default : object + Returned if no common ancestor between `node1` and `node2` + + Returns + ------- + The lowest common ancestor of node1 and node2, + or default if they have no common ancestors. + + Examples + -------- + >>> G = nx.DiGraph() + >>> nx.add_path(G, (0, 1, 2, 3)) + >>> nx.add_path(G, (0, 4, 3)) + >>> nx.lowest_common_ancestor(G, 2, 4) + 0 + + See Also + -------- + all_pairs_lowest_common_ancestor""" + + ans = list(all_pairs_lowest_common_ancestor(G, pairs=[(node1, node2)])) + if ans: + assert len(ans) == 1 + return ans[0][1] + return default + + +@not_implemented_for("undirected") +def tree_all_pairs_lowest_common_ancestor(G, root=None, pairs=None): + r"""Yield the lowest common ancestor for sets of pairs in a tree. + + Parameters + ---------- + G : NetworkX directed graph (must be a tree) + + root : node, optional (default: None) + The root of the subtree to operate on. + If None, assume the entire graph has exactly one source and use that. + + pairs : iterable or iterator of pairs of nodes, optional (default: None) + The pairs of interest. If None, Defaults to all pairs of nodes + under `root` that have a lowest common ancestor. + + Returns + ------- + lcas : generator of tuples `((u, v), lca)` where `u` and `v` are nodes + in `pairs` and `lca` is their lowest common ancestor. + + Examples + -------- + >>> import pprint + >>> G = nx.DiGraph([(1, 3), (2, 4), (1, 2)]) + >>> pprint.pprint(dict(nx.tree_all_pairs_lowest_common_ancestor(G))) + {(1, 1): 1, + (2, 1): 1, + (2, 2): 2, + (3, 1): 1, + (3, 2): 1, + (3, 3): 3, + (3, 4): 1, + (4, 1): 1, + (4, 2): 2, + (4, 4): 4} + + We can also use `pairs` argument to specify the pairs of nodes for which we + want to compute lowest common ancestors. Here is an example: + + >>> dict(nx.tree_all_pairs_lowest_common_ancestor(G, pairs=[(1, 4), (2, 3)])) + {(2, 3): 1, (1, 4): 1} + + Notes + ----- + Only defined on non-null trees represented with directed edges from + parents to children. Uses Tarjan's off-line lowest-common-ancestors + algorithm. Runs in time $O(4 \times (V + E + P))$ time, where 4 is the largest + value of the inverse Ackermann function likely to ever come up in actual + use, and $P$ is the number of pairs requested (or $V^2$ if all are needed). + + Tarjan, R. E. (1979), "Applications of path compression on balanced trees", + Journal of the ACM 26 (4): 690-715, doi:10.1145/322154.322161. + + See Also + -------- + all_pairs_lowest_common_ancestor: similar routine for general DAGs + lowest_common_ancestor: just a single pair for general DAGs + """ + if len(G) == 0: + raise nx.NetworkXPointlessConcept("LCA meaningless on null graphs.") + + # Index pairs of interest for efficient lookup from either side. + if pairs is not None: + pair_dict = defaultdict(set) + # See note on all_pairs_lowest_common_ancestor. + if not isinstance(pairs, (Mapping, Set)): + pairs = set(pairs) + for u, v in pairs: + for n in (u, v): + if n not in G: + msg = f"The node {str(n)} is not in the digraph." + raise nx.NodeNotFound(msg) + pair_dict[u].add(v) + pair_dict[v].add(u) + + # If root is not specified, find the exactly one node with in degree 0 and + # use it. Raise an error if none are found, or more than one is. Also check + # for any nodes with in degree larger than 1, which would imply G is not a + # tree. + if root is None: + for n, deg in G.in_degree: + if deg == 0: + if root is not None: + msg = "No root specified and tree has multiple sources." + raise nx.NetworkXError(msg) + root = n + # checking deg>1 is not sufficient for MultiDiGraphs + elif deg > 1 and len(G.pred[n]) > 1: + msg = "Tree LCA only defined on trees; use DAG routine." + raise nx.NetworkXError(msg) + if root is None: + raise nx.NetworkXError("Graph contains a cycle.") + + # Iterative implementation of Tarjan's offline lca algorithm + # as described in CLRS on page 521 (2nd edition)/page 584 (3rd edition) + uf = UnionFind() + ancestors = {} + for node in G: + ancestors[node] = uf[node] + + colors = defaultdict(bool) + for node in nx.dfs_postorder_nodes(G, root): + colors[node] = True + for v in pair_dict[node] if pairs is not None else G: + if colors[v]: + # If the user requested both directions of a pair, give it. + # Otherwise, just give one. + if pairs is not None and (node, v) in pairs: + yield (node, v), ancestors[uf[v]] + if pairs is None or (v, node) in pairs: + yield (v, node), ancestors[uf[v]] + if node != root: + parent = arbitrary_element(G.pred[node]) + uf.union(parent, node) + ancestors[uf[parent]] = parent diff --git a/shared/package-files/43/4332091478c51b69dc229a09ec218ccc9e87b9d56a07644da76c811c18e44b3f/blob b/shared/package-files/43/4332091478c51b69dc229a09ec218ccc9e87b9d56a07644da76c811c18e44b3f/blob new file mode 100644 index 0000000000000000000000000000000000000000..993a8e33fe8aa588f9953970a6f238ad3b7d363b --- /dev/null +++ b/shared/package-files/43/4332091478c51b69dc229a09ec218ccc9e87b9d56a07644da76c811c18e44b3f/blob @@ -0,0 +1,515 @@ +from sympy.core.numbers import igcd, mod_inverse +from sympy.core.power import integer_nthroot +from sympy.ntheory.residue_ntheory import _sqrt_mod_prime_power +from sympy.ntheory import isprime +from math import log, sqrt +import random + +rgen = random.Random() + +class SievePolynomial: + def __init__(self, modified_coeff=(), a=None, b=None): + """This class denotes the seive polynomial. + If ``g(x) = (a*x + b)**2 - N``. `g(x)` can be expanded + to ``a*x**2 + 2*a*b*x + b**2 - N``, so the coefficient + is stored in the form `[a**2, 2*a*b, b**2 - N]`. This + ensures faster `eval` method because we dont have to + perform `a**2, 2*a*b, b**2` every time we call the + `eval` method. As multiplication is more expensive + than addition, by using modified_coefficient we get + a faster seiving process. + + Parameters + ========== + + modified_coeff : modified_coefficient of sieve polynomial + a : parameter of the sieve polynomial + b : parameter of the sieve polynomial + """ + self.modified_coeff = modified_coeff + self.a = a + self.b = b + + def eval(self, x): + """ + Compute the value of the sieve polynomial at point x. + + Parameters + ========== + + x : Integer parameter for sieve polynomial + """ + ans = 0 + for coeff in self.modified_coeff: + ans *= x + ans += coeff + return ans + + +class FactorBaseElem: + """This class stores an element of the `factor_base`. + """ + def __init__(self, prime, tmem_p, log_p): + """ + Initialization of factor_base_elem. + + Parameters + ========== + + prime : prime number of the factor_base + tmem_p : Integer square root of x**2 = n mod prime + log_p : Compute Natural Logarithm of the prime + """ + self.prime = prime + self.tmem_p = tmem_p + self.log_p = log_p + self.soln1 = None + self.soln2 = None + self.a_inv = None + self.b_ainv = None + + +def _generate_factor_base(prime_bound, n): + """Generate `factor_base` for Quadratic Sieve. The `factor_base` + consists of all the points whose ``legendre_symbol(n, p) == 1`` + and ``p < num_primes``. Along with the prime `factor_base` also stores + natural logarithm of prime and the residue n modulo p. + It also returns the of primes numbers in the `factor_base` which are + close to 1000 and 5000. + + Parameters + ========== + + prime_bound : upper prime bound of the factor_base + n : integer to be factored + """ + from sympy.ntheory.generate import sieve + factor_base = [] + idx_1000, idx_5000 = None, None + for prime in sieve.primerange(1, prime_bound): + if pow(n, (prime - 1) // 2, prime) == 1: + if prime > 1000 and idx_1000 is None: + idx_1000 = len(factor_base) - 1 + if prime > 5000 and idx_5000 is None: + idx_5000 = len(factor_base) - 1 + residue = _sqrt_mod_prime_power(n, prime, 1)[0] + log_p = round(log(prime)*2**10) + factor_base.append(FactorBaseElem(prime, residue, log_p)) + return idx_1000, idx_5000, factor_base + + +def _initialize_first_polynomial(N, M, factor_base, idx_1000, idx_5000, seed=None): + """This step is the initialization of the 1st sieve polynomial. + Here `a` is selected as a product of several primes of the factor_base + such that `a` is about to ``sqrt(2*N) / M``. Other initial values of + factor_base elem are also initialized which includes a_inv, b_ainv, soln1, + soln2 which are used when the sieve polynomial is changed. The b_ainv + is required for fast polynomial change as we do not have to calculate + `2*b*mod_inverse(a, prime)` every time. + We also ensure that the `factor_base` primes which make `a` are between + 1000 and 5000. + + Parameters + ========== + + N : Number to be factored + M : sieve interval + factor_base : factor_base primes + idx_1000 : index of prime number in the factor_base near 1000 + idx_5000 : index of prime number in the factor_base near to 5000 + seed : Generate pseudoprime numbers + """ + if seed is not None: + rgen.seed(seed) + approx_val = sqrt(2*N) / M + # `a` is a parameter of the sieve polynomial and `q` is the prime factors of `a` + # randomly search for a combination of primes whose multiplication is close to approx_val + # This multiplication of primes will be `a` and the primes will be `q` + # `best_a` denotes that `a` is close to approx_val in the random search of combination + best_a, best_q, best_ratio = None, None, None + start = 0 if idx_1000 is None else idx_1000 + end = len(factor_base) - 1 if idx_5000 is None else idx_5000 + for _ in range(50): + a = 1 + q = [] + while(a < approx_val): + rand_p = 0 + while(rand_p == 0 or rand_p in q): + rand_p = rgen.randint(start, end) + p = factor_base[rand_p].prime + a *= p + q.append(rand_p) + ratio = a / approx_val + if best_ratio is None or abs(ratio - 1) < abs(best_ratio - 1): + best_q = q + best_a = a + best_ratio = ratio + + a = best_a + q = best_q + + B = [] + for idx, val in enumerate(q): + q_l = factor_base[val].prime + gamma = factor_base[val].tmem_p * mod_inverse(a // q_l, q_l) % q_l + if gamma > q_l / 2: + gamma = q_l - gamma + B.append(a//q_l*gamma) + + b = sum(B) + g = SievePolynomial([a*a, 2*a*b, b*b - N], a, b) + + for fb in factor_base: + if a % fb.prime == 0: + continue + fb.a_inv = mod_inverse(a, fb.prime) + fb.b_ainv = [2*b_elem*fb.a_inv % fb.prime for b_elem in B] + fb.soln1 = (fb.a_inv*(fb.tmem_p - b)) % fb.prime + fb.soln2 = (fb.a_inv*(-fb.tmem_p - b)) % fb.prime + return g, B + + +def _initialize_ith_poly(N, factor_base, i, g, B): + """Initialization stage of ith poly. After we finish sieving 1`st polynomial + here we quickly change to the next polynomial from which we will again + start sieving. Suppose we generated ith sieve polynomial and now we + want to generate (i + 1)th polynomial, where ``1 <= i <= 2**(j - 1) - 1`` + where `j` is the number of prime factors of the coefficient `a` + then this function can be used to go to the next polynomial. If + ``i = 2**(j - 1) - 1`` then go to _initialize_first_polynomial stage. + + Parameters + ========== + + N : number to be factored + factor_base : factor_base primes + i : integer denoting ith polynomial + g : (i - 1)th polynomial + B : array that stores a//q_l*gamma + """ + from sympy.functions.elementary.integers import ceiling + v = 1 + j = i + while(j % 2 == 0): + v += 1 + j //= 2 + if ceiling(i / (2**v)) % 2 == 1: + neg_pow = -1 + else: + neg_pow = 1 + b = g.b + 2*neg_pow*B[v - 1] + a = g.a + g = SievePolynomial([a*a, 2*a*b, b*b - N], a, b) + for fb in factor_base: + if a % fb.prime == 0: + continue + fb.soln1 = (fb.soln1 - neg_pow*fb.b_ainv[v - 1]) % fb.prime + fb.soln2 = (fb.soln2 - neg_pow*fb.b_ainv[v - 1]) % fb.prime + + return g + + +def _gen_sieve_array(M, factor_base): + """Sieve Stage of the Quadratic Sieve. For every prime in the factor_base + that does not divide the coefficient `a` we add log_p over the sieve_array + such that ``-M <= soln1 + i*p <= M`` and ``-M <= soln2 + i*p <= M`` where `i` + is an integer. When p = 2 then log_p is only added using + ``-M <= soln1 + i*p <= M``. + + Parameters + ========== + + M : sieve interval + factor_base : factor_base primes + """ + sieve_array = [0]*(2*M + 1) + for factor in factor_base: + if factor.soln1 is None: #The prime does not divides a + continue + for idx in range((M + factor.soln1) % factor.prime, 2*M, factor.prime): + sieve_array[idx] += factor.log_p + if factor.prime == 2: + continue + #if prime is 2 then sieve only with soln_1_p + for idx in range((M + factor.soln2) % factor.prime, 2*M, factor.prime): + sieve_array[idx] += factor.log_p + return sieve_array + + +def _check_smoothness(num, factor_base): + """Here we check that if `num` is a smooth number or not. If `a` is a smooth + number then it returns a vector of prime exponents modulo 2. For example + if a = 2 * 5**2 * 7**3 and the factor base contains {2, 3, 5, 7} then + `a` is a smooth number and this function returns ([1, 0, 0, 1], True). If + `a` is a partial relation which means that `a` a has one prime factor + greater than the `factor_base` then it returns `(a, False)` which denotes `a` + is a partial relation. + + Parameters + ========== + + a : integer whose smootheness is to be checked + factor_base : factor_base primes + """ + vec = [] + if num < 0: + vec.append(1) + num *= -1 + else: + vec.append(0) + #-1 is not included in factor_base add -1 in vector + for factor in factor_base: + if num % factor.prime != 0: + vec.append(0) + continue + factor_exp = 0 + while num % factor.prime == 0: + factor_exp += 1 + num //= factor.prime + vec.append(factor_exp % 2) + if num == 1: + return vec, True + if isprime(num): + return num, False + return None, None + + +def _trial_division_stage(N, M, factor_base, sieve_array, sieve_poly, partial_relations, ERROR_TERM): + """Trial division stage. Here we trial divide the values generetated + by sieve_poly in the sieve interval and if it is a smooth number then + it is stored in `smooth_relations`. Moreover, if we find two partial relations + with same large prime then they are combined to form a smooth relation. + First we iterate over sieve array and look for values which are greater + than accumulated_val, as these values have a high chance of being smooth + number. Then using these values we find smooth relations. + In general, let ``t**2 = u*p modN`` and ``r**2 = v*p modN`` be two partial relations + with the same large prime p. Then they can be combined ``(t*r/p)**2 = u*v modN`` + to form a smooth relation. + + Parameters + ========== + + N : Number to be factored + M : sieve interval + factor_base : factor_base primes + sieve_array : stores log_p values + sieve_poly : polynomial from which we find smooth relations + partial_relations : stores partial relations with one large prime + ERROR_TERM : error term for accumulated_val + """ + sqrt_n = sqrt(float(N)) + accumulated_val = log(M * sqrt_n)*2**10 - ERROR_TERM + smooth_relations = [] + proper_factor = set() + partial_relation_upper_bound = 128*factor_base[-1].prime + for idx, val in enumerate(sieve_array): + if val < accumulated_val: + continue + x = idx - M + v = sieve_poly.eval(x) + vec, is_smooth = _check_smoothness(v, factor_base) + if is_smooth is None:#Neither smooth nor partial + continue + u = sieve_poly.a*x + sieve_poly.b + # Update the partial relation + # If 2 partial relation with same large prime is found then generate smooth relation + if is_smooth is False:#partial relation found + large_prime = vec + #Consider the large_primes under 128*F + if large_prime > partial_relation_upper_bound: + continue + if large_prime not in partial_relations: + partial_relations[large_prime] = (u, v) + continue + else: + u_prev, v_prev = partial_relations[large_prime] + partial_relations.pop(large_prime) + try: + large_prime_inv = mod_inverse(large_prime, N) + except ValueError:#if large_prine divides N + proper_factor.add(large_prime) + continue + u = u*u_prev*large_prime_inv + v = v*v_prev // (large_prime*large_prime) + vec, is_smooth = _check_smoothness(v, factor_base) + #assert u*u % N == v % N + smooth_relations.append((u, v, vec)) + return smooth_relations, proper_factor + + +#LINEAR ALGEBRA STAGE +def _build_matrix(smooth_relations): + """Build a 2D matrix from smooth relations. + + Parameters + ========== + + smooth_relations : Stores smooth relations + """ + matrix = [] + for s_relation in smooth_relations: + matrix.append(s_relation[2]) + return matrix + + +def _gauss_mod_2(A): + """Fast gaussian reduction for modulo 2 matrix. + + Parameters + ========== + + A : Matrix + + Examples + ======== + + >>> from sympy.ntheory.qs import _gauss_mod_2 + >>> _gauss_mod_2([[0, 1, 1], [1, 0, 1], [0, 1, 0], [1, 1, 1]]) + ([[[1, 0, 1], 3]], + [True, True, True, False], + [[0, 1, 0], [1, 0, 0], [0, 0, 1], [1, 0, 1]]) + + Reference + ========== + + .. [1] A fast algorithm for gaussian elimination over GF(2) and + its implementation on the GAPP. Cetin K.Koc, Sarath N.Arachchige""" + import copy + matrix = copy.deepcopy(A) + row = len(matrix) + col = len(matrix[0]) + mark = [False]*row + for c in range(col): + for r in range(row): + if matrix[r][c] == 1: + break + mark[r] = True + for c1 in range(col): + if c1 == c: + continue + if matrix[r][c1] == 1: + for r2 in range(row): + matrix[r2][c1] = (matrix[r2][c1] + matrix[r2][c]) % 2 + dependent_row = [] + for idx, val in enumerate(mark): + if val == False: + dependent_row.append([matrix[idx], idx]) + return dependent_row, mark, matrix + + +def _find_factor(dependent_rows, mark, gauss_matrix, index, smooth_relations, N): + """Finds proper factor of N. Here, transform the dependent rows as a + combination of independent rows of the gauss_matrix to form the desired + relation of the form ``X**2 = Y**2 modN``. After obtaining the desired relation + we obtain a proper factor of N by `gcd(X - Y, N)`. + + Parameters + ========== + + dependent_rows : denoted dependent rows in the reduced matrix form + mark : boolean array to denoted dependent and independent rows + gauss_matrix : Reduced form of the smooth relations matrix + index : denoted the index of the dependent_rows + smooth_relations : Smooth relations vectors matrix + N : Number to be factored + """ + idx_in_smooth = dependent_rows[index][1] + independent_u = [smooth_relations[idx_in_smooth][0]] + independent_v = [smooth_relations[idx_in_smooth][1]] + dept_row = dependent_rows[index][0] + + for idx, val in enumerate(dept_row): + if val == 1: + for row in range(len(gauss_matrix)): + if gauss_matrix[row][idx] == 1 and mark[row] == True: + independent_u.append(smooth_relations[row][0]) + independent_v.append(smooth_relations[row][1]) + break + + u = 1 + v = 1 + for i in independent_u: + u *= i + for i in independent_v: + v *= i + #assert u**2 % N == v % N + v = integer_nthroot(v, 2)[0] + return igcd(u - v, N) + + +def qs(N, prime_bound, M, ERROR_TERM=25, seed=1234): + """Performs factorization using Self-Initializing Quadratic Sieve. + In SIQS, let N be a number to be factored, and this N should not be a + perfect power. If we find two integers such that ``X**2 = Y**2 modN`` and + ``X != +-Y modN``, then `gcd(X + Y, N)` will reveal a proper factor of N. + In order to find these integers X and Y we try to find relations of form + t**2 = u modN where u is a product of small primes. If we have enough of + these relations then we can form ``(t1*t2...ti)**2 = u1*u2...ui modN`` such that + the right hand side is a square, thus we found a relation of ``X**2 = Y**2 modN``. + + Here, several optimizations are done like using multiple polynomials for + sieving, fast changing between polynomials and using partial relations. + The use of partial relations can speeds up the factoring by 2 times. + + Parameters + ========== + + N : Number to be Factored + prime_bound : upper bound for primes in the factor base + M : Sieve Interval + ERROR_TERM : Error term for checking smoothness + threshold : Extra smooth relations for factorization + seed : generate pseudo prime numbers + + Examples + ======== + + >>> from sympy.ntheory import qs + >>> qs(25645121643901801, 2000, 10000) + {5394769, 4753701529} + >>> qs(9804659461513846513, 2000, 10000) + {4641991, 2112166839943} + + References + ========== + + .. [1] https://pdfs.semanticscholar.org/5c52/8a975c1405bd35c65993abf5a4edb667c1db.pdf + .. [2] https://www.rieselprime.de/ziki/Self-initializing_quadratic_sieve + """ + ERROR_TERM*=2**10 + rgen.seed(seed) + idx_1000, idx_5000, factor_base = _generate_factor_base(prime_bound, N) + smooth_relations = [] + ith_poly = 0 + partial_relations = {} + proper_factor = set() + threshold = 5*len(factor_base) // 100 + while True: + if ith_poly == 0: + ith_sieve_poly, B_array = _initialize_first_polynomial(N, M, factor_base, idx_1000, idx_5000) + else: + ith_sieve_poly = _initialize_ith_poly(N, factor_base, ith_poly, ith_sieve_poly, B_array) + ith_poly += 1 + if ith_poly >= 2**(len(B_array) - 1): # time to start with a new sieve polynomial + ith_poly = 0 + sieve_array = _gen_sieve_array(M, factor_base) + s_rel, p_f = _trial_division_stage(N, M, factor_base, sieve_array, ith_sieve_poly, partial_relations, ERROR_TERM) + smooth_relations += s_rel + proper_factor |= p_f + if len(smooth_relations) >= len(factor_base) + threshold: + break + matrix = _build_matrix(smooth_relations) + dependent_row, mark, gauss_matrix = _gauss_mod_2(matrix) + N_copy = N + for index in range(len(dependent_row)): + factor = _find_factor(dependent_row, mark, gauss_matrix, index, smooth_relations, N) + if factor > 1 and factor < N: + proper_factor.add(factor) + while(N_copy % factor == 0): + N_copy //= factor + if isprime(N_copy): + proper_factor.add(N_copy) + break + if(N_copy == 1): + break + return proper_factor diff --git a/shared/package-files/43/4333610e3354704d33815f7b3767626d93f46ff8bd6c69f417d90b9d5734e4d2/blob b/shared/package-files/43/4333610e3354704d33815f7b3767626d93f46ff8bd6c69f417d90b9d5734e4d2/blob new file mode 100644 index 0000000000000000000000000000000000000000..ee4447074f127780c32651e462189fb328668bd5 --- /dev/null +++ b/shared/package-files/43/4333610e3354704d33815f7b3767626d93f46ff8bd6c69f417d90b9d5734e4d2/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4333610e3354704d33815f7b3767626d93f46ff8bd6c69f417d90b9d5734e4d2 +size 133897 diff --git a/shared/package-files/43/4334003c80be2234d5dc3c73f7b8419ef2c10a617c929b014c17244e18604634/blob b/shared/package-files/43/4334003c80be2234d5dc3c73f7b8419ef2c10a617c929b014c17244e18604634/blob new file mode 100644 index 0000000000000000000000000000000000000000..702be2486515402d835e44d361d8642211919487 --- /dev/null +++ b/shared/package-files/43/4334003c80be2234d5dc3c73f7b8419ef2c10a617c929b014c17244e18604634/blob @@ -0,0 +1,1248 @@ +import itertools +import sys +import platform + +import pytest + +import numpy as np +from numpy.testing import ( + assert_, assert_equal, assert_array_equal, assert_almost_equal, + assert_raises, suppress_warnings, assert_raises_regex, assert_allclose + ) + +try: + COMPILERS = np.show_config(mode="dicts")["Compilers"] + USING_CLANG_CL = COMPILERS["c"]["name"] == "clang-cl" +except TypeError: + USING_CLANG_CL = False + +# Setup for optimize einsum +chars = 'abcdefghij' +sizes = np.array([2, 3, 4, 5, 4, 3, 2, 6, 5, 4, 3]) +global_size_dict = dict(zip(chars, sizes)) + + +class TestEinsum: + def test_einsum_errors(self): + for do_opt in [True, False]: + # Need enough arguments + assert_raises(ValueError, np.einsum, optimize=do_opt) + assert_raises(ValueError, np.einsum, "", optimize=do_opt) + + # subscripts must be a string + assert_raises(TypeError, np.einsum, 0, 0, optimize=do_opt) + + # out parameter must be an array + assert_raises(TypeError, np.einsum, "", 0, out='test', + optimize=do_opt) + + # order parameter must be a valid order + assert_raises(ValueError, np.einsum, "", 0, order='W', + optimize=do_opt) + + # casting parameter must be a valid casting + assert_raises(ValueError, np.einsum, "", 0, casting='blah', + optimize=do_opt) + + # dtype parameter must be a valid dtype + assert_raises(TypeError, np.einsum, "", 0, dtype='bad_data_type', + optimize=do_opt) + + # other keyword arguments are rejected + assert_raises(TypeError, np.einsum, "", 0, bad_arg=0, + optimize=do_opt) + + # issue 4528 revealed a segfault with this call + assert_raises(TypeError, np.einsum, *(None,)*63, optimize=do_opt) + + # number of operands must match count in subscripts string + assert_raises(ValueError, np.einsum, "", 0, 0, optimize=do_opt) + assert_raises(ValueError, np.einsum, ",", 0, [0], [0], + optimize=do_opt) + assert_raises(ValueError, np.einsum, ",", [0], optimize=do_opt) + + # can't have more subscripts than dimensions in the operand + assert_raises(ValueError, np.einsum, "i", 0, optimize=do_opt) + assert_raises(ValueError, np.einsum, "ij", [0, 0], optimize=do_opt) + assert_raises(ValueError, np.einsum, "...i", 0, optimize=do_opt) + assert_raises(ValueError, np.einsum, "i...j", [0, 0], optimize=do_opt) + assert_raises(ValueError, np.einsum, "i...", 0, optimize=do_opt) + assert_raises(ValueError, np.einsum, "ij...", [0, 0], optimize=do_opt) + + # invalid ellipsis + assert_raises(ValueError, np.einsum, "i..", [0, 0], optimize=do_opt) + assert_raises(ValueError, np.einsum, ".i...", [0, 0], optimize=do_opt) + assert_raises(ValueError, np.einsum, "j->..j", [0, 0], optimize=do_opt) + assert_raises(ValueError, np.einsum, "j->.j...", [0, 0], optimize=do_opt) + + # invalid subscript character + assert_raises(ValueError, np.einsum, "i%...", [0, 0], optimize=do_opt) + assert_raises(ValueError, np.einsum, "...j$", [0, 0], optimize=do_opt) + assert_raises(ValueError, np.einsum, "i->&", [0, 0], optimize=do_opt) + + # output subscripts must appear in input + assert_raises(ValueError, np.einsum, "i->ij", [0, 0], optimize=do_opt) + + # output subscripts may only be specified once + assert_raises(ValueError, np.einsum, "ij->jij", [[0, 0], [0, 0]], + optimize=do_opt) + + # dimensions much match when being collapsed + assert_raises(ValueError, np.einsum, "ii", + np.arange(6).reshape(2, 3), optimize=do_opt) + assert_raises(ValueError, np.einsum, "ii->i", + np.arange(6).reshape(2, 3), optimize=do_opt) + + # broadcasting to new dimensions must be enabled explicitly + assert_raises(ValueError, np.einsum, "i", np.arange(6).reshape(2, 3), + optimize=do_opt) + assert_raises(ValueError, np.einsum, "i->i", [[0, 1], [0, 1]], + out=np.arange(4).reshape(2, 2), optimize=do_opt) + with assert_raises_regex(ValueError, "'b'"): + # gh-11221 - 'c' erroneously appeared in the error message + a = np.ones((3, 3, 4, 5, 6)) + b = np.ones((3, 4, 5)) + np.einsum('aabcb,abc', a, b) + + # Check order kwarg, asanyarray allows 1d to pass through + assert_raises(ValueError, np.einsum, "i->i", np.arange(6).reshape(-1, 1), + optimize=do_opt, order='d') + + def test_einsum_object_errors(self): + # Exceptions created by object arithmetic should + # successfully propagate + + class CustomException(Exception): + pass + + class DestructoBox: + + def __init__(self, value, destruct): + self._val = value + self._destruct = destruct + + def __add__(self, other): + tmp = self._val + other._val + if tmp >= self._destruct: + raise CustomException + else: + self._val = tmp + return self + + def __radd__(self, other): + if other == 0: + return self + else: + return self.__add__(other) + + def __mul__(self, other): + tmp = self._val * other._val + if tmp >= self._destruct: + raise CustomException + else: + self._val = tmp + return self + + def __rmul__(self, other): + if other == 0: + return self + else: + return self.__mul__(other) + + a = np.array([DestructoBox(i, 5) for i in range(1, 10)], + dtype='object').reshape(3, 3) + + # raised from unbuffered_loop_nop1_ndim2 + assert_raises(CustomException, np.einsum, "ij->i", a) + + # raised from unbuffered_loop_nop1_ndim3 + b = np.array([DestructoBox(i, 100) for i in range(0, 27)], + dtype='object').reshape(3, 3, 3) + assert_raises(CustomException, np.einsum, "i...k->...", b) + + # raised from unbuffered_loop_nop2_ndim2 + b = np.array([DestructoBox(i, 55) for i in range(1, 4)], + dtype='object') + assert_raises(CustomException, np.einsum, "ij, j", a, b) + + # raised from unbuffered_loop_nop2_ndim3 + assert_raises(CustomException, np.einsum, "ij, jh", a, a) + + # raised from PyArray_EinsteinSum + assert_raises(CustomException, np.einsum, "ij->", a) + + def test_einsum_views(self): + # pass-through + for do_opt in [True, False]: + a = np.arange(6) + a.shape = (2, 3) + + b = np.einsum("...", a, optimize=do_opt) + assert_(b.base is a) + + b = np.einsum(a, [Ellipsis], optimize=do_opt) + assert_(b.base is a) + + b = np.einsum("ij", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a) + + b = np.einsum(a, [0, 1], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a) + + # output is writeable whenever input is writeable + b = np.einsum("...", a, optimize=do_opt) + assert_(b.flags['WRITEABLE']) + a.flags['WRITEABLE'] = False + b = np.einsum("...", a, optimize=do_opt) + assert_(not b.flags['WRITEABLE']) + + # transpose + a = np.arange(6) + a.shape = (2, 3) + + b = np.einsum("ji", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.T) + + b = np.einsum(a, [1, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.T) + + # diagonal + a = np.arange(9) + a.shape = (3, 3) + + b = np.einsum("ii->i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i] for i in range(3)]) + + b = np.einsum(a, [0, 0], [0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i] for i in range(3)]) + + # diagonal with various ways of broadcasting an additional dimension + a = np.arange(27) + a.shape = (3, 3, 3) + + b = np.einsum("...ii->...i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] for x in a]) + + b = np.einsum(a, [Ellipsis, 0, 0], [Ellipsis, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] for x in a]) + + b = np.einsum("ii...->...i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(2, 0, 1)]) + + b = np.einsum(a, [0, 0, Ellipsis], [Ellipsis, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(2, 0, 1)]) + + b = np.einsum("...ii->i...", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum(a, [Ellipsis, 0, 0], [0, Ellipsis], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum("jii->ij", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum(a, [1, 0, 0], [0, 1], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum("ii...->i...", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(2, 0, 1)[:, i, i] for i in range(3)]) + + b = np.einsum(a, [0, 0, Ellipsis], [0, Ellipsis], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(2, 0, 1)[:, i, i] for i in range(3)]) + + b = np.einsum("i...i->i...", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(1, 0, 2)[:, i, i] for i in range(3)]) + + b = np.einsum(a, [0, Ellipsis, 0], [0, Ellipsis], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(1, 0, 2)[:, i, i] for i in range(3)]) + + b = np.einsum("i...i->...i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(1, 0, 2)]) + + b = np.einsum(a, [0, Ellipsis, 0], [Ellipsis, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(1, 0, 2)]) + + # triple diagonal + a = np.arange(27) + a.shape = (3, 3, 3) + + b = np.einsum("iii->i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i, i] for i in range(3)]) + + b = np.einsum(a, [0, 0, 0], [0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i, i] for i in range(3)]) + + # swap axes + a = np.arange(24) + a.shape = (2, 3, 4) + + b = np.einsum("ijk->jik", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.swapaxes(0, 1)) + + b = np.einsum(a, [0, 1, 2], [1, 0, 2], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.swapaxes(0, 1)) + + @np._no_nep50_warning() + def check_einsum_sums(self, dtype, do_opt=False): + dtype = np.dtype(dtype) + # Check various sums. Does many sizes to exercise unrolled loops. + + # sum(a, axis=-1) + for n in range(1, 17): + a = np.arange(n, dtype=dtype) + b = np.sum(a, axis=-1) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("i->", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0], [], optimize=do_opt), b) + + for n in range(1, 17): + a = np.arange(2*3*n, dtype=dtype).reshape(2, 3, n) + b = np.sum(a, axis=-1) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("...i->...", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [Ellipsis, 0], [Ellipsis], optimize=do_opt), b) + + # sum(a, axis=0) + for n in range(1, 17): + a = np.arange(2*n, dtype=dtype).reshape(2, n) + b = np.sum(a, axis=0) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("i...->...", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0, Ellipsis], [Ellipsis], optimize=do_opt), b) + + for n in range(1, 17): + a = np.arange(2*3*n, dtype=dtype).reshape(2, 3, n) + b = np.sum(a, axis=0) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("i...->...", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0, Ellipsis], [Ellipsis], optimize=do_opt), b) + + # trace(a) + for n in range(1, 17): + a = np.arange(n*n, dtype=dtype).reshape(n, n) + b = np.trace(a) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("ii", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0, 0], optimize=do_opt), b) + + # gh-15961: should accept numpy int64 type in subscript list + np_array = np.asarray([0, 0]) + assert_equal(np.einsum(a, np_array, optimize=do_opt), b) + assert_equal(np.einsum(a, list(np_array), optimize=do_opt), b) + + # multiply(a, b) + assert_equal(np.einsum("..., ...", 3, 4), 12) # scalar case + for n in range(1, 17): + a = np.arange(3 * n, dtype=dtype).reshape(3, n) + b = np.arange(2 * 3 * n, dtype=dtype).reshape(2, 3, n) + assert_equal(np.einsum("..., ...", a, b, optimize=do_opt), + np.multiply(a, b)) + assert_equal(np.einsum(a, [Ellipsis], b, [Ellipsis], optimize=do_opt), + np.multiply(a, b)) + + # inner(a,b) + for n in range(1, 17): + a = np.arange(2 * 3 * n, dtype=dtype).reshape(2, 3, n) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("...i, ...i", a, b, optimize=do_opt), np.inner(a, b)) + assert_equal(np.einsum(a, [Ellipsis, 0], b, [Ellipsis, 0], optimize=do_opt), + np.inner(a, b)) + + for n in range(1, 11): + a = np.arange(n * 3 * 2, dtype=dtype).reshape(n, 3, 2) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("i..., i...", a, b, optimize=do_opt), + np.inner(a.T, b.T).T) + assert_equal(np.einsum(a, [0, Ellipsis], b, [0, Ellipsis], optimize=do_opt), + np.inner(a.T, b.T).T) + + # outer(a,b) + for n in range(1, 17): + a = np.arange(3, dtype=dtype)+1 + b = np.arange(n, dtype=dtype)+1 + assert_equal(np.einsum("i,j", a, b, optimize=do_opt), + np.outer(a, b)) + assert_equal(np.einsum(a, [0], b, [1], optimize=do_opt), + np.outer(a, b)) + + # Suppress the complex warnings for the 'as f8' tests + with suppress_warnings() as sup: + sup.filter(np.ComplexWarning) + + # matvec(a,b) / a.dot(b) where a is matrix, b is vector + for n in range(1, 17): + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("ij, j", a, b, optimize=do_opt), + np.dot(a, b)) + assert_equal(np.einsum(a, [0, 1], b, [1], optimize=do_opt), + np.dot(a, b)) + + c = np.arange(4, dtype=dtype) + np.einsum("ij,j", a, b, out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + c[...] = 0 + np.einsum(a, [0, 1], b, [1], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + + for n in range(1, 17): + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("ji,j", a.T, b.T, optimize=do_opt), + np.dot(b.T, a.T)) + assert_equal(np.einsum(a.T, [1, 0], b.T, [1], optimize=do_opt), + np.dot(b.T, a.T)) + + c = np.arange(4, dtype=dtype) + np.einsum("ji,j", a.T, b.T, out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(b.T.astype('f8'), + a.T.astype('f8')).astype(dtype)) + c[...] = 0 + np.einsum(a.T, [1, 0], b.T, [1], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(b.T.astype('f8'), + a.T.astype('f8')).astype(dtype)) + + # matmat(a,b) / a.dot(b) where a is matrix, b is matrix + for n in range(1, 17): + if n < 8 or dtype != 'f2': + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n*6, dtype=dtype).reshape(n, 6) + assert_equal(np.einsum("ij,jk", a, b, optimize=do_opt), + np.dot(a, b)) + assert_equal(np.einsum(a, [0, 1], b, [1, 2], optimize=do_opt), + np.dot(a, b)) + + for n in range(1, 17): + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n*6, dtype=dtype).reshape(n, 6) + c = np.arange(24, dtype=dtype).reshape(4, 6) + np.einsum("ij,jk", a, b, out=c, dtype='f8', casting='unsafe', + optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + c[...] = 0 + np.einsum(a, [0, 1], b, [1, 2], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + + # matrix triple product (note this is not currently an efficient + # way to multiply 3 matrices) + a = np.arange(12, dtype=dtype).reshape(3, 4) + b = np.arange(20, dtype=dtype).reshape(4, 5) + c = np.arange(30, dtype=dtype).reshape(5, 6) + if dtype != 'f2': + assert_equal(np.einsum("ij,jk,kl", a, b, c, optimize=do_opt), + a.dot(b).dot(c)) + assert_equal(np.einsum(a, [0, 1], b, [1, 2], c, [2, 3], + optimize=do_opt), a.dot(b).dot(c)) + + d = np.arange(18, dtype=dtype).reshape(3, 6) + np.einsum("ij,jk,kl", a, b, c, out=d, + dtype='f8', casting='unsafe', optimize=do_opt) + tgt = a.astype('f8').dot(b.astype('f8')) + tgt = tgt.dot(c.astype('f8')).astype(dtype) + assert_equal(d, tgt) + + d[...] = 0 + np.einsum(a, [0, 1], b, [1, 2], c, [2, 3], out=d, + dtype='f8', casting='unsafe', optimize=do_opt) + tgt = a.astype('f8').dot(b.astype('f8')) + tgt = tgt.dot(c.astype('f8')).astype(dtype) + assert_equal(d, tgt) + + # tensordot(a, b) + if np.dtype(dtype) != np.dtype('f2'): + a = np.arange(60, dtype=dtype).reshape(3, 4, 5) + b = np.arange(24, dtype=dtype).reshape(4, 3, 2) + assert_equal(np.einsum("ijk, jil -> kl", a, b), + np.tensordot(a, b, axes=([1, 0], [0, 1]))) + assert_equal(np.einsum(a, [0, 1, 2], b, [1, 0, 3], [2, 3]), + np.tensordot(a, b, axes=([1, 0], [0, 1]))) + + c = np.arange(10, dtype=dtype).reshape(5, 2) + np.einsum("ijk,jil->kl", a, b, out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, np.tensordot(a.astype('f8'), b.astype('f8'), + axes=([1, 0], [0, 1])).astype(dtype)) + c[...] = 0 + np.einsum(a, [0, 1, 2], b, [1, 0, 3], [2, 3], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, np.tensordot(a.astype('f8'), b.astype('f8'), + axes=([1, 0], [0, 1])).astype(dtype)) + + # logical_and(logical_and(a!=0, b!=0), c!=0) + neg_val = -2 if dtype.kind != "u" else np.iinfo(dtype).max - 1 + a = np.array([1, 3, neg_val, 0, 12, 13, 0, 1], dtype=dtype) + b = np.array([0, 3.5, 0., neg_val, 0, 1, 3, 12], dtype=dtype) + c = np.array([True, True, False, True, True, False, True, True]) + + assert_equal(np.einsum("i,i,i->i", a, b, c, + dtype='?', casting='unsafe', optimize=do_opt), + np.logical_and(np.logical_and(a != 0, b != 0), c != 0)) + assert_equal(np.einsum(a, [0], b, [0], c, [0], [0], + dtype='?', casting='unsafe'), + np.logical_and(np.logical_and(a != 0, b != 0), c != 0)) + + a = np.arange(9, dtype=dtype) + assert_equal(np.einsum(",i->", 3, a), 3*np.sum(a)) + assert_equal(np.einsum(3, [], a, [0], []), 3*np.sum(a)) + assert_equal(np.einsum("i,->", a, 3), 3*np.sum(a)) + assert_equal(np.einsum(a, [0], 3, [], []), 3*np.sum(a)) + + # Various stride0, contiguous, and SSE aligned variants + for n in range(1, 25): + a = np.arange(n, dtype=dtype) + if np.dtype(dtype).itemsize > 1: + assert_equal(np.einsum("...,...", a, a, optimize=do_opt), + np.multiply(a, a)) + assert_equal(np.einsum("i,i", a, a, optimize=do_opt), np.dot(a, a)) + assert_equal(np.einsum("i,->i", a, 2, optimize=do_opt), 2*a) + assert_equal(np.einsum(",i->i", 2, a, optimize=do_opt), 2*a) + assert_equal(np.einsum("i,->", a, 2, optimize=do_opt), 2*np.sum(a)) + assert_equal(np.einsum(",i->", 2, a, optimize=do_opt), 2*np.sum(a)) + + assert_equal(np.einsum("...,...", a[1:], a[:-1], optimize=do_opt), + np.multiply(a[1:], a[:-1])) + assert_equal(np.einsum("i,i", a[1:], a[:-1], optimize=do_opt), + np.dot(a[1:], a[:-1])) + assert_equal(np.einsum("i,->i", a[1:], 2, optimize=do_opt), 2*a[1:]) + assert_equal(np.einsum(",i->i", 2, a[1:], optimize=do_opt), 2*a[1:]) + assert_equal(np.einsum("i,->", a[1:], 2, optimize=do_opt), + 2*np.sum(a[1:])) + assert_equal(np.einsum(",i->", 2, a[1:], optimize=do_opt), + 2*np.sum(a[1:])) + + # An object array, summed as the data type + a = np.arange(9, dtype=object) + + b = np.einsum("i->", a, dtype=dtype, casting='unsafe') + assert_equal(b, np.sum(a)) + if hasattr(b, "dtype"): + # Can be a python object when dtype is object + assert_equal(b.dtype, np.dtype(dtype)) + + b = np.einsum(a, [0], [], dtype=dtype, casting='unsafe') + assert_equal(b, np.sum(a)) + if hasattr(b, "dtype"): + # Can be a python object when dtype is object + assert_equal(b.dtype, np.dtype(dtype)) + + # A case which was failing (ticket #1885) + p = np.arange(2) + 1 + q = np.arange(4).reshape(2, 2) + 3 + r = np.arange(4).reshape(2, 2) + 7 + assert_equal(np.einsum('z,mz,zm->', p, q, r), 253) + + # singleton dimensions broadcast (gh-10343) + p = np.ones((10,2)) + q = np.ones((1,2)) + assert_array_equal(np.einsum('ij,ij->j', p, q, optimize=True), + np.einsum('ij,ij->j', p, q, optimize=False)) + assert_array_equal(np.einsum('ij,ij->j', p, q, optimize=True), + [10.] * 2) + + # a blas-compatible contraction broadcasting case which was failing + # for optimize=True (ticket #10930) + x = np.array([2., 3.]) + y = np.array([4.]) + assert_array_equal(np.einsum("i, i", x, y, optimize=False), 20.) + assert_array_equal(np.einsum("i, i", x, y, optimize=True), 20.) + + # all-ones array was bypassing bug (ticket #10930) + p = np.ones((1, 5)) / 2 + q = np.ones((5, 5)) / 2 + for optimize in (True, False): + assert_array_equal(np.einsum("...ij,...jk->...ik", p, p, + optimize=optimize), + np.einsum("...ij,...jk->...ik", p, q, + optimize=optimize)) + assert_array_equal(np.einsum("...ij,...jk->...ik", p, q, + optimize=optimize), + np.full((1, 5), 1.25)) + + # Cases which were failing (gh-10899) + x = np.eye(2, dtype=dtype) + y = np.ones(2, dtype=dtype) + assert_array_equal(np.einsum("ji,i->", x, y, optimize=optimize), + [2.]) # contig_contig_outstride0_two + assert_array_equal(np.einsum("i,ij->", y, x, optimize=optimize), + [2.]) # stride0_contig_outstride0_two + assert_array_equal(np.einsum("ij,i->", x, y, optimize=optimize), + [2.]) # contig_stride0_outstride0_two + + def test_einsum_sums_int8(self): + if ( + (sys.platform == 'darwin' and platform.machine() == 'x86_64') + or + USING_CLANG_CL + ): + pytest.xfail('Fails on macOS x86-64 and when using clang-cl ' + 'with Meson, see gh-23838') + self.check_einsum_sums('i1') + + def test_einsum_sums_uint8(self): + if ( + (sys.platform == 'darwin' and platform.machine() == 'x86_64') + or + USING_CLANG_CL + ): + pytest.xfail('Fails on macOS x86-64 and when using clang-cl ' + 'with Meson, see gh-23838') + self.check_einsum_sums('u1') + + def test_einsum_sums_int16(self): + self.check_einsum_sums('i2') + + def test_einsum_sums_uint16(self): + self.check_einsum_sums('u2') + + def test_einsum_sums_int32(self): + self.check_einsum_sums('i4') + self.check_einsum_sums('i4', True) + + def test_einsum_sums_uint32(self): + self.check_einsum_sums('u4') + self.check_einsum_sums('u4', True) + + def test_einsum_sums_int64(self): + self.check_einsum_sums('i8') + + def test_einsum_sums_uint64(self): + self.check_einsum_sums('u8') + + def test_einsum_sums_float16(self): + self.check_einsum_sums('f2') + + def test_einsum_sums_float32(self): + self.check_einsum_sums('f4') + + def test_einsum_sums_float64(self): + self.check_einsum_sums('f8') + self.check_einsum_sums('f8', True) + + def test_einsum_sums_longdouble(self): + self.check_einsum_sums(np.longdouble) + + def test_einsum_sums_cfloat64(self): + self.check_einsum_sums('c8') + self.check_einsum_sums('c8', True) + + def test_einsum_sums_cfloat128(self): + self.check_einsum_sums('c16') + + def test_einsum_sums_clongdouble(self): + self.check_einsum_sums(np.clongdouble) + + def test_einsum_sums_object(self): + self.check_einsum_sums('object') + self.check_einsum_sums('object', True) + + def test_einsum_misc(self): + # This call used to crash because of a bug in + # PyArray_AssignZero + a = np.ones((1, 2)) + b = np.ones((2, 2, 1)) + assert_equal(np.einsum('ij...,j...->i...', a, b), [[[2], [2]]]) + assert_equal(np.einsum('ij...,j...->i...', a, b, optimize=True), [[[2], [2]]]) + + # Regression test for issue #10369 (test unicode inputs with Python 2) + assert_equal(np.einsum('ij...,j...->i...', a, b), [[[2], [2]]]) + assert_equal(np.einsum('...i,...i', [1, 2, 3], [2, 3, 4]), 20) + assert_equal(np.einsum('...i,...i', [1, 2, 3], [2, 3, 4], + optimize='greedy'), 20) + + # The iterator had an issue with buffering this reduction + a = np.ones((5, 12, 4, 2, 3), np.int64) + b = np.ones((5, 12, 11), np.int64) + assert_equal(np.einsum('ijklm,ijn,ijn->', a, b, b), + np.einsum('ijklm,ijn->', a, b)) + assert_equal(np.einsum('ijklm,ijn,ijn->', a, b, b, optimize=True), + np.einsum('ijklm,ijn->', a, b, optimize=True)) + + # Issue #2027, was a problem in the contiguous 3-argument + # inner loop implementation + a = np.arange(1, 3) + b = np.arange(1, 5).reshape(2, 2) + c = np.arange(1, 9).reshape(4, 2) + assert_equal(np.einsum('x,yx,zx->xzy', a, b, c), + [[[1, 3], [3, 9], [5, 15], [7, 21]], + [[8, 16], [16, 32], [24, 48], [32, 64]]]) + assert_equal(np.einsum('x,yx,zx->xzy', a, b, c, optimize=True), + [[[1, 3], [3, 9], [5, 15], [7, 21]], + [[8, 16], [16, 32], [24, 48], [32, 64]]]) + + # Ensure explicitly setting out=None does not cause an error + # see issue gh-15776 and issue gh-15256 + assert_equal(np.einsum('i,j', [1], [2], out=None), [[2]]) + + def test_object_loop(self): + + class Mult: + def __mul__(self, other): + return 42 + + objMult = np.array([Mult()]) + objNULL = np.ndarray(buffer = b'\0' * np.intp(0).itemsize, shape=1, dtype=object) + + with pytest.raises(TypeError): + np.einsum("i,j", [1], objNULL) + with pytest.raises(TypeError): + np.einsum("i,j", objNULL, [1]) + assert np.einsum("i,j", objMult, objMult) == 42 + + def test_subscript_range(self): + # Issue #7741, make sure that all letters of Latin alphabet (both uppercase & lowercase) can be used + # when creating a subscript from arrays + a = np.ones((2, 3)) + b = np.ones((3, 4)) + np.einsum(a, [0, 20], b, [20, 2], [0, 2], optimize=False) + np.einsum(a, [0, 27], b, [27, 2], [0, 2], optimize=False) + np.einsum(a, [0, 51], b, [51, 2], [0, 2], optimize=False) + assert_raises(ValueError, lambda: np.einsum(a, [0, 52], b, [52, 2], [0, 2], optimize=False)) + assert_raises(ValueError, lambda: np.einsum(a, [-1, 5], b, [5, 2], [-1, 2], optimize=False)) + + def test_einsum_broadcast(self): + # Issue #2455 change in handling ellipsis + # remove the 'middle broadcast' error + # only use the 'RIGHT' iteration in prepare_op_axes + # adds auto broadcast on left where it belongs + # broadcast on right has to be explicit + # We need to test the optimized parsing as well + + A = np.arange(2 * 3 * 4).reshape(2, 3, 4) + B = np.arange(3) + ref = np.einsum('ijk,j->ijk', A, B, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('ij...,j...->ij...', A, B, optimize=opt), ref) + assert_equal(np.einsum('ij...,...j->ij...', A, B, optimize=opt), ref) + assert_equal(np.einsum('ij...,j->ij...', A, B, optimize=opt), ref) # used to raise error + + A = np.arange(12).reshape((4, 3)) + B = np.arange(6).reshape((3, 2)) + ref = np.einsum('ik,kj->ij', A, B, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('ik...,k...->i...', A, B, optimize=opt), ref) + assert_equal(np.einsum('ik...,...kj->i...j', A, B, optimize=opt), ref) + assert_equal(np.einsum('...k,kj', A, B, optimize=opt), ref) # used to raise error + assert_equal(np.einsum('ik,k...->i...', A, B, optimize=opt), ref) # used to raise error + + dims = [2, 3, 4, 5] + a = np.arange(np.prod(dims)).reshape(dims) + v = np.arange(dims[2]) + ref = np.einsum('ijkl,k->ijl', a, v, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('ijkl,k', a, v, optimize=opt), ref) + assert_equal(np.einsum('...kl,k', a, v, optimize=opt), ref) # used to raise error + assert_equal(np.einsum('...kl,k...', a, v, optimize=opt), ref) + + J, K, M = 160, 160, 120 + A = np.arange(J * K * M).reshape(1, 1, 1, J, K, M) + B = np.arange(J * K * M * 3).reshape(J, K, M, 3) + ref = np.einsum('...lmn,...lmno->...o', A, B, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('...lmn,lmno->...o', A, B, + optimize=opt), ref) # used to raise error + + def test_einsum_fixedstridebug(self): + # Issue #4485 obscure einsum bug + # This case revealed a bug in nditer where it reported a stride + # as 'fixed' (0) when it was in fact not fixed during processing + # (0 or 4). The reason for the bug was that the check for a fixed + # stride was using the information from the 2D inner loop reuse + # to restrict the iteration dimensions it had to validate to be + # the same, but that 2D inner loop reuse logic is only triggered + # during the buffer copying step, and hence it was invalid to + # rely on those values. The fix is to check all the dimensions + # of the stride in question, which in the test case reveals that + # the stride is not fixed. + # + # NOTE: This test is triggered by the fact that the default buffersize, + # used by einsum, is 8192, and 3*2731 = 8193, is larger than that + # and results in a mismatch between the buffering and the + # striding for operand A. + A = np.arange(2 * 3).reshape(2, 3).astype(np.float32) + B = np.arange(2 * 3 * 2731).reshape(2, 3, 2731).astype(np.int16) + es = np.einsum('cl, cpx->lpx', A, B) + tp = np.tensordot(A, B, axes=(0, 0)) + assert_equal(es, tp) + # The following is the original test case from the bug report, + # made repeatable by changing random arrays to aranges. + A = np.arange(3 * 3).reshape(3, 3).astype(np.float64) + B = np.arange(3 * 3 * 64 * 64).reshape(3, 3, 64, 64).astype(np.float32) + es = np.einsum('cl, cpxy->lpxy', A, B) + tp = np.tensordot(A, B, axes=(0, 0)) + assert_equal(es, tp) + + def test_einsum_fixed_collapsingbug(self): + # Issue #5147. + # The bug only occurred when output argument of einssum was used. + x = np.random.normal(0, 1, (5, 5, 5, 5)) + y1 = np.zeros((5, 5)) + np.einsum('aabb->ab', x, out=y1) + idx = np.arange(5) + y2 = x[idx[:, None], idx[:, None], idx, idx] + assert_equal(y1, y2) + + def test_einsum_failed_on_p9_and_s390x(self): + # Issues gh-14692 and gh-12689 + # Bug with signed vs unsigned char errored on power9 and s390x Linux + tensor = np.random.random_sample((10, 10, 10, 10)) + x = np.einsum('ijij->', tensor) + y = tensor.trace(axis1=0, axis2=2).trace() + assert_allclose(x, y) + + def test_einsum_all_contig_non_contig_output(self): + # Issue gh-5907, tests that the all contiguous special case + # actually checks the contiguity of the output + x = np.ones((5, 5)) + out = np.ones(10)[::2] + correct_base = np.ones(10) + correct_base[::2] = 5 + # Always worked (inner iteration is done with 0-stride): + np.einsum('mi,mi,mi->m', x, x, x, out=out) + assert_array_equal(out.base, correct_base) + # Example 1: + out = np.ones(10)[::2] + np.einsum('im,im,im->m', x, x, x, out=out) + assert_array_equal(out.base, correct_base) + # Example 2, buffering causes x to be contiguous but + # special cases do not catch the operation before: + out = np.ones((2, 2, 2))[..., 0] + correct_base = np.ones((2, 2, 2)) + correct_base[..., 0] = 2 + x = np.ones((2, 2), np.float32) + np.einsum('ij,jk->ik', x, x, out=out) + assert_array_equal(out.base, correct_base) + + @pytest.mark.parametrize("dtype", + np.typecodes["AllFloat"] + np.typecodes["AllInteger"]) + def test_different_paths(self, dtype): + # Test originally added to cover broken float16 path: gh-20305 + # Likely most are covered elsewhere, at least partially. + dtype = np.dtype(dtype) + # Simple test, designed to exercise most specialized code paths, + # note the +0.5 for floats. This makes sure we use a float value + # where the results must be exact. + arr = (np.arange(7) + 0.5).astype(dtype) + scalar = np.array(2, dtype=dtype) + + # contig -> scalar: + res = np.einsum('i->', arr) + assert res == arr.sum() + # contig, contig -> contig: + res = np.einsum('i,i->i', arr, arr) + assert_array_equal(res, arr * arr) + # noncontig, noncontig -> contig: + res = np.einsum('i,i->i', arr.repeat(2)[::2], arr.repeat(2)[::2]) + assert_array_equal(res, arr * arr) + # contig + contig -> scalar + assert np.einsum('i,i->', arr, arr) == (arr * arr).sum() + # contig + scalar -> contig (with out) + out = np.ones(7, dtype=dtype) + res = np.einsum('i,->i', arr, dtype.type(2), out=out) + assert_array_equal(res, arr * dtype.type(2)) + # scalar + contig -> contig (with out) + res = np.einsum(',i->i', scalar, arr) + assert_array_equal(res, arr * dtype.type(2)) + # scalar + contig -> scalar + res = np.einsum(',i->', scalar, arr) + # Use einsum to compare to not have difference due to sum round-offs: + assert res == np.einsum('i->', scalar * arr) + # contig + scalar -> scalar + res = np.einsum('i,->', arr, scalar) + # Use einsum to compare to not have difference due to sum round-offs: + assert res == np.einsum('i->', scalar * arr) + # contig + contig + contig -> scalar + arr = np.array([0.5, 0.5, 0.25, 4.5, 3.], dtype=dtype) + res = np.einsum('i,i,i->', arr, arr, arr) + assert_array_equal(res, (arr * arr * arr).sum()) + # four arrays: + res = np.einsum('i,i,i,i->', arr, arr, arr, arr) + assert_array_equal(res, (arr * arr * arr * arr).sum()) + + def test_small_boolean_arrays(self): + # See gh-5946. + # Use array of True embedded in False. + a = np.zeros((16, 1, 1), dtype=np.bool_)[:2] + a[...] = True + out = np.zeros((16, 1, 1), dtype=np.bool_)[:2] + tgt = np.ones((2, 1, 1), dtype=np.bool_) + res = np.einsum('...ij,...jk->...ik', a, a, out=out) + assert_equal(res, tgt) + + def test_out_is_res(self): + a = np.arange(9).reshape(3, 3) + res = np.einsum('...ij,...jk->...ik', a, a, out=a) + assert res is a + + def optimize_compare(self, subscripts, operands=None): + # Tests all paths of the optimization function against + # conventional einsum + if operands is None: + args = [subscripts] + terms = subscripts.split('->')[0].split(',') + for term in terms: + dims = [global_size_dict[x] for x in term] + args.append(np.random.rand(*dims)) + else: + args = [subscripts] + operands + + noopt = np.einsum(*args, optimize=False) + opt = np.einsum(*args, optimize='greedy') + assert_almost_equal(opt, noopt) + opt = np.einsum(*args, optimize='optimal') + assert_almost_equal(opt, noopt) + + def test_hadamard_like_products(self): + # Hadamard outer products + self.optimize_compare('a,ab,abc->abc') + self.optimize_compare('a,b,ab->ab') + + def test_index_transformations(self): + # Simple index transformation cases + self.optimize_compare('ea,fb,gc,hd,abcd->efgh') + self.optimize_compare('ea,fb,abcd,gc,hd->efgh') + self.optimize_compare('abcd,ea,fb,gc,hd->efgh') + + def test_complex(self): + # Long test cases + self.optimize_compare('acdf,jbje,gihb,hfac,gfac,gifabc,hfac') + self.optimize_compare('acdf,jbje,gihb,hfac,gfac,gifabc,hfac') + self.optimize_compare('cd,bdhe,aidb,hgca,gc,hgibcd,hgac') + self.optimize_compare('abhe,hidj,jgba,hiab,gab') + self.optimize_compare('bde,cdh,agdb,hica,ibd,hgicd,hiac') + self.optimize_compare('chd,bde,agbc,hiad,hgc,hgi,hiad') + self.optimize_compare('chd,bde,agbc,hiad,bdi,cgh,agdb') + self.optimize_compare('bdhe,acad,hiab,agac,hibd') + + def test_collapse(self): + # Inner products + self.optimize_compare('ab,ab,c->') + self.optimize_compare('ab,ab,c->c') + self.optimize_compare('ab,ab,cd,cd->') + self.optimize_compare('ab,ab,cd,cd->ac') + self.optimize_compare('ab,ab,cd,cd->cd') + self.optimize_compare('ab,ab,cd,cd,ef,ef->') + + def test_expand(self): + # Outer products + self.optimize_compare('ab,cd,ef->abcdef') + self.optimize_compare('ab,cd,ef->acdf') + self.optimize_compare('ab,cd,de->abcde') + self.optimize_compare('ab,cd,de->be') + self.optimize_compare('ab,bcd,cd->abcd') + self.optimize_compare('ab,bcd,cd->abd') + + def test_edge_cases(self): + # Difficult edge cases for optimization + self.optimize_compare('eb,cb,fb->cef') + self.optimize_compare('dd,fb,be,cdb->cef') + self.optimize_compare('bca,cdb,dbf,afc->') + self.optimize_compare('dcc,fce,ea,dbf->ab') + self.optimize_compare('fdf,cdd,ccd,afe->ae') + self.optimize_compare('abcd,ad') + self.optimize_compare('ed,fcd,ff,bcf->be') + self.optimize_compare('baa,dcf,af,cde->be') + self.optimize_compare('bd,db,eac->ace') + self.optimize_compare('fff,fae,bef,def->abd') + self.optimize_compare('efc,dbc,acf,fd->abe') + self.optimize_compare('ba,ac,da->bcd') + + def test_inner_product(self): + # Inner products + self.optimize_compare('ab,ab') + self.optimize_compare('ab,ba') + self.optimize_compare('abc,abc') + self.optimize_compare('abc,bac') + self.optimize_compare('abc,cba') + + def test_random_cases(self): + # Randomly built test cases + self.optimize_compare('aab,fa,df,ecc->bde') + self.optimize_compare('ecb,fef,bad,ed->ac') + self.optimize_compare('bcf,bbb,fbf,fc->') + self.optimize_compare('bb,ff,be->e') + self.optimize_compare('bcb,bb,fc,fff->') + self.optimize_compare('fbb,dfd,fc,fc->') + self.optimize_compare('afd,ba,cc,dc->bf') + self.optimize_compare('adb,bc,fa,cfc->d') + self.optimize_compare('bbd,bda,fc,db->acf') + self.optimize_compare('dba,ead,cad->bce') + self.optimize_compare('aef,fbc,dca->bde') + + def test_combined_views_mapping(self): + # gh-10792 + a = np.arange(9).reshape(1, 1, 3, 1, 3) + b = np.einsum('bbcdc->d', a) + assert_equal(b, [12]) + + def test_broadcasting_dot_cases(self): + # Ensures broadcasting cases are not mistaken for GEMM + + a = np.random.rand(1, 5, 4) + b = np.random.rand(4, 6) + c = np.random.rand(5, 6) + d = np.random.rand(10) + + self.optimize_compare('ijk,kl,jl', operands=[a, b, c]) + self.optimize_compare('ijk,kl,jl,i->i', operands=[a, b, c, d]) + + e = np.random.rand(1, 1, 5, 4) + f = np.random.rand(7, 7) + self.optimize_compare('abjk,kl,jl', operands=[e, b, c]) + self.optimize_compare('abjk,kl,jl,ab->ab', operands=[e, b, c, f]) + + # Edge case found in gh-11308 + g = np.arange(64).reshape(2, 4, 8) + self.optimize_compare('obk,ijk->ioj', operands=[g, g]) + + def test_output_order(self): + # Ensure output order is respected for optimize cases, the below + # conraction should yield a reshaped tensor view + # gh-16415 + + a = np.ones((2, 3, 5), order='F') + b = np.ones((4, 3), order='F') + + for opt in [True, False]: + tmp = np.einsum('...ft,mf->...mt', a, b, order='a', optimize=opt) + assert_(tmp.flags.f_contiguous) + + tmp = np.einsum('...ft,mf->...mt', a, b, order='f', optimize=opt) + assert_(tmp.flags.f_contiguous) + + tmp = np.einsum('...ft,mf->...mt', a, b, order='c', optimize=opt) + assert_(tmp.flags.c_contiguous) + + tmp = np.einsum('...ft,mf->...mt', a, b, order='k', optimize=opt) + assert_(tmp.flags.c_contiguous is False) + assert_(tmp.flags.f_contiguous is False) + + tmp = np.einsum('...ft,mf->...mt', a, b, optimize=opt) + assert_(tmp.flags.c_contiguous is False) + assert_(tmp.flags.f_contiguous is False) + + c = np.ones((4, 3), order='C') + for opt in [True, False]: + tmp = np.einsum('...ft,mf->...mt', a, c, order='a', optimize=opt) + assert_(tmp.flags.c_contiguous) + + d = np.ones((2, 3, 5), order='C') + for opt in [True, False]: + tmp = np.einsum('...ft,mf->...mt', d, c, order='a', optimize=opt) + assert_(tmp.flags.c_contiguous) + +class TestEinsumPath: + def build_operands(self, string, size_dict=global_size_dict): + + # Builds views based off initial operands + operands = [string] + terms = string.split('->')[0].split(',') + for term in terms: + dims = [size_dict[x] for x in term] + operands.append(np.random.rand(*dims)) + + return operands + + def assert_path_equal(self, comp, benchmark): + # Checks if list of tuples are equivalent + ret = (len(comp) == len(benchmark)) + assert_(ret) + for pos in range(len(comp) - 1): + ret &= isinstance(comp[pos + 1], tuple) + ret &= (comp[pos + 1] == benchmark[pos + 1]) + assert_(ret) + + def test_memory_contraints(self): + # Ensure memory constraints are satisfied + + outer_test = self.build_operands('a,b,c->abc') + + path, path_str = np.einsum_path(*outer_test, optimize=('greedy', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2)]) + + path, path_str = np.einsum_path(*outer_test, optimize=('optimal', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2)]) + + long_test = self.build_operands('acdf,jbje,gihb,hfac') + path, path_str = np.einsum_path(*long_test, optimize=('greedy', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2, 3)]) + + path, path_str = np.einsum_path(*long_test, optimize=('optimal', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2, 3)]) + + def test_long_paths(self): + # Long complex cases + + # Long test 1 + long_test1 = self.build_operands('acdf,jbje,gihb,hfac,gfac,gifabc,hfac') + path, path_str = np.einsum_path(*long_test1, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', + (3, 6), (3, 4), (2, 4), (2, 3), (0, 2), (0, 1)]) + + path, path_str = np.einsum_path(*long_test1, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', + (3, 6), (3, 4), (2, 4), (2, 3), (0, 2), (0, 1)]) + + # Long test 2 + long_test2 = self.build_operands('chd,bde,agbc,hiad,bdi,cgh,agdb') + path, path_str = np.einsum_path(*long_test2, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', + (3, 4), (0, 3), (3, 4), (1, 3), (1, 2), (0, 1)]) + + path, path_str = np.einsum_path(*long_test2, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', + (0, 5), (1, 4), (3, 4), (1, 3), (1, 2), (0, 1)]) + + def test_edge_paths(self): + # Difficult edge cases + + # Edge test1 + edge_test1 = self.build_operands('eb,cb,fb->cef') + path, path_str = np.einsum_path(*edge_test1, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (0, 2), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test1, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (0, 2), (0, 1)]) + + # Edge test2 + edge_test2 = self.build_operands('dd,fb,be,cdb->cef') + path, path_str = np.einsum_path(*edge_test2, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (0, 3), (0, 1), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test2, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (0, 3), (0, 1), (0, 1)]) + + # Edge test3 + edge_test3 = self.build_operands('bca,cdb,dbf,afc->') + path, path_str = np.einsum_path(*edge_test3, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 2), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test3, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 2), (0, 1)]) + + # Edge test4 + edge_test4 = self.build_operands('dcc,fce,ea,dbf->ab') + path, path_str = np.einsum_path(*edge_test4, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 1), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test4, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 2), (0, 1)]) + + # Edge test5 + edge_test4 = self.build_operands('a,ac,ab,ad,cd,bd,bc->', + size_dict={"a": 20, "b": 20, "c": 20, "d": 20}) + path, path_str = np.einsum_path(*edge_test4, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (0, 1), (0, 1, 2, 3, 4, 5)]) + + path, path_str = np.einsum_path(*edge_test4, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (0, 1), (0, 1, 2, 3, 4, 5)]) + + def test_path_type_input(self): + # Test explicit path handling + path_test = self.build_operands('dcc,fce,ea,dbf->ab') + + path, path_str = np.einsum_path(*path_test, optimize=False) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2, 3)]) + + path, path_str = np.einsum_path(*path_test, optimize=True) + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 1), (0, 1)]) + + exp_path = ['einsum_path', (0, 2), (0, 2), (0, 1)] + path, path_str = np.einsum_path(*path_test, optimize=exp_path) + self.assert_path_equal(path, exp_path) + + # Double check einsum works on the input path + noopt = np.einsum(*path_test, optimize=False) + opt = np.einsum(*path_test, optimize=exp_path) + assert_almost_equal(noopt, opt) + + def test_path_type_input_internal_trace(self): + #gh-20962 + path_test = self.build_operands('cab,cdd->ab') + exp_path = ['einsum_path', (1,), (0, 1)] + + path, path_str = np.einsum_path(*path_test, optimize=exp_path) + self.assert_path_equal(path, exp_path) + + # Double check einsum works on the input path + noopt = np.einsum(*path_test, optimize=False) + opt = np.einsum(*path_test, optimize=exp_path) + assert_almost_equal(noopt, opt) + + def test_path_type_input_invalid(self): + path_test = self.build_operands('ab,bc,cd,de->ae') + exp_path = ['einsum_path', (2, 3), (0, 1)] + assert_raises(RuntimeError, np.einsum, *path_test, optimize=exp_path) + assert_raises( + RuntimeError, np.einsum_path, *path_test, optimize=exp_path) + + path_test = self.build_operands('a,a,a->a') + exp_path = ['einsum_path', (1,), (0, 1)] + assert_raises(RuntimeError, np.einsum, *path_test, optimize=exp_path) + assert_raises( + RuntimeError, np.einsum_path, *path_test, optimize=exp_path) + + def test_spaces(self): + #gh-10794 + arr = np.array([[1]]) + for sp in itertools.product(['', ' '], repeat=4): + # no error for any spacing + np.einsum('{}...a{}->{}...a{}'.format(*sp), arr) + +def test_overlap(): + a = np.arange(9, dtype=int).reshape(3, 3) + b = np.arange(9, dtype=int).reshape(3, 3) + d = np.dot(a, b) + # sanity check + c = np.einsum('ij,jk->ik', a, b) + assert_equal(c, d) + #gh-10080, out overlaps one of the operands + c = np.einsum('ij,jk->ik', a, b, out=b) + assert_equal(c, d) diff --git a/shared/package-files/43/4338c1aef91147bfc194833b7f3cd078105b0e8d2de261edb49d52610838d168/blob b/shared/package-files/43/4338c1aef91147bfc194833b7f3cd078105b0e8d2de261edb49d52610838d168/blob new file mode 100644 index 0000000000000000000000000000000000000000..6e23812bf276959533844a8d962de9a27c1fdec8 --- /dev/null +++ b/shared/package-files/43/4338c1aef91147bfc194833b7f3cd078105b0e8d2de261edb49d52610838d168/blob @@ -0,0 +1,102 @@ +""" +This module provides the following: read and write of p2g format +used in metabolic pathway studies. + +See https://web.archive.org/web/20080626113807/http://www.cs.purdue.edu/homes/koyuturk/pathway/ for a description. + +The summary is included here: + +A file that describes a uniquely labeled graph (with extension ".gr") +format looks like the following: + + +name +3 4 +a +1 2 +b + +c +0 2 + +"name" is simply a description of what the graph corresponds to. The +second line displays the number of nodes and number of edges, +respectively. This sample graph contains three nodes labeled "a", "b", +and "c". The rest of the graph contains two lines for each node. The +first line for a node contains the node label. After the declaration +of the node label, the out-edges of that node in the graph are +provided. For instance, "a" is linked to nodes 1 and 2, which are +labeled "b" and "c", while the node labeled "b" has no outgoing +edges. Observe that node labeled "c" has an outgoing edge to +itself. Indeed, self-loops are allowed. Node index starts from 0. + +""" +import networkx +from networkx.utils import open_file + + +@open_file(1, mode="w") +def write_p2g(G, path, encoding="utf-8"): + """Write NetworkX graph in p2g format. + + Notes + ----- + This format is meant to be used with directed graphs with + possible self loops. + """ + path.write((f"{G.name}\n").encode(encoding)) + path.write((f"{G.order()} {G.size()}\n").encode(encoding)) + nodes = list(G) + # make dictionary mapping nodes to integers + nodenumber = dict(zip(nodes, range(len(nodes)))) + for n in nodes: + path.write((f"{n}\n").encode(encoding)) + for nbr in G.neighbors(n): + path.write((f"{nodenumber[nbr]} ").encode(encoding)) + path.write("\n".encode(encoding)) + + +@open_file(0, mode="r") +def read_p2g(path, encoding="utf-8"): + """Read graph in p2g format from path. + + Returns + ------- + MultiDiGraph + + Notes + ----- + If you want a DiGraph (with no self loops allowed and no edge data) + use D=networkx.DiGraph(read_p2g(path)) + """ + lines = (line.decode(encoding) for line in path) + G = parse_p2g(lines) + return G + + +def parse_p2g(lines): + """Parse p2g format graph from string or iterable. + + Returns + ------- + MultiDiGraph + """ + description = next(lines).strip() + # are multiedges (parallel edges) allowed? + G = networkx.MultiDiGraph(name=description, selfloops=True) + nnodes, nedges = map(int, next(lines).split()) + nodelabel = {} + nbrs = {} + # loop over the nodes keeping track of node labels and out neighbors + # defer adding edges until all node labels are known + for i in range(nnodes): + n = next(lines).strip() + nodelabel[i] = n + G.add_node(n) + nbrs[n] = map(int, next(lines).split()) + # now we know all of the node labels so we can add the edges + # with the correct labels + for n in G: + for nbr in nbrs[n]: + G.add_edge(n, nodelabel[nbr]) + return G diff --git a/shared/package-files/43/433c589e472f3494bf0124daf171a87bc34d369f0b5fc5ae695aac4266c9e4e0/blob b/shared/package-files/43/433c589e472f3494bf0124daf171a87bc34d369f0b5fc5ae695aac4266c9e4e0/blob new file mode 100644 index 0000000000000000000000000000000000000000..de606b9fbf58001178e402e172dc46edb2436b47 --- /dev/null +++ b/shared/package-files/43/433c589e472f3494bf0124daf171a87bc34d369f0b5fc5ae695aac4266c9e4e0/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor _addmm_activation(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta=1, const at::Scalar & alpha=1, bool use_gelu=false); +TORCH_API at::Tensor & _addmm_activation_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta=1, const at::Scalar & alpha=1, bool use_gelu=false); +TORCH_API at::Tensor & _addmm_activation_outf(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, bool use_gelu, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/43/433df3699d3ca5610697eeea3d2fcbadd6b70ccc6f2309e65bffc9e33b97aa56/blob b/shared/package-files/43/433df3699d3ca5610697eeea3d2fcbadd6b70ccc6f2309e65bffc9e33b97aa56/blob new file mode 100644 index 0000000000000000000000000000000000000000..182a480920df74aeb584c98e47761c47674c8954 --- /dev/null +++ b/shared/package-files/43/433df3699d3ca5610697eeea3d2fcbadd6b70ccc6f2309e65bffc9e33b97aa56/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:433df3699d3ca5610697eeea3d2fcbadd6b70ccc6f2309e65bffc9e33b97aa56 +size 182128 diff --git a/shared/package-files/43/434096829406e7330fc707342ceaf97903847e63aa8257e9c9d3df055c624ad7/blob b/shared/package-files/43/434096829406e7330fc707342ceaf97903847e63aa8257e9c9d3df055c624ad7/blob new file mode 100644 index 0000000000000000000000000000000000000000..30463da4e4de705df72619ca186997e44e17dfa2 --- /dev/null +++ b/shared/package-files/43/434096829406e7330fc707342ceaf97903847e63aa8257e9c9d3df055c624ad7/blob @@ -0,0 +1 @@ +def is_fp_closed(obj): ... diff --git a/shared/package-files/43/43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8/blob b/shared/package-files/43/43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8/blob new file mode 100644 index 0000000000000000000000000000000000000000..725a55b9c47230c32c63b3e6cd036f0319173046 --- /dev/null +++ b/shared/package-files/43/43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8/blob @@ -0,0 +1,30 @@ +"Test , coverage %." + +from idlelib import zzdummy +import unittest +from test.support import requires +from tkinter import Tk + + +class Test(unittest.TestCase): + + @classmethod + def setUpClass(cls): + requires('gui') + cls.root = Tk() + cls.root.withdraw() + + @classmethod + def tearDownClass(cls): + cls.root.update_idletasks() +## for id in cls.root.tk.call('after', 'info'): +## cls.root.after_cancel(id) # Need for EditorWindow. + cls.root.destroy() + del cls.root + + def test_init(self): + self.assertTrue(True) + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/shared/package-files/43/434278a2390e651df0f7a19061ca835b9f2817a57529b85dcd1324963abe4a85/blob b/shared/package-files/43/434278a2390e651df0f7a19061ca835b9f2817a57529b85dcd1324963abe4a85/blob new file mode 100644 index 0000000000000000000000000000000000000000..66147f0d45c9e4e85ff5a617224889826a70f2b3 --- /dev/null +++ b/shared/package-files/43/434278a2390e651df0f7a19061ca835b9f2817a57529b85dcd1324963abe4a85/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:434278a2390e651df0f7a19061ca835b9f2817a57529b85dcd1324963abe4a85 +size 828890 diff --git a/shared/package-files/43/43430bd542f6d28be949cf455686e9fefdaac873a387426dcf7305fcce282fe2/blob b/shared/package-files/43/43430bd542f6d28be949cf455686e9fefdaac873a387426dcf7305fcce282fe2/blob new file mode 100644 index 0000000000000000000000000000000000000000..ff37d730671ab91e1198d5cf920606cb151eabc5 Binary files /dev/null and b/shared/package-files/43/43430bd542f6d28be949cf455686e9fefdaac873a387426dcf7305fcce282fe2/blob differ diff --git a/shared/package-files/43/4343151fbedc5015ccb4a5740f67fc4b27fdd2b7a63ded047cba9eebe9ac01e2/blob b/shared/package-files/43/4343151fbedc5015ccb4a5740f67fc4b27fdd2b7a63ded047cba9eebe9ac01e2/blob new file mode 100644 index 0000000000000000000000000000000000000000..9b2e64df22bd3c9259af5273b412d356d6d889c1 --- /dev/null +++ b/shared/package-files/43/4343151fbedc5015ccb4a5740f67fc4b27fdd2b7a63ded047cba9eebe9ac01e2/blob @@ -0,0 +1,117 @@ +"""Utility.""" +from __future__ import annotations +from functools import wraps, lru_cache +import warnings +import re +from typing import Callable, Any + +DEBUG = 0x00001 + +RE_PATTERN_LINE_SPLIT = re.compile(r'(?:\r\n|(?!\r\n)[\n\r])|$') + +UC_A = ord('A') +UC_Z = ord('Z') + + +@lru_cache(maxsize=512) +def lower(string: str) -> str: + """Lower.""" + + new_string = [] + for c in string: + o = ord(c) + new_string.append(chr(o + 32) if UC_A <= o <= UC_Z else c) + return ''.join(new_string) + + +class SelectorSyntaxError(Exception): + """Syntax error in a CSS selector.""" + + def __init__(self, msg: str, pattern: str | None = None, index: int | None = None) -> None: + """Initialize.""" + + self.line = None + self.col = None + self.context = None + + if pattern is not None and index is not None: + # Format pattern to show line and column position + self.context, self.line, self.col = get_pattern_context(pattern, index) + msg = f'{msg}\n line {self.line}:\n{self.context}' + + super().__init__(msg) + + +def deprecated(message: str, stacklevel: int = 2) -> Callable[..., Any]: # pragma: no cover + """ + Raise a `DeprecationWarning` when wrapped function/method is called. + + Usage: + + @deprecated("This method will be removed in version X; use Y instead.") + def some_method()" + pass + """ + + def _wrapper(func: Callable[..., Any]) -> Callable[..., Any]: + @wraps(func) + def _deprecated_func(*args: Any, **kwargs: Any) -> Any: + warnings.warn( + f"'{func.__name__}' is deprecated. {message}", + category=DeprecationWarning, + stacklevel=stacklevel + ) + return func(*args, **kwargs) + return _deprecated_func + return _wrapper + + +def warn_deprecated(message: str, stacklevel: int = 2) -> None: # pragma: no cover + """Warn deprecated.""" + + warnings.warn( + message, + category=DeprecationWarning, + stacklevel=stacklevel + ) + + +def get_pattern_context(pattern: str, index: int) -> tuple[str, int, int]: + """Get the pattern context.""" + + last = 0 + current_line = 1 + col = 1 + text = [] # type: list[str] + line = 1 + offset = None # type: int | None + + # Split pattern by newline and handle the text before the newline + for m in RE_PATTERN_LINE_SPLIT.finditer(pattern): + linetext = pattern[last:m.start(0)] + if not len(m.group(0)) and not len(text): + indent = '' + offset = -1 + col = index - last + 1 + elif last <= index < m.end(0): + indent = '--> ' + offset = (-1 if index > m.start(0) else 0) + 3 + col = index - last + 1 + else: + indent = ' ' + offset = None + if len(text): + # Regardless of whether we are presented with `\r\n`, `\r`, or `\n`, + # we will render the output with just `\n`. We will still log the column + # correctly though. + text.append('\n') + text.append(f'{indent}{linetext}') + if offset is not None: + text.append('\n') + text.append(' ' * (col + offset) + '^') + line = current_line + + current_line += 1 + last = m.end(0) + + return ''.join(text), line, col diff --git a/shared/package-files/43/43455392e64315bf29a808669fc4ab06175ff703465e14728a52dc6fb9ec673a/blob b/shared/package-files/43/43455392e64315bf29a808669fc4ab06175ff703465e14728a52dc6fb9ec673a/blob new file mode 100644 index 0000000000000000000000000000000000000000..058fdbb796fc12e1238b3a76ade4575504b0f0f0 --- /dev/null +++ b/shared/package-files/43/43455392e64315bf29a808669fc4ab06175ff703465e14728a52dc6fb9ec673a/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor floor(const at::Tensor & self); +TORCH_API at::Tensor & floor_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & floor_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & floor_(at::Tensor & self); + +} // namespace meta +} // namespace at diff --git a/shared/package-files/43/43468b24c718f10346d5b61b54b90a50fb97417dc4f9fa2a39fd58b979f5ba60/blob b/shared/package-files/43/43468b24c718f10346d5b61b54b90a50fb97417dc4f9fa2a39fd58b979f5ba60/blob new file mode 100644 index 0000000000000000000000000000000000000000..4f8b922fd1a2d4b97b8322328461c2b5dd528dcc --- /dev/null +++ b/shared/package-files/43/43468b24c718f10346d5b61b54b90a50fb97417dc4f9fa2a39fd58b979f5ba60/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & triu_indices_out(at::Tensor & out, int64_t row, int64_t col, int64_t offset=0); +TORCH_API at::Tensor & triu_indices_outf(int64_t row, int64_t col, int64_t offset, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/43/4347103a34515e5a5989ec49fc4ea8fe142e0daecf73feb1e28dc1ce097046db/blob b/shared/package-files/43/4347103a34515e5a5989ec49fc4ea8fe142e0daecf73feb1e28dc1ce097046db/blob new file mode 100644 index 0000000000000000000000000000000000000000..e5cff27878114cfd50192a97d2efdc7bed7228a0 --- /dev/null +++ b/shared/package-files/43/4347103a34515e5a5989ec49fc4ea8fe142e0daecf73feb1e28dc1ce097046db/blob @@ -0,0 +1,141 @@ +import argparse +import os +import sys +from pprint import pprint + +from . import __version__, api + + +def parse_args(parse_this=None): + parser = build_parser() + return parser.parse_args(parse_this) + + +def build_parser(): + parser = argparse.ArgumentParser() + parser.add_argument( + "-V", + "--version", + action="version", + help="Show the conda-package-handling version number and exit.", + version=f"conda-package-handling {__version__}", + ) + sp = parser.add_subparsers(title="subcommands", dest="subcommand", required=True) + + extract_parser = sp.add_parser("extract", help="extract package contents", aliases=["x"]) + extract_parser.add_argument("archive_path", help="path to archive to extract") + extract_parser.add_argument( + "--dest", + help="destination folder to extract to. If not set, defaults to" + " package filename minus extension in the same folder as the input archive." + " May be relative path used in tandem with the --prefix flag.", + ) + extract_parser.add_argument( + "--prefix", + help="base directory to extract to. Use this to set the base" + " directory, while allowing the folder name to be automatically determined " + "by the input filename. An abspath --prefix with an unset --dest will " + "achieve this.", + ) + extract_parser.add_argument( + "--info", + help="If the archive supports separate metadata, this" + " flag extracts only the metadata in the info folder from the " + "package. If the archive does not support separate metadata, this " + "flag has no effect and all files are extracted.", + action="store_true", + ) + + create_parser = sp.add_parser("create", help="bundle files into a package", aliases=["c"]) + create_parser.add_argument( + "prefix", + help="folder of files to bundle. Not strictly required to" + " have conda package metadata, but if conda package metadata isn't " + "present, you'll see a warning and your file will not work as a " + "conda package", + ) + create_parser.add_argument( + "out_fn", + help="Filename of archive to be created. Extension determines package type.", + ) + create_parser.add_argument( + "--file-list", + help="Path to file containing one relative path per" + " line that should be included in the archive. If not provided, " + "lists all files in the prefix.", + ) + create_parser.add_argument("--out-folder", help="Folder to dump final archive to") + + convert_parser = sp.add_parser( + "transmute", help="convert from one package type to another", aliases=["t"] + ) + convert_parser.add_argument( + "in_file", help="existing file to convert from. Glob patterns accepted." + ) + convert_parser.add_argument( + "out_ext", + help="extension of file to convert to. Examples: .tar.bz2, .conda", + ) + convert_parser.add_argument("--out-folder", help="Folder to dump final archive to") + convert_parser.add_argument( + "--force", action="store_true", help="Force overwrite existing package" + ) + convert_parser.add_argument( + "--processes", + type=int, + help="Max number of processes to use. If not set, defaults to 1.", + ) + convert_parser.add_argument( + "--zstd-compression-level", + help=( + "When building v2 packages, set the compression level used by " + "conda-package-handling. Defaults to 19." + ), + type=int, + choices=range(1, 23), + default=19, + ) + convert_parser.add_argument( + "--zstd-compression-threads", + help=( + "When building v2 packages, set the compression threads used by " + "conda-package-handling. Defaults to 1. -1=automatic." + ), + type=int, + default=1, + ) + + return parser + + +def main(args=None): + args = parse_args(args) + if hasattr(args, "out_folder") and args.out_folder: + args.out_folder = ( + os.path.abspath(os.path.normpath(os.path.expanduser(args.out_folder))) + os.sep + ) + if args.subcommand in ("extract", "x"): + if args.info: + api.extract(args.archive_path, args.dest, components="info", prefix=args.prefix) + else: + api.extract(args.archive_path, args.dest, prefix=args.prefix) + elif args.subcommand in ("create", "c"): + api.create(args.prefix, args.file_list, args.out_fn, args.out_folder) + elif args.subcommand in ("transmute", "t"): + failed_files = api.transmute( + args.in_file, + args.out_ext, + args.out_folder, + args.processes or 1, + force=args.force, + zstd_compress_level=args.zstd_compression_level, + zstd_compress_threads=args.zstd_compression_threads, + ) + if failed_files: + print("failed files:") + pprint(failed_files) + sys.exit(1) + + +if __name__ == "__main__": # pragma: no cover + main(args=None) diff --git a/shared/package-files/43/43478e3e3c1982284b64c0a2a217b73580dd38e9b332be9a888e20ebac18c516/blob b/shared/package-files/43/43478e3e3c1982284b64c0a2a217b73580dd38e9b332be9a888e20ebac18c516/blob new file mode 100644 index 0000000000000000000000000000000000000000..670eff51bdf56c0e2fe9fd64a60f3e4d65020c1f --- /dev/null +++ b/shared/package-files/43/43478e3e3c1982284b64c0a2a217b73580dd38e9b332be9a888e20ebac18c516/blob @@ -0,0 +1,24 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & _to_sparse_csr_out(const at::Tensor & self, c10::optional dense_dim, at::Tensor & out); +TORCH_API at::Tensor dense_to_sparse_csr(const at::Tensor & self, c10::optional dense_dim=c10::nullopt); +TORCH_API at::Tensor coo_to_sparse_csr(const at::Tensor & self, c10::optional dense_dim=c10::nullopt); +TORCH_API at::Tensor sparse_compressed_to_sparse_csr(const at::Tensor & self, c10::optional dense_dim=c10::nullopt); +} // namespace native +} // namespace at diff --git a/shared/package-files/43/4348eb6f8cde0eb77ad5b53857c4ea8cc73421ea7cad667266a274baab2e9f1b/blob b/shared/package-files/43/4348eb6f8cde0eb77ad5b53857c4ea8cc73421ea7cad667266a274baab2e9f1b/blob new file mode 100644 index 0000000000000000000000000000000000000000..0666fb0dd161cb732b29f84d49c49cc985a3559a Binary files /dev/null and b/shared/package-files/43/4348eb6f8cde0eb77ad5b53857c4ea8cc73421ea7cad667266a274baab2e9f1b/blob differ diff --git a/shared/package-files/43/434af71ad039cb644690e8f9e8e4d91b9b6e072d41ea47db872ac9a8281fdbb8/blob b/shared/package-files/43/434af71ad039cb644690e8f9e8e4d91b9b6e072d41ea47db872ac9a8281fdbb8/blob new file mode 100644 index 0000000000000000000000000000000000000000..9e74745ca79137918281337fa270c5fec4bd7da1 Binary files /dev/null and b/shared/package-files/43/434af71ad039cb644690e8f9e8e4d91b9b6e072d41ea47db872ac9a8281fdbb8/blob differ diff --git a/shared/package-files/43/434b323cc23912fb6033e084f985ca3a42fd7855006678ff5f6221a23e91e29e/blob b/shared/package-files/43/434b323cc23912fb6033e084f985ca3a42fd7855006678ff5f6221a23e91e29e/blob new file mode 100644 index 0000000000000000000000000000000000000000..f404665579a0b1916174203f13f7339a75a347a5 Binary files /dev/null and b/shared/package-files/43/434b323cc23912fb6033e084f985ca3a42fd7855006678ff5f6221a23e91e29e/blob differ diff --git a/shared/package-files/43/434fab2b9c1705b6f3bf1e0ca5ff767484cf80becbc23c3cb7808b7e9615d21c/blob b/shared/package-files/43/434fab2b9c1705b6f3bf1e0ca5ff767484cf80becbc23c3cb7808b7e9615d21c/blob new file mode 100644 index 0000000000000000000000000000000000000000..b44e66081fab5c788faf712ec4cece96d2a6db6f --- /dev/null +++ b/shared/package-files/43/434fab2b9c1705b6f3bf1e0ca5ff767484cf80becbc23c3cb7808b7e9615d21c/blob @@ -0,0 +1,31 @@ +from tkinter.commondialog import Dialog +from typing import Any, Optional + +ERROR: str +INFO: str +QUESTION: str +WARNING: str +ABORTRETRYIGNORE: str +OK: str +OKCANCEL: str +RETRYCANCEL: str +YESNO: str +YESNOCANCEL: str +ABORT: str +RETRY: str +IGNORE: str +CANCEL: str +YES: str +NO: str + +class Message(Dialog): + command: str = ... + +def showinfo(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... +def showwarning(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... +def showerror(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... +def askquestion(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... +def askokcancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ... +def askyesno(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ... +def askyesnocancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> Optional[bool]: ... +def askretrycancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ... diff --git a/shared/package-files/43/43526b09c1f8f6d7854fa767c51a347d0bc323d495e380470a4f6d8c97372e9d/blob b/shared/package-files/43/43526b09c1f8f6d7854fa767c51a347d0bc323d495e380470a4f6d8c97372e9d/blob new file mode 100644 index 0000000000000000000000000000000000000000..b6227e6152ef9b8743d08c60bb0492a07bf9cf80 --- /dev/null +++ b/shared/package-files/43/43526b09c1f8f6d7854fa767c51a347d0bc323d495e380470a4f6d8c97372e9d/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API max_pool3d_with_indices_backward_grad_input { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::max_pool3d_with_indices_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "grad_input") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "max_pool3d_with_indices_backward.grad_input(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, int[3] dilation, bool ceil_mode, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices, at::Tensor & grad_input); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices, at::Tensor & grad_input); +}; + +struct TORCH_API max_pool3d_with_indices_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::max_pool3d_with_indices_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "max_pool3d_with_indices_backward(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, int[3] dilation, bool ceil_mode, Tensor indices) -> Tensor") + static at::Tensor call(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/43/4355a8ae1353dc1f690b923a8aa2fad9b50e905130dc1d5cacf049b0752c6636/blob b/shared/package-files/43/4355a8ae1353dc1f690b923a8aa2fad9b50e905130dc1d5cacf049b0752c6636/blob new file mode 100644 index 0000000000000000000000000000000000000000..d28c43c45647a53bea2877760868ae1fa11264d6 --- /dev/null +++ b/shared/package-files/43/4355a8ae1353dc1f690b923a8aa2fad9b50e905130dc1d5cacf049b0752c6636/blob @@ -0,0 +1,644 @@ +""" +Tests dtype specification during parsing +for all of the parsers defined in parsers.py +""" +from collections import defaultdict +from io import StringIO + +import numpy as np +import pytest + +from pandas.errors import ParserWarning + +import pandas as pd +from pandas import ( + DataFrame, + Timestamp, +) +import pandas._testing as tm +from pandas.core.arrays import IntegerArray + +pytestmark = pytest.mark.filterwarnings( + "ignore:Passing a BlockManager to DataFrame:DeprecationWarning" +) + +xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail") + + +@pytest.mark.parametrize("dtype", [str, object]) +@pytest.mark.parametrize("check_orig", [True, False]) +@pytest.mark.usefixtures("pyarrow_xfail") +def test_dtype_all_columns(all_parsers, dtype, check_orig, using_infer_string): + # see gh-3795, gh-6607 + parser = all_parsers + + df = DataFrame( + np.random.default_rng(2).random((5, 2)).round(4), + columns=list("AB"), + index=["1A", "1B", "1C", "1D", "1E"], + ) + + with tm.ensure_clean("__passing_str_as_dtype__.csv") as path: + df.to_csv(path) + + result = parser.read_csv(path, dtype=dtype, index_col=0) + + if check_orig: + expected = df.copy() + result = result.astype(float) + elif using_infer_string and dtype is str: + expected = df.astype(str) + else: + expected = df.astype(str).astype(object) + + tm.assert_frame_equal(result, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_dtype_per_column(all_parsers): + parser = all_parsers + data = """\ +one,two +1,2.5 +2,3.5 +3,4.5 +4,5.5""" + expected = DataFrame( + [[1, "2.5"], [2, "3.5"], [3, "4.5"], [4, "5.5"]], columns=["one", "two"] + ) + expected["one"] = expected["one"].astype(np.float64) + + result = parser.read_csv(StringIO(data), dtype={"one": np.float64, 1: str}) + tm.assert_frame_equal(result, expected) + + +def test_invalid_dtype_per_column(all_parsers): + parser = all_parsers + data = """\ +one,two +1,2.5 +2,3.5 +3,4.5 +4,5.5""" + + with pytest.raises(TypeError, match="data type [\"']foo[\"'] not understood"): + parser.read_csv(StringIO(data), dtype={"one": "foo", 1: "int"}) + + +def test_raise_on_passed_int_dtype_with_nas(all_parsers): + # see gh-2631 + parser = all_parsers + data = """YEAR, DOY, a +2001,106380451,10 +2001,,11 +2001,106380451,67""" + + if parser.engine == "c": + msg = "Integer column has NA values" + elif parser.engine == "pyarrow": + msg = "The 'skipinitialspace' option is not supported with the 'pyarrow' engine" + else: + msg = "Unable to convert column DOY" + + with pytest.raises(ValueError, match=msg): + parser.read_csv(StringIO(data), dtype={"DOY": np.int64}, skipinitialspace=True) + + +def test_dtype_with_converters(all_parsers): + parser = all_parsers + data = """a,b +1.1,2.2 +1.2,2.3""" + + if parser.engine == "pyarrow": + msg = "The 'converters' option is not supported with the 'pyarrow' engine" + with pytest.raises(ValueError, match=msg): + parser.read_csv( + StringIO(data), dtype={"a": "i8"}, converters={"a": lambda x: str(x)} + ) + return + + # Dtype spec ignored if converted specified. + result = parser.read_csv_check_warnings( + ParserWarning, + "Both a converter and dtype were specified for column a " + "- only the converter will be used.", + StringIO(data), + dtype={"a": "i8"}, + converters={"a": lambda x: str(x)}, + ) + expected = DataFrame({"a": ["1.1", "1.2"], "b": [2.2, 2.3]}) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.parametrize( + "dtype", list(np.typecodes["AllInteger"] + np.typecodes["Float"]) +) +def test_numeric_dtype(all_parsers, dtype): + data = "0\n1" + parser = all_parsers + expected = DataFrame([0, 1], dtype=dtype) + + result = parser.read_csv(StringIO(data), header=None, dtype=dtype) + tm.assert_frame_equal(expected, result) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_boolean_dtype(all_parsers): + parser = all_parsers + data = "\n".join( + [ + "a", + "True", + "TRUE", + "true", + "1", + "1.0", + "False", + "FALSE", + "false", + "0", + "0.0", + "NaN", + "nan", + "NA", + "null", + "NULL", + ] + ) + + result = parser.read_csv(StringIO(data), dtype="boolean") + expected = DataFrame( + { + "a": pd.array( + [ + True, + True, + True, + True, + True, + False, + False, + False, + False, + False, + None, + None, + None, + None, + None, + ], + dtype="boolean", + ) + } + ) + + tm.assert_frame_equal(result, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_delimiter_with_usecols_and_parse_dates(all_parsers): + # GH#35873 + result = all_parsers.read_csv( + StringIO('"dump","-9,1","-9,1",20101010'), + engine="python", + names=["col", "col1", "col2", "col3"], + usecols=["col1", "col2", "col3"], + parse_dates=["col3"], + decimal=",", + ) + expected = DataFrame( + {"col1": [-9.1], "col2": [-9.1], "col3": [Timestamp("2010-10-10")]} + ) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.parametrize("thousands", ["_", None]) +def test_decimal_and_exponential( + request, python_parser_only, numeric_decimal, thousands +): + # GH#31920 + decimal_number_check(request, python_parser_only, numeric_decimal, thousands, None) + + +@pytest.mark.parametrize("thousands", ["_", None]) +@pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"]) +def test_1000_sep_decimal_float_precision( + request, c_parser_only, numeric_decimal, float_precision, thousands +): + # test decimal and thousand sep handling in across 'float_precision' + # parsers + decimal_number_check( + request, c_parser_only, numeric_decimal, thousands, float_precision + ) + text, value = numeric_decimal + text = " " + text + " " + if isinstance(value, str): # the negative cases (parse as text) + value = " " + value + " " + decimal_number_check( + request, c_parser_only, (text, value), thousands, float_precision + ) + + +def decimal_number_check(request, parser, numeric_decimal, thousands, float_precision): + # GH#31920 + value = numeric_decimal[0] + if thousands is None and value in ("1_,", "1_234,56", "1_234,56e0"): + request.applymarker( + pytest.mark.xfail(reason=f"thousands={thousands} and sep is in {value}") + ) + df = parser.read_csv( + StringIO(value), + float_precision=float_precision, + sep="|", + thousands=thousands, + decimal=",", + header=None, + ) + val = df.iloc[0, 0] + assert val == numeric_decimal[1] + + +@pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"]) +def test_skip_whitespace(c_parser_only, float_precision): + DATA = """id\tnum\t +1\t1.2 \t +1\t 2.1\t +2\t 1\t +2\t 1.2 \t +""" + df = c_parser_only.read_csv( + StringIO(DATA), + float_precision=float_precision, + sep="\t", + header=0, + dtype={1: np.float64}, + ) + tm.assert_series_equal(df.iloc[:, 1], pd.Series([1.2, 2.1, 1.0, 1.2], name="num")) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_true_values_cast_to_bool(all_parsers): + # GH#34655 + text = """a,b +yes,xxx +no,yyy +1,zzz +0,aaa + """ + parser = all_parsers + result = parser.read_csv( + StringIO(text), + true_values=["yes"], + false_values=["no"], + dtype={"a": "boolean"}, + ) + expected = DataFrame( + {"a": [True, False, True, False], "b": ["xxx", "yyy", "zzz", "aaa"]} + ) + expected["a"] = expected["a"].astype("boolean") + tm.assert_frame_equal(result, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +@pytest.mark.parametrize("dtypes, exp_value", [({}, "1"), ({"a.1": "int64"}, 1)]) +def test_dtype_mangle_dup_cols(all_parsers, dtypes, exp_value): + # GH#35211 + parser = all_parsers + data = """a,a\n1,1""" + dtype_dict = {"a": str, **dtypes} + # GH#42462 + dtype_dict_copy = dtype_dict.copy() + result = parser.read_csv(StringIO(data), dtype=dtype_dict) + expected = DataFrame({"a": ["1"], "a.1": [exp_value]}) + assert dtype_dict == dtype_dict_copy, "dtype dict changed" + tm.assert_frame_equal(result, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_dtype_mangle_dup_cols_single_dtype(all_parsers): + # GH#42022 + parser = all_parsers + data = """a,a\n1,1""" + result = parser.read_csv(StringIO(data), dtype=str) + expected = DataFrame({"a": ["1"], "a.1": ["1"]}) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_dtype_multi_index(all_parsers): + # GH 42446 + parser = all_parsers + data = "A,B,B\nX,Y,Z\n1,2,3" + + result = parser.read_csv( + StringIO(data), + header=list(range(2)), + dtype={ + ("A", "X"): np.int32, + ("B", "Y"): np.int32, + ("B", "Z"): np.float32, + }, + ) + + expected = DataFrame( + { + ("A", "X"): np.int32([1]), + ("B", "Y"): np.int32([2]), + ("B", "Z"): np.float32([3]), + } + ) + + tm.assert_frame_equal(result, expected) + + +def test_nullable_int_dtype(all_parsers, any_int_ea_dtype): + # GH 25472 + parser = all_parsers + dtype = any_int_ea_dtype + + data = """a,b,c +,3,5 +1,,6 +2,4,""" + expected = DataFrame( + { + "a": pd.array([pd.NA, 1, 2], dtype=dtype), + "b": pd.array([3, pd.NA, 4], dtype=dtype), + "c": pd.array([5, 6, pd.NA], dtype=dtype), + } + ) + actual = parser.read_csv(StringIO(data), dtype=dtype) + tm.assert_frame_equal(actual, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +@pytest.mark.parametrize("default", ["float", "float64"]) +def test_dtypes_defaultdict(all_parsers, default): + # GH#41574 + data = """a,b +1,2 +""" + dtype = defaultdict(lambda: default, a="int64") + parser = all_parsers + result = parser.read_csv(StringIO(data), dtype=dtype) + expected = DataFrame({"a": [1], "b": 2.0}) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_dtypes_defaultdict_mangle_dup_cols(all_parsers): + # GH#41574 + data = """a,b,a,b,b.1 +1,2,3,4,5 +""" + dtype = defaultdict(lambda: "float64", a="int64") + dtype["b.1"] = "int64" + parser = all_parsers + result = parser.read_csv(StringIO(data), dtype=dtype) + expected = DataFrame({"a": [1], "b": [2.0], "a.1": [3], "b.2": [4.0], "b.1": [5]}) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.usefixtures("pyarrow_xfail") +def test_dtypes_defaultdict_invalid(all_parsers): + # GH#41574 + data = """a,b +1,2 +""" + dtype = defaultdict(lambda: "invalid_dtype", a="int64") + parser = all_parsers + with pytest.raises(TypeError, match="not understood"): + parser.read_csv(StringIO(data), dtype=dtype) + + +def test_dtype_backend(all_parsers): + # GH#36712 + + parser = all_parsers + + data = """a,b,c,d,e,f,g,h,i,j +1,2.5,True,a,,,,,12-31-2019, +3,4.5,False,b,6,7.5,True,a,12-31-2019, +""" + result = parser.read_csv( + StringIO(data), dtype_backend="numpy_nullable", parse_dates=["i"] + ) + expected = DataFrame( + { + "a": pd.Series([1, 3], dtype="Int64"), + "b": pd.Series([2.5, 4.5], dtype="Float64"), + "c": pd.Series([True, False], dtype="boolean"), + "d": pd.Series(["a", "b"], dtype="string"), + "e": pd.Series([pd.NA, 6], dtype="Int64"), + "f": pd.Series([pd.NA, 7.5], dtype="Float64"), + "g": pd.Series([pd.NA, True], dtype="boolean"), + "h": pd.Series([pd.NA, "a"], dtype="string"), + "i": pd.Series([Timestamp("2019-12-31")] * 2), + "j": pd.Series([pd.NA, pd.NA], dtype="Int64"), + } + ) + tm.assert_frame_equal(result, expected) + + +def test_dtype_backend_and_dtype(all_parsers): + # GH#36712 + + parser = all_parsers + + data = """a,b +1,2.5 +, +""" + result = parser.read_csv( + StringIO(data), dtype_backend="numpy_nullable", dtype="float64" + ) + expected = DataFrame({"a": [1.0, np.nan], "b": [2.5, np.nan]}) + tm.assert_frame_equal(result, expected) + + +def test_dtype_backend_string(all_parsers, string_storage): + # GH#36712 + with pd.option_context("mode.string_storage", string_storage): + parser = all_parsers + + data = """a,b +a,x +b, +""" + result = parser.read_csv(StringIO(data), dtype_backend="numpy_nullable") + + expected = DataFrame( + { + "a": pd.array(["a", "b"], dtype=pd.StringDtype(string_storage)), + "b": pd.array(["x", pd.NA], dtype=pd.StringDtype(string_storage)), + }, + ) + tm.assert_frame_equal(result, expected) + + +def test_dtype_backend_ea_dtype_specified(all_parsers): + # GH#491496 + data = """a,b +1,2 +""" + parser = all_parsers + result = parser.read_csv( + StringIO(data), dtype="Int64", dtype_backend="numpy_nullable" + ) + expected = DataFrame({"a": [1], "b": 2}, dtype="Int64") + tm.assert_frame_equal(result, expected) + + +def test_dtype_backend_pyarrow(all_parsers, request): + # GH#36712 + pa = pytest.importorskip("pyarrow") + parser = all_parsers + + data = """a,b,c,d,e,f,g,h,i,j +1,2.5,True,a,,,,,12-31-2019, +3,4.5,False,b,6,7.5,True,a,12-31-2019, +""" + result = parser.read_csv(StringIO(data), dtype_backend="pyarrow", parse_dates=["i"]) + expected = DataFrame( + { + "a": pd.Series([1, 3], dtype="int64[pyarrow]"), + "b": pd.Series([2.5, 4.5], dtype="float64[pyarrow]"), + "c": pd.Series([True, False], dtype="bool[pyarrow]"), + "d": pd.Series(["a", "b"], dtype=pd.ArrowDtype(pa.string())), + "e": pd.Series([pd.NA, 6], dtype="int64[pyarrow]"), + "f": pd.Series([pd.NA, 7.5], dtype="float64[pyarrow]"), + "g": pd.Series([pd.NA, True], dtype="bool[pyarrow]"), + "h": pd.Series( + [pd.NA, "a"], + dtype=pd.ArrowDtype(pa.string()), + ), + "i": pd.Series([Timestamp("2019-12-31")] * 2), + "j": pd.Series([pd.NA, pd.NA], dtype="null[pyarrow]"), + } + ) + tm.assert_frame_equal(result, expected) + + +# pyarrow engine failing: +# https://github.com/pandas-dev/pandas/issues/56136 +@pytest.mark.usefixtures("pyarrow_xfail") +def test_ea_int_avoid_overflow(all_parsers): + # GH#32134 + parser = all_parsers + data = """a,b +1,1 +,1 +1582218195625938945,1 +""" + result = parser.read_csv(StringIO(data), dtype={"a": "Int64"}) + expected = DataFrame( + { + "a": IntegerArray( + np.array([1, 1, 1582218195625938945]), np.array([False, True, False]) + ), + "b": 1, + } + ) + tm.assert_frame_equal(result, expected) + + +def test_string_inference(all_parsers): + # GH#54430 + dtype = pd.StringDtype(na_value=np.nan) + + data = """a,b +x,1 +y,2 +,3""" + parser = all_parsers + with pd.option_context("future.infer_string", True): + result = parser.read_csv(StringIO(data)) + + expected = DataFrame( + {"a": pd.Series(["x", "y", None], dtype=dtype), "b": [1, 2, 3]}, + columns=pd.Index(["a", "b"], dtype=dtype), + ) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.parametrize("dtype", ["O", object, "object", np.object_, str, np.str_]) +def test_string_inference_object_dtype(all_parsers, dtype, using_infer_string): + # GH#56047 + data = """a,b +x,a +y,a +z,a""" + parser = all_parsers + with pd.option_context("future.infer_string", True): + result = parser.read_csv(StringIO(data), dtype=dtype) + + expected_dtype = pd.StringDtype(na_value=np.nan) if dtype is str else object + expected = DataFrame( + { + "a": pd.Series(["x", "y", "z"], dtype=expected_dtype), + "b": pd.Series(["a", "a", "a"], dtype=expected_dtype), + }, + columns=pd.Index(["a", "b"], dtype=pd.StringDtype(na_value=np.nan)), + ) + tm.assert_frame_equal(result, expected) + + with pd.option_context("future.infer_string", True): + result = parser.read_csv(StringIO(data), dtype={"a": dtype}) + + expected = DataFrame( + { + "a": pd.Series(["x", "y", "z"], dtype=expected_dtype), + "b": pd.Series(["a", "a", "a"], dtype=pd.StringDtype(na_value=np.nan)), + }, + columns=pd.Index(["a", "b"], dtype=pd.StringDtype(na_value=np.nan)), + ) + tm.assert_frame_equal(result, expected) + + +@xfail_pyarrow +def test_accurate_parsing_of_large_integers(all_parsers): + # GH#52505 + data = """SYMBOL,MOMENT,ID,ID_DEAL +AAPL,20230301181139587,1925036343869802844, +AAPL,20230301181139587,2023552585717889863,2023552585717263358 +NVDA,20230301181139587,2023552585717889863,2023552585717263359 +AMC,20230301181139587,2023552585717889863,2023552585717263360 +AMZN,20230301181139587,2023552585717889759,2023552585717263360 +MSFT,20230301181139587,2023552585717889863,2023552585717263361 +NVDA,20230301181139587,2023552585717889827,2023552585717263361""" + orders = all_parsers.read_csv(StringIO(data), dtype={"ID_DEAL": pd.Int64Dtype()}) + assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263358, "ID_DEAL"]) == 1 + assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263359, "ID_DEAL"]) == 1 + assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263360, "ID_DEAL"]) == 2 + assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263361, "ID_DEAL"]) == 2 + + +def test_dtypes_with_usecols(all_parsers): + # GH#54868 + + parser = all_parsers + data = """a,b,c +1,2,3 +4,5,6""" + + result = parser.read_csv(StringIO(data), usecols=["a", "c"], dtype={"a": object}) + if parser.engine == "pyarrow": + values = [1, 4] + else: + values = ["1", "4"] + expected = DataFrame({"a": pd.Series(values, dtype=object), "c": [3, 6]}) + tm.assert_frame_equal(result, expected) + + +def test_index_col_with_dtype_no_rangeindex(all_parsers): + data = StringIO("345.5,519.5,0\n519.5,726.5,1") + result = all_parsers.read_csv( + data, + header=None, + names=["start", "stop", "bin_id"], + dtype={"start": np.float32, "stop": np.float32, "bin_id": np.uint32}, + index_col="bin_id", + ).index + expected = pd.Index([0, 1], dtype=np.uint32, name="bin_id") + tm.assert_index_equal(result, expected) diff --git a/shared/package-files/43/4358374c599427b08746241c6294a33661daf0fc5c421a6cafb69d0c4b7b3354/blob b/shared/package-files/43/4358374c599427b08746241c6294a33661daf0fc5c421a6cafb69d0c4b7b3354/blob new file mode 100644 index 0000000000000000000000000000000000000000..15f16f04b1d1ffdae952d3fa695908833aff7642 --- /dev/null +++ b/shared/package-files/43/4358374c599427b08746241c6294a33661daf0fc5c421a6cafb69d0c4b7b3354/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4358374c599427b08746241c6294a33661daf0fc5c421a6cafb69d0c4b7b3354 +size 811113 diff --git a/shared/package-files/43/435a5c538077791b30e63b2ff92d0cb047cd51ba7fe1a31d3bfa379f4aed0360/blob b/shared/package-files/43/435a5c538077791b30e63b2ff92d0cb047cd51ba7fe1a31d3bfa379f4aed0360/blob new file mode 100644 index 0000000000000000000000000000000000000000..f53613ba2fd4bb70ec28c0d38b2c4197232e5dce --- /dev/null +++ b/shared/package-files/43/435a5c538077791b30e63b2ff92d0cb047cd51ba7fe1a31d3bfa379f4aed0360/blob @@ -0,0 +1,28 @@ +import sys +from collections.abc import Mapping +from typing import Any, SupportsIndex + +import numpy as np +import numpy.typing as npt + +if sys.version_info >= (3, 11): + from typing import assert_type +else: + from typing_extensions import assert_type + +def mode_func( + ar: npt.NDArray[np.number[Any]], + width: tuple[int, int], + iaxis: SupportsIndex, + kwargs: Mapping[str, Any], +) -> None: ... + +AR_i8: npt.NDArray[np.int64] +AR_f8: npt.NDArray[np.float64] +AR_LIKE: list[int] + +assert_type(np.pad(AR_i8, (2, 3), "constant"), npt.NDArray[np.int64]) +assert_type(np.pad(AR_LIKE, (2, 3), "constant"), npt.NDArray[Any]) + +assert_type(np.pad(AR_f8, (2, 3), mode_func), npt.NDArray[np.float64]) +assert_type(np.pad(AR_f8, (2, 3), mode_func, a=1, b=2), npt.NDArray[np.float64]) diff --git a/shared/package-files/43/435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3/blob b/shared/package-files/43/435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3/blob new file mode 100644 index 0000000000000000000000000000000000000000..e9ebcc326142596b289ef74ee3c35460f598b138 --- /dev/null +++ b/shared/package-files/43/435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3/blob @@ -0,0 +1,206 @@ +import socket +import warnings + + +class TransportSocket: + + """A socket-like wrapper for exposing real transport sockets. + + These objects can be safely returned by APIs like + `transport.get_extra_info('socket')`. All potentially disruptive + operations (like "socket.close()") are banned. + """ + + __slots__ = ('_sock',) + + def __init__(self, sock: socket.socket): + self._sock = sock + + def _na(self, what): + warnings.warn( + f"Using {what} on sockets returned from get_extra_info('socket') " + f"will be prohibited in asyncio 3.9. Please report your use case " + f"to bugs.python.org.", + DeprecationWarning, source=self) + + @property + def family(self): + return self._sock.family + + @property + def type(self): + return self._sock.type + + @property + def proto(self): + return self._sock.proto + + def __repr__(self): + s = ( + f"" + + def __getstate__(self): + raise TypeError("Cannot serialize asyncio.TransportSocket object") + + def fileno(self): + return self._sock.fileno() + + def dup(self): + return self._sock.dup() + + def get_inheritable(self): + return self._sock.get_inheritable() + + def shutdown(self, how): + # asyncio doesn't currently provide a high-level transport API + # to shutdown the connection. + self._sock.shutdown(how) + + def getsockopt(self, *args, **kwargs): + return self._sock.getsockopt(*args, **kwargs) + + def setsockopt(self, *args, **kwargs): + self._sock.setsockopt(*args, **kwargs) + + def getpeername(self): + return self._sock.getpeername() + + def getsockname(self): + return self._sock.getsockname() + + def getsockbyname(self): + return self._sock.getsockbyname() + + def accept(self): + self._na('accept() method') + return self._sock.accept() + + def connect(self, *args, **kwargs): + self._na('connect() method') + return self._sock.connect(*args, **kwargs) + + def connect_ex(self, *args, **kwargs): + self._na('connect_ex() method') + return self._sock.connect_ex(*args, **kwargs) + + def bind(self, *args, **kwargs): + self._na('bind() method') + return self._sock.bind(*args, **kwargs) + + def ioctl(self, *args, **kwargs): + self._na('ioctl() method') + return self._sock.ioctl(*args, **kwargs) + + def listen(self, *args, **kwargs): + self._na('listen() method') + return self._sock.listen(*args, **kwargs) + + def makefile(self): + self._na('makefile() method') + return self._sock.makefile() + + def sendfile(self, *args, **kwargs): + self._na('sendfile() method') + return self._sock.sendfile(*args, **kwargs) + + def close(self): + self._na('close() method') + return self._sock.close() + + def detach(self): + self._na('detach() method') + return self._sock.detach() + + def sendmsg_afalg(self, *args, **kwargs): + self._na('sendmsg_afalg() method') + return self._sock.sendmsg_afalg(*args, **kwargs) + + def sendmsg(self, *args, **kwargs): + self._na('sendmsg() method') + return self._sock.sendmsg(*args, **kwargs) + + def sendto(self, *args, **kwargs): + self._na('sendto() method') + return self._sock.sendto(*args, **kwargs) + + def send(self, *args, **kwargs): + self._na('send() method') + return self._sock.send(*args, **kwargs) + + def sendall(self, *args, **kwargs): + self._na('sendall() method') + return self._sock.sendall(*args, **kwargs) + + def set_inheritable(self, *args, **kwargs): + self._na('set_inheritable() method') + return self._sock.set_inheritable(*args, **kwargs) + + def share(self, process_id): + self._na('share() method') + return self._sock.share(process_id) + + def recv_into(self, *args, **kwargs): + self._na('recv_into() method') + return self._sock.recv_into(*args, **kwargs) + + def recvfrom_into(self, *args, **kwargs): + self._na('recvfrom_into() method') + return self._sock.recvfrom_into(*args, **kwargs) + + def recvmsg_into(self, *args, **kwargs): + self._na('recvmsg_into() method') + return self._sock.recvmsg_into(*args, **kwargs) + + def recvmsg(self, *args, **kwargs): + self._na('recvmsg() method') + return self._sock.recvmsg(*args, **kwargs) + + def recvfrom(self, *args, **kwargs): + self._na('recvfrom() method') + return self._sock.recvfrom(*args, **kwargs) + + def recv(self, *args, **kwargs): + self._na('recv() method') + return self._sock.recv(*args, **kwargs) + + def settimeout(self, value): + if value == 0: + return + raise ValueError( + 'settimeout(): only 0 timeout is allowed on transport sockets') + + def gettimeout(self): + return 0 + + def setblocking(self, flag): + if not flag: + return + raise ValueError( + 'setblocking(): transport sockets cannot be blocking') + + def __enter__(self): + self._na('context manager protocol') + return self._sock.__enter__() + + def __exit__(self, *err): + self._na('context manager protocol') + return self._sock.__exit__(*err) diff --git a/shared/package-files/43/435ea41af1cbc72636039cb3c7a968a62f747944ddc00d04aa4c62c6a395bca5/blob b/shared/package-files/43/435ea41af1cbc72636039cb3c7a968a62f747944ddc00d04aa4c62c6a395bca5/blob new file mode 100644 index 0000000000000000000000000000000000000000..447db7a23ebbac3eac27e0d2d53bdd6fd598c64b --- /dev/null +++ b/shared/package-files/43/435ea41af1cbc72636039cb3c7a968a62f747944ddc00d04aa4c62c6a395bca5/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _native_batch_norm_legit_no_training { + using schema = ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double, double); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_native_batch_norm_legit_no_training") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_native_batch_norm_legit_no_training(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, float momentum, float eps) -> (Tensor, Tensor, Tensor)") + static ::std::tuple call(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps); +}; + +struct TORCH_API _native_batch_norm_legit_no_training_out { + using schema = ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double, double, at::Tensor &, at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_native_batch_norm_legit_no_training") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_native_batch_norm_legit_no_training.out(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, float momentum, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))") + static ::std::tuple call(const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const c10::optional & weight, const c10::optional & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/43/436097ef0fbe9f2b6c9ed43a2245311eeb61a441e8f0740c788b1a0b8328ab57/blob b/shared/package-files/43/436097ef0fbe9f2b6c9ed43a2245311eeb61a441e8f0740c788b1a0b8328ab57/blob new file mode 100644 index 0000000000000000000000000000000000000000..8d1ef04dafc2e8f6b68aa35753fadac4348c9df4 --- /dev/null +++ b/shared/package-files/43/436097ef0fbe9f2b6c9ed43a2245311eeb61a441e8f0740c788b1a0b8328ab57/blob @@ -0,0 +1,6 @@ +from typing import Any + +from django.core.handlers.wsgi import WSGIRequest +from django.http.response import FileResponse + +def serve(request: WSGIRequest, path: str, insecure: bool = ..., **kwargs: Any) -> FileResponse: ... diff --git a/shared/package-files/43/4361486b588fbb45cc46a2536fcc1ec1d3e84d712725766216e60bf999b44f5a/blob b/shared/package-files/43/4361486b588fbb45cc46a2536fcc1ec1d3e84d712725766216e60bf999b44f5a/blob new file mode 100644 index 0000000000000000000000000000000000000000..044edb0e33e47a472990d8264bfa0758e6d8b3c3 --- /dev/null +++ b/shared/package-files/43/4361486b588fbb45cc46a2536fcc1ec1d3e84d712725766216e60bf999b44f5a/blob @@ -0,0 +1,16 @@ +from typing import Any + +from markdown.extensions import Extension +from markdown.inlinepatterns import InlineProcessor + +def build_url(label, base, end): ... + +class WikiLinkExtension(Extension): + def __init__(self, **kwargs) -> None: ... + md: Any + +class WikiLinksInlineProcessor(InlineProcessor): + config: Any + def __init__(self, pattern, config) -> None: ... + +def makeExtension(**kwargs): ... diff --git a/shared/package-files/43/43628687aa0cac91af25c910a5106439c01c446d8a31999dc4f9bd944d2753ff/blob b/shared/package-files/43/43628687aa0cac91af25c910a5106439c01c446d8a31999dc4f9bd944d2753ff/blob new file mode 100644 index 0000000000000000000000000000000000000000..02dd3d04941a3aec22c40cb05ac0ebfdad6d7bd3 --- /dev/null +++ b/shared/package-files/43/43628687aa0cac91af25c910a5106439c01c446d8a31999dc4f9bd944d2753ff/blob @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor _lazy_clone(const at::Tensor & self); +} // namespace native +} // namespace at diff --git a/shared/package-files/43/4362b3293c5c8a44c481d340a2e1708f0b28ac56b7c04f485642aa61df28fcbc/blob b/shared/package-files/43/4362b3293c5c8a44c481d340a2e1708f0b28ac56b7c04f485642aa61df28fcbc/blob new file mode 100644 index 0000000000000000000000000000000000000000..201b8cef790d0bf617b91e93b85a507676660424 --- /dev/null +++ b/shared/package-files/43/4362b3293c5c8a44c481d340a2e1708f0b28ac56b7c04f485642aa61df28fcbc/blob @@ -0,0 +1,643 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "arrow/result.h" +#include "arrow/status.h" +#include "arrow/util/cancel.h" +#include "arrow/util/config.h" +#include "arrow/util/functional.h" +#include "arrow/util/future.h" +#include "arrow/util/iterator.h" +#include "arrow/util/macros.h" +#include "arrow/util/visibility.h" + +#if defined(_MSC_VER) +// Disable harmless warning for decorated name length limit +# pragma warning(disable : 4503) +#endif + +namespace arrow { + +/// \brief Get the capacity of the global thread pool +/// +/// Return the number of worker threads in the thread pool to which +/// Arrow dispatches various CPU-bound tasks. This is an ideal number, +/// not necessarily the exact number of threads at a given point in time. +/// +/// You can change this number using SetCpuThreadPoolCapacity(). +ARROW_EXPORT int GetCpuThreadPoolCapacity(); + +/// \brief Set the capacity of the global thread pool +/// +/// Set the number of worker threads int the thread pool to which +/// Arrow dispatches various CPU-bound tasks. +/// +/// The current number is returned by GetCpuThreadPoolCapacity(). +ARROW_EXPORT Status SetCpuThreadPoolCapacity(int threads); + +namespace internal { + +// Hints about a task that may be used by an Executor. +// They are ignored by the provided ThreadPool implementation. +struct TaskHints { + // The lower, the more urgent + int32_t priority = 0; + // The IO transfer size in bytes + int64_t io_size = -1; + // The approximate CPU cost in number of instructions + int64_t cpu_cost = -1; + // An application-specific ID + int64_t external_id = -1; +}; + +class ARROW_EXPORT Executor { + public: + using StopCallback = internal::FnOnce; + + virtual ~Executor(); + + // Spawn a fire-and-forget task. + template + Status Spawn(Function&& func) { + return SpawnReal(TaskHints{}, std::forward(func), StopToken::Unstoppable(), + StopCallback{}); + } + template + Status Spawn(Function&& func, StopToken stop_token) { + return SpawnReal(TaskHints{}, std::forward(func), std::move(stop_token), + StopCallback{}); + } + template + Status Spawn(TaskHints hints, Function&& func) { + return SpawnReal(hints, std::forward(func), StopToken::Unstoppable(), + StopCallback{}); + } + template + Status Spawn(TaskHints hints, Function&& func, StopToken stop_token) { + return SpawnReal(hints, std::forward(func), std::move(stop_token), + StopCallback{}); + } + template + Status Spawn(TaskHints hints, Function&& func, StopToken stop_token, + StopCallback stop_callback) { + return SpawnReal(hints, std::forward(func), std::move(stop_token), + std::move(stop_callback)); + } + + // Transfers a future to this executor. Any continuations added to the + // returned future will run in this executor. Otherwise they would run + // on the same thread that called MarkFinished. + // + // This is necessary when (for example) an I/O task is completing a future. + // The continuations of that future should run on the CPU thread pool keeping + // CPU heavy work off the I/O thread pool. So the I/O task should transfer + // the future to the CPU executor before returning. + // + // By default this method will only transfer if the future is not already completed. If + // the future is already completed then any callback would be run synchronously and so + // no transfer is typically necessary. However, in cases where you want to force a + // transfer (e.g. to help the scheduler break up units of work across multiple cores) + // then you can override this behavior with `always_transfer`. + template + Future Transfer(Future future) { + return DoTransfer(std::move(future), false); + } + + // Overload of Transfer which will always schedule callbacks on new threads even if the + // future is finished when the callback is added. + // + // This can be useful in cases where you want to ensure parallelism + template + Future TransferAlways(Future future) { + return DoTransfer(std::move(future), true); + } + + // Submit a callable and arguments for execution. Return a future that + // will return the callable's result value once. + // The callable's arguments are copied before execution. + template > + Result Submit(TaskHints hints, StopToken stop_token, Function&& func, + Args&&... args) { + using ValueType = typename FutureType::ValueType; + + auto future = FutureType::Make(); + auto task = std::bind(::arrow::detail::ContinueFuture{}, future, + std::forward(func), std::forward(args)...); + struct { + WeakFuture weak_fut; + + void operator()(const Status& st) { + auto fut = weak_fut.get(); + if (fut.is_valid()) { + fut.MarkFinished(st); + } + } + } stop_callback{WeakFuture(future)}; + ARROW_RETURN_NOT_OK(SpawnReal(hints, std::move(task), std::move(stop_token), + std::move(stop_callback))); + + return future; + } + + template > + Result Submit(StopToken stop_token, Function&& func, Args&&... args) { + return Submit(TaskHints{}, stop_token, std::forward(func), + std::forward(args)...); + } + + template > + Result Submit(TaskHints hints, Function&& func, Args&&... args) { + return Submit(std::move(hints), StopToken::Unstoppable(), + std::forward(func), std::forward(args)...); + } + + template > + Result Submit(Function&& func, Args&&... args) { + return Submit(TaskHints{}, StopToken::Unstoppable(), std::forward(func), + std::forward(args)...); + } + + // Return the level of parallelism (the number of tasks that may be executed + // concurrently). This may be an approximate number. + virtual int GetCapacity() = 0; + + // Return true if the thread from which this function is called is owned by this + // Executor. Returns false if this Executor does not support this property. + virtual bool OwnsThisThread() { return false; } + + // Return true if this is the current executor being called + // n.b. this defaults to just calling OwnsThisThread + // unless the threadpool is disabled + virtual bool IsCurrentExecutor() { return OwnsThisThread(); } + + /// \brief An interface to represent something with a custom destructor + /// + /// \see KeepAlive + class ARROW_EXPORT Resource { + public: + virtual ~Resource() = default; + }; + + /// \brief Keep a resource alive until all executor threads have terminated + /// + /// Executors may have static storage duration. In particular, the CPU and I/O + /// executors are currently implemented this way. These threads may access other + /// objects with static storage duration such as the OpenTelemetry runtime context + /// the default memory pool, or other static executors. + /// + /// The order in which these objects are destroyed is difficult to control. In order + /// to ensure those objects remain alive until all threads have finished those objects + /// should be wrapped in a Resource object and passed into this method. The given + /// shared_ptr will be kept alive until all threads have finished their worker loops. + virtual void KeepAlive(std::shared_ptr resource); + + protected: + ARROW_DISALLOW_COPY_AND_ASSIGN(Executor); + + Executor() = default; + + template , typename FTSync = typename FT::SyncType> + Future DoTransfer(Future future, bool always_transfer = false) { + auto transferred = Future::Make(); + if (always_transfer) { + CallbackOptions callback_options = CallbackOptions::Defaults(); + callback_options.should_schedule = ShouldSchedule::Always; + callback_options.executor = this; + auto sync_callback = [transferred](const FTSync& result) mutable { + transferred.MarkFinished(result); + }; + future.AddCallback(sync_callback, callback_options); + return transferred; + } + + // We could use AddCallback's ShouldSchedule::IfUnfinished but we can save a bit of + // work by doing the test here. + auto callback = [this, transferred](const FTSync& result) mutable { + auto spawn_status = + Spawn([transferred, result]() mutable { transferred.MarkFinished(result); }); + if (!spawn_status.ok()) { + transferred.MarkFinished(spawn_status); + } + }; + auto callback_factory = [&callback]() { return callback; }; + if (future.TryAddCallback(callback_factory)) { + return transferred; + } + // If the future is already finished and we aren't going to force spawn a thread + // then we don't need to add another layer of callback and can return the original + // future + return future; + } + + // Subclassing API + virtual Status SpawnReal(TaskHints hints, FnOnce task, StopToken, + StopCallback&&) = 0; +}; + +/// \brief An executor implementation that runs all tasks on a single thread using an +/// event loop. +/// +/// Note: Any sort of nested parallelism will deadlock this executor. Blocking waits are +/// fine but if one task needs to wait for another task it must be expressed as an +/// asynchronous continuation. +class ARROW_EXPORT SerialExecutor : public Executor { + public: + template + using TopLevelTask = internal::FnOnce(Executor*)>; + + ~SerialExecutor() override; + + int GetCapacity() override { return 1; }; + bool OwnsThisThread() override; + Status SpawnReal(TaskHints hints, FnOnce task, StopToken, + StopCallback&&) override; + + // Return the number of tasks either running or in the queue. + int GetNumTasks(); + + /// \brief Runs the TopLevelTask and any scheduled tasks + /// + /// The TopLevelTask (or one of the tasks it schedules) must either return an invalid + /// status or call the finish signal. Failure to do this will result in a deadlock. For + /// this reason it is preferable (if possible) to use the helper methods (below) + /// RunSynchronously/RunSerially which delegates the responsibility onto a Future + /// producer's existing responsibility to always mark a future finished (which can + /// someday be aided by ARROW-12207). + template , + typename FTSync = typename FT::SyncType> + static FTSync RunInSerialExecutor(TopLevelTask initial_task) { + Future fut = SerialExecutor().Run(std::move(initial_task)); + return FutureToSync(fut); + } + + /// \brief Transform an AsyncGenerator into an Iterator + /// + /// An event loop will be created and each call to Next will power the event loop with + /// the calling thread until the next item is ready to be delivered. + /// + /// Note: The iterator's destructor will run until the given generator is fully + /// exhausted. If you wish to abandon iteration before completion then the correct + /// approach is to use a stop token to cause the generator to exhaust early. + template + static Iterator IterateGenerator( + internal::FnOnce()>>(Executor*)> initial_task) { + auto serial_executor = std::unique_ptr(new SerialExecutor()); + auto maybe_generator = std::move(initial_task)(serial_executor.get()); + if (!maybe_generator.ok()) { + return MakeErrorIterator(maybe_generator.status()); + } + auto generator = maybe_generator.MoveValueUnsafe(); + struct SerialIterator { + SerialIterator(std::unique_ptr executor, + std::function()> generator) + : executor(std::move(executor)), generator(std::move(generator)) {} + ARROW_DISALLOW_COPY_AND_ASSIGN(SerialIterator); + ARROW_DEFAULT_MOVE_AND_ASSIGN(SerialIterator); + ~SerialIterator() { + // A serial iterator must be consumed before it can be destroyed. Allowing it to + // do otherwise would lead to resource leakage. There will likely be deadlocks at + // this spot in the future but these will be the result of other bugs and not the + // fact that we are forcing consumption here. + + // If a streaming API needs to support early abandonment then it should be done so + // with a cancellation token and not simply discarding the iterator and expecting + // the underlying work to clean up correctly. + if (executor && !executor->IsFinished()) { + while (true) { + Result maybe_next = Next(); + if (!maybe_next.ok() || IsIterationEnd(*maybe_next)) { + break; + } + } + } + } + + Result Next() { + executor->Unpause(); + // This call may lead to tasks being scheduled in the serial executor + Future next_fut = generator(); + next_fut.AddCallback([this](const Result& res) { + // If we're done iterating we should drain the rest of the tasks in the executor + if (!res.ok() || IsIterationEnd(*res)) { + executor->Finish(); + return; + } + // Otherwise we will break out immediately, leaving the remaining tasks for + // the next call. + executor->Pause(); + }); +#ifdef ARROW_ENABLE_THREADING + // future must run on this thread + // Borrow this thread and run tasks until the future is finished + executor->RunLoop(); +#else + next_fut.Wait(); +#endif + if (!next_fut.is_finished()) { + // Not clear this is possible since RunLoop wouldn't generally exit + // unless we paused/finished which would imply next_fut has been + // finished. + return Status::Invalid( + "Serial executor terminated before next result computed"); + } + // At this point we may still have tasks in the executor, that is ok. + // We will run those tasks the next time through. + return next_fut.result(); + } + + std::unique_ptr executor; + std::function()> generator; + }; + return Iterator(SerialIterator{std::move(serial_executor), std::move(generator)}); + } + +#ifndef ARROW_ENABLE_THREADING + // run a pending task from loop + // returns true if any tasks were run in the last go round the loop (i.e. if it + // returns false, all executors are waiting) + static bool RunTasksOnAllExecutors(); + static SerialExecutor* GetCurrentExecutor(); + + bool IsCurrentExecutor() override; + +#endif + + protected: + virtual void RunLoop(); + + // State uses mutex + struct State; + std::shared_ptr state_; + + SerialExecutor(); + + // We mark the serial executor "finished" when there should be + // no more tasks scheduled on it. It's not strictly needed but + // can help catch bugs where we are trying to use the executor + // after we are done with it. + void Finish(); + bool IsFinished(); + // We pause the executor when we are running an async generator + // and we have received an item that we can deliver. + void Pause(); + void Unpause(); + + template ::SyncType> + Future Run(TopLevelTask initial_task) { + auto final_fut = std::move(initial_task)(this); + final_fut.AddCallback([this](const FTSync&) { Finish(); }); + RunLoop(); + return final_fut; + } + +#ifndef ARROW_ENABLE_THREADING + // we have to run tasks from all live executors + // during RunLoop if we don't have threading + static std::unordered_set all_executors; + // a pointer to the last one called by the loop + // so all tasks get spawned equally + // on multiple calls to RunTasksOnAllExecutors + static SerialExecutor* last_called_executor; + // without threading we can't tell which executor called the + // current process - so we set it in spawning the task + static SerialExecutor* current_executor; +#endif // ARROW_ENABLE_THREADING +}; + +#ifdef ARROW_ENABLE_THREADING + +/// An Executor implementation spawning tasks in FIFO manner on a fixed-size +/// pool of worker threads. +/// +/// Note: Any sort of nested parallelism will deadlock this executor. Blocking waits are +/// fine but if one task needs to wait for another task it must be expressed as an +/// asynchronous continuation. +class ARROW_EXPORT ThreadPool : public Executor { + public: + // Construct a thread pool with the given number of worker threads + static Result> Make(int threads); + + // Like Make(), but takes care that the returned ThreadPool is compatible + // with destruction late at process exit. + static Result> MakeEternal(int threads); + + // Destroy thread pool; the pool will first be shut down + ~ThreadPool() override; + + // Return the desired number of worker threads. + // The actual number of workers may lag a bit before being adjusted to + // match this value. + int GetCapacity() override; + + // Return the number of tasks either running or in the queue. + int GetNumTasks(); + + bool OwnsThisThread() override; + // Dynamically change the number of worker threads. + // + // This function always returns immediately. + // If fewer threads are running than this number, new threads are spawned + // on-demand when needed for task execution. + // If more threads are running than this number, excess threads are reaped + // as soon as possible. + Status SetCapacity(int threads); + + // Heuristic for the default capacity of a thread pool for CPU-bound tasks. + // This is exposed as a static method to help with testing. + // The number returned is guaranteed to be greater or equal to one. + static int DefaultCapacity(); + + // Shutdown the pool. Once the pool starts shutting down, new tasks + // cannot be submitted anymore. + // If "wait" is true, shutdown waits for all pending tasks to be finished. + // If "wait" is false, workers are stopped as soon as currently executing + // tasks are finished. + Status Shutdown(bool wait = true); + + // Wait for the thread pool to become idle + // + // This is useful for sequencing tests + void WaitForIdle(); + + void KeepAlive(std::shared_ptr resource) override; + + struct State; + + protected: + FRIEND_TEST(TestThreadPool, SetCapacity); + FRIEND_TEST(TestGlobalThreadPool, Capacity); + ARROW_FRIEND_EXPORT friend ThreadPool* GetCpuThreadPool(); + + ThreadPool(); + + Status SpawnReal(TaskHints hints, FnOnce task, StopToken, + StopCallback&&) override; + + // Collect finished worker threads, making sure the OS threads have exited + void CollectFinishedWorkersUnlocked(); + // Launch a given number of additional workers + void LaunchWorkersUnlocked(int threads); + // Get the current actual capacity + int GetActualCapacity(); + + static std::shared_ptr MakeCpuThreadPool(); + + std::shared_ptr sp_state_; + State* state_; + bool shutdown_on_destroy_; +}; +#else // ARROW_ENABLE_THREADING +// an executor implementation which pretends to be a thread pool but runs everything +// on the main thread using a static queue (shared between all thread pools, otherwise +// cross-threadpool dependencies will break everything) +class ARROW_EXPORT ThreadPool : public SerialExecutor { + public: + ARROW_FRIEND_EXPORT friend ThreadPool* GetCpuThreadPool(); + + static Result> Make(int threads); + + // Like Make(), but takes care that the returned ThreadPool is compatible + // with destruction late at process exit. + static Result> MakeEternal(int threads); + + // Destroy thread pool; the pool will first be shut down + ~ThreadPool() override; + + // Return the desired number of worker threads. + // The actual number of workers may lag a bit before being adjusted to + // match this value. + int GetCapacity() override; + + virtual int GetActualCapacity(); + + bool OwnsThisThread() override { return true; } + + // Dynamically change the number of worker threads. + // without threading this is equal to the + // number of tasks that can be running at once + // (inside each other) + Status SetCapacity(int threads); + + static int DefaultCapacity() { return 8; } + + // Shutdown the pool. Once the pool starts shutting down, new tasks + // cannot be submitted anymore. + // If "wait" is true, shutdown waits for all pending tasks to be finished. + // If "wait" is false, workers are stopped as soon as currently executing + // tasks are finished. + Status Shutdown(bool wait = true); + + // Wait for the thread pool to become idle + // + // This is useful for sequencing tests + void WaitForIdle(); + + protected: + static std::shared_ptr MakeCpuThreadPool(); + ThreadPool(); +}; + +#endif // ARROW_ENABLE_THREADING + +// Return the process-global thread pool for CPU-bound tasks. +ARROW_EXPORT ThreadPool* GetCpuThreadPool(); + +/// \brief Potentially run an async operation serially (if use_threads is false) +/// \see RunSerially +/// +/// If `use_threads` is true, the global CPU executor is used. +/// If `use_threads` is false, a temporary SerialExecutor is used. +/// `get_future` is called (from this thread) with the chosen executor and must +/// return a future that will eventually finish. This function returns once the +/// future has finished. +template +typename Fut::SyncType RunSynchronously(FnOnce get_future, + bool use_threads) { + if (use_threads) { + auto fut = std::move(get_future)(GetCpuThreadPool()); + return FutureToSync(fut); + } else { + return SerialExecutor::RunInSerialExecutor(std::move(get_future)); + } +} + +/// \brief Potentially iterate an async generator serially (if use_threads is false) +/// using a potentially custom Executor +/// \see IterateGenerator +/// +/// If `use_threads` is true, the custom executor or, if null, +/// the global CPU executor will be used. Each call to +/// the iterator will simply wait until the next item is available. Tasks may run in +/// the background between calls. +/// +/// If `use_threads` is false, the calling thread only will be used. Each call to +/// the iterator will use the calling thread to do enough work to generate one item. +/// Tasks will be left in a queue until the next call and no work will be done between +/// calls. +template +Iterator IterateSynchronously( + FnOnce()>>(Executor*)> get_gen, bool use_threads, + Executor* executor) { + if (use_threads) { + auto used_executor = executor != NULLPTR ? executor : GetCpuThreadPool(); + auto maybe_gen = std::move(get_gen)(used_executor); + if (!maybe_gen.ok()) { + return MakeErrorIterator(maybe_gen.status()); + } + return MakeGeneratorIterator(*maybe_gen); + } else { + return SerialExecutor::IterateGenerator(std::move(get_gen)); + } +} + +/// \brief Potentially iterate an async generator serially (if use_threads is false) +/// using the default CPU thread pool +/// \see IterateGenerator +/// +/// If `use_threads` is true, the global CPU executor will be used. Each call to +/// the iterator will simply wait until the next item is available. Tasks may run in +/// the background between calls. +/// +/// If `use_threads` is false, the calling thread only will be used. Each call to +/// the iterator will use the calling thread to do enough work to generate one item. +/// Tasks will be left in a queue until the next call and no work will be done between +/// calls. +template +Iterator IterateSynchronously( + FnOnce()>>(Executor*)> get_gen, bool use_threads) { + return IterateSynchronously(std::move(get_gen), use_threads, NULLPTR); +} + +} // namespace internal +} // namespace arrow diff --git a/shared/package-files/43/436381bdecd5b99ce2b56bfab79ef225058735c09ef10350b7a6e08a008e8bb1/blob b/shared/package-files/43/436381bdecd5b99ce2b56bfab79ef225058735c09ef10350b7a6e08a008e8bb1/blob new file mode 100644 index 0000000000000000000000000000000000000000..7b6da995c5d3e0e39b9bdf51ae2674f853c070dd --- /dev/null +++ b/shared/package-files/43/436381bdecd5b99ce2b56bfab79ef225058735c09ef10350b7a6e08a008e8bb1/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:436381bdecd5b99ce2b56bfab79ef225058735c09ef10350b7a6e08a008e8bb1 +size 471000 diff --git a/shared/package-files/43/4367347163a998ff4b7ce6cc2c84db86672e2800757dde85695225822320c3a9/blob b/shared/package-files/43/4367347163a998ff4b7ce6cc2c84db86672e2800757dde85695225822320c3a9/blob new file mode 100644 index 0000000000000000000000000000000000000000..236664d9dd6e9750075979ee6d5f9fc517dbdc4f Binary files /dev/null and b/shared/package-files/43/4367347163a998ff4b7ce6cc2c84db86672e2800757dde85695225822320c3a9/blob differ diff --git a/shared/package-files/43/4368c00966aec2cd06c4873f433c5b00e80cac947a42cee8cb1ffa2caef356df/blob b/shared/package-files/43/4368c00966aec2cd06c4873f433c5b00e80cac947a42cee8cb1ffa2caef356df/blob new file mode 100644 index 0000000000000000000000000000000000000000..cb1595e68264fbe5f07b014be4975657fa2fa8cf --- /dev/null +++ b/shared/package-files/43/4368c00966aec2cd06c4873f433c5b00e80cac947a42cee8cb1ffa2caef356df/blob @@ -0,0 +1,29 @@ +import numpy as np +import pytest + +from pandas import ( + IntervalIndex, + Series, + period_range, +) +import pandas._testing as tm + + +class TestValues: + @pytest.mark.parametrize( + "data", + [ + period_range("2000", periods=4), + IntervalIndex.from_breaks([1, 2, 3, 4]), + ], + ) + def test_values_object_extension_dtypes(self, data): + # https://github.com/pandas-dev/pandas/issues/23995 + result = Series(data).values + expected = np.array(data.astype(object)) + tm.assert_numpy_array_equal(result, expected) + + def test_values(self, datetime_series): + tm.assert_almost_equal( + datetime_series.values, list(datetime_series), check_dtype=False + ) diff --git a/shared/package-files/43/4369cfb0a2da996dee21db528550931887deb74233d10cc7e3f854c3b9e2ee33/blob b/shared/package-files/43/4369cfb0a2da996dee21db528550931887deb74233d10cc7e3f854c3b9e2ee33/blob new file mode 100644 index 0000000000000000000000000000000000000000..cbd582bd3ae4c0f38c4ab3c019d053cf665f61f1 --- /dev/null +++ b/shared/package-files/43/4369cfb0a2da996dee21db528550931887deb74233d10cc7e3f854c3b9e2ee33/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor bincount(const at::Tensor & self, const c10::optional & weights={}, int64_t minlength=0); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/43/436cdf92c51d61cf764cbf29a3cd48fda40e9b01d3c1918f8ea5ef24cedc81e9/blob b/shared/package-files/43/436cdf92c51d61cf764cbf29a3cd48fda40e9b01d3c1918f8ea5ef24cedc81e9/blob new file mode 100644 index 0000000000000000000000000000000000000000..638c4870f1ded4567f9b77f695ac8c8f67db85b5 --- /dev/null +++ b/shared/package-files/43/436cdf92c51d61cf764cbf29a3cd48fda40e9b01d3c1918f8ea5ef24cedc81e9/blob @@ -0,0 +1,887 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include "arrow/util/endian.h" +#include "arrow/util/macros.h" +#include "arrow/util/type_traits.h" +#include "arrow/util/visibility.h" + +namespace arrow { + +enum class DecimalStatus { + kSuccess, + kDivideByZero, + kOverflow, + kRescaleDataLoss, +}; + +template +class GenericBasicDecimal { + protected: + struct LittleEndianArrayTag {}; + +#if ARROW_LITTLE_ENDIAN + static constexpr int kHighWordIndex = NWORDS - 1; + static constexpr int kLowWordIndex = 0; +#else + static constexpr int kHighWordIndex = 0; + static constexpr int kLowWordIndex = NWORDS - 1; +#endif + + public: + static constexpr int kBitWidth = BIT_WIDTH; + static constexpr int kByteWidth = kBitWidth / 8; + static constexpr int kNumWords = NWORDS; + + // A constructor tag to introduce a little-endian encoded array + static constexpr LittleEndianArrayTag LittleEndianArray{}; + + using WordArray = std::array; + + /// \brief Empty constructor creates a decimal with a value of 0. + constexpr GenericBasicDecimal() noexcept : array_({0}) {} + + /// \brief Create a decimal from the two's complement representation. + /// + /// Input array is assumed to be in native endianness. + explicit constexpr GenericBasicDecimal(const WordArray& array) noexcept + : array_(array) {} + + /// \brief Create a decimal from the two's complement representation. + /// + /// Input array is assumed to be in little endianness, with native endian elements. + GenericBasicDecimal(LittleEndianArrayTag, const WordArray& array) noexcept + : GenericBasicDecimal(bit_util::little_endian::ToNative(array)) {} + + /// \brief Create a decimal from any integer not wider than 64 bits. + template ::value && (sizeof(T) <= sizeof(uint64_t)), T>::type> + constexpr GenericBasicDecimal(T value) noexcept // NOLINT(runtime/explicit) + : array_(WordsFromLowBits(value)) {} + + /// \brief Create a decimal from an array of bytes. + /// + /// Bytes are assumed to be in native-endian byte order. + explicit GenericBasicDecimal(const uint8_t* bytes) { + memcpy(array_.data(), bytes, sizeof(array_)); + } + + /// \brief Get the bits of the two's complement representation of the number. + /// + /// The elements are in native endian order. The bits within each uint64_t element + /// are in native endian order. For example, on a little endian machine, + /// BasicDecimal128(123).native_endian_array() = {123, 0}; + /// but on a big endian machine, + /// BasicDecimal128(123).native_endian_array() = {0, 123}; + constexpr const WordArray& native_endian_array() const { return array_; } + + /// \brief Get the bits of the two's complement representation of the number. + /// + /// The elements are in little endian order. However, the bits within each + /// uint64_t element are in native endian order. + /// For example, BasicDecimal128(123).little_endian_array() = {123, 0}; + WordArray little_endian_array() const { + return bit_util::little_endian::FromNative(array_); + } + + const uint8_t* native_endian_bytes() const { + return reinterpret_cast(array_.data()); + } + + uint8_t* mutable_native_endian_bytes() { + return reinterpret_cast(array_.data()); + } + + /// \brief Return the raw bytes of the value in native-endian byte order. + std::array ToBytes() const { + std::array out{{0}}; + memcpy(out.data(), array_.data(), kByteWidth); + return out; + } + + /// \brief Copy the raw bytes of the value in native-endian byte order. + void ToBytes(uint8_t* out) const { memcpy(out, array_.data(), kByteWidth); } + + /// Return 1 if positive or zero, -1 if strictly negative. + int64_t Sign() const { + return 1 | (static_cast(array_[kHighWordIndex]) >> 63); + } + + bool IsNegative() const { return static_cast(array_[kHighWordIndex]) < 0; } + + explicit operator bool() const { return array_ != WordArray{}; } + + friend bool operator==(const GenericBasicDecimal& left, + const GenericBasicDecimal& right) { + return left.array_ == right.array_; + } + + friend bool operator!=(const GenericBasicDecimal& left, + const GenericBasicDecimal& right) { + return left.array_ != right.array_; + } + + protected: + WordArray array_; + + template + static constexpr uint64_t SignExtend(T low_bits) noexcept { + return low_bits >= T{} ? uint64_t{0} : ~uint64_t{0}; + } + + template + static constexpr WordArray WordsFromLowBits(T low_bits) { + WordArray words{}; + if (low_bits < T{}) { + for (auto& word : words) { + word = ~uint64_t{0}; + } + } + words[kLowWordIndex] = static_cast(low_bits); + return words; + } +}; + +template +class ARROW_EXPORT SmallBasicDecimal { + public: + static_assert( + std::is_same_v || std::is_same_v, + "for bitwidths larger than 64 bits use BasicDecimal128 and BasicDecimal256"); + + static constexpr int kMaxPrecision = std::numeric_limits::digits10; + static constexpr int kMaxScale = kMaxPrecision; + static constexpr int kBitWidth = sizeof(DigitType) * CHAR_BIT; + static constexpr int kByteWidth = sizeof(DigitType); + + using WordArray = std::array, 1>; + + /// \brief Empty constructor creates a decimal with a value of 0. + constexpr SmallBasicDecimal() noexcept : value_(0) {} + + /// \brief Create a decimal from any integer not wider than 64 bits. + template ::value && (sizeof(T) <= sizeof(int64_t)), T>::type> + constexpr SmallBasicDecimal(T value) noexcept // NOLINT(runtime/explicit) + : value_(static_cast(value)) {} + + /// \brief Create a decimal from an array of bytes. + /// + /// Bytes are assumed to be in native-endian byte order. + explicit SmallBasicDecimal(const uint8_t* bytes) { + memcpy(&value_, bytes, sizeof(value_)); + } + + constexpr const WordArray native_endian_array() const { + return WordArray{static_cast(value_)}; + } + + constexpr const WordArray little_endian_array() const { + return bit_util::little_endian::FromNative( + WordArray{static_cast(value_)}); + } + + const uint8_t* native_endian_bytes() const { + return reinterpret_cast(&value_); + } + + uint8_t* mutable_native_endian_bytes() { return reinterpret_cast(&value_); } + + /// \brief Return the raw bytes of the value in native-endian byte order. + std::array ToBytes() const { + std::array out{{0}}; + memcpy(out.data(), &value_, kByteWidth); + return out; + } + + /// \brief Copy the raw bytes of the value in native-endian byte order + void ToBytes(uint8_t* out) const { memcpy(out, &value_, kByteWidth); } + + /// \brief Return 1 if positive or 0, -1 if strictly negative + int64_t Sign() const { return 1 | (value_ >> (kBitWidth - 1)); } + + bool IsNegative() const { return value_ < 0; } + + explicit operator bool() const { return value_ != 0; } + + friend bool operator==(const SmallBasicDecimal& left, const SmallBasicDecimal& right) { + return left.value_ == right.value_; + } + + friend bool operator!=(const SmallBasicDecimal& left, const SmallBasicDecimal& right) { + return left.value_ != right.value_; + } + + DigitType value() const { return value_; } + + /// \brief count the number of leading binary zeroes. + int32_t CountLeadingBinaryZeros() const; + + constexpr uint64_t low_bits() const { return static_cast(value_); } + + protected: + DigitType value_; +}; + +class BasicDecimal32; +class BasicDecimal64; + +ARROW_EXPORT bool operator<(const BasicDecimal32& left, const BasicDecimal32& right); +ARROW_EXPORT bool operator<=(const BasicDecimal32& left, const BasicDecimal32& right); +ARROW_EXPORT bool operator>(const BasicDecimal32& left, const BasicDecimal32& right); +ARROW_EXPORT bool operator>=(const BasicDecimal32& left, const BasicDecimal32& right); + +ARROW_EXPORT BasicDecimal32 operator-(const BasicDecimal32& self); +ARROW_EXPORT BasicDecimal32 operator~(const BasicDecimal32& self); +ARROW_EXPORT BasicDecimal32 operator+(const BasicDecimal32& left, + const BasicDecimal32& right); +ARROW_EXPORT BasicDecimal32 operator-(const BasicDecimal32& left, + const BasicDecimal32& right); +ARROW_EXPORT BasicDecimal32 operator*(const BasicDecimal32& left, + const BasicDecimal32& right); +ARROW_EXPORT BasicDecimal32 operator/(const BasicDecimal32& left, + const BasicDecimal32& right); +ARROW_EXPORT BasicDecimal32 operator%(const BasicDecimal32& left, + const BasicDecimal32& right); + +class ARROW_EXPORT BasicDecimal32 : public SmallBasicDecimal { + public: + using SmallBasicDecimal::SmallBasicDecimal; + using ValueType = int32_t; + + /// \brief Negate the current value (in-place) + BasicDecimal32& Negate(); + + /// \brief Absolute value (in-place) + BasicDecimal32& Abs() { return *this < 0 ? Negate() : *this; } + + /// \brief Absolute value + static BasicDecimal32 Abs(const BasicDecimal32& in) { + BasicDecimal32 result(in); + return result.Abs(); + } + + /// \brief Add a number to this one. The result is truncated to 32 bits. + BasicDecimal32& operator+=(const BasicDecimal32& right) { + value_ += right.value_; + return *this; + } + + /// \brief Subtract a number from this one. The result is truncated to 32 bits. + BasicDecimal32& operator-=(const BasicDecimal32& right) { + value_ -= right.value_; + return *this; + } + + /// \brief Multiply this number by another. The result is truncated to 32 bits. + BasicDecimal32& operator*=(const BasicDecimal32& right) { + value_ *= static_cast(right.value_); + return *this; + } + + /// \brief Divide this number by the divisor and return the result. + /// + /// This operation is not destructive. + /// The answer rounds to zero. Signs work like: + /// 21 / 5 -> 4, 1 + /// -21 / 5 -> -4, -1 + /// 21 / -5 -> -4, 1 + /// -21 / -5 -> 4, -1 + /// \param[in] divisor the number to divide by + /// \param[out] result the quotient + /// \param[out] remainder the remainder after the division + DecimalStatus Divide(const BasicDecimal32& divisor, BasicDecimal32* result, + BasicDecimal32* remainder) const; + + /// \brief In-place division + BasicDecimal32& operator/=(const BasicDecimal32& right) { + value_ /= right.value_; + return *this; + } + + /// \brief Bitwise "or" between two BasicDecimal32s + BasicDecimal32& operator|=(const BasicDecimal32& right) { + value_ |= right.value_; + return *this; + } + + /// \brief Bitwise "and" between two BasicDecimal32s + BasicDecimal32& operator&=(const BasicDecimal32& right) { + value_ &= right.value_; + return *this; + } + /// \brief Shift left by the given number of bits. + BasicDecimal32& operator<<=(uint32_t bits); + + BasicDecimal32 operator<<(uint32_t bits) const { + auto res = *this; + res <<= bits; + return res; + } + + /// \brief Shift right by the given number of bits. + /// + /// Negative values will sign-extend + BasicDecimal32& operator>>=(uint32_t bits); + + BasicDecimal32 operator>>(uint32_t bits) const { + auto res = *this; + res >>= bits; + return res; + } + + /// \brief Convert BasicDecimal32 from one scale to another + DecimalStatus Rescale(int32_t original_scale, int32_t new_scale, + BasicDecimal32* out) const; + + void GetWholeAndFraction(int scale, BasicDecimal32* whole, + BasicDecimal32* fraction) const; + + /// \brief Scale up. + BasicDecimal32 IncreaseScaleBy(int32_t increase_by) const; + + /// \brief Scale down. + /// + /// - If 'round' is true, the right-most digits are dropped and the result value is + /// rounded up (+1 for +ve, -1 for -ve) based on the value of the dropped digits + /// (>= 10^reduce_by / 2). + /// - If 'round' is false, the right-most digits are simply dropped. + BasicDecimal32 ReduceScaleBy(int32_t reduce_by, bool round = true) const; + + /// \brief Whether this number fits in the given precision + /// + /// Return true if the number of significant digits is less or equal to 'precision'. + bool FitsInPrecision(int32_t precision) const; + + /// \brief Get the maximum valid unscaled decimal value. + static const BasicDecimal32& GetMaxValue(); + /// \brief Get the maximum valid unscaled decimal value for the given precision. + static BasicDecimal32 GetMaxValue(int32_t precision); + + /// \brief Get the maximum decimal value (is not a valid value). + static constexpr BasicDecimal32 GetMaxSentinel() { + return BasicDecimal32(std::numeric_limits::max()); + } + + /// \brief Get the minimum decimal value (is not a valid value). + static constexpr BasicDecimal32 GetMinSentinel() { + return BasicDecimal32(std::numeric_limits::min()); + } + + /// \brief Scale multiplier for a given scale value. + static const BasicDecimal32& GetScaleMultiplier(int32_t scale); + /// \brief Half-scale multiplier for a given scale value. + static const BasicDecimal32& GetHalfScaleMultiplier(int32_t scale); + + explicit operator BasicDecimal64() const; +}; + +ARROW_EXPORT bool operator<(const BasicDecimal64& left, const BasicDecimal64& right); +ARROW_EXPORT bool operator<=(const BasicDecimal64& left, const BasicDecimal64& right); +ARROW_EXPORT bool operator>(const BasicDecimal64& left, const BasicDecimal64& right); +ARROW_EXPORT bool operator>=(const BasicDecimal64& left, const BasicDecimal64& right); + +ARROW_EXPORT BasicDecimal64 operator-(const BasicDecimal64& self); +ARROW_EXPORT BasicDecimal64 operator~(const BasicDecimal64& self); +ARROW_EXPORT BasicDecimal64 operator+(const BasicDecimal64& left, + const BasicDecimal64& right); +ARROW_EXPORT BasicDecimal64 operator-(const BasicDecimal64& left, + const BasicDecimal64& right); +ARROW_EXPORT BasicDecimal64 operator*(const BasicDecimal64& left, + const BasicDecimal64& right); +ARROW_EXPORT BasicDecimal64 operator/(const BasicDecimal64& left, + const BasicDecimal64& right); +ARROW_EXPORT BasicDecimal64 operator%(const BasicDecimal64& left, + const BasicDecimal64& right); + +class ARROW_EXPORT BasicDecimal64 : public SmallBasicDecimal { + public: + using SmallBasicDecimal::SmallBasicDecimal; + using ValueType = int64_t; + + /// \brief Negate the current value (in-place) + BasicDecimal64& Negate(); + + /// \brief Absolute value (in-place) + BasicDecimal64& Abs() { return *this < 0 ? Negate() : *this; } + + /// \brief Absolute value + static BasicDecimal64 Abs(const BasicDecimal64& in) { + BasicDecimal64 result(in); + return result.Abs(); + } + + /// \brief Add a number to this one. The result is truncated to 32 bits. + BasicDecimal64& operator+=(const BasicDecimal64& right) { + value_ += right.value_; + return *this; + } + + /// \brief Subtract a number from this one. The result is truncated to 32 bits. + BasicDecimal64& operator-=(const BasicDecimal64& right) { + value_ -= right.value_; + return *this; + } + + /// \brief Multiply this number by another. The result is truncated to 32 bits. + BasicDecimal64& operator*=(const BasicDecimal64& right) { + value_ *= static_cast(right.value_); + return *this; + } + + /// \brief Divide this number by the divisor and return the result. + /// + /// This operation is not destructive. + /// The answer rounds to zero. Signs work like: + /// 21 / 5 -> 4, 1 + /// -21 / 5 -> -4, -1 + /// 21 / -5 -> -4, 1 + /// -21 / -5 -> 4, -1 + /// \param[in] divisor the number to divide by + /// \param[out] result the quotient + /// \param[out] remainder the remainder after the division + DecimalStatus Divide(const BasicDecimal64& divisor, BasicDecimal64* result, + BasicDecimal64* remainder) const; + + /// \brief In-place division + BasicDecimal64& operator/=(const BasicDecimal64& right) { + value_ /= right.value_; + return *this; + } + + /// \brief Bitwise "or" between two BasicDecimal64s + BasicDecimal64& operator|=(const BasicDecimal64& right) { + value_ |= right.value_; + return *this; + } + + /// \brief Bitwise "and" between two BasicDecimal64s + BasicDecimal64& operator&=(const BasicDecimal64& right) { + value_ &= right.value_; + return *this; + } + + /// \brief Shift left by the given number of bits. + BasicDecimal64& operator<<=(uint32_t bits); + + BasicDecimal64 operator<<(uint32_t bits) const { + auto res = *this; + res <<= bits; + return res; + } + + /// \brief Shift right by the given number of bits. + /// + /// Negative values will sign-extend + BasicDecimal64& operator>>=(uint32_t bits); + + BasicDecimal64 operator>>(uint32_t bits) const { + auto res = *this; + res >>= bits; + return res; + } + + /// \brief Convert BasicDecimal32 from one scale to another + DecimalStatus Rescale(int32_t original_scale, int32_t new_scale, + BasicDecimal64* out) const; + + void GetWholeAndFraction(int scale, BasicDecimal64* whole, + BasicDecimal64* fraction) const; + + /// \brief Scale up. + BasicDecimal64 IncreaseScaleBy(int32_t increase_by) const; + + /// \brief Scale down. + /// + /// - If 'round' is true, the right-most digits are dropped and the result value is + /// rounded up (+1 for +ve, -1 for -ve) based on the value of the dropped digits + /// (>= 10^reduce_by / 2). + /// - If 'round' is false, the right-most digits are simply dropped. + BasicDecimal64 ReduceScaleBy(int32_t reduce_by, bool round = true) const; + + /// \brief Whether this number fits in the given precision + /// + /// Return true if the number of significant digits is less or equal to 'precision'. + bool FitsInPrecision(int32_t precision) const; + + /// \brief Get the maximum valid unscaled decimal value. + static const BasicDecimal64& GetMaxValue(); + /// \brief Get the maximum valid unscaled decimal value for the given precision. + static BasicDecimal64 GetMaxValue(int32_t precision); + + /// \brief Get the maximum decimal value (is not a valid value). + static constexpr BasicDecimal64 GetMaxSentinel() { + return BasicDecimal64(std::numeric_limits::max()); + } + + /// \brief Get the minimum decimal value (is not a valid value). + static constexpr BasicDecimal64 GetMinSentinel() { + return BasicDecimal64(std::numeric_limits::min()); + } + + /// \brief Scale multiplier for a given scale value. + static const BasicDecimal64& GetScaleMultiplier(int32_t scale); + /// \brief Half-scale multiplier for a given scale value. + static const BasicDecimal64& GetHalfScaleMultiplier(int32_t scale); +}; + +/// Represents a signed 128-bit integer in two's complement. +/// +/// This class is also compiled into LLVM IR - so, it should not have cpp references like +/// streams and boost. +class ARROW_EXPORT BasicDecimal128 : public GenericBasicDecimal { + public: + static constexpr int kMaxPrecision = 38; + static constexpr int kMaxScale = 38; + + using GenericBasicDecimal::GenericBasicDecimal; + + constexpr BasicDecimal128() noexcept : GenericBasicDecimal() {} + + /// \brief Create a BasicDecimal128 from the two's complement representation. +#if ARROW_LITTLE_ENDIAN + constexpr BasicDecimal128(int64_t high, uint64_t low) noexcept + : BasicDecimal128(WordArray{low, static_cast(high)}) {} +#else + constexpr BasicDecimal128(int64_t high, uint64_t low) noexcept + : BasicDecimal128(WordArray{static_cast(high), low}) {} +#endif + + /// \brief Negate the current value (in-place) + BasicDecimal128& Negate(); + + /// \brief Absolute value (in-place) + BasicDecimal128& Abs(); + + /// \brief Absolute value + static BasicDecimal128 Abs(const BasicDecimal128& left); + + /// \brief Add a number to this one. The result is truncated to 128 bits. + BasicDecimal128& operator+=(const BasicDecimal128& right); + + /// \brief Subtract a number from this one. The result is truncated to 128 bits. + BasicDecimal128& operator-=(const BasicDecimal128& right); + + /// \brief Multiply this number by another number. The result is truncated to 128 bits. + BasicDecimal128& operator*=(const BasicDecimal128& right); + + /// Divide this number by right and return the result. + /// + /// This operation is not destructive. + /// The answer rounds to zero. Signs work like: + /// 21 / 5 -> 4, 1 + /// -21 / 5 -> -4, -1 + /// 21 / -5 -> -4, 1 + /// -21 / -5 -> 4, -1 + /// \param[in] divisor the number to divide by + /// \param[out] result the quotient + /// \param[out] remainder the remainder after the division + DecimalStatus Divide(const BasicDecimal128& divisor, BasicDecimal128* result, + BasicDecimal128* remainder) const; + + /// \brief In-place division. + BasicDecimal128& operator/=(const BasicDecimal128& right); + + /// \brief Bitwise "or" between two BasicDecimal128. + BasicDecimal128& operator|=(const BasicDecimal128& right); + + /// \brief Bitwise "and" between two BasicDecimal128. + BasicDecimal128& operator&=(const BasicDecimal128& right); + + /// \brief Shift left by the given number of bits. + BasicDecimal128& operator<<=(uint32_t bits); + + BasicDecimal128 operator<<(uint32_t bits) const { + auto res = *this; + res <<= bits; + return res; + } + + /// \brief Shift right by the given number of bits. + /// + /// Negative values will sign-extend. + BasicDecimal128& operator>>=(uint32_t bits); + + BasicDecimal128 operator>>(uint32_t bits) const { + auto res = *this; + res >>= bits; + return res; + } + + /// \brief Get the high bits of the two's complement representation of the number. + constexpr int64_t high_bits() const { +#if ARROW_LITTLE_ENDIAN + return static_cast(array_[1]); +#else + return static_cast(array_[0]); +#endif + } + + /// \brief Get the low bits of the two's complement representation of the number. + constexpr uint64_t low_bits() const { +#if ARROW_LITTLE_ENDIAN + return array_[0]; +#else + return array_[1]; +#endif + } + + /// \brief separate the integer and fractional parts for the given scale. + void GetWholeAndFraction(int32_t scale, BasicDecimal128* whole, + BasicDecimal128* fraction) const; + + /// \brief Scale multiplier for given scale value. + static const BasicDecimal128& GetScaleMultiplier(int32_t scale); + /// \brief Half-scale multiplier for given scale value. + static const BasicDecimal128& GetHalfScaleMultiplier(int32_t scale); + + /// \brief Convert BasicDecimal128 from one scale to another + DecimalStatus Rescale(int32_t original_scale, int32_t new_scale, + BasicDecimal128* out) const; + + /// \brief Scale up. + BasicDecimal128 IncreaseScaleBy(int32_t increase_by) const; + + /// \brief Scale down. + /// - If 'round' is true, the right-most digits are dropped and the result value is + /// rounded up (+1 for +ve, -1 for -ve) based on the value of the dropped digits + /// (>= 10^reduce_by / 2). + /// - If 'round' is false, the right-most digits are simply dropped. + BasicDecimal128 ReduceScaleBy(int32_t reduce_by, bool round = true) const; + + /// \brief Whether this number fits in the given precision + /// + /// Return true if the number of significant digits is less or equal to `precision`. + bool FitsInPrecision(int32_t precision) const; + + /// \brief count the number of leading binary zeroes. + int32_t CountLeadingBinaryZeros() const; + + /// \brief Get the maximum valid unscaled decimal value. + static const BasicDecimal128& GetMaxValue(); + + /// \brief Get the maximum valid unscaled decimal value for the given precision. + static BasicDecimal128 GetMaxValue(int32_t precision); + + /// \brief Get the maximum decimal value (is not a valid value). + static constexpr BasicDecimal128 GetMaxSentinel() { + return BasicDecimal128(/*high=*/std::numeric_limits::max(), + /*low=*/std::numeric_limits::max()); + } + /// \brief Get the minimum decimal value (is not a valid value). + static constexpr BasicDecimal128 GetMinSentinel() { + return BasicDecimal128(/*high=*/std::numeric_limits::min(), + /*low=*/std::numeric_limits::min()); + } +}; + +ARROW_EXPORT bool operator<(const BasicDecimal128& left, const BasicDecimal128& right); +ARROW_EXPORT bool operator<=(const BasicDecimal128& left, const BasicDecimal128& right); +ARROW_EXPORT bool operator>(const BasicDecimal128& left, const BasicDecimal128& right); +ARROW_EXPORT bool operator>=(const BasicDecimal128& left, const BasicDecimal128& right); + +ARROW_EXPORT BasicDecimal128 operator-(const BasicDecimal128& operand); +ARROW_EXPORT BasicDecimal128 operator~(const BasicDecimal128& operand); +ARROW_EXPORT BasicDecimal128 operator+(const BasicDecimal128& left, + const BasicDecimal128& right); +ARROW_EXPORT BasicDecimal128 operator-(const BasicDecimal128& left, + const BasicDecimal128& right); +ARROW_EXPORT BasicDecimal128 operator*(const BasicDecimal128& left, + const BasicDecimal128& right); +ARROW_EXPORT BasicDecimal128 operator/(const BasicDecimal128& left, + const BasicDecimal128& right); +ARROW_EXPORT BasicDecimal128 operator%(const BasicDecimal128& left, + const BasicDecimal128& right); + +class ARROW_EXPORT BasicDecimal256 : public GenericBasicDecimal { + public: + using GenericBasicDecimal::GenericBasicDecimal; + + static constexpr int kMaxPrecision = 76; + static constexpr int kMaxScale = 76; + + constexpr BasicDecimal256() noexcept : GenericBasicDecimal() {} + + explicit BasicDecimal256(const BasicDecimal128& value) noexcept + : BasicDecimal256(bit_util::little_endian::ToNative( + {value.low_bits(), static_cast(value.high_bits()), + SignExtend(value.high_bits()), SignExtend(value.high_bits())})) {} + + explicit BasicDecimal256(const BasicDecimal64& value) noexcept + : BasicDecimal256(bit_util::little_endian::ToNative( + {value.low_bits(), SignExtend(value.value()), SignExtend(value.value()), + SignExtend(value.value())})) {} + + explicit BasicDecimal256(const BasicDecimal32& value) noexcept + : BasicDecimal256(bit_util::little_endian::ToNative( + {value.low_bits(), SignExtend(value.value()), SignExtend(value.value()), + SignExtend(value.value())})) {} + + /// \brief Negate the current value (in-place) + BasicDecimal256& Negate(); + + /// \brief Absolute value (in-place) + BasicDecimal256& Abs(); + + /// \brief Absolute value + static BasicDecimal256 Abs(const BasicDecimal256& left); + + /// \brief Add a number to this one. The result is truncated to 256 bits. + BasicDecimal256& operator+=(const BasicDecimal256& right); + + /// \brief Subtract a number from this one. The result is truncated to 256 bits. + BasicDecimal256& operator-=(const BasicDecimal256& right); + + /// \brief Get the lowest bits of the two's complement representation of the number. + uint64_t low_bits() const { return bit_util::little_endian::Make(array_)[0]; } + + /// \brief separate the integer and fractional parts for the given scale. + void GetWholeAndFraction(int32_t scale, BasicDecimal256* whole, + BasicDecimal256* fraction) const; + + /// \brief Scale multiplier for given scale value. + static const BasicDecimal256& GetScaleMultiplier(int32_t scale); + /// \brief Half-scale multiplier for given scale value. + static const BasicDecimal256& GetHalfScaleMultiplier(int32_t scale); + + /// \brief Convert BasicDecimal256 from one scale to another + DecimalStatus Rescale(int32_t original_scale, int32_t new_scale, + BasicDecimal256* out) const; + + /// \brief Scale up. + BasicDecimal256 IncreaseScaleBy(int32_t increase_by) const; + + /// \brief Scale down. + /// - If 'round' is true, the right-most digits are dropped and the result value is + /// rounded up (+1 for positive, -1 for negative) based on the value of the + /// dropped digits (>= 10^reduce_by / 2). + /// - If 'round' is false, the right-most digits are simply dropped. + BasicDecimal256 ReduceScaleBy(int32_t reduce_by, bool round = true) const; + + /// \brief Whether this number fits in the given precision + /// + /// Return true if the number of significant digits is less or equal to `precision`. + bool FitsInPrecision(int32_t precision) const; + + /// \brief Multiply this number by another number. The result is truncated to 256 bits. + BasicDecimal256& operator*=(const BasicDecimal256& right); + + /// Divide this number by right and return the result. + /// + /// This operation is not destructive. + /// The answer rounds to zero. Signs work like: + /// 21 / 5 -> 4, 1 + /// -21 / 5 -> -4, -1 + /// 21 / -5 -> -4, 1 + /// -21 / -5 -> 4, -1 + /// \param[in] divisor the number to divide by + /// \param[out] result the quotient + /// \param[out] remainder the remainder after the division + DecimalStatus Divide(const BasicDecimal256& divisor, BasicDecimal256* result, + BasicDecimal256* remainder) const; + + /// \brief Shift left by the given number of bits. + BasicDecimal256& operator<<=(uint32_t bits); + + BasicDecimal256 operator<<(uint32_t bits) const { + auto res = *this; + res <<= bits; + return res; + } + + /// \brief Shift right by the given number of bits. + /// + /// Negative values will sign-extend. + BasicDecimal256& operator>>=(uint32_t bits); + + BasicDecimal256 operator>>(uint32_t bits) const { + auto res = *this; + res >>= bits; + return res; + } + + /// \brief In-place division. + BasicDecimal256& operator/=(const BasicDecimal256& right); + + /// \brief Get the maximum valid unscaled decimal value for the given precision. + static BasicDecimal256 GetMaxValue(int32_t precision); + + /// \brief Get the maximum decimal value (is not a valid value). + static constexpr BasicDecimal256 GetMaxSentinel() { +#if ARROW_LITTLE_ENDIAN + return BasicDecimal256({std::numeric_limits::max(), + std::numeric_limits::max(), + std::numeric_limits::max(), + static_cast(std::numeric_limits::max())}); +#else + return BasicDecimal256({static_cast(std::numeric_limits::max()), + std::numeric_limits::max(), + std::numeric_limits::max(), + std::numeric_limits::max()}); +#endif + } + /// \brief Get the minimum decimal value (is not a valid value). + static constexpr BasicDecimal256 GetMinSentinel() { +#if ARROW_LITTLE_ENDIAN + return BasicDecimal256( + {0, 0, 0, static_cast(std::numeric_limits::min())}); +#else + return BasicDecimal256( + {static_cast(std::numeric_limits::min()), 0, 0, 0}); +#endif + } +}; + +ARROW_EXPORT bool operator<(const BasicDecimal256& left, const BasicDecimal256& right); + +ARROW_EXPORT inline bool operator<=(const BasicDecimal256& left, + const BasicDecimal256& right) { + return !operator<(right, left); +} + +ARROW_EXPORT inline bool operator>(const BasicDecimal256& left, + const BasicDecimal256& right) { + return operator<(right, left); +} + +ARROW_EXPORT inline bool operator>=(const BasicDecimal256& left, + const BasicDecimal256& right) { + return !operator<(left, right); +} + +ARROW_EXPORT BasicDecimal256 operator-(const BasicDecimal256& operand); +ARROW_EXPORT BasicDecimal256 operator~(const BasicDecimal256& operand); +ARROW_EXPORT BasicDecimal256 operator+(const BasicDecimal256& left, + const BasicDecimal256& right); +ARROW_EXPORT BasicDecimal256 operator*(const BasicDecimal256& left, + const BasicDecimal256& right); +ARROW_EXPORT BasicDecimal256 operator/(const BasicDecimal256& left, + const BasicDecimal256& right); + +} // namespace arrow diff --git a/shared/package-files/43/436e5e803854b3ec6b961e68cb86419673aa179a49b50d52468dbcaf99e7b9d6/blob b/shared/package-files/43/436e5e803854b3ec6b961e68cb86419673aa179a49b50d52468dbcaf99e7b9d6/blob new file mode 100644 index 0000000000000000000000000000000000000000..53f0ac4a8d610192733aaca456b3a69e03bbd97f --- /dev/null +++ b/shared/package-files/43/436e5e803854b3ec6b961e68cb86419673aa179a49b50d52468dbcaf99e7b9d6/blob @@ -0,0 +1,961 @@ +from sympy.core.numbers import I, pi +from sympy.functions.elementary.exponential import (exp, log) +from sympy.polys.partfrac import apart +from sympy.core.symbol import Dummy +from sympy.external import import_module +from sympy.functions import arg, Abs +from sympy.integrals.laplace import _fast_inverse_laplace +from sympy.physics.control.lti import SISOLinearTimeInvariant +from sympy.plotting.plot import LineOver1DRangeSeries +from sympy.polys.polytools import Poly +from sympy.printing.latex import latex + +__all__ = ['pole_zero_numerical_data', 'pole_zero_plot', + 'step_response_numerical_data', 'step_response_plot', + 'impulse_response_numerical_data', 'impulse_response_plot', + 'ramp_response_numerical_data', 'ramp_response_plot', + 'bode_magnitude_numerical_data', 'bode_phase_numerical_data', + 'bode_magnitude_plot', 'bode_phase_plot', 'bode_plot'] + +matplotlib = import_module( + 'matplotlib', import_kwargs={'fromlist': ['pyplot']}, + catch=(RuntimeError,)) + +numpy = import_module('numpy') + +if matplotlib: + plt = matplotlib.pyplot + +if numpy: + np = numpy # Matplotlib already has numpy as a compulsory dependency. No need to install it separately. + + +def _check_system(system): + """Function to check whether the dynamical system passed for plots is + compatible or not.""" + if not isinstance(system, SISOLinearTimeInvariant): + raise NotImplementedError("Only SISO LTI systems are currently supported.") + sys = system.to_expr() + len_free_symbols = len(sys.free_symbols) + if len_free_symbols > 1: + raise ValueError("Extra degree of freedom found. Make sure" + " that there are no free symbols in the dynamical system other" + " than the variable of Laplace transform.") + if sys.has(exp): + # Should test that exp is not part of a constant, in which case + # no exception is required, compare exp(s) with s*exp(1) + raise NotImplementedError("Time delay terms are not supported.") + + +def pole_zero_numerical_data(system): + """ + Returns the numerical data of poles and zeros of the system. + It is internally used by ``pole_zero_plot`` to get the data + for plotting poles and zeros. Users can use this data to further + analyse the dynamics of the system or plot using a different + backend/plotting-module. + + Parameters + ========== + + system : SISOLinearTimeInvariant + The system for which the pole-zero data is to be computed. + + Returns + ======= + + tuple : (zeros, poles) + zeros = Zeros of the system. NumPy array of complex numbers. + poles = Poles of the system. NumPy array of complex numbers. + + Raises + ====== + + NotImplementedError + When a SISO LTI system is not passed. + + When time delay terms are present in the system. + + ValueError + When more than one free symbol is present in the system. + The only variable in the transfer function should be + the variable of the Laplace transform. + + Examples + ======== + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import pole_zero_numerical_data + >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s) + >>> pole_zero_numerical_data(tf1) # doctest: +SKIP + ([-0.+1.j 0.-1.j], [-2. +0.j -0.5+0.8660254j -0.5-0.8660254j -1. +0.j ]) + + See Also + ======== + + pole_zero_plot + + """ + _check_system(system) + system = system.doit() # Get the equivalent TransferFunction object. + + num_poly = Poly(system.num, system.var).all_coeffs() + den_poly = Poly(system.den, system.var).all_coeffs() + + num_poly = np.array(num_poly, dtype=np.complex128) + den_poly = np.array(den_poly, dtype=np.complex128) + + zeros = np.roots(num_poly) + poles = np.roots(den_poly) + + return zeros, poles + + +def pole_zero_plot(system, pole_color='blue', pole_markersize=10, + zero_color='orange', zero_markersize=7, grid=True, show_axes=True, + show=True, **kwargs): + r""" + Returns the Pole-Zero plot (also known as PZ Plot or PZ Map) of a system. + + A Pole-Zero plot is a graphical representation of a system's poles and + zeros. It is plotted on a complex plane, with circular markers representing + the system's zeros and 'x' shaped markers representing the system's poles. + + Parameters + ========== + + system : SISOLinearTimeInvariant type systems + The system for which the pole-zero plot is to be computed. + pole_color : str, tuple, optional + The color of the pole points on the plot. Default color + is blue. The color can be provided as a matplotlib color string, + or a 3-tuple of floats each in the 0-1 range. + pole_markersize : Number, optional + The size of the markers used to mark the poles in the plot. + Default pole markersize is 10. + zero_color : str, tuple, optional + The color of the zero points on the plot. Default color + is orange. The color can be provided as a matplotlib color string, + or a 3-tuple of floats each in the 0-1 range. + zero_markersize : Number, optional + The size of the markers used to mark the zeros in the plot. + Default zero markersize is 7. + grid : boolean, optional + If ``True``, the plot will have a grid. Defaults to True. + show_axes : boolean, optional + If ``True``, the coordinate axes will be shown. Defaults to False. + show : boolean, optional + If ``True``, the plot will be displayed otherwise + the equivalent matplotlib ``plot`` object will be returned. + Defaults to True. + + Examples + ======== + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import pole_zero_plot + >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s) + >>> pole_zero_plot(tf1) # doctest: +SKIP + + See Also + ======== + + pole_zero_numerical_data + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Pole%E2%80%93zero_plot + + """ + zeros, poles = pole_zero_numerical_data(system) + + zero_real = np.real(zeros) + zero_imag = np.imag(zeros) + + pole_real = np.real(poles) + pole_imag = np.imag(poles) + + plt.plot(pole_real, pole_imag, 'x', mfc='none', + markersize=pole_markersize, color=pole_color) + plt.plot(zero_real, zero_imag, 'o', markersize=zero_markersize, + color=zero_color) + plt.xlabel('Real Axis') + plt.ylabel('Imaginary Axis') + plt.title(f'Poles and Zeros of ${latex(system)}$', pad=20) + + if grid: + plt.grid() + if show_axes: + plt.axhline(0, color='black') + plt.axvline(0, color='black') + if show: + plt.show() + return + + return plt + + +def step_response_numerical_data(system, prec=8, lower_limit=0, + upper_limit=10, **kwargs): + """ + Returns the numerical values of the points in the step response plot + of a SISO continuous-time system. By default, adaptive sampling + is used. If the user wants to instead get an uniformly + sampled response, then ``adaptive`` kwarg should be passed ``False`` + and ``nb_of_points`` must be passed as additional kwargs. + Refer to the parameters of class :class:`sympy.plotting.plot.LineOver1DRangeSeries` + for more details. + + Parameters + ========== + + system : SISOLinearTimeInvariant + The system for which the unit step response data is to be computed. + prec : int, optional + The decimal point precision for the point coordinate values. + Defaults to 8. + lower_limit : Number, optional + The lower limit of the plot range. Defaults to 0. + upper_limit : Number, optional + The upper limit of the plot range. Defaults to 10. + kwargs : + Additional keyword arguments are passed to the underlying + :class:`sympy.plotting.plot.LineOver1DRangeSeries` class. + + Returns + ======= + + tuple : (x, y) + x = Time-axis values of the points in the step response. NumPy array. + y = Amplitude-axis values of the points in the step response. NumPy array. + + Raises + ====== + + NotImplementedError + When a SISO LTI system is not passed. + + When time delay terms are present in the system. + + ValueError + When more than one free symbol is present in the system. + The only variable in the transfer function should be + the variable of the Laplace transform. + + When ``lower_limit`` parameter is less than 0. + + Examples + ======== + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import step_response_numerical_data + >>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s) + >>> step_response_numerical_data(tf1) # doctest: +SKIP + ([0.0, 0.025413462339411542, 0.0484508722725343, ... , 9.670250533855183, 9.844291913708725, 10.0], + [0.0, 0.023844582399907256, 0.042894276802320226, ..., 6.828770759094287e-12, 6.456457160755703e-12]) + + See Also + ======== + + step_response_plot + + """ + if lower_limit < 0: + raise ValueError("Lower limit of time must be greater " + "than or equal to zero.") + _check_system(system) + _x = Dummy("x") + expr = system.to_expr()/(system.var) + expr = apart(expr, system.var, full=True) + _y = _fast_inverse_laplace(expr, system.var, _x).evalf(prec) + return LineOver1DRangeSeries(_y, (_x, lower_limit, upper_limit), + **kwargs).get_points() + + +def step_response_plot(system, color='b', prec=8, lower_limit=0, + upper_limit=10, show_axes=False, grid=True, show=True, **kwargs): + r""" + Returns the unit step response of a continuous-time system. It is + the response of the system when the input signal is a step function. + + Parameters + ========== + + system : SISOLinearTimeInvariant type + The LTI SISO system for which the Step Response is to be computed. + color : str, tuple, optional + The color of the line. Default is Blue. + show : boolean, optional + If ``True``, the plot will be displayed otherwise + the equivalent matplotlib ``plot`` object will be returned. + Defaults to True. + lower_limit : Number, optional + The lower limit of the plot range. Defaults to 0. + upper_limit : Number, optional + The upper limit of the plot range. Defaults to 10. + prec : int, optional + The decimal point precision for the point coordinate values. + Defaults to 8. + show_axes : boolean, optional + If ``True``, the coordinate axes will be shown. Defaults to False. + grid : boolean, optional + If ``True``, the plot will have a grid. Defaults to True. + + Examples + ======== + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import step_response_plot + >>> tf1 = TransferFunction(8*s**2 + 18*s + 32, s**3 + 6*s**2 + 14*s + 24, s) + >>> step_response_plot(tf1) # doctest: +SKIP + + See Also + ======== + + impulse_response_plot, ramp_response_plot + + References + ========== + + .. [1] https://www.mathworks.com/help/control/ref/lti.step.html + + """ + x, y = step_response_numerical_data(system, prec=prec, + lower_limit=lower_limit, upper_limit=upper_limit, **kwargs) + plt.plot(x, y, color=color) + plt.xlabel('Time (s)') + plt.ylabel('Amplitude') + plt.title(f'Unit Step Response of ${latex(system)}$', pad=20) + + if grid: + plt.grid() + if show_axes: + plt.axhline(0, color='black') + plt.axvline(0, color='black') + if show: + plt.show() + return + + return plt + + +def impulse_response_numerical_data(system, prec=8, lower_limit=0, + upper_limit=10, **kwargs): + """ + Returns the numerical values of the points in the impulse response plot + of a SISO continuous-time system. By default, adaptive sampling + is used. If the user wants to instead get an uniformly + sampled response, then ``adaptive`` kwarg should be passed ``False`` + and ``nb_of_points`` must be passed as additional kwargs. + Refer to the parameters of class :class:`sympy.plotting.plot.LineOver1DRangeSeries` + for more details. + + Parameters + ========== + + system : SISOLinearTimeInvariant + The system for which the impulse response data is to be computed. + prec : int, optional + The decimal point precision for the point coordinate values. + Defaults to 8. + lower_limit : Number, optional + The lower limit of the plot range. Defaults to 0. + upper_limit : Number, optional + The upper limit of the plot range. Defaults to 10. + kwargs : + Additional keyword arguments are passed to the underlying + :class:`sympy.plotting.plot.LineOver1DRangeSeries` class. + + Returns + ======= + + tuple : (x, y) + x = Time-axis values of the points in the impulse response. NumPy array. + y = Amplitude-axis values of the points in the impulse response. NumPy array. + + Raises + ====== + + NotImplementedError + When a SISO LTI system is not passed. + + When time delay terms are present in the system. + + ValueError + When more than one free symbol is present in the system. + The only variable in the transfer function should be + the variable of the Laplace transform. + + When ``lower_limit`` parameter is less than 0. + + Examples + ======== + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import impulse_response_numerical_data + >>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s) + >>> impulse_response_numerical_data(tf1) # doctest: +SKIP + ([0.0, 0.06616480200395854,... , 9.854500743565858, 10.0], + [0.9999999799999999, 0.7042848373025861,...,7.170748906965121e-13, -5.1901263495547205e-12]) + + See Also + ======== + + impulse_response_plot + + """ + if lower_limit < 0: + raise ValueError("Lower limit of time must be greater " + "than or equal to zero.") + _check_system(system) + _x = Dummy("x") + expr = system.to_expr() + expr = apart(expr, system.var, full=True) + _y = _fast_inverse_laplace(expr, system.var, _x).evalf(prec) + return LineOver1DRangeSeries(_y, (_x, lower_limit, upper_limit), + **kwargs).get_points() + + +def impulse_response_plot(system, color='b', prec=8, lower_limit=0, + upper_limit=10, show_axes=False, grid=True, show=True, **kwargs): + r""" + Returns the unit impulse response (Input is the Dirac-Delta Function) of a + continuous-time system. + + Parameters + ========== + + system : SISOLinearTimeInvariant type + The LTI SISO system for which the Impulse Response is to be computed. + color : str, tuple, optional + The color of the line. Default is Blue. + show : boolean, optional + If ``True``, the plot will be displayed otherwise + the equivalent matplotlib ``plot`` object will be returned. + Defaults to True. + lower_limit : Number, optional + The lower limit of the plot range. Defaults to 0. + upper_limit : Number, optional + The upper limit of the plot range. Defaults to 10. + prec : int, optional + The decimal point precision for the point coordinate values. + Defaults to 8. + show_axes : boolean, optional + If ``True``, the coordinate axes will be shown. Defaults to False. + grid : boolean, optional + If ``True``, the plot will have a grid. Defaults to True. + + Examples + ======== + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import impulse_response_plot + >>> tf1 = TransferFunction(8*s**2 + 18*s + 32, s**3 + 6*s**2 + 14*s + 24, s) + >>> impulse_response_plot(tf1) # doctest: +SKIP + + See Also + ======== + + step_response_plot, ramp_response_plot + + References + ========== + + .. [1] https://www.mathworks.com/help/control/ref/lti.impulse.html + + """ + x, y = impulse_response_numerical_data(system, prec=prec, + lower_limit=lower_limit, upper_limit=upper_limit, **kwargs) + plt.plot(x, y, color=color) + plt.xlabel('Time (s)') + plt.ylabel('Amplitude') + plt.title(f'Impulse Response of ${latex(system)}$', pad=20) + + if grid: + plt.grid() + if show_axes: + plt.axhline(0, color='black') + plt.axvline(0, color='black') + if show: + plt.show() + return + + return plt + + +def ramp_response_numerical_data(system, slope=1, prec=8, + lower_limit=0, upper_limit=10, **kwargs): + """ + Returns the numerical values of the points in the ramp response plot + of a SISO continuous-time system. By default, adaptive sampling + is used. If the user wants to instead get an uniformly + sampled response, then ``adaptive`` kwarg should be passed ``False`` + and ``nb_of_points`` must be passed as additional kwargs. + Refer to the parameters of class :class:`sympy.plotting.plot.LineOver1DRangeSeries` + for more details. + + Parameters + ========== + + system : SISOLinearTimeInvariant + The system for which the ramp response data is to be computed. + slope : Number, optional + The slope of the input ramp function. Defaults to 1. + prec : int, optional + The decimal point precision for the point coordinate values. + Defaults to 8. + lower_limit : Number, optional + The lower limit of the plot range. Defaults to 0. + upper_limit : Number, optional + The upper limit of the plot range. Defaults to 10. + kwargs : + Additional keyword arguments are passed to the underlying + :class:`sympy.plotting.plot.LineOver1DRangeSeries` class. + + Returns + ======= + + tuple : (x, y) + x = Time-axis values of the points in the ramp response plot. NumPy array. + y = Amplitude-axis values of the points in the ramp response plot. NumPy array. + + Raises + ====== + + NotImplementedError + When a SISO LTI system is not passed. + + When time delay terms are present in the system. + + ValueError + When more than one free symbol is present in the system. + The only variable in the transfer function should be + the variable of the Laplace transform. + + When ``lower_limit`` parameter is less than 0. + + When ``slope`` is negative. + + Examples + ======== + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import ramp_response_numerical_data + >>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s) + >>> ramp_response_numerical_data(tf1) # doctest: +SKIP + (([0.0, 0.12166980856813935,..., 9.861246379582118, 10.0], + [1.4504508011325967e-09, 0.006046440489058766,..., 0.12499999999568202, 0.12499999999661349])) + + See Also + ======== + + ramp_response_plot + + """ + if slope < 0: + raise ValueError("Slope must be greater than or equal" + " to zero.") + if lower_limit < 0: + raise ValueError("Lower limit of time must be greater " + "than or equal to zero.") + _check_system(system) + _x = Dummy("x") + expr = (slope*system.to_expr())/((system.var)**2) + expr = apart(expr, system.var, full=True) + _y = _fast_inverse_laplace(expr, system.var, _x).evalf(prec) + return LineOver1DRangeSeries(_y, (_x, lower_limit, upper_limit), + **kwargs).get_points() + + +def ramp_response_plot(system, slope=1, color='b', prec=8, lower_limit=0, + upper_limit=10, show_axes=False, grid=True, show=True, **kwargs): + r""" + Returns the ramp response of a continuous-time system. + + Ramp function is defined as the straight line + passing through origin ($f(x) = mx$). The slope of + the ramp function can be varied by the user and + the default value is 1. + + Parameters + ========== + + system : SISOLinearTimeInvariant type + The LTI SISO system for which the Ramp Response is to be computed. + slope : Number, optional + The slope of the input ramp function. Defaults to 1. + color : str, tuple, optional + The color of the line. Default is Blue. + show : boolean, optional + If ``True``, the plot will be displayed otherwise + the equivalent matplotlib ``plot`` object will be returned. + Defaults to True. + lower_limit : Number, optional + The lower limit of the plot range. Defaults to 0. + upper_limit : Number, optional + The upper limit of the plot range. Defaults to 10. + prec : int, optional + The decimal point precision for the point coordinate values. + Defaults to 8. + show_axes : boolean, optional + If ``True``, the coordinate axes will be shown. Defaults to False. + grid : boolean, optional + If ``True``, the plot will have a grid. Defaults to True. + + Examples + ======== + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import ramp_response_plot + >>> tf1 = TransferFunction(s, (s+4)*(s+8), s) + >>> ramp_response_plot(tf1, upper_limit=2) # doctest: +SKIP + + See Also + ======== + + step_response_plot, ramp_response_plot + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Ramp_function + + """ + x, y = ramp_response_numerical_data(system, slope=slope, prec=prec, + lower_limit=lower_limit, upper_limit=upper_limit, **kwargs) + plt.plot(x, y, color=color) + plt.xlabel('Time (s)') + plt.ylabel('Amplitude') + plt.title(f'Ramp Response of ${latex(system)}$ [Slope = {slope}]', pad=20) + + if grid: + plt.grid() + if show_axes: + plt.axhline(0, color='black') + plt.axvline(0, color='black') + if show: + plt.show() + return + + return plt + + +def bode_magnitude_numerical_data(system, initial_exp=-5, final_exp=5, freq_unit='rad/sec', **kwargs): + """ + Returns the numerical data of the Bode magnitude plot of the system. + It is internally used by ``bode_magnitude_plot`` to get the data + for plotting Bode magnitude plot. Users can use this data to further + analyse the dynamics of the system or plot using a different + backend/plotting-module. + + Parameters + ========== + + system : SISOLinearTimeInvariant + The system for which the data is to be computed. + initial_exp : Number, optional + The initial exponent of 10 of the semilog plot. Defaults to -5. + final_exp : Number, optional + The final exponent of 10 of the semilog plot. Defaults to 5. + freq_unit : string, optional + User can choose between ``'rad/sec'`` (radians/second) and ``'Hz'`` (Hertz) as frequency units. + + Returns + ======= + + tuple : (x, y) + x = x-axis values of the Bode magnitude plot. + y = y-axis values of the Bode magnitude plot. + + Raises + ====== + + NotImplementedError + When a SISO LTI system is not passed. + + When time delay terms are present in the system. + + ValueError + When more than one free symbol is present in the system. + The only variable in the transfer function should be + the variable of the Laplace transform. + + When incorrect frequency units are given as input. + + Examples + ======== + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import bode_magnitude_numerical_data + >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s) + >>> bode_magnitude_numerical_data(tf1) # doctest: +SKIP + ([1e-05, 1.5148378120533502e-05,..., 68437.36188804005, 100000.0], + [-6.020599914256786, -6.0205999155219505,..., -193.4117304087953, -200.00000000260573]) + + See Also + ======== + + bode_magnitude_plot, bode_phase_numerical_data + + """ + _check_system(system) + expr = system.to_expr() + freq_units = ('rad/sec', 'Hz') + if freq_unit not in freq_units: + raise ValueError('Only "rad/sec" and "Hz" are accepted frequency units.') + + _w = Dummy("w", real=True) + if freq_unit == 'Hz': + repl = I*_w*2*pi + else: + repl = I*_w + w_expr = expr.subs({system.var: repl}) + + mag = 20*log(Abs(w_expr), 10) + + x, y = LineOver1DRangeSeries(mag, + (_w, 10**initial_exp, 10**final_exp), xscale='log', **kwargs).get_points() + + return x, y + + +def bode_magnitude_plot(system, initial_exp=-5, final_exp=5, + color='b', show_axes=False, grid=True, show=True, freq_unit='rad/sec', **kwargs): + r""" + Returns the Bode magnitude plot of a continuous-time system. + + See ``bode_plot`` for all the parameters. + """ + x, y = bode_magnitude_numerical_data(system, initial_exp=initial_exp, + final_exp=final_exp, freq_unit=freq_unit) + plt.plot(x, y, color=color, **kwargs) + plt.xscale('log') + + + plt.xlabel('Frequency (%s) [Log Scale]' % freq_unit) + plt.ylabel('Magnitude (dB)') + plt.title(f'Bode Plot (Magnitude) of ${latex(system)}$', pad=20) + + if grid: + plt.grid(True) + if show_axes: + plt.axhline(0, color='black') + plt.axvline(0, color='black') + if show: + plt.show() + return + + return plt + + +def bode_phase_numerical_data(system, initial_exp=-5, final_exp=5, freq_unit='rad/sec', phase_unit='rad', **kwargs): + """ + Returns the numerical data of the Bode phase plot of the system. + It is internally used by ``bode_phase_plot`` to get the data + for plotting Bode phase plot. Users can use this data to further + analyse the dynamics of the system or plot using a different + backend/plotting-module. + + Parameters + ========== + + system : SISOLinearTimeInvariant + The system for which the Bode phase plot data is to be computed. + initial_exp : Number, optional + The initial exponent of 10 of the semilog plot. Defaults to -5. + final_exp : Number, optional + The final exponent of 10 of the semilog plot. Defaults to 5. + freq_unit : string, optional + User can choose between ``'rad/sec'`` (radians/second) and '``'Hz'`` (Hertz) as frequency units. + phase_unit : string, optional + User can choose between ``'rad'`` (radians) and ``'deg'`` (degree) as phase units. + + Returns + ======= + + tuple : (x, y) + x = x-axis values of the Bode phase plot. + y = y-axis values of the Bode phase plot. + + Raises + ====== + + NotImplementedError + When a SISO LTI system is not passed. + + When time delay terms are present in the system. + + ValueError + When more than one free symbol is present in the system. + The only variable in the transfer function should be + the variable of the Laplace transform. + + When incorrect frequency or phase units are given as input. + + Examples + ======== + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import bode_phase_numerical_data + >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s) + >>> bode_phase_numerical_data(tf1) # doctest: +SKIP + ([1e-05, 1.4472354033813751e-05, 2.035581932165858e-05,..., 47577.3248186011, 67884.09326036123, 100000.0], + [-2.5000000000291665e-05, -3.6180885085e-05, -5.08895483066e-05,...,-3.1415085799262523, -3.14155265358979]) + + See Also + ======== + + bode_magnitude_plot, bode_phase_numerical_data + + """ + _check_system(system) + expr = system.to_expr() + freq_units = ('rad/sec', 'Hz') + phase_units = ('rad', 'deg') + if freq_unit not in freq_units: + raise ValueError('Only "rad/sec" and "Hz" are accepted frequency units.') + if phase_unit not in phase_units: + raise ValueError('Only "rad" and "deg" are accepted phase units.') + + _w = Dummy("w", real=True) + if freq_unit == 'Hz': + repl = I*_w*2*pi + else: + repl = I*_w + w_expr = expr.subs({system.var: repl}) + + if phase_unit == 'deg': + phase = arg(w_expr)*180/pi + else: + phase = arg(w_expr) + + x, y = LineOver1DRangeSeries(phase, + (_w, 10**initial_exp, 10**final_exp), xscale='log', **kwargs).get_points() + + return x, y + + +def bode_phase_plot(system, initial_exp=-5, final_exp=5, + color='b', show_axes=False, grid=True, show=True, freq_unit='rad/sec', phase_unit='rad', **kwargs): + r""" + Returns the Bode phase plot of a continuous-time system. + + See ``bode_plot`` for all the parameters. + """ + x, y = bode_phase_numerical_data(system, initial_exp=initial_exp, + final_exp=final_exp, freq_unit=freq_unit, phase_unit=phase_unit) + plt.plot(x, y, color=color, **kwargs) + plt.xscale('log') + + plt.xlabel('Frequency (%s) [Log Scale]' % freq_unit) + plt.ylabel('Phase (%s)' % phase_unit) + plt.title(f'Bode Plot (Phase) of ${latex(system)}$', pad=20) + + if grid: + plt.grid(True) + if show_axes: + plt.axhline(0, color='black') + plt.axvline(0, color='black') + if show: + plt.show() + return + + return plt + + +def bode_plot(system, initial_exp=-5, final_exp=5, + grid=True, show_axes=False, show=True, freq_unit='rad/sec', phase_unit='rad', **kwargs): + r""" + Returns the Bode phase and magnitude plots of a continuous-time system. + + Parameters + ========== + + system : SISOLinearTimeInvariant type + The LTI SISO system for which the Bode Plot is to be computed. + initial_exp : Number, optional + The initial exponent of 10 of the semilog plot. Defaults to -5. + final_exp : Number, optional + The final exponent of 10 of the semilog plot. Defaults to 5. + show : boolean, optional + If ``True``, the plot will be displayed otherwise + the equivalent matplotlib ``plot`` object will be returned. + Defaults to True. + prec : int, optional + The decimal point precision for the point coordinate values. + Defaults to 8. + grid : boolean, optional + If ``True``, the plot will have a grid. Defaults to True. + show_axes : boolean, optional + If ``True``, the coordinate axes will be shown. Defaults to False. + freq_unit : string, optional + User can choose between ``'rad/sec'`` (radians/second) and ``'Hz'`` (Hertz) as frequency units. + phase_unit : string, optional + User can choose between ``'rad'`` (radians) and ``'deg'`` (degree) as phase units. + + Examples + ======== + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> from sympy.abc import s + >>> from sympy.physics.control.lti import TransferFunction + >>> from sympy.physics.control.control_plots import bode_plot + >>> tf1 = TransferFunction(1*s**2 + 0.1*s + 7.5, 1*s**4 + 0.12*s**3 + 9*s**2, s) + >>> bode_plot(tf1, initial_exp=0.2, final_exp=0.7) # doctest: +SKIP + + See Also + ======== + + bode_magnitude_plot, bode_phase_plot + + """ + plt.subplot(211) + mag = bode_magnitude_plot(system, initial_exp=initial_exp, final_exp=final_exp, + show=False, grid=grid, show_axes=show_axes, + freq_unit=freq_unit, **kwargs) + mag.title(f'Bode Plot of ${latex(system)}$', pad=20) + mag.xlabel(None) + plt.subplot(212) + bode_phase_plot(system, initial_exp=initial_exp, final_exp=final_exp, + show=False, grid=grid, show_axes=show_axes, freq_unit=freq_unit, phase_unit=phase_unit, **kwargs).title(None) + + if show: + plt.show() + return + + return plt diff --git a/shared/package-files/43/436f0c44005a2cd0a5e49a6fa6d0c0bd1d950b8565a1c1d2bfd948d279cb95d5/blob b/shared/package-files/43/436f0c44005a2cd0a5e49a6fa6d0c0bd1d950b8565a1c1d2bfd948d279cb95d5/blob new file mode 100644 index 0000000000000000000000000000000000000000..a42b424e66b29cf0720a83ff4a8883868b8db5d2 --- /dev/null +++ b/shared/package-files/43/436f0c44005a2cd0a5e49a6fa6d0c0bd1d950b8565a1c1d2bfd948d279cb95d5/blob @@ -0,0 +1,384 @@ +from pathlib import Path + +import numpy as np +from numpy.testing import ( + assert_allclose, + assert_array_almost_equal, +) +import pandas as pd +import pytest + +from statsmodels.formula._manager import FormulaManager +from statsmodels.multivariate.multivariate_ols import ( + MultivariateLS, + _MultivariateOLS, +) +from statsmodels.regression.linear_model import OLS + +dir_path = Path(__file__).resolve().parent +csv_path = Path(dir_path).joinpath("results", "mvreg.csv") +data_mvreg = pd.read_csv(csv_path) + +data = pd.DataFrame( + [ + ["Morphine", "N", 0.04, 0.20, 0.10, 0.08], + ["Morphine", "N", 0.02, 0.06, 0.02, 0.02], + ["Morphine", "N", 0.07, 1.40, 0.48, 0.24], + ["Morphine", "N", 0.17, 0.57, 0.35, 0.24], + ["Morphine", "Y", 0.10, 0.09, 0.13, 0.14], + ["placebo", "Y", 0.07, 0.07, 0.06, 0.07], + ["placebo", "Y", 0.05, 0.07, 0.06, 0.07], + ["placebo", "N", 0.03, 0.62, 0.31, 0.22], + ["placebo", "N", 0.03, 1.05, 0.73, 0.60], + ["placebo", "N", 0.07, 0.83, 1.07, 0.80], + ["Trimethaphan", "N", 0.09, 3.13, 2.06, 1.23], + ["Trimethaphan", "Y", 0.10, 0.09, 0.09, 0.08], + ["Trimethaphan", "Y", 0.08, 0.09, 0.09, 0.10], + ["Trimethaphan", "Y", 0.13, 0.10, 0.12, 0.12], + ["Trimethaphan", "Y", 0.06, 0.05, 0.05, 0.05], + ], + columns=[ + "Drug", + "Depleted", + "Histamine0", + "Histamine1", + "Histamine3", + "Histamine5", + ], +) + +for i in range(2, 6): + data.iloc[:, i] = np.log(data.iloc[:, i]) + +models = [_MultivariateOLS, MultivariateLS] + + +def compare_r_output_dogs_data(method, model): + """Testing within-subject effect interact with 2 between-subject effect + Compares with R car library Anova(, type=3) output + + Note: The test statistis Phillai, Wilks, Hotelling-Lawley + and Roy are the same as R output but the approximate F and degree + of freedoms can be different. This is due to the fact that this + implementation is based on SAS formula [1] + + .. [*] https://support.sas.com/documentation/cdl/en/statug/63033/HTML/default/ + viewer.htm#statug_introreg_sect012.htm + """ + + # Repeated measures with orthogonal polynomial contrasts coding + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", data + ) + r = mod.fit(method=method) + r = r.mv_test() + a = [ + [2.68607660e-02, 4, 6, 5.43435304e01, 7.59585610e-05], + [9.73139234e-01, 4, 6, 5.43435304e01, 7.59585610e-05], + [3.62290202e01, 4, 6, 5.43435304e01, 7.59585610e-05], + [3.62290202e01, 4, 6, 5.43435304e01, 7.59585610e-05], + ] + assert_array_almost_equal(r["Intercept"]["stat"].values, a, decimal=6) + a = [ + [8.39646619e-02, 8, 1.20000000e01, 3.67658068e00, 2.12614444e-02], + [1.18605382e00, 8, 1.40000000e01, 2.55003861e00, 6.01270701e-02], + [7.69391362e00, 8, 6.63157895e00, 5.50814270e00, 2.07392260e-02], + [7.25036952e00, 4, 7.00000000e00, 1.26881467e01, 2.52669877e-03], + ] + assert_array_almost_equal(r["Drug"]["stat"].values, a, decimal=6) + a = [ + [0.32048892, 4.0, 6.0, 3.18034906, 0.10002373], + [0.67951108, 4.0, 6.0, 3.18034906, 0.10002373], + [2.12023271, 4.0, 6.0, 3.18034906, 0.10002373], + [2.12023271, 4.0, 6.0, 3.18034906, 0.10002373], + ] + assert_array_almost_equal(r["Depleted"]["stat"].values, a, decimal=6) + a = [ + [0.15234366, 8.0, 12.0, 2.34307678, 0.08894239], + [1.13013353, 8.0, 14.0, 2.27360606, 0.08553213], + [3.70989596, 8.0, 6.63157895, 2.65594824, 0.11370285], + [3.1145597, 4.0, 7.0, 5.45047947, 0.02582767], + ] + assert_array_almost_equal(r["Drug:Depleted"]["stat"].values, a, decimal=6) + + +@pytest.mark.parametrize("model", models) +def test_glm_dogs_example(model): + compare_r_output_dogs_data(method="svd", model=model) + compare_r_output_dogs_data(method="pinv", model=model) + + +@pytest.mark.parametrize("model", models) +def test_invalid_fit_method_raises(model): + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", data + ) + with pytest.raises(ValueError, match="method"): + mod.fit(method="not-a-method") + + +@pytest.mark.parametrize("model", models) +def test_specify_L_M_by_string(model): + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", data + ) + r = mod.fit() + r1 = r.mv_test(hypotheses=[["Intercept", ["Intercept"], None]]) + a = [ + [2.68607660e-02, 4, 6, 5.43435304e01, 7.59585610e-05], + [9.73139234e-01, 4, 6, 5.43435304e01, 7.59585610e-05], + [3.62290202e01, 4, 6, 5.43435304e01, 7.59585610e-05], + [3.62290202e01, 4, 6, 5.43435304e01, 7.59585610e-05], + ] + assert_array_almost_equal(r1["Intercept"]["stat"].values, a, decimal=6) + L = ["Intercept", "Drug[T.Trimethaphan]", "Drug[T.placebo]"] + M = ["Histamine1", "Histamine3", "Histamine5"] + r1 = r.mv_test(hypotheses=[["a", L, M]]) + a = [[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0]] + assert_array_almost_equal(r1["a"]["contrast_L"], a, decimal=10) + a = [[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] + assert_array_almost_equal(r1["a"]["transform_M"].T, a, decimal=10) + + +@pytest.mark.parametrize("model", models) +def test_independent_variable_singular(model): + data1 = data.copy() + data1["dup"] = data1["Drug"] + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * dup", data1 + ) + with pytest.raises(ValueError): + mod.fit() + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * dup", data1 + ) + with pytest.raises(ValueError): + mod.fit() + + +@pytest.mark.parametrize("model", models) +def test_from_formula_vs_no_formula(model): + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", data + ) + r = mod.fit(method="svd") + r0 = r.mv_test() + mgr = FormulaManager() + endog, exog = mgr.get_matrices( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", data + ) + L = np.array([[1, 0, 0, 0, 0, 0]]) + # DataFrame input + r = model(endog, exog).fit(method="svd") + r1 = r.mv_test(hypotheses=[["Intercept", L, None]]) + assert_array_almost_equal( + r1["Intercept"]["stat"].values, r0["Intercept"]["stat"].values, decimal=6 + ) + # Numpy array input + r = model(endog.values, exog.values).fit(method="svd") + r1 = r.mv_test(hypotheses=[["Intercept", L, None]]) + assert_array_almost_equal( + r1["Intercept"]["stat"].values, r0["Intercept"]["stat"].values, decimal=6 + ) + L = np.array( + [ + [0, 1, 0, 0, 0, 0], + [0, 0, 1, 0, 0, 0], + ] + ) + r1 = r.mv_test(hypotheses=[["Drug", L, None]]) + # DataFrame input + r = model(endog, exog).fit(method="svd") + r1 = r.mv_test(hypotheses=[["Drug", L, None]]) + assert_array_almost_equal( + r1["Drug"]["stat"].values, r0["Drug"]["stat"].values, decimal=6 + ) + # Numpy array input + r = model(endog.values, exog.values).fit(method="svd") + r1 = r.mv_test(hypotheses=[["Drug", L, None]]) + assert_array_almost_equal( + r1["Drug"]["stat"].values, r0["Drug"]["stat"].values, decimal=6 + ) + + +@pytest.mark.parametrize("model", models) +def test_L_M_matrices_1D_array(model): + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", data + ) + r = mod.fit(method="svd") + L = np.array([1, 0, 0, 0, 0, 0]) + with pytest.raises(ValueError): + r.mv_test(hypotheses=[["Drug", L, None]]) + L = np.array([[1, 0, 0, 0, 0, 0]]) + M = np.array([1, 0, 0, 0, 0, 0]) + with pytest.raises(ValueError): + r.mv_test(hypotheses=[["Drug", L, M]]) + + +@pytest.mark.parametrize("model", models) +def test_exog_1D_array(model): + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ 0 + Depleted", data + ) + r = mod.fit(method="svd") + r0 = r.mv_test() + a = [ + [0.0019, 8.0000, 20.0000, 55.0013, 0.0000], + [1.8112, 8.0000, 22.0000, 26.3796, 0.0000], + [97.8858, 8.0000, 12.1818, 117.1133, 0.0000], + [93.2742, 4.0000, 11.0000, 256.5041, 0.0000], + ] + assert_array_almost_equal(r0["Depleted"]["stat"].values, a, decimal=4) + + +def test_endog_1D_array(): + with pytest.raises(ValueError): + _MultivariateOLS.from_formula("Histamine0 ~ 0 + Depleted", data) + + +@pytest.mark.parametrize("model", models) +def test_affine_hypothesis(model): + # Testing affine hypothesis, compared with R car linearHypothesis + # Note: The test statistis Phillai, Wilks, Hotelling-Lawley + # and Roy are the same as R output but the approximate F and degree + # of freedoms can be different. This is due to the fact that this + # implementation is based on SAS formula [1] + mod = model.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", data + ) + r = mod.fit(method="svd") + L = np.array([[0, 1.2, 1.1, 1.3, 1.5, 1.4], [0, 3.2, 2.1, 3.3, 5.5, 4.4]]) + M = None + C = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) + r0 = r.mv_test(hypotheses=[("test1", L, M, C)]) + a = [ + [0.0269, 8.0000, 12.0000, 7.6441, 0.0010], + [1.4277, 8.0000, 14.0000, 4.3657, 0.0080], + [19.2678, 8.0000, 6.6316, 13.7940, 0.0016], + [18.3470, 4.0000, 7.0000, 32.1072, 0.0001], + ] + assert_array_almost_equal(r0["test1"]["stat"].values, a, decimal=4) + r0.summary(show_contrast_L=True, show_transform_M=True, show_constant_C=True) + + +class CheckMVConsistent: + + def test_basic(self): + res = self.res + tt = res.t_test(np.eye(res.params.size)) + assert_allclose(tt.effect, res.params.to_numpy().ravel(order="F"), rtol=1e-13) + assert_allclose(tt.sd, res.bse.to_numpy().ravel(order="F"), rtol=1e-13) + assert_allclose(tt.tvalue, res.tvalues.to_numpy().ravel(order="F"), rtol=1e-13) + assert_allclose(tt.pvalue, res.pvalues.to_numpy().ravel(order="F"), rtol=1e-13) + assert_allclose(tt.conf_int(), res.conf_int().to_numpy(), rtol=1e-13) + + exog_names = res.model.exog_names + endog_names = res.model.endog_names + + # hypothesis test for one parameter: + for xn in exog_names: + cnx = [] + for yn in endog_names: + cn = f"y{yn}_{xn}" + tt = res.t_test(cn) + mvt = res.mv_test(hypotheses=[("one", [xn], [yn])]) + assert_allclose( + tt.pvalue, mvt.summary_frame["Pr > F"].iloc[0], rtol=1e-10 + ) + cnx.append(cn) + + # wald test effect of an exog is zero across all endog + # test methods are only asymptotically equivalent + tt = res.wald_test(cnx, scalar=True) + mvt = res.mv_test(hypotheses=[(xn, [xn], endog_names)]) + assert_allclose( + tt.pvalue, mvt.summary_frame["Pr > F"].iloc[0], rtol=0.1, atol=1e-20 + ) + + def test_ols(self): + res1 = self.res._results # use numpy results, not pandas + endog = res1.model.endog + exog = res1.model.exog + k_endog = endog.shape[1] + k_exog = exog.shape[1] + + for k in range(k_endog): + res_ols = OLS(endog[:, k], exog).fit() + assert_allclose(res1.params[:, k], res_ols.params, rtol=1e-12) + assert_allclose(res1.bse[:, k], res_ols.bse, rtol=1e-13) + assert_allclose(res1.tvalues[:, k], res_ols.tvalues, rtol=1e-12) + assert_allclose(res1.pvalues[:, k], res_ols.pvalues, rtol=1e-12, atol=1e-15) + # todo: why does conf_int have endog at axis=0 + assert_allclose(res1.conf_int()[k], res_ols.conf_int(), rtol=1e-10) + + idx0 = k * k_exog + idx1 = (k + 1) * k_exog + assert_allclose( + res1.cov_params()[idx0:idx1, idx0:idx1], + res_ols.cov_params(), + rtol=1e-12, + ) + + assert_allclose(res1.resid[:, k], res_ols.resid, rtol=1e-10) + assert_allclose(res1.fittedvalues[:, k], res_ols.fittedvalues, rtol=1e-10) + + +class TestMultivariateLS(CheckMVConsistent): + + @classmethod + def setup_class(cls): + formula2 = ( + "locus_of_control + self_concept + motivation ~ " + "read + write + science + prog" + ) + mod = MultivariateLS.from_formula(formula2, data=data_mvreg) + cls.res = mod.fit() + # ttn = cls.res.mv_test() + + +def test_multivariate_ls_results_summary(): + # MultivariateLSResults.summary is exported via the multivariate api + # but had no direct test coverage: existing tests call mv_test() + # rather than summary() on the fit result itself. + mod = MultivariateLS.from_formula( + "Histamine0 + Histamine1 + Histamine3 + Histamine5 ~ Drug * Depleted", + data, + ) + res = mod.fit(method="svd") + smry = res.summary() + text = str(smry) + + assert "MultivariateLS Regression Results" in text + for name in ["Histamine0", "Histamine1", "Histamine3", "Histamine5"]: + assert name in text + assert str(res.model.endog.shape[0]) in text # No. Observations + + custom = res.summary(title="Custom Title") + assert "Custom Title" in str(custom) + + +def test_resid_distance_and_hat_matrix_diag(): + rs = np.random.RandomState(20260821) + n, k_endog, k_exog = 40, 3, 2 + exog = np.column_stack([np.ones(n), rs.standard_normal((n, k_exog))]) + beta = rs.standard_normal((k_exog + 1, k_endog)) + endog = exog @ beta + rs.standard_normal((n, k_endog)) + + mod = MultivariateLS(endog, exog) + res = mod.fit(method="svd") + + resid = res.resid + cov = res.cov_resid + expected_dist = (resid * np.linalg.solve(cov, resid.T).T).sum(1) + assert_allclose(res.resid_distance, expected_dist) + assert np.all(res.resid_distance >= 0) + + pinv_exog = np.linalg.pinv(exog) + expected_hd = (exog * pinv_exog.T).sum(1) + assert_allclose(res._hat_matrix_diag, expected_hd) + # OLS leverage: diagonal of a projection matrix, sums to the rank + assert_allclose(res._hat_matrix_diag.sum(), np.linalg.matrix_rank(exog), + atol=1e-8) + assert np.all(res._hat_matrix_diag > -1e-10) + assert np.all(res._hat_matrix_diag < 1 + 1e-10) diff --git a/shared/package-files/43/4370551884cbd54c254e606c143f622dfda98202604c4e5b1b7d9000d76432fa/blob b/shared/package-files/43/4370551884cbd54c254e606c143f622dfda98202604c4e5b1b7d9000d76432fa/blob new file mode 100644 index 0000000000000000000000000000000000000000..bdb4d1c03e6880c97f96698520b2075c0bef1a57 --- /dev/null +++ b/shared/package-files/43/4370551884cbd54c254e606c143f622dfda98202604c4e5b1b7d9000d76432fa/blob @@ -0,0 +1 @@ +from .urllib.parse import * diff --git a/shared/package-files/43/4370727df7bb68c5ad9240b4c1d0a05a88279d79d0721fac1f389117140049da/blob b/shared/package-files/43/4370727df7bb68c5ad9240b4c1d0a05a88279d79d0721fac1f389117140049da/blob new file mode 100644 index 0000000000000000000000000000000000000000..b2ca83fc8701f4a427a9b1e74cf2eb9aae1327e8 --- /dev/null +++ b/shared/package-files/43/4370727df7bb68c5ad9240b4c1d0a05a88279d79d0721fac1f389117140049da/blob @@ -0,0 +1,61 @@ +from yaml.emitter import Emitter +from yaml.representer import BaseRepresenter, Representer, SafeRepresenter +from yaml.resolver import BaseResolver, Resolver +from yaml.serializer import Serializer + +class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): + def __init__( + self, + stream, + default_style=..., + default_flow_style=..., + canonical=..., + indent=..., + width=..., + allow_unicode=..., + line_break=..., + encoding=..., + explicit_start=..., + explicit_end=..., + version=..., + tags=..., + sort_keys: bool = ..., + ) -> None: ... + +class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): + def __init__( + self, + stream, + default_style=..., + default_flow_style=..., + canonical=..., + indent=..., + width=..., + allow_unicode=..., + line_break=..., + encoding=..., + explicit_start=..., + explicit_end=..., + version=..., + tags=..., + sort_keys: bool = ..., + ) -> None: ... + +class Dumper(Emitter, Serializer, Representer, Resolver): + def __init__( + self, + stream, + default_style=..., + default_flow_style=..., + canonical=..., + indent=..., + width=..., + allow_unicode=..., + line_break=..., + encoding=..., + explicit_start=..., + explicit_end=..., + version=..., + tags=..., + sort_keys: bool = ..., + ) -> None: ... diff --git a/shared/package-files/43/4370d23bfe1c34d8c0bc0c02ff042510fb2ce393d51ebae9e75a977681d99637/blob b/shared/package-files/43/4370d23bfe1c34d8c0bc0c02ff042510fb2ce393d51ebae9e75a977681d99637/blob new file mode 100644 index 0000000000000000000000000000000000000000..231f838d4aa4bee22d39fe0680b1af8ad858f96a --- /dev/null +++ b/shared/package-files/43/4370d23bfe1c34d8c0bc0c02ff042510fb2ce393d51ebae9e75a977681d99637/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor mvlgamma(const at::Tensor & self, int64_t p); +TORCH_API at::Tensor & mvlgamma_(at::Tensor & self, int64_t p); +TORCH_API at::Tensor & mvlgamma_out(const at::Tensor & self, int64_t p, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/shared/package-files/43/4370db5b3a96745b7c864ab5e816e0e0c43c59ac602ae8612a9e9710467c6d6c/blob b/shared/package-files/43/4370db5b3a96745b7c864ab5e816e0e0c43c59ac602ae8612a9e9710467c6d6c/blob new file mode 100644 index 0000000000000000000000000000000000000000..05129585b8f7041c202f1ae8a1d47d56336b4b67 --- /dev/null +++ b/shared/package-files/43/4370db5b3a96745b7c864ab5e816e0e0c43c59ac602ae8612a9e9710467c6d6c/blob @@ -0,0 +1,552 @@ +# Pytest customization +import json +import os +import warnings +import tempfile +from contextlib import contextmanager + +import numpy as np +import numpy.testing as npt +import pytest +import hypothesis + +from scipy._lib._fpumode import get_fpu_mode +from scipy._lib._testutils import FPUModeChangeWarning +from scipy._lib._array_api import SCIPY_ARRAY_API, SCIPY_DEVICE +from scipy._lib import _pep440 + +try: + from scipy_doctest.conftest import dt_config + HAVE_SCPDT = True +except ModuleNotFoundError: + HAVE_SCPDT = False + +try: + import pytest_run_parallel # noqa:F401 + PARALLEL_RUN_AVAILABLE = True +except Exception: + PARALLEL_RUN_AVAILABLE = False + + +def pytest_configure(config): + config.addinivalue_line("markers", + "slow: Tests that are very slow.") + config.addinivalue_line("markers", + "xslow: mark test as extremely slow (not run unless explicitly requested)") + config.addinivalue_line("markers", + "xfail_on_32bit: mark test as failing on 32-bit platforms") + try: + import pytest_timeout # noqa:F401 + except Exception: + config.addinivalue_line( + "markers", 'timeout: mark a test for a non-default timeout') + try: + # This is a more reliable test of whether pytest_fail_slow is installed + # When I uninstalled it, `import pytest_fail_slow` didn't fail! + from pytest_fail_slow import parse_duration # type: ignore[import-not-found] # noqa:F401,E501 + except Exception: + config.addinivalue_line( + "markers", 'fail_slow: mark a test for a non-default timeout failure') + config.addinivalue_line("markers", + "skip_xp_backends(backends, reason=None, np_only=False, cpu_only=False, " + "exceptions=None): " + "mark the desired skip configuration for the `skip_xp_backends` fixture.") + config.addinivalue_line("markers", + "xfail_xp_backends(backends, reason=None, np_only=False, cpu_only=False, " + "exceptions=None): " + "mark the desired xfail configuration for the `xfail_xp_backends` fixture.") + if not PARALLEL_RUN_AVAILABLE: + config.addinivalue_line( + 'markers', + 'parallel_threads(n): run the given test function in parallel ' + 'using `n` threads.') + config.addinivalue_line( + "markers", + "thread_unsafe: mark the test function as single-threaded", + ) + config.addinivalue_line( + "markers", + "iterations(n): run the given test function `n` times in each thread", + ) + + +def pytest_runtest_setup(item): + mark = item.get_closest_marker("xslow") + if mark is not None: + try: + v = int(os.environ.get('SCIPY_XSLOW', '0')) + except ValueError: + v = False + if not v: + pytest.skip("very slow test; " + "set environment variable SCIPY_XSLOW=1 to run it") + mark = item.get_closest_marker("xfail_on_32bit") + if mark is not None and np.intp(0).itemsize < 8: + pytest.xfail(f'Fails on our 32-bit test platform(s): {mark.args[0]}') + + # Older versions of threadpoolctl have an issue that may lead to this + # warning being emitted, see gh-14441 + with npt.suppress_warnings() as sup: + sup.filter(pytest.PytestUnraisableExceptionWarning) + + try: + from threadpoolctl import threadpool_limits + + HAS_THREADPOOLCTL = True + except Exception: # observed in gh-14441: (ImportError, AttributeError) + # Optional dependency only. All exceptions are caught, for robustness + HAS_THREADPOOLCTL = False + + if HAS_THREADPOOLCTL: + # Set the number of openmp threads based on the number of workers + # xdist is using to prevent oversubscription. Simplified version of what + # sklearn does (it can rely on threadpoolctl and its builtin OpenMP helper + # functions) + try: + xdist_worker_count = int(os.environ['PYTEST_XDIST_WORKER_COUNT']) + except KeyError: + # raises when pytest-xdist is not installed + return + + if not os.getenv('OMP_NUM_THREADS'): + max_openmp_threads = os.cpu_count() // 2 # use nr of physical cores + threads_per_worker = max(max_openmp_threads // xdist_worker_count, 1) + try: + threadpool_limits(threads_per_worker, user_api='blas') + except Exception: + # May raise AttributeError for older versions of OpenBLAS. + # Catch any error for robustness. + return + + +@pytest.fixture(scope="function", autouse=True) +def check_fpu_mode(request): + """ + Check FPU mode was not changed during the test. + """ + old_mode = get_fpu_mode() + yield + new_mode = get_fpu_mode() + + if old_mode != new_mode: + warnings.warn(f"FPU mode changed from {old_mode:#x} to {new_mode:#x} during " + "the test", + category=FPUModeChangeWarning, stacklevel=0) + + +if not PARALLEL_RUN_AVAILABLE: + @pytest.fixture + def num_parallel_threads(): + return 1 + + +# Array API backend handling +xp_available_backends = {'numpy': np} + +if SCIPY_ARRAY_API and isinstance(SCIPY_ARRAY_API, str): + # fill the dict of backends with available libraries + try: + import array_api_strict + xp_available_backends.update({'array_api_strict': array_api_strict}) + if _pep440.parse(array_api_strict.__version__) < _pep440.Version('2.0'): + raise ImportError("array-api-strict must be >= version 2.0") + array_api_strict.set_array_api_strict_flags( + api_version='2023.12' + ) + except ImportError: + pass + + try: + import torch # type: ignore[import-not-found] + xp_available_backends.update({'torch': torch}) + # can use `mps` or `cpu` + torch.set_default_device(SCIPY_DEVICE) + except ImportError: + pass + + try: + import cupy # type: ignore[import-not-found] + xp_available_backends.update({'cupy': cupy}) + except ImportError: + pass + + try: + import jax.numpy # type: ignore[import-not-found] + xp_available_backends.update({'jax.numpy': jax.numpy}) + jax.config.update("jax_enable_x64", True) + jax.config.update("jax_default_device", jax.devices(SCIPY_DEVICE)[0]) + except ImportError: + pass + + # by default, use all available backends + if SCIPY_ARRAY_API.lower() not in ("1", "true"): + SCIPY_ARRAY_API_ = json.loads(SCIPY_ARRAY_API) + + if 'all' in SCIPY_ARRAY_API_: + pass # same as True + else: + # only select a subset of backend by filtering out the dict + try: + xp_available_backends = { + backend: xp_available_backends[backend] + for backend in SCIPY_ARRAY_API_ + } + except KeyError: + msg = f"'--array-api-backend' must be in {xp_available_backends.keys()}" + raise ValueError(msg) + +if 'cupy' in xp_available_backends: + SCIPY_DEVICE = 'cuda' + +array_api_compatible = pytest.mark.parametrize("xp", xp_available_backends.values()) + +skip_xp_invalid_arg = pytest.mark.skipif(SCIPY_ARRAY_API, + reason = ('Test involves masked arrays, object arrays, or other types ' + 'that are not valid input when `SCIPY_ARRAY_API` is used.')) + + +def _backends_kwargs_from_request(request, skip_or_xfail): + """A helper for {skip,xfail}_xp_backends""" + # do not allow multiple backends + args_ = request.keywords[f'{skip_or_xfail}_xp_backends'].args + if len(args_) > 1: + # np_only / cpu_only has args=(), otherwise it's ('numpy',) + # and we do not allow ('numpy', 'cupy') + raise ValueError(f"multiple backends: {args_}") + + markers = list(request.node.iter_markers(f'{skip_or_xfail}_xp_backends')) + backends = [] + kwargs = {} + for marker in markers: + if marker.kwargs.get('np_only'): + kwargs['np_only'] = True + kwargs['exceptions'] = marker.kwargs.get('exceptions', []) + elif marker.kwargs.get('cpu_only'): + if not kwargs.get('np_only'): + # if np_only is given, it is certainly cpu only + kwargs['cpu_only'] = True + kwargs['exceptions'] = marker.kwargs.get('exceptions', []) + + # add backends, if any + if len(marker.args) > 0: + backend = marker.args[0] # was a tuple, ('numpy',) etc + backends.append(backend) + kwargs.update(**{backend: marker.kwargs}) + + return backends, kwargs + + +@pytest.fixture +def skip_xp_backends(xp, request): + """skip_xp_backends(backend=None, reason=None, np_only=False, cpu_only=False, exceptions=None) + + Skip a decorated test for the provided backend, or skip a category of backends. + + See ``skip_or_xfail_backends`` docstring for details. Note that, contrary to + ``skip_or_xfail_backends``, the ``backend`` and ``reason`` arguments are optional + single strings: this function only skips a single backend at a time. + To skip multiple backends, provide multiple decorators. + """ # noqa: E501 + if "skip_xp_backends" not in request.keywords: + return + + backends, kwargs = _backends_kwargs_from_request(request, skip_or_xfail='skip') + skip_or_xfail_xp_backends(xp, backends, kwargs, skip_or_xfail='skip') + + +@pytest.fixture +def xfail_xp_backends(xp, request): + """xfail_xp_backends(backend=None, reason=None, np_only=False, cpu_only=False, exceptions=None) + + xfail a decorated test for the provided backend, or xfail a category of backends. + + See ``skip_or_xfail_backends`` docstring for details. Note that, contrary to + ``skip_or_xfail_backends``, the ``backend`` and ``reason`` arguments are optional + single strings: this function only xfails a single backend at a time. + To xfail multiple backends, provide multiple decorators. + """ # noqa: E501 + if "xfail_xp_backends" not in request.keywords: + return + backends, kwargs = _backends_kwargs_from_request(request, skip_or_xfail='xfail') + skip_or_xfail_xp_backends(xp, backends, kwargs, skip_or_xfail='xfail') + + +def skip_or_xfail_xp_backends(xp, backends, kwargs, skip_or_xfail='skip'): + """ + Skip based on the ``skip_xp_backends`` or ``xfail_xp_backends`` marker. + + See the "Support for the array API standard" docs page for usage examples. + + Parameters + ---------- + backends : tuple + Backends to skip/xfail, e.g. ``("array_api_strict", "torch")``. + These are overriden when ``np_only`` is ``True``, and are not + necessary to provide for non-CPU backends when ``cpu_only`` is ``True``. + For a custom reason to apply, you should pass a dict ``{'reason': '...'}`` + to a keyword matching the name of the backend. + reason : str, optional + A reason for the skip/xfail in the case of ``np_only=True``. + If unprovided, a default reason is used. Note that it is not possible + to specify a custom reason with ``cpu_only``. + np_only : bool, optional + When ``True``, the test is skipped/xfailed for all backends other + than the default NumPy backend. There is no need to provide + any ``backends`` in this case. To specify a reason, pass a + value to ``reason``. Default: ``False``. + cpu_only : bool, optional + When ``True``, the test is skipped/xfailed on non-CPU devices. + There is no need to provide any ``backends`` in this case, + but any ``backends`` will also be skipped on the CPU. + Default: ``False``. + exceptions : list, optional + A list of exceptions for use with ``cpu_only`` or ``np_only``. + This should be provided when delegation is implemented for some, + but not all, non-CPU/non-NumPy backends. + skip_or_xfail : str + ``'skip'`` to skip, ``'xfail'`` to xfail. + """ + skip_or_xfail = getattr(pytest, skip_or_xfail) + np_only = kwargs.get("np_only", False) + cpu_only = kwargs.get("cpu_only", False) + exceptions = kwargs.get("exceptions", []) + + if reasons := kwargs.get("reasons"): + raise ValueError(f"provide a single `reason=` kwarg; got {reasons=} instead") + + # input validation + if np_only and cpu_only: + # np_only is a stricter subset of cpu_only + cpu_only = False + if exceptions and not (cpu_only or np_only): + raise ValueError("`exceptions` is only valid alongside `cpu_only` or `np_only`") + + if np_only: + reason = kwargs.get("reason", "do not run with non-NumPy backends.") + if not isinstance(reason, str) and len(reason) > 1: + raise ValueError("please provide a singleton `reason` " + "when using `np_only`") + if xp.__name__ != 'numpy' and xp.__name__ not in exceptions: + skip_or_xfail(reason=reason) + return + if cpu_only: + reason = ("no array-agnostic implementation or delegation available " + "for this backend and device") + exceptions = [] if exceptions is None else exceptions + if SCIPY_ARRAY_API and SCIPY_DEVICE != 'cpu': + if xp.__name__ == 'cupy' and 'cupy' not in exceptions: + skip_or_xfail(reason=reason) + elif xp.__name__ == 'torch' and 'torch' not in exceptions: + if 'cpu' not in xp.empty(0).device.type: + skip_or_xfail(reason=reason) + elif xp.__name__ == 'jax.numpy' and 'jax.numpy' not in exceptions: + for d in xp.empty(0).devices(): + if 'cpu' not in d.device_kind: + skip_or_xfail(reason=reason) + + if backends is not None: + for i, backend in enumerate(backends): + if xp.__name__ == backend: + reason = kwargs[backend].get('reason') + if not reason: + reason = f"do not run with array API backend: {backend}" + + skip_or_xfail(reason=reason) + + +# Following the approach of NumPy's conftest.py... +# Use a known and persistent tmpdir for hypothesis' caches, which +# can be automatically cleared by the OS or user. +hypothesis.configuration.set_hypothesis_home_dir( + os.path.join(tempfile.gettempdir(), ".hypothesis") +) + +# We register two custom profiles for SciPy - for details see +# https://hypothesis.readthedocs.io/en/latest/settings.html +# The first is designed for our own CI runs; the latter also +# forces determinism and is designed for use via scipy.test() +hypothesis.settings.register_profile( + name="nondeterministic", deadline=None, print_blob=True, +) +hypothesis.settings.register_profile( + name="deterministic", + deadline=None, print_blob=True, database=None, derandomize=True, + suppress_health_check=list(hypothesis.HealthCheck), +) + +# Profile is currently set by environment variable `SCIPY_HYPOTHESIS_PROFILE` +# In the future, it would be good to work the choice into dev.py. +SCIPY_HYPOTHESIS_PROFILE = os.environ.get("SCIPY_HYPOTHESIS_PROFILE", + "deterministic") +hypothesis.settings.load_profile(SCIPY_HYPOTHESIS_PROFILE) + + +############################################################################ +# doctesting stuff + +if HAVE_SCPDT: + + # FIXME: populate the dict once + @contextmanager + def warnings_errors_and_rng(test=None): + """Temporarily turn (almost) all warnings to errors. + + Filter out known warnings which we allow. + """ + known_warnings = dict() + + # these functions are known to emit "divide by zero" RuntimeWarnings + divide_by_zero = [ + 'scipy.linalg.norm', 'scipy.ndimage.center_of_mass', + ] + for name in divide_by_zero: + known_warnings[name] = dict(category=RuntimeWarning, + message='divide by zero') + + # Deprecated stuff in scipy.signal and elsewhere + deprecated = [ + 'scipy.signal.cwt', 'scipy.signal.morlet', 'scipy.signal.morlet2', + 'scipy.signal.ricker', + 'scipy.integrate.simpson', + 'scipy.interpolate.interp2d', + 'scipy.linalg.kron', + ] + for name in deprecated: + known_warnings[name] = dict(category=DeprecationWarning) + + from scipy import integrate + # the functions are known to emit IntegrationWarnings + integration_w = ['scipy.special.ellip_normal', + 'scipy.special.ellip_harm_2', + ] + for name in integration_w: + known_warnings[name] = dict(category=integrate.IntegrationWarning, + message='The occurrence of roundoff') + + # scipy.stats deliberately emits UserWarnings sometimes + user_w = ['scipy.stats.anderson_ksamp', 'scipy.stats.kurtosistest', + 'scipy.stats.normaltest', 'scipy.sparse.linalg.norm'] + for name in user_w: + known_warnings[name] = dict(category=UserWarning) + + # additional one-off warnings to filter + dct = { + 'scipy.sparse.linalg.norm': + dict(category=UserWarning, message="Exited at iteration"), + # tutorials + 'linalg.rst': + dict(message='the matrix subclass is not', + category=PendingDeprecationWarning), + 'stats.rst': + dict(message='The maximum number of subdivisions', + category=integrate.IntegrationWarning), + } + known_warnings.update(dct) + + # these legitimately emit warnings in examples + legit = set('scipy.signal.normalize') + + # Now, the meat of the matter: filter warnings, + # also control the random seed for each doctest. + + # XXX: this matches the refguide-check behavior, but is a tad strange: + # makes sure that the seed the old-fashioned np.random* methods is + # *NOT* reproducible but the new-style `default_rng()` *IS* repoducible. + # Should these two be either both repro or both not repro? + + from scipy._lib._util import _fixed_default_rng + import numpy as np + with _fixed_default_rng(): + np.random.seed(None) + with warnings.catch_warnings(): + if test and test.name in known_warnings: + warnings.filterwarnings('ignore', + **known_warnings[test.name]) + yield + elif test and test.name in legit: + yield + else: + warnings.simplefilter('error', Warning) + yield + + dt_config.user_context_mgr = warnings_errors_and_rng + dt_config.skiplist = set([ + 'scipy.linalg.LinAlgError', # comes from numpy + 'scipy.fftpack.fftshift', # fftpack stuff is also from numpy + 'scipy.fftpack.ifftshift', + 'scipy.fftpack.fftfreq', + 'scipy.special.sinc', # sinc is from numpy + 'scipy.optimize.show_options', # does not have much to doctest + 'scipy.signal.normalize', # manipulates warnings (XXX temp skip) + 'scipy.sparse.linalg.norm', # XXX temp skip + # these below test things which inherit from np.ndarray + # cross-ref https://github.com/numpy/numpy/issues/28019 + 'scipy.io.matlab.MatlabObject.strides', + 'scipy.io.matlab.MatlabObject.dtype', + 'scipy.io.matlab.MatlabOpaque.dtype', + 'scipy.io.matlab.MatlabOpaque.strides', + 'scipy.io.matlab.MatlabFunction.strides', + 'scipy.io.matlab.MatlabFunction.dtype' + ]) + + # these are affected by NumPy 2.0 scalar repr: rely on string comparison + if np.__version__ < "2": + dt_config.skiplist.update(set([ + 'scipy.io.hb_read', + 'scipy.io.hb_write', + 'scipy.sparse.csgraph.connected_components', + 'scipy.sparse.csgraph.depth_first_order', + 'scipy.sparse.csgraph.shortest_path', + 'scipy.sparse.csgraph.floyd_warshall', + 'scipy.sparse.csgraph.dijkstra', + 'scipy.sparse.csgraph.bellman_ford', + 'scipy.sparse.csgraph.johnson', + 'scipy.sparse.csgraph.yen', + 'scipy.sparse.csgraph.breadth_first_order', + 'scipy.sparse.csgraph.reverse_cuthill_mckee', + 'scipy.sparse.csgraph.structural_rank', + 'scipy.sparse.csgraph.construct_dist_matrix', + 'scipy.sparse.csgraph.reconstruct_path', + 'scipy.ndimage.value_indices', + 'scipy.stats.mstats.describe', + ])) + + # help pytest collection a bit: these names are either private + # (distributions), or just do not need doctesting. + dt_config.pytest_extra_ignore = [ + "scipy.stats.distributions", + "scipy.optimize.cython_optimize", + "scipy.test", + "scipy.show_config", + # equivalent to "pytest --ignore=path/to/file" + "scipy/special/_precompute", + "scipy/interpolate/_interpnd_info.py", + "scipy/_lib/array_api_compat", + "scipy/_lib/highs", + "scipy/_lib/unuran", + "scipy/_lib/_gcutils.py", + "scipy/_lib/doccer.py", + "scipy/_lib/_uarray", + ] + + dt_config.pytest_extra_xfail = { + # name: reason + "ND_regular_grid.rst": "ReST parser limitation", + "extrapolation_examples.rst": "ReST parser limitation", + "sampling_pinv.rst": "__cinit__ unexpected argument", + "sampling_srou.rst": "nan in scalar_power", + "probability_distributions.rst": "integration warning", + } + + # tutorials + dt_config.pseudocode = set(['integrate.nquad(func,']) + dt_config.local_resources = { + 'io.rst': [ + "octave_a.mat", + "octave_cells.mat", + "octave_struct.mat" + ] + } + + dt_config.strict_check = True +############################################################################ diff --git a/shared/package-files/43/4374e6c327df169558404a79e59a164c30e19ed7bbcd02a25f296c7db10c0ae2/blob b/shared/package-files/43/4374e6c327df169558404a79e59a164c30e19ed7bbcd02a25f296c7db10c0ae2/blob new file mode 100644 index 0000000000000000000000000000000000000000..b0cf1010289ead191c735ad48c999f1a850953b4 --- /dev/null +++ b/shared/package-files/43/4374e6c327df169558404a79e59a164c30e19ed7bbcd02a25f296c7db10c0ae2/blob @@ -0,0 +1,160 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include "arrow/python/platform.h" + +#include +#include +#include +#include + +#include "arrow/python/numpy_interop.h" + +#include "arrow/python/visibility.h" +#include "arrow/type.h" +#include "arrow/util/macros.h" + +namespace arrow { + +namespace py { + +class OwnedRef; + +// \brief Get an arrow DataType instance from Arrow's Type::type enum +// \param[in] type One of the values of Arrow's Type::type enum +// \return A shared pointer to DataType +ARROW_PYTHON_EXPORT std::shared_ptr GetPrimitiveType(Type::type type); + +// \brief Construct a Python float object from a half-float uint16_t value. +ARROW_PYTHON_EXPORT PyObject* PyFloat_FromHalf(uint16_t value); + +// \brief Convert a Python object to a half-float uint16_t value. +ARROW_PYTHON_EXPORT Result PyFloat_AsHalf(PyObject* obj); + +namespace internal { + +// \brief Check that a Python module has been already imported +// \param[in] module_name The name of the module +Result IsModuleImported(const std::string& module_name); + +// \brief Import a Python module +// \param[in] module_name The name of the module +// \param[out] ref The OwnedRef containing the module PyObject* +ARROW_PYTHON_EXPORT +Status ImportModule(const std::string& module_name, OwnedRef* ref); + +// \brief Import an object from a Python module +// \param[in] module A Python module +// \param[in] name The name of the object to import +// \param[out] ref The OwnedRef containing the \c name attribute of the Python module \c +// module +ARROW_PYTHON_EXPORT +Status ImportFromModule(PyObject* module, const std::string& name, OwnedRef* ref); + +// \brief Check whether obj is an integer, independent of Python versions. +inline bool IsPyInteger(PyObject* obj) { return PyLong_Check(obj); } + +// \brief Import symbols from pandas that we need for various type-checking, +// like pandas.NaT or pandas.NA +void InitPandasStaticData(); + +// \brief Use pandas missing value semantics to check if a value is null +ARROW_PYTHON_EXPORT +bool PandasObjectIsNull(PyObject* obj); + +// \brief Check that obj is a pandas.Timedelta instance +ARROW_PYTHON_EXPORT +bool IsPandasTimedelta(PyObject* obj); + +// \brief Check that obj is a pandas.Timestamp instance +bool IsPandasTimestamp(PyObject* obj); + +// \brief Returned a borrowed reference to the pandas.tseries.offsets.DateOffset +PyObject* BorrowPandasDataOffsetType(); + +// \brief Check whether obj is a floating-point NaN +ARROW_PYTHON_EXPORT +bool PyFloat_IsNaN(PyObject* obj); + +inline bool IsPyBinary(PyObject* obj) { + return PyBytes_Check(obj) || PyByteArray_Check(obj) || PyMemoryView_Check(obj); +} + +// \brief Convert a Python integer into a C integer +// \param[in] obj A Python integer +// \param[out] out A pointer to a C integer to hold the result of the conversion +// \return The status of the operation +template +Status CIntFromPython(PyObject* obj, Int* out, const std::string& overflow_message = ""); + +// \brief Convert a Python unicode string to a std::string +ARROW_PYTHON_EXPORT +Status PyUnicode_AsStdString(PyObject* obj, std::string* out); + +// \brief Convert a Python bytes object to a std::string +ARROW_PYTHON_EXPORT +std::string PyBytes_AsStdString(PyObject* obj); + +// \brief Call str() on the given object and return the result as a std::string +ARROW_PYTHON_EXPORT +Status PyObject_StdStringStr(PyObject* obj, std::string* out); + +// \brief Return the repr() of the given object (always succeeds) +ARROW_PYTHON_EXPORT +std::string PyObject_StdStringRepr(PyObject* obj); + +// \brief Cast the given size to int32_t, with error checking +inline Status CastSize(Py_ssize_t size, int32_t* out, + const char* error_msg = "Maximum size exceeded (2GB)") { + // size is assumed to be positive + if (size > std::numeric_limits::max()) { + return Status::Invalid(error_msg); + } + *out = static_cast(size); + return Status::OK(); +} + +inline Status CastSize(Py_ssize_t size, int64_t* out, const char* error_msg = NULLPTR) { + // size is assumed to be positive + *out = static_cast(size); + return Status::OK(); +} + +// \brief Print the Python object's __str__ form along with the passed error +// message +ARROW_PYTHON_EXPORT +Status InvalidValue(PyObject* obj, const std::string& why); + +ARROW_PYTHON_EXPORT +Status InvalidType(PyObject* obj, const std::string& why); + +ARROW_PYTHON_EXPORT +Status IntegerScalarToDoubleSafe(PyObject* obj, double* result); +ARROW_PYTHON_EXPORT +Status IntegerScalarToFloat32Safe(PyObject* obj, float* result); + +// \brief Print Python object __repr__ +void DebugPrint(PyObject* obj); + +ARROW_PYTHON_EXPORT +bool IsThreadingEnabled(); + +} // namespace internal +} // namespace py +} // namespace arrow diff --git a/shared/package-files/43/437706df16a2e27d48cdf55273f365db958f1c01e8b6f0b41a09854cb34532fa/blob b/shared/package-files/43/437706df16a2e27d48cdf55273f365db958f1c01e8b6f0b41a09854cb34532fa/blob new file mode 100644 index 0000000000000000000000000000000000000000..966993cb89acc0a5cd94ce908ae9ebb795999153 Binary files /dev/null and b/shared/package-files/43/437706df16a2e27d48cdf55273f365db958f1c01e8b6f0b41a09854cb34532fa/blob differ diff --git a/shared/package-files/43/437bb3e916b0b52e2babfc844ed0f39b6ddb3f8bf7e730deb2653c2a39018fc2/blob b/shared/package-files/43/437bb3e916b0b52e2babfc844ed0f39b6ddb3f8bf7e730deb2653c2a39018fc2/blob new file mode 100644 index 0000000000000000000000000000000000000000..8ef384282b37fc358c66b289825fa229a0133d2d --- /dev/null +++ b/shared/package-files/43/437bb3e916b0b52e2babfc844ed0f39b6ddb3f8bf7e730deb2653c2a39018fc2/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor linalg_matmul(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & linalg_matmul_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & linalg_matmul_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/43/437c598dd05017878cda71e0e25a772570bcef7bdc87b53bee99740820c5a610/blob b/shared/package-files/43/437c598dd05017878cda71e0e25a772570bcef7bdc87b53bee99740820c5a610/blob new file mode 100644 index 0000000000000000000000000000000000000000..14a84485bf62f735eca43ae48b379150ca0da17e --- /dev/null +++ b/shared/package-files/43/437c598dd05017878cda71e0e25a772570bcef7bdc87b53bee99740820c5a610/blob @@ -0,0 +1,186 @@ +import collections +import pickle + +import pytest + +import networkx as nx +from networkx.utils.configs import Config + + +# Define this at module level so we can test pickling +class ExampleConfig(Config): + """Example configuration.""" + + x: int + y: str + + def _check_config(self, key, value): + if key == "x" and value <= 0: + raise ValueError("x must be positive") + if key == "y" and not isinstance(value, str): + raise TypeError("y must be a str") + + +class EmptyConfig(Config): + pass + + +@pytest.mark.parametrize("cfg", [EmptyConfig(), Config()]) +def test_config_empty(cfg): + assert dir(cfg) == [] + with pytest.raises(AttributeError): + cfg.x = 1 + with pytest.raises(KeyError): + cfg["x"] = 1 + with pytest.raises(AttributeError): + cfg.x + with pytest.raises(KeyError): + cfg["x"] + assert len(cfg) == 0 + assert "x" not in cfg + assert cfg == cfg + assert cfg.get("x", 2) == 2 + assert set(cfg.keys()) == set() + assert set(cfg.values()) == set() + assert set(cfg.items()) == set() + cfg2 = pickle.loads(pickle.dumps(cfg)) + assert cfg == cfg2 + assert isinstance(cfg, collections.abc.Collection) + assert isinstance(cfg, collections.abc.Mapping) + + +def test_config_subclass(): + with pytest.raises(TypeError, match="missing 2 required keyword-only"): + ExampleConfig() + with pytest.raises(ValueError, match="x must be positive"): + ExampleConfig(x=0, y="foo") + with pytest.raises(TypeError, match="unexpected keyword"): + ExampleConfig(x=1, y="foo", z="bad config") + with pytest.raises(TypeError, match="unexpected keyword"): + EmptyConfig(z="bad config") + cfg = ExampleConfig(x=1, y="foo") + assert cfg.x == 1 + assert cfg["x"] == 1 + assert cfg["y"] == "foo" + assert cfg.y == "foo" + assert "x" in cfg + assert "y" in cfg + assert "z" not in cfg + assert len(cfg) == 2 + assert set(iter(cfg)) == {"x", "y"} + assert set(cfg.keys()) == {"x", "y"} + assert set(cfg.values()) == {1, "foo"} + assert set(cfg.items()) == {("x", 1), ("y", "foo")} + assert dir(cfg) == ["x", "y"] + cfg.x = 2 + cfg["y"] = "bar" + assert cfg["x"] == 2 + assert cfg.y == "bar" + with pytest.raises(TypeError, match="can't be deleted"): + del cfg.x + with pytest.raises(TypeError, match="can't be deleted"): + del cfg["y"] + assert cfg.x == 2 + assert cfg == cfg + assert cfg == ExampleConfig(x=2, y="bar") + assert cfg != ExampleConfig(x=3, y="baz") + assert cfg != Config(x=2, y="bar") + with pytest.raises(TypeError, match="y must be a str"): + cfg["y"] = 5 + with pytest.raises(ValueError, match="x must be positive"): + cfg.x = -5 + assert cfg.get("x", 10) == 2 + with pytest.raises(AttributeError): + cfg.z = 5 + with pytest.raises(KeyError): + cfg["z"] = 5 + with pytest.raises(AttributeError): + cfg.z + with pytest.raises(KeyError): + cfg["z"] + cfg2 = pickle.loads(pickle.dumps(cfg)) + assert cfg == cfg2 + assert cfg.__doc__ == "Example configuration." + assert cfg2.__doc__ == "Example configuration." + + +def test_config_defaults(): + class DefaultConfig(Config): + x: int = 0 + y: int + + cfg = DefaultConfig(y=1) + assert cfg.x == 0 + cfg = DefaultConfig(x=2, y=1) + assert cfg.x == 2 + + +def test_nxconfig(): + assert isinstance(nx.config.backend_priority, list) + assert isinstance(nx.config.backends, Config) + with pytest.raises(TypeError, match="must be a list of backend names"): + nx.config.backend_priority = "nx_loopback" + with pytest.raises(ValueError, match="Unknown backend when setting"): + nx.config.backend_priority = ["this_almost_certainly_is_not_a_backend"] + with pytest.raises(TypeError, match="must be a Config of backend configs"): + nx.config.backends = {} + with pytest.raises(TypeError, match="must be a Config of backend configs"): + nx.config.backends = Config(plausible_backend_name={}) + with pytest.raises(ValueError, match="Unknown backend when setting"): + nx.config.backends = Config(this_almost_certainly_is_not_a_backend=Config()) + with pytest.raises(TypeError, match="must be True or False"): + nx.config.cache_converted_graphs = "bad value" + + +def test_not_strict(): + class FlexibleConfig(Config, strict=False): + x: int + + cfg = FlexibleConfig(x=1) + assert "_strict" not in cfg + assert len(cfg) == 1 + assert list(cfg) == ["x"] + assert list(cfg.keys()) == ["x"] + assert list(cfg.values()) == [1] + assert list(cfg.items()) == [("x", 1)] + assert cfg.x == 1 + assert cfg["x"] == 1 + assert "x" in cfg + assert hasattr(cfg, "x") + assert "FlexibleConfig(x=1)" in repr(cfg) + assert cfg == FlexibleConfig(x=1) + del cfg.x + assert "FlexibleConfig()" in repr(cfg) + assert len(cfg) == 0 + assert not hasattr(cfg, "x") + assert "x" not in cfg + assert not hasattr(cfg, "y") + assert "y" not in cfg + cfg.y = 2 + assert len(cfg) == 1 + assert list(cfg) == ["y"] + assert list(cfg.keys()) == ["y"] + assert list(cfg.values()) == [2] + assert list(cfg.items()) == [("y", 2)] + assert cfg.y == 2 + assert cfg["y"] == 2 + assert hasattr(cfg, "y") + assert "y" in cfg + del cfg["y"] + assert len(cfg) == 0 + assert list(cfg) == [] + with pytest.raises(AttributeError, match="y"): + del cfg.y + with pytest.raises(KeyError, match="y"): + del cfg["y"] + with pytest.raises(TypeError, match="missing 1 required keyword-only"): + FlexibleConfig() + # Be strict when first creating the config object + with pytest.raises(TypeError, match="unexpected keyword argument 'y'"): + FlexibleConfig(x=1, y=2) + + class FlexibleConfigWithDefault(Config, strict=False): + x: int = 0 + + assert FlexibleConfigWithDefault().x == 0 + assert FlexibleConfigWithDefault(x=1)["x"] == 1 diff --git a/shared/package-files/43/437d4da7e1e729f0fdffef141d1af82afcddbe22c8e078da21a72f30a4060457/blob b/shared/package-files/43/437d4da7e1e729f0fdffef141d1af82afcddbe22c8e078da21a72f30a4060457/blob new file mode 100644 index 0000000000000000000000000000000000000000..a4bf5489baf95ec7ae4580fd06185ae43c221438 --- /dev/null +++ b/shared/package-files/43/437d4da7e1e729f0fdffef141d1af82afcddbe22c8e078da21a72f30a4060457/blob @@ -0,0 +1,16 @@ +from typing import Pattern + +from .compat import tobytes as tobytes + +WS: str +OWS: str +RWS: str +BWS = str +TCHAR: str +OBS_TEXT: str +TOKEN: str +VCHAR: str +FIELD_VCHAR: str +FIELD_CONTENT: str +FIELD_VALUE: str +HEADER_FIELD: Pattern diff --git a/shared/package-files/43/437ff3964bd30fb04ea74f68d2fa4f848f6bff50016ffea7e42ba75cf4bc6425/blob b/shared/package-files/43/437ff3964bd30fb04ea74f68d2fa4f848f6bff50016ffea7e42ba75cf4bc6425/blob new file mode 100644 index 0000000000000000000000000000000000000000..df565e97235828e5c89c76f0373bc1cdaee01287 --- /dev/null +++ b/shared/package-files/43/437ff3964bd30fb04ea74f68d2fa4f848f6bff50016ffea7e42ba75cf4bc6425/blob @@ -0,0 +1,9 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include diff --git a/shared/package-files/43/437ffecdb57c1d8357a8d275df3e54bd4c96a9a58e6671dfe0b25fbc51b26ef1/blob b/shared/package-files/43/437ffecdb57c1d8357a8d275df3e54bd4c96a9a58e6671dfe0b25fbc51b26ef1/blob new file mode 100644 index 0000000000000000000000000000000000000000..41d245b57474965b4f5c7f0de3127fedd1688af2 --- /dev/null +++ b/shared/package-files/43/437ffecdb57c1d8357a8d275df3e54bd4c96a9a58e6671dfe0b25fbc51b26ef1/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:437ffecdb57c1d8357a8d275df3e54bd4c96a9a58e6671dfe0b25fbc51b26ef1 +size 210768 diff --git a/shared/package-files/43/43853874c3cd489f5ec8568aba1839e589a8d60406976e54ea628f024015ab4c/blob b/shared/package-files/43/43853874c3cd489f5ec8568aba1839e589a8d60406976e54ea628f024015ab4c/blob new file mode 100644 index 0000000000000000000000000000000000000000..b0cfa308aee66c616230154d7713d09a74e491d9 --- /dev/null +++ b/shared/package-files/43/43853874c3cd489f5ec8568aba1839e589a8d60406976e54ea628f024015ab4c/blob @@ -0,0 +1,26 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_max_pool2d_with_indices_backward_out_cpu : public at::meta::structured_max_pool2d_with_indices_backward { +void impl(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices, const at::Tensor & grad_input); +}; +struct TORCH_API structured_max_pool2d_with_indices_backward_out_cuda : public at::meta::structured_max_pool2d_with_indices_backward { +void impl(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices, const at::Tensor & grad_input); +}; +} // namespace native +} // namespace at diff --git a/shared/package-files/43/438551a6034e4e8f57dc2d71904785e46def84c8128c13e40d1bfeac23d67804/blob b/shared/package-files/43/438551a6034e4e8f57dc2d71904785e46def84c8128c13e40d1bfeac23d67804/blob new file mode 100644 index 0000000000000000000000000000000000000000..007aa045513c189e941d8b9acc03a8b18121b0dc --- /dev/null +++ b/shared/package-files/43/438551a6034e4e8f57dc2d71904785e46def84c8128c13e40d1bfeac23d67804/blob @@ -0,0 +1,34 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_any_out : public at::meta::structured_any_dim { +void impl(const at::Tensor & self, int64_t dim, bool keepdim, const at::Tensor & out); +}; +TORCH_API at::Tensor any_dims_default(const at::Tensor & self, at::OptionalIntArrayRef dim=c10::nullopt, bool keepdim=false); +TORCH_API at::Tensor & any_dims_out_default(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out); +struct TORCH_API structured_any_dims_out : public at::meta::structured_any_dims { +void impl(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, const at::Tensor & out); +}; +TORCH_API at::Tensor any(const at::Tensor & self, at::Dimname dim, bool keepdim=false); +TORCH_API at::Tensor & any_out(const at::Tensor & self, at::Dimname dim, bool keepdim, at::Tensor & out); +struct TORCH_API structured_any_all_out : public at::meta::structured_any { +void impl(const at::Tensor & self, const at::Tensor & out); +}; +TORCH_API at::Tensor any_sparse(const at::Tensor & self); +} // namespace native +} // namespace at diff --git a/shared/package-files/43/4387a80905442a99eb95baa2419d723c066eecc9cd42012aa00c245ddd93d3ad/blob b/shared/package-files/43/4387a80905442a99eb95baa2419d723c066eecc9cd42012aa00c245ddd93d3ad/blob new file mode 100644 index 0000000000000000000000000000000000000000..afd71cf7dbe0d98f61816cbbf960e19ab16231d3 --- /dev/null +++ b/shared/package-files/43/4387a80905442a99eb95baa2419d723c066eecc9cd42012aa00c245ddd93d3ad/blob @@ -0,0 +1,26 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + + +} diff --git a/shared/package-files/43/438a4c75f3be39ee7ce1ce2a04e9466309ea29383e744158af1b61c7877a01d6/blob b/shared/package-files/43/438a4c75f3be39ee7ce1ce2a04e9466309ea29383e744158af1b61c7877a01d6/blob new file mode 100644 index 0000000000000000000000000000000000000000..518ed94a2a0f6fb00c4b7ba9097bbe595b66eec5 Binary files /dev/null and b/shared/package-files/43/438a4c75f3be39ee7ce1ce2a04e9466309ea29383e744158af1b61c7877a01d6/blob differ diff --git a/shared/package-files/43/4391efa11d42d3bca6045b24768f32d93533a7f4ef4d5f43d804d8efc6b107be/blob b/shared/package-files/43/4391efa11d42d3bca6045b24768f32d93533a7f4ef4d5f43d804d8efc6b107be/blob new file mode 100644 index 0000000000000000000000000000000000000000..1127bf9acb81ea9a5803bd18181f25a311cefa07 --- /dev/null +++ b/shared/package-files/43/4391efa11d42d3bca6045b24768f32d93533a7f4ef4d5f43d804d8efc6b107be/blob @@ -0,0 +1,17 @@ +# flake8: noqa: F401 +r"""Quantized Modules. + +This file is in the process of migration to `torch/ao/nn/quantized`, and +is kept here for compatibility while the migration process is ongoing. +If you are adding a new entry/functionality, please, add it to the +appropriate file under the `torch/ao/nn/quantized/modules`, +while adding an import statement here. +""" + +__all__ = ['LayerNorm', 'GroupNorm', 'InstanceNorm1d', 'InstanceNorm2d', 'InstanceNorm3d'] + +from torch.ao.nn.quantized.modules.normalization import LayerNorm +from torch.ao.nn.quantized.modules.normalization import GroupNorm +from torch.ao.nn.quantized.modules.normalization import InstanceNorm1d +from torch.ao.nn.quantized.modules.normalization import InstanceNorm2d +from torch.ao.nn.quantized.modules.normalization import InstanceNorm3d diff --git a/shared/package-files/43/43930bfd3e191ca2e015a768bf7d4b43ade8592b577fe51a8af13de58a162250/blob b/shared/package-files/43/43930bfd3e191ca2e015a768bf7d4b43ade8592b577fe51a8af13de58a162250/blob new file mode 100644 index 0000000000000000000000000000000000000000..af7e27a9053fa12a668672d41f32af1619f526dd --- /dev/null +++ b/shared/package-files/43/43930bfd3e191ca2e015a768bf7d4b43ade8592b577fe51a8af13de58a162250/blob @@ -0,0 +1,74 @@ +library(coin) +library(exact2x2) + +tables = list() + +tables[[1]] = matrix(c(23, 15, 19, 31), ncol=2, byrow=TRUE) + +tables[[2]] = matrix(c(144, 33, 84, 126, + 2, 4, 14, 29, + 0, 2, 6, 25, + 0, 0, 1, 5), ncol=4, byrow=TRUE) + +tables[[3]] = matrix(c(20, 10, 5, + 3, 30, 15, + 0, 5, 40), + ncol=3, byrow=TRUE) + +results = array(0, c(length(tables), 17)) + +for (k in 1:3) { + + table = as.table(tables[[k]]) + names(attributes(table)$dimnames) = c("x", "y") + + # Nominal homogeneity test with chi^2 reference + rslt = mh_test(table) + results[k, 1] = rslt@statistic@teststatistic + results[k, 2] = rslt@statistic@df + + # Nominal homogeneity test with binomial reference + if (prod(dim(table)) == 4) { + rslt = mcnemar.exact(table) + results[k, 3] = rslt$p.value + } + + # Nominal homogeneity test with continuity correction + if (prod(dim(table)) == 4) { + rslt = mcnemar.test(table) + results[k, 4] = rslt$p.value + } + + # Linear-by-linear homogeneity test with linear weights + scores = list(x=seq(dim(table)[1]), y=seq(dim(table)[2])) + rslt = lbl_test(table, scores=scores) + results[k, 5] = rslt@statistic@linearstatistic + results[k, 6] = rslt@statistic@expectation + results[k, 7] = rslt@statistic@covariance@variance + results[k, 8] = rslt@statistic@teststatistic + results[k, 9] = rslt@distribution@pvalue(rslt@statistic@teststatistic) + + # Linear-by-linear homogeneity test with quadratic column weights + scores = list(x=seq(dim(table)[1]), y=seq(dim(table)[2])^2) + rslt = lbl_test(table, scores=scores) + results[k, 10] = rslt@statistic@linearstatistic + results[k, 11] = rslt@statistic@expectation + results[k, 12] = rslt@statistic@covariance@variance + results[k, 13] = rslt@statistic@teststatistic + results[k, 14] = rslt@distribution@pvalue(rslt@statistic@teststatistic) + + # Bowker symmetry test (apparently mcnemar.test performs a + # symmetry test when dim>2 although this is not documented). + rslt = mcnemar.test(table, correct=FALSE) + results[k, 15] = rslt$statistic + results[k, 16] = rslt$parameter[1] + results[k, 17] = rslt$p.value +} + +colnames(results) = c("homog_stat", "homog_df", "homog_binom_p", + "homog_cont_p", "lbl_stat", "lbl_expval", "lbl_var", + "lbl_chi2", "lbl_pvalue", "lbl2_stat", "lbl2_expval", + "lbl2_var", "lbl2_chi2", "lbl2_pvalue", "bowker_stat", + "bowker_df", "bowker_pvalue") + +write.csv(results, file="contingency_table_r_results.csv", row.names=FALSE) diff --git a/shared/package-files/43/439349b40a073f9987df58616a08bd77cfa3237aa84490e545034230c069386f/blob b/shared/package-files/43/439349b40a073f9987df58616a08bd77cfa3237aa84490e545034230c069386f/blob new file mode 100644 index 0000000000000000000000000000000000000000..25df24324da5a2191b5d894a8df4642737b103a9 --- /dev/null +++ b/shared/package-files/43/439349b40a073f9987df58616a08bd77cfa3237aa84490e545034230c069386f/blob @@ -0,0 +1 @@ +from .classic import deprecated as deprecated diff --git a/shared/package-files/43/4393eb6733fa1e367f41769b382f4f1be7bf0daeb1e243ed92b3f5d8bafd236f/blob b/shared/package-files/43/4393eb6733fa1e367f41769b382f4f1be7bf0daeb1e243ed92b3f5d8bafd236f/blob new file mode 100644 index 0000000000000000000000000000000000000000..c8fc60f32e80077abc2c7c1e968b3fcf44cde304 --- /dev/null +++ b/shared/package-files/43/4393eb6733fa1e367f41769b382f4f1be7bf0daeb1e243ed92b3f5d8bafd236f/blob @@ -0,0 +1,11 @@ +Copyright (c) 2011 Stefan Kögl + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/shared/package-files/43/4396805681a2e0ccc08ce1d4dbb22eb0610c1cfc179fdd0f20e258b13ae49f56/blob b/shared/package-files/43/4396805681a2e0ccc08ce1d4dbb22eb0610c1cfc179fdd0f20e258b13ae49f56/blob new file mode 100644 index 0000000000000000000000000000000000000000..14538b858416e4439783f1653585ec5053040c2b Binary files /dev/null and b/shared/package-files/43/4396805681a2e0ccc08ce1d4dbb22eb0610c1cfc179fdd0f20e258b13ae49f56/blob differ diff --git a/shared/package-files/43/4399faf37922b5c18b28a3a64408329ae99b0b5c6f408043df1242d761c83138/blob b/shared/package-files/43/4399faf37922b5c18b28a3a64408329ae99b0b5c6f408043df1242d761c83138/blob new file mode 100644 index 0000000000000000000000000000000000000000..2dbc1290e9ef045f39404f2f229bdf360e565af0 --- /dev/null +++ b/shared/package-files/43/4399faf37922b5c18b28a3a64408329ae99b0b5c6f408043df1242d761c83138/blob @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor upsample_bicubic2d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor upsample_bicubic2d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_bicubic2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_bicubic2d_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional scales_h, c10::optional scales_w, at::Tensor & out); +TORCH_API at::Tensor & upsample_bicubic2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_bicubic2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, c10::optional scales_h, c10::optional scales_w, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/shared/package-files/43/439e1ca44e245387148c1141d7d7c5e84bcca73188ff85351a126c8deea0e12e/blob b/shared/package-files/43/439e1ca44e245387148c1141d7d7c5e84bcca73188ff85351a126c8deea0e12e/blob new file mode 100644 index 0000000000000000000000000000000000000000..a60bddd7b2c96628f11598f143918915c98052cc Binary files /dev/null and b/shared/package-files/43/439e1ca44e245387148c1141d7d7c5e84bcca73188ff85351a126c8deea0e12e/blob differ diff --git a/shared/package-files/43/43a263316c6b9d854248f4cf0d1baa79744a6be29d80d6da57eb476ddc45ed89/blob b/shared/package-files/43/43a263316c6b9d854248f4cf0d1baa79744a6be29d80d6da57eb476ddc45ed89/blob new file mode 100644 index 0000000000000000000000000000000000000000..4594979199a3581e2b82464526cc85a3a6029c39 --- /dev/null +++ b/shared/package-files/43/43a263316c6b9d854248f4cf0d1baa79744a6be29d80d6da57eb476ddc45ed89/blob @@ -0,0 +1,168 @@ +# This file is part of Hypothesis, which may be found at +# https://github.com/HypothesisWorks/hypothesis/ +# +# Copyright the Hypothesis Authors. +# Individual contributors are listed in AUTHORS.rst and the git log. +# +# This Source Code Form is subject to the terms of the Mozilla Public License, +# v. 2.0. If a copy of the MPL was not distributed with this file, You can +# obtain one at https://mozilla.org/MPL/2.0/. + +from hypothesis.internal.compat import int_from_bytes, int_to_bytes +from hypothesis.internal.conjecture.data import Status +from hypothesis.internal.conjecture.engine import BUFFER_SIZE +from hypothesis.internal.conjecture.junkdrawer import find_integer +from hypothesis.internal.conjecture.pareto import NO_SCORE + + +class Optimiser: + """A fairly basic optimiser designed to increase the value of scores for + targeted property-based testing. + + This implements a fairly naive hill climbing algorithm based on randomly + regenerating parts of the test case to attempt to improve the result. It is + not expected to produce amazing results, because it is designed to be run + in a fairly small testing budget, so it prioritises finding easy wins and + bailing out quickly if that doesn't work. + + For more information about targeted property-based testing, see + Löscher, Andreas, and Konstantinos Sagonas. "Targeted property-based + testing." Proceedings of the 26th ACM SIGSOFT International Symposium on + Software Testing and Analysis. ACM, 2017. + """ + + def __init__(self, engine, data, target, max_improvements=100): + """Optimise ``target`` starting from ``data``. Will stop either when + we seem to have found a local maximum or when the target score has + been improved ``max_improvements`` times. This limit is in place to + deal with the fact that the target score may not be bounded above.""" + self.engine = engine + self.current_data = data + self.target = target + self.max_improvements = max_improvements + self.improvements = 0 + + def run(self): + self.hill_climb() + + def score_function(self, data): + return data.target_observations.get(self.target, NO_SCORE) + + @property + def current_score(self): + return self.score_function(self.current_data) + + def consider_new_test_data(self, data): + """Consider a new data object as a candidate target. If it is better + than the current one, return True.""" + if data.status < Status.VALID: + return False + score = self.score_function(data) + if score < self.current_score: + return False + if score > self.current_score: + self.improvements += 1 + self.current_data = data + return True + assert score == self.current_score + # We allow transitions that leave the score unchanged as long as they + # don't increase the buffer size. This gives us a certain amount of + # freedom for lateral moves that will take us out of local maxima. + if len(data.buffer) <= len(self.current_data.buffer): + self.current_data = data + return True + return False + + def hill_climb(self): + """The main hill climbing loop where we actually do the work: Take + data, and attempt to improve its score for target. select_example takes + a data object and returns an index to an example where we should focus + our efforts.""" + + blocks_examined = set() + + prev = None + i = len(self.current_data.blocks) - 1 + while i >= 0 and self.improvements <= self.max_improvements: + if prev is not self.current_data: + i = len(self.current_data.blocks) - 1 + prev = self.current_data + + if i in blocks_examined: + i -= 1 + continue + + blocks_examined.add(i) + data = self.current_data + block = data.blocks[i] + prefix = data.buffer[: block.start] + + existing = data.buffer[block.start : block.end] + existing_as_int = int_from_bytes(existing) + max_int_value = (256 ** len(existing)) - 1 + + if existing_as_int == max_int_value: + continue + + def attempt_replace(v): + """Try replacing the current block in the current best test case + with an integer of value i. Note that we use the *current* + best and not the one we started with. This helps ensure that + if we luck into a good draw when making random choices we get + to keep the good bits.""" + if v < 0 or v > max_int_value: + return False + v_as_bytes = int_to_bytes(v, len(existing)) + + # We make a couple attempts at replacement. This only matters + # if we end up growing the buffer - otherwise we exit the loop + # early - but in the event that there *is* some randomized + # component we want to give it a couple of tries to succeed. + for _ in range(3): + attempt = self.engine.cached_test_function( + prefix + + v_as_bytes + + self.current_data.buffer[block.end :] + + bytes(BUFFER_SIZE), + ) + + if self.consider_new_test_data(attempt): + return True + + if attempt.status < Status.INVALID or len(attempt.buffer) == len( + self.current_data.buffer + ): + return False + + for i, ex in enumerate(self.current_data.examples): + if ex.start >= block.end: + break + if ex.end <= block.start: + continue + ex_attempt = attempt.examples[i] + if ex.length == ex_attempt.length: + continue + replacement = attempt.buffer[ex_attempt.start : ex_attempt.end] + if self.consider_new_test_data( + self.engine.cached_test_function( + prefix + + replacement + + self.current_data.buffer[ex.end :] + ) + ): + return True + return False + + # We unconditionally scan both upwards and downwards. The reason + # for this is that we allow "lateral" moves that don't increase the + # score but instead leave it constant. All else being equal we'd + # like to leave the test case closer to shrunk, so afterwards we + # try lowering the value towards zero even if we've just raised it. + + if not attempt_replace(max_int_value): + find_integer(lambda k: attempt_replace(k + existing_as_int)) + + existing = self.current_data.buffer[block.start : block.end] + existing_as_int = int_from_bytes(existing) + if not attempt_replace(0): + find_integer(lambda k: attempt_replace(existing_as_int - k)) diff --git a/shared/package-files/43/43a6bc37d209bb25353d8bb8862f32822c11e33927b528a2b35fe7c67d033ee1/blob b/shared/package-files/43/43a6bc37d209bb25353d8bb8862f32822c11e33927b528a2b35fe7c67d033ee1/blob new file mode 100644 index 0000000000000000000000000000000000000000..ff40dbe779bbaff085240ce2af06c52aede3197d --- /dev/null +++ b/shared/package-files/43/43a6bc37d209bb25353d8bb8862f32822c11e33927b528a2b35fe7c67d033ee1/blob @@ -0,0 +1,189 @@ +import abc +import functools +from collections.abc import Hashable as _CanHash, Mapping, Sequence as _Sequence +from typing import ( + Any, + Literal as _Literal, + Protocol, + TypeAlias, + overload, + type_check_only, +) +from typing_extensions import ClassVar, Generic, Never, Self, TypeVar, override + +from numba.core.typeconv import castgraph +from numba.core.typing import context, templates +from .npytypes import Array + +### + +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T_contra = TypeVar("_T_contra", contravariant=True) +_T_co = TypeVar("_T_co", covariant=True) +_TypeT_co = TypeVar("_TypeT_co", bound=Type, default=Type, covariant=True) + +@type_check_only +class _CanCastPythonValue(Protocol[_T_contra, _T_co]): + def cast_python_value(self, value: _T_contra, /) -> _T_co: ... + +# the step is `Any` instead of `Literal[1] | None` so we can use it as invariant `list` +# element type +_SpecSlice: TypeAlias = slice[None, None, Any] +_Layout: TypeAlias = _Literal["C", "F", "CS", "FS", "A"] + +### + +class _TypeMetaclass(abc.ABCMeta): + def __init__( + cls, name: str, bases: tuple[type, ...], orig_vars: dict[str, Any] + ) -> None: ... + def __call__(cls, *args: Any, **kwargs: Any) -> Any: ... + +class Type(metaclass=_TypeMetaclass): + reflected: ClassVar[bool] = False + + name: str + mutable: bool = False + + def __init__(self, name: str) -> None: ... + + # + @overload # () -> Signature + def __call__(self, /) -> templates.Signature: ... + @overload # (Type, ...) -> Signature + def __call__(self, arg0: Type, /, *args: Type) -> templates.Signature: ... + @overload # (_: object) -> self.cast_python_value(_) + def __call__(self: _CanCastPythonValue[_T1, _T2], arg0: _T1, /) -> _T2: ... + + # + def __getitem__( + self, args: _SpecSlice | tuple[_SpecSlice, ...] | list[_SpecSlice], / + ) -> Array: ... + + # + @property + def key(self) -> _CanHash: ... + @property + def mangling_args(self) -> tuple[str, tuple[object, ...]]: ... + @property + def is_internal(self) -> bool: ... + + # + def can_convert_to( + self, + typingctx: context.Context, + other: Type, + ) -> castgraph.Conversion | None: ... + def can_convert_from( + self, + typingctx: context.Context, + other: Type, + ) -> castgraph.Conversion | None: ... + def cast_python_value(self, args: Never, /) -> Any: ... + + # + def is_precise(self) -> bool: ... + def augment(self, other: Type) -> Self | None: ... + def unify(self, typingctx: context.Context, other: Type) -> Type | None: ... + def dump(self, tab: str = "") -> None: ... + +class Dummy(Type): ... +class Hashable(Type): ... + +class Number(Hashable): + @override + @overload + def unify(self, typingctx: context.Context, other: Number) -> Number: ... + @overload + def unify(self, typingctx: context.Context, other: Type) -> Number | None: ... + +class Callable(Type): + @abc.abstractmethod + def get_call_type( + self, context: context.Context, args: tuple[Type, ...], kws: Mapping[str, Type] + ) -> templates.Signature | None: ... + @abc.abstractmethod + def get_call_signatures(self) -> tuple[_Sequence[templates.Signature], bool]: ... + @abc.abstractmethod + def get_impl_key(self, sig: templates.Signature) -> _CanHash: ... + +class DTypeSpec(Type): + @property + @abc.abstractmethod + def dtype(self) -> Any: ... + +class IterableType(Type, Generic[_TypeT_co]): + @property + @abc.abstractmethod + def iterator_type(self) -> IteratorType[_TypeT_co]: ... + +class Sized(Type): ... + +class ConstSized(Sized): + @abc.abstractmethod + def __len__(self) -> int: ... + +class IteratorType(IterableType[_TypeT_co], Generic[_TypeT_co]): + def __init__(self, name: str, **kwargs: Never) -> None: ... + @property + @abc.abstractmethod + def yield_type(self) -> _TypeT_co: ... + @property + @override + def iterator_type(self) -> Self: ... + +# pyrefly: ignore[invalid-inheritance] +class Container( + Sized, + IterableType[_TypeT_co], + Generic[_TypeT_co], + metaclass=abc.ABCMeta, +): ... +class Sequence(Container[_TypeT_co], Generic[_TypeT_co], metaclass=abc.ABCMeta): ... + +class MutableSequence(Sequence[_TypeT_co], Generic[_TypeT_co], metaclass=abc.ABCMeta): + mutable: bool = True + +class ArrayCompatible(Type): + array_priority: ClassVar[float] = 0.0 + + @property + @abc.abstractmethod + def as_array(self) -> ArrayCompatible: ... + + # + @functools.cached_property + def ndim(self) -> int: ... + @functools.cached_property + def layout(self) -> _Layout: ... + @functools.cached_property + def dtype(self) -> Type: ... + +class Literal(Type, Generic[_T_co]): + ctor_map: ClassVar[dict[type, type[Literal[Any]]]] = ... + + def __init__(self, value: _T_co) -> None: ... + @property + def literal_value(self) -> _T_co: ... + @property + def literal_type(self) -> Type: ... + +class TypeRef(Dummy, Generic[_TypeT_co]): + instance_type: _TypeT_co # readonly + + def __init__(self, instance_type: _TypeT_co) -> None: ... + @property + @override + def key(self) -> _TypeT_co: ... + +class InitialValue(Generic[_T_co]): + def __init__(self, initial_value: _T_co) -> None: ... + @property + def initial_value(self) -> _T_co: ... + +class Poison(Type, Generic[_TypeT_co]): # like `Never` + def __init__(self, ty: _TypeT_co) -> None: ... + def __unliteral__(self) -> Poison[Self]: ... + @override + def unify(self, typingctx: context.Context, other: Type) -> None: ... diff --git a/shared/package-files/43/43a7e71d6a2aefd310629e7cd71f9979702cc406eb2b0e12586fb6f56eebec3f/blob b/shared/package-files/43/43a7e71d6a2aefd310629e7cd71f9979702cc406eb2b0e12586fb6f56eebec3f/blob new file mode 100644 index 0000000000000000000000000000000000000000..9fc481ec095e7fc04ba48e7b9fbd14f4cfa1d8a1 --- /dev/null +++ b/shared/package-files/43/43a7e71d6a2aefd310629e7cd71f9979702cc406eb2b0e12586fb6f56eebec3f/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:43a7e71d6a2aefd310629e7cd71f9979702cc406eb2b0e12586fb6f56eebec3f +size 266840 diff --git a/shared/package-files/43/43a7ed8d8fe1b67caea71704e8236d271f78dae9e193991b1195c069b4cf9b3e/blob b/shared/package-files/43/43a7ed8d8fe1b67caea71704e8236d271f78dae9e193991b1195c069b4cf9b3e/blob new file mode 100644 index 0000000000000000000000000000000000000000..6ba7d6a2207b60ee99d67f79ebc302c57f564907 --- /dev/null +++ b/shared/package-files/43/43a7ed8d8fe1b67caea71704e8236d271f78dae9e193991b1195c069b4cf9b3e/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & select_scatter_out_symint(const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index, at::Tensor & out); +TORCH_API at::Tensor select_scatter_symint(const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index); +} // namespace native +} // namespace at diff --git a/shared/package-files/43/43ab8c767e1e6da404a0b73dd4ff8d219b05742a8a85f0b1b427a4cbaf99d71d/blob b/shared/package-files/43/43ab8c767e1e6da404a0b73dd4ff8d219b05742a8a85f0b1b427a4cbaf99d71d/blob new file mode 100644 index 0000000000000000000000000000000000000000..16239ed8c46970f38159ae12bc9a45da31ffd617 --- /dev/null +++ b/shared/package-files/43/43ab8c767e1e6da404a0b73dd4ff8d219b05742a8a85f0b1b427a4cbaf99d71d/blob @@ -0,0 +1,155 @@ +""" +Methods used by Block.replace and related methods. +""" +from __future__ import annotations + +import operator +import re +from re import Pattern +from typing import ( + TYPE_CHECKING, + Any, +) + +import numpy as np + +from pandas.core.dtypes.common import ( + is_bool, + is_re, + is_re_compilable, +) +from pandas.core.dtypes.missing import isna + +if TYPE_CHECKING: + from pandas._typing import ( + ArrayLike, + Scalar, + npt, + ) + + +def should_use_regex(regex: bool, to_replace: Any) -> bool: + """ + Decide whether to treat `to_replace` as a regular expression. + """ + if is_re(to_replace): + regex = True + + regex = regex and is_re_compilable(to_replace) + + # Don't use regex if the pattern is empty. + regex = regex and re.compile(to_replace).pattern != "" + return regex + + +def compare_or_regex_search( + a: ArrayLike, b: Scalar | Pattern, regex: bool, mask: npt.NDArray[np.bool_] +) -> ArrayLike: + """ + Compare two array-like inputs of the same shape or two scalar values + + Calls operator.eq or re.search, depending on regex argument. If regex is + True, perform an element-wise regex matching. + + Parameters + ---------- + a : array-like + b : scalar or regex pattern + regex : bool + mask : np.ndarray[bool] + + Returns + ------- + mask : array-like of bool + """ + if isna(b): + return ~mask + + def _check_comparison_types( + result: ArrayLike | bool, a: ArrayLike, b: Scalar | Pattern + ): + """ + Raises an error if the two arrays (a,b) cannot be compared. + Otherwise, returns the comparison result as expected. + """ + if is_bool(result) and isinstance(a, np.ndarray): + type_names = [type(a).__name__, type(b).__name__] + + type_names[0] = f"ndarray(dtype={a.dtype})" + + raise TypeError( + f"Cannot compare types {repr(type_names[0])} and {repr(type_names[1])}" + ) + + if not regex or not should_use_regex(regex, b): + # TODO: should use missing.mask_missing? + op = lambda x: operator.eq(x, b) + else: + op = np.vectorize( + lambda x: bool(re.search(b, x)) + if isinstance(x, str) and isinstance(b, (str, Pattern)) + else False + ) + + # GH#32621 use mask to avoid comparing to NAs + if isinstance(a, np.ndarray) and mask is not None: + a = a[mask] + result = op(a) + + if isinstance(result, np.ndarray): + # The shape of the mask can differ to that of the result + # since we may compare only a subset of a's or b's elements + tmp = np.zeros(mask.shape, dtype=np.bool_) + np.place(tmp, mask, result) + result = tmp + else: + result = op(a) + + _check_comparison_types(result, a, b) + return result + + +def replace_regex( + values: ArrayLike, rx: re.Pattern, value, mask: npt.NDArray[np.bool_] | None +) -> None: + """ + Parameters + ---------- + values : ArrayLike + Object dtype. + rx : re.Pattern + value : Any + mask : np.ndarray[bool], optional + + Notes + ----- + Alters values in-place. + """ + + # deal with replacing values with objects (strings) that match but + # whose replacement is not a string (numeric, nan, object) + if isna(value) or not isinstance(value, str): + + def re_replacer(s): + if is_re(rx) and isinstance(s, str): + return value if rx.search(s) is not None else s + else: + return s + + else: + # value is guaranteed to be a string here, s can be either a string + # or null if it's null it gets returned + def re_replacer(s): + if is_re(rx) and isinstance(s, str): + return rx.sub(value, s) + else: + return s + + f = np.vectorize(re_replacer, otypes=[np.object_]) + + if mask is None: + values[:] = f(values) + else: + if values.ndim != mask.ndim: + mask = np.broadcast_to(mask, values.shape) + values[mask] = f(values[mask]) diff --git a/shared/package-files/43/43ad6a32c4ac342b663b410c4711e3e59ed1613cab10b5699337c963978af19d/blob b/shared/package-files/43/43ad6a32c4ac342b663b410c4711e3e59ed1613cab10b5699337c963978af19d/blob new file mode 100644 index 0000000000000000000000000000000000000000..7e79230663c2956acdc6addeab8efaca5b44d563 --- /dev/null +++ b/shared/package-files/43/43ad6a32c4ac342b663b410c4711e3e59ed1613cab10b5699337c963978af19d/blob @@ -0,0 +1,11 @@ +import numpy as np +import numpy.typing as npt + +AR_f8: npt.NDArray[np.float64] + +# NOTE: Mypy bug presumably due to the special-casing of heterogeneous tuples; +# xref numpy/numpy#20901 +# +# The expected output should be no different than, e.g., when using a +# list instead of a tuple +np.concatenate(([1], AR_f8)) # E: Argument 1 to "concatenate" has incompatible type diff --git a/shared/package-files/43/43af59cbca29df506af21ff4b3f92869a4ecf9fd3dcb24eaab439b17e788e21f/blob b/shared/package-files/43/43af59cbca29df506af21ff4b3f92869a4ecf9fd3dcb24eaab439b17e788e21f/blob new file mode 100644 index 0000000000000000000000000000000000000000..fc9f643c96938040defbb326562e0a7eb8896297 --- /dev/null +++ b/shared/package-files/43/43af59cbca29df506af21ff4b3f92869a4ecf9fd3dcb24eaab439b17e788e21f/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor nll_loss_nd(const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, int64_t reduction=at::Reduction::Mean, int64_t ignore_index=-100); +TORCH_API at::Tensor nll_loss_nd_symint(const at::Tensor & self, const at::Tensor & target, const c10::optional & weight={}, int64_t reduction=at::Reduction::Mean, c10::SymInt ignore_index=-100); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/43/43b039e25b28bc3c410c4a94ed734126a9773e834b17b355797c2f30582b548d/blob b/shared/package-files/43/43b039e25b28bc3c410c4a94ed734126a9773e834b17b355797c2f30582b548d/blob new file mode 100644 index 0000000000000000000000000000000000000000..ad7769c6b96714b30fe4f3a1e1468de05ec1e6f2 --- /dev/null +++ b/shared/package-files/43/43b039e25b28bc3c410c4a94ed734126a9773e834b17b355797c2f30582b548d/blob @@ -0,0 +1,402 @@ +from datetime import ( + datetime, + timedelta, +) + +import dateutil.tz +from dateutil.tz import gettz +import numpy as np +import pytest +import pytz + +from pandas import ( + DatetimeIndex, + Timestamp, + bdate_range, + date_range, + offsets, + to_datetime, +) +import pandas._testing as tm + +try: + from zoneinfo import ZoneInfo +except ImportError: + # Cannot assign to a type [misc] + ZoneInfo = None # type: ignore[misc, assignment] + + +easts = [pytz.timezone("US/Eastern"), gettz("US/Eastern")] +if ZoneInfo is not None: + try: + tz = ZoneInfo("US/Eastern") + except KeyError: + # no tzdata + pass + else: + easts.append(tz) + + +class TestTZLocalize: + def test_tz_localize_invalidates_freq(self): + # we only preserve freq in unambiguous cases + + # if localized to US/Eastern, this crosses a DST transition + dti = date_range("2014-03-08 23:00", "2014-03-09 09:00", freq="h") + assert dti.freq == "h" + + result = dti.tz_localize(None) # no-op + assert result.freq == "h" + + result = dti.tz_localize("UTC") # unambiguous freq preservation + assert result.freq == "h" + + result = dti.tz_localize("US/Eastern", nonexistent="shift_forward") + assert result.freq is None + assert result.inferred_freq is None # i.e. we are not _too_ strict here + + # Case where we _can_ keep freq because we're length==1 + dti2 = dti[:1] + result = dti2.tz_localize("US/Eastern") + assert result.freq == "h" + + def test_tz_localize_utc_copies(self, utc_fixture): + # GH#46460 + times = ["2015-03-08 01:00", "2015-03-08 02:00", "2015-03-08 03:00"] + index = DatetimeIndex(times) + + res = index.tz_localize(utc_fixture) + assert not tm.shares_memory(res, index) + + res2 = index._data.tz_localize(utc_fixture) + assert not tm.shares_memory(index._data, res2) + + def test_dti_tz_localize_nonexistent_raise_coerce(self): + # GH#13057 + times = ["2015-03-08 01:00", "2015-03-08 02:00", "2015-03-08 03:00"] + index = DatetimeIndex(times) + tz = "US/Eastern" + with pytest.raises(pytz.NonExistentTimeError, match="|".join(times)): + index.tz_localize(tz=tz) + + with pytest.raises(pytz.NonExistentTimeError, match="|".join(times)): + index.tz_localize(tz=tz, nonexistent="raise") + + result = index.tz_localize(tz=tz, nonexistent="NaT") + test_times = ["2015-03-08 01:00-05:00", "NaT", "2015-03-08 03:00-04:00"] + dti = to_datetime(test_times, utc=True) + expected = dti.tz_convert("US/Eastern") + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize("tz", easts) + def test_dti_tz_localize_ambiguous_infer(self, tz): + # November 6, 2011, fall back, repeat 2 AM hour + # With no repeated hours, we cannot infer the transition + dr = date_range(datetime(2011, 11, 6, 0), periods=5, freq=offsets.Hour()) + with pytest.raises(pytz.AmbiguousTimeError, match="Cannot infer dst time"): + dr.tz_localize(tz) + + @pytest.mark.parametrize("tz", easts) + def test_dti_tz_localize_ambiguous_infer2(self, tz, unit): + # With repeated hours, we can infer the transition + dr = date_range( + datetime(2011, 11, 6, 0), periods=5, freq=offsets.Hour(), tz=tz, unit=unit + ) + times = [ + "11/06/2011 00:00", + "11/06/2011 01:00", + "11/06/2011 01:00", + "11/06/2011 02:00", + "11/06/2011 03:00", + ] + di = DatetimeIndex(times).as_unit(unit) + result = di.tz_localize(tz, ambiguous="infer") + expected = dr._with_freq(None) + tm.assert_index_equal(result, expected) + result2 = DatetimeIndex(times, tz=tz, ambiguous="infer").as_unit(unit) + tm.assert_index_equal(result2, expected) + + @pytest.mark.parametrize("tz", easts) + def test_dti_tz_localize_ambiguous_infer3(self, tz): + # When there is no dst transition, nothing special happens + dr = date_range(datetime(2011, 6, 1, 0), periods=10, freq=offsets.Hour()) + localized = dr.tz_localize(tz) + localized_infer = dr.tz_localize(tz, ambiguous="infer") + tm.assert_index_equal(localized, localized_infer) + + @pytest.mark.parametrize("tz", easts) + def test_dti_tz_localize_ambiguous_times(self, tz): + # March 13, 2011, spring forward, skip from 2 AM to 3 AM + dr = date_range(datetime(2011, 3, 13, 1, 30), periods=3, freq=offsets.Hour()) + with pytest.raises(pytz.NonExistentTimeError, match="2011-03-13 02:30:00"): + dr.tz_localize(tz) + + # after dst transition, it works + dr = date_range( + datetime(2011, 3, 13, 3, 30), periods=3, freq=offsets.Hour(), tz=tz + ) + + # November 6, 2011, fall back, repeat 2 AM hour + dr = date_range(datetime(2011, 11, 6, 1, 30), periods=3, freq=offsets.Hour()) + with pytest.raises(pytz.AmbiguousTimeError, match="Cannot infer dst time"): + dr.tz_localize(tz) + + # UTC is OK + dr = date_range( + datetime(2011, 3, 13), periods=48, freq=offsets.Minute(30), tz=pytz.utc + ) + + @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"]) + def test_dti_tz_localize_pass_dates_to_utc(self, tzstr): + strdates = ["1/1/2012", "3/1/2012", "4/1/2012"] + + idx = DatetimeIndex(strdates) + conv = idx.tz_localize(tzstr) + + fromdates = DatetimeIndex(strdates, tz=tzstr) + + assert conv.tz == fromdates.tz + tm.assert_numpy_array_equal(conv.values, fromdates.values) + + @pytest.mark.parametrize("prefix", ["", "dateutil/"]) + def test_dti_tz_localize(self, prefix): + tzstr = prefix + "US/Eastern" + dti = date_range(start="1/1/2005", end="1/1/2005 0:00:30.256", freq="ms") + dti2 = dti.tz_localize(tzstr) + + dti_utc = date_range( + start="1/1/2005 05:00", end="1/1/2005 5:00:30.256", freq="ms", tz="utc" + ) + + tm.assert_numpy_array_equal(dti2.values, dti_utc.values) + + dti3 = dti2.tz_convert(prefix + "US/Pacific") + tm.assert_numpy_array_equal(dti3.values, dti_utc.values) + + dti = date_range(start="11/6/2011 1:59", end="11/6/2011 2:00", freq="ms") + with pytest.raises(pytz.AmbiguousTimeError, match="Cannot infer dst time"): + dti.tz_localize(tzstr) + + dti = date_range(start="3/13/2011 1:59", end="3/13/2011 2:00", freq="ms") + with pytest.raises(pytz.NonExistentTimeError, match="2011-03-13 02:00:00"): + dti.tz_localize(tzstr) + + @pytest.mark.parametrize( + "tz", + [ + "US/Eastern", + "dateutil/US/Eastern", + pytz.timezone("US/Eastern"), + gettz("US/Eastern"), + ], + ) + def test_dti_tz_localize_utc_conversion(self, tz): + # Localizing to time zone should: + # 1) check for DST ambiguities + # 2) convert to UTC + + rng = date_range("3/10/2012", "3/11/2012", freq="30min") + + converted = rng.tz_localize(tz) + expected_naive = rng + offsets.Hour(5) + tm.assert_numpy_array_equal(converted.asi8, expected_naive.asi8) + + # DST ambiguity, this should fail + rng = date_range("3/11/2012", "3/12/2012", freq="30min") + # Is this really how it should fail?? + with pytest.raises(pytz.NonExistentTimeError, match="2012-03-11 02:00:00"): + rng.tz_localize(tz) + + def test_dti_tz_localize_roundtrip(self, tz_aware_fixture): + # note: this tz tests that a tz-naive index can be localized + # and de-localized successfully, when there are no DST transitions + # in the range. + idx = date_range(start="2014-06-01", end="2014-08-30", freq="15min") + tz = tz_aware_fixture + localized = idx.tz_localize(tz) + # can't localize a tz-aware object + with pytest.raises( + TypeError, match="Already tz-aware, use tz_convert to convert" + ): + localized.tz_localize(tz) + reset = localized.tz_localize(None) + assert reset.tzinfo is None + expected = idx._with_freq(None) + tm.assert_index_equal(reset, expected) + + def test_dti_tz_localize_naive(self): + rng = date_range("1/1/2011", periods=100, freq="h") + + conv = rng.tz_localize("US/Pacific") + exp = date_range("1/1/2011", periods=100, freq="h", tz="US/Pacific") + + tm.assert_index_equal(conv, exp._with_freq(None)) + + def test_dti_tz_localize_tzlocal(self): + # GH#13583 + offset = dateutil.tz.tzlocal().utcoffset(datetime(2011, 1, 1)) + offset = int(offset.total_seconds() * 1000000000) + + dti = date_range(start="2001-01-01", end="2001-03-01") + dti2 = dti.tz_localize(dateutil.tz.tzlocal()) + tm.assert_numpy_array_equal(dti2.asi8 + offset, dti.asi8) + + dti = date_range(start="2001-01-01", end="2001-03-01", tz=dateutil.tz.tzlocal()) + dti2 = dti.tz_localize(None) + tm.assert_numpy_array_equal(dti2.asi8 - offset, dti.asi8) + + @pytest.mark.parametrize("tz", easts) + def test_dti_tz_localize_ambiguous_nat(self, tz): + times = [ + "11/06/2011 00:00", + "11/06/2011 01:00", + "11/06/2011 01:00", + "11/06/2011 02:00", + "11/06/2011 03:00", + ] + di = DatetimeIndex(times) + localized = di.tz_localize(tz, ambiguous="NaT") + + times = [ + "11/06/2011 00:00", + np.nan, + np.nan, + "11/06/2011 02:00", + "11/06/2011 03:00", + ] + di_test = DatetimeIndex(times, tz="US/Eastern") + + # left dtype is datetime64[ns, US/Eastern] + # right is datetime64[ns, tzfile('/usr/share/zoneinfo/US/Eastern')] + tm.assert_numpy_array_equal(di_test.values, localized.values) + + @pytest.mark.parametrize("tz", easts) + def test_dti_tz_localize_ambiguous_flags(self, tz, unit): + # November 6, 2011, fall back, repeat 2 AM hour + + # Pass in flags to determine right dst transition + dr = date_range( + datetime(2011, 11, 6, 0), periods=5, freq=offsets.Hour(), tz=tz, unit=unit + ) + times = [ + "11/06/2011 00:00", + "11/06/2011 01:00", + "11/06/2011 01:00", + "11/06/2011 02:00", + "11/06/2011 03:00", + ] + + # Test tz_localize + di = DatetimeIndex(times).as_unit(unit) + is_dst = [1, 1, 0, 0, 0] + localized = di.tz_localize(tz, ambiguous=is_dst) + expected = dr._with_freq(None) + tm.assert_index_equal(expected, localized) + + result = DatetimeIndex(times, tz=tz, ambiguous=is_dst).as_unit(unit) + tm.assert_index_equal(result, expected) + + localized = di.tz_localize(tz, ambiguous=np.array(is_dst)) + tm.assert_index_equal(dr, localized) + + localized = di.tz_localize(tz, ambiguous=np.array(is_dst).astype("bool")) + tm.assert_index_equal(dr, localized) + + # Test constructor + localized = DatetimeIndex(times, tz=tz, ambiguous=is_dst).as_unit(unit) + tm.assert_index_equal(dr, localized) + + # Test duplicate times where inferring the dst fails + times += times + di = DatetimeIndex(times).as_unit(unit) + + # When the sizes are incompatible, make sure error is raised + msg = "Length of ambiguous bool-array must be the same size as vals" + with pytest.raises(Exception, match=msg): + di.tz_localize(tz, ambiguous=is_dst) + + # When sizes are compatible and there are repeats ('infer' won't work) + is_dst = np.hstack((is_dst, is_dst)) + localized = di.tz_localize(tz, ambiguous=is_dst) + dr = dr.append(dr) + tm.assert_index_equal(dr, localized) + + @pytest.mark.parametrize("tz", easts) + def test_dti_tz_localize_ambiguous_flags2(self, tz, unit): + # When there is no dst transition, nothing special happens + dr = date_range(datetime(2011, 6, 1, 0), periods=10, freq=offsets.Hour()) + is_dst = np.array([1] * 10) + localized = dr.tz_localize(tz) + localized_is_dst = dr.tz_localize(tz, ambiguous=is_dst) + tm.assert_index_equal(localized, localized_is_dst) + + def test_dti_tz_localize_bdate_range(self): + dr = bdate_range("1/1/2009", "1/1/2010") + dr_utc = bdate_range("1/1/2009", "1/1/2010", tz=pytz.utc) + localized = dr.tz_localize(pytz.utc) + tm.assert_index_equal(dr_utc, localized) + + @pytest.mark.parametrize( + "start_ts, tz, end_ts, shift", + [ + ["2015-03-29 02:20:00", "Europe/Warsaw", "2015-03-29 03:00:00", "forward"], + [ + "2015-03-29 02:20:00", + "Europe/Warsaw", + "2015-03-29 01:59:59.999999999", + "backward", + ], + [ + "2015-03-29 02:20:00", + "Europe/Warsaw", + "2015-03-29 03:20:00", + timedelta(hours=1), + ], + [ + "2015-03-29 02:20:00", + "Europe/Warsaw", + "2015-03-29 01:20:00", + timedelta(hours=-1), + ], + ["2018-03-11 02:33:00", "US/Pacific", "2018-03-11 03:00:00", "forward"], + [ + "2018-03-11 02:33:00", + "US/Pacific", + "2018-03-11 01:59:59.999999999", + "backward", + ], + [ + "2018-03-11 02:33:00", + "US/Pacific", + "2018-03-11 03:33:00", + timedelta(hours=1), + ], + [ + "2018-03-11 02:33:00", + "US/Pacific", + "2018-03-11 01:33:00", + timedelta(hours=-1), + ], + ], + ) + @pytest.mark.parametrize("tz_type", ["", "dateutil/"]) + def test_dti_tz_localize_nonexistent_shift( + self, start_ts, tz, end_ts, shift, tz_type, unit + ): + # GH#8917 + tz = tz_type + tz + if isinstance(shift, str): + shift = "shift_" + shift + dti = DatetimeIndex([Timestamp(start_ts)]).as_unit(unit) + result = dti.tz_localize(tz, nonexistent=shift) + expected = DatetimeIndex([Timestamp(end_ts)]).tz_localize(tz).as_unit(unit) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize("offset", [-1, 1]) + def test_dti_tz_localize_nonexistent_shift_invalid(self, offset, warsaw): + # GH#8917 + tz = warsaw + dti = DatetimeIndex([Timestamp("2015-03-29 02:20:00")]) + msg = "The provided timedelta will relocalize on a nonexistent time" + with pytest.raises(ValueError, match=msg): + dti.tz_localize(tz, nonexistent=timedelta(seconds=offset)) diff --git a/shared/package-files/43/43b1dba08ece96a76809dc9bcae54caad34fd97455d98d949e664b1bab14694a/blob b/shared/package-files/43/43b1dba08ece96a76809dc9bcae54caad34fd97455d98d949e664b1bab14694a/blob new file mode 100644 index 0000000000000000000000000000000000000000..1067bdad16589995b51a1e6b3c5ad2024fbfb766 --- /dev/null +++ b/shared/package-files/43/43b1dba08ece96a76809dc9bcae54caad34fd97455d98d949e664b1bab14694a/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor special_bessel_j0(const at::Tensor & self); +TORCH_API at::Tensor & special_bessel_j0_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & special_bessel_j0_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/43/43b27f3746ecf713b935288b3bbe212c813935421c9abd859a4492fde2dfd462/blob b/shared/package-files/43/43b27f3746ecf713b935288b3bbe212c813935421c9abd859a4492fde2dfd462/blob new file mode 100644 index 0000000000000000000000000000000000000000..e55d2a58d709926a24467a0056323096e0890fa9 --- /dev/null +++ b/shared/package-files/43/43b27f3746ecf713b935288b3bbe212c813935421c9abd859a4492fde2dfd462/blob @@ -0,0 +1,2 @@ +#pragma once +#include diff --git a/shared/package-files/43/43b2dcaa9f24d5edfd4f1da736b63496bde5b938bbddc9170c15cb5d8917c629/blob b/shared/package-files/43/43b2dcaa9f24d5edfd4f1da736b63496bde5b938bbddc9170c15cb5d8917c629/blob new file mode 100644 index 0000000000000000000000000000000000000000..a8e6e18b645ef9781acbf9d05c463c6a431d6c83 --- /dev/null +++ b/shared/package-files/43/43b2dcaa9f24d5edfd4f1da736b63496bde5b938bbddc9170c15cb5d8917c629/blob @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API hardsigmoid_out { + using schema = at::Tensor & (const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hardsigmoid") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hardsigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +struct TORCH_API hardsigmoid { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hardsigmoid") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hardsigmoid(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API hardsigmoid_ { + using schema = at::Tensor & (at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hardsigmoid_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hardsigmoid_(Tensor(a!) self) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/43/43b45e3d636fc2a571c5e2106815428b544bd22a2feeaa3aa087f3006d810ecd/massformer_data.py b/shared/package-files/43/43b45e3d636fc2a571c5e2106815428b544bd22a2feeaa3aa087f3006d810ecd/massformer_data.py new file mode 100644 index 0000000000000000000000000000000000000000..866b17ec9c68b9b6b50342a002f353c79903adef --- /dev/null +++ b/shared/package-files/43/43b45e3d636fc2a571c5e2106815428b544bd22a2feeaa3aa087f3006d810ecd/massformer_data.py @@ -0,0 +1,246 @@ +import logging +import json +import numpy as np + +import torch +from rdkit import Chem +from torch.utils.data.dataset import Dataset +import dgl + +import ms_pred.common as common +from ._massformer_graph_featurizer import MassformerGraphFeaturizer + + +class BinnedDataset(Dataset): + """BinnedDataset.""" + + def __init__( + self, + df, + data_dir, + num_bins, + num_workers=0, + upper_limit=1500, + form_dir_name: str = "subform_20", + use_ray=False, + **kwargs, + ): + self.df = df + self.num_bins = num_bins + self.num_workers = num_workers + self.upper_limit = upper_limit + self.bins = np.linspace(0, self.upper_limit, self.num_bins) + self.name_to_adduct = dict(self.df[["spec", "ionization"]].values) + self.subform_path = data_dir / "subformulae" / f"{form_dir_name}" + self.subform_h5 = None + + # Read in all molecules & specs + self.graph_featurizer = MassformerGraphFeaturizer() + + def process_df(df_row): + smi, spec_name, ces = df_row["smiles"], df_row['spec'], df_row['collision_energies'] + mol = Chem.MolFromSmiles(smi) + mw = common.ExactMolWt(mol) + graph = self.graph_featurizer(mol) + + # load spectrum + all_spec_output = [] + for ce in eval(ces): + ce = int(ce) # collision energies are integers in NIST + all_spec_output.append((spec_name, smi, mol, mw, graph, ce)) + return all_spec_output + + dfrows = [i for _, i in self.df.iterrows()] + if self.num_workers == 0: + outputs = [process_df(i) for i in dfrows] + else: + outputs = common.chunked_parallel( + dfrows, + process_df, + chunks=100, + max_cpu=self.num_workers, + ) + outputs = [j for i in outputs for j in i] # unroll + + self.spec_names, self.smiles, self.mols, self.weights, self.mol_graphs, self.collision_energies = zip(*outputs) + + # collision energy statistics + self.collision_energy_mean = common.NIST_COLLISION_ENERGY_MEAN + self.collision_energy_std = common.NIST_COLLISION_ENERGY_STD + + # Self.weights, self. mol_graphs + self.adducts = [ + common.ion2onehot_pos[self.name_to_adduct[i]] for i in self.spec_names + ] + + def __len__(self): + return len(self.spec_names) + + def __getitem__(self, idx: int): + name = self.spec_names[idx] + collision_energy = self.collision_energies[idx] + graph = self.mol_graphs[idx] + full_weight = self.weights[idx] + adduct = self.adducts[idx] + + if self.subform_h5 is None: + self.subform_h5 = common.HDF5Dataset(self.subform_path) + json_str = self.subform_h5.read_str(f'{name}_collision {collision_energy}.json') + meta, spec_ar = common.bin_from_str(json_str, num_bins=self.num_bins, upper_limit=self.upper_limit) + + norm_collision_energy = (collision_energy - self.collision_energy_mean) / (self.collision_energy_std + 1e-6) # it's not "NCE" on Thermo instruments!! + outdict = { + "name": name, + "binned": spec_ar, + "full_weight": full_weight, + "adduct": adduct, + "gf_v2_data": graph, + "collision_energy": collision_energy, + "norm_collision_energy": norm_collision_energy, # it's not "NCE" on Thermo instruments!! + "_meta": meta, + } + return outdict + + @classmethod + def get_collate_fn(cls): + return BinnedDataset.collate_fn + + @staticmethod + def collate_fn(input_list): + """collate_fn""" + names = [j["name"] for j in input_list] + spec_ars = [j["binned"] for j in input_list] + graphs = MassformerGraphFeaturizer.collate_func( + [j["gf_v2_data"] for j in input_list] + ) + full_weight = [j["full_weight"] for j in input_list] + adducts = [j["adduct"] for j in input_list] + collision_energies = [j["collision_energy"] for j in input_list] + norm_collision_energies = [j["norm_collision_energy"] for j in input_list] # it's not "NCE" on Thermo instruments!! + + # Now pad everything else to the max channel dim + spectra_tensors = torch.stack([torch.tensor(spectra) for spectra in spec_ars]) + full_weight = torch.FloatTensor(full_weight) + + # frag_batch.set_n_initializer(dgl.init.zero_initializer) + # frag_batch.set_e_initializer(dgl.init.zero_initializer) + + adducts = torch.FloatTensor(adducts) + collision_energies = torch.FloatTensor(collision_energies) + norm_collision_energies = torch.FloatTensor(norm_collision_energies) + + return_dict = { + "spectra": spectra_tensors, + "gf_v2_data": graphs, + "names": names, + "adducts": adducts, + "collision_energies": collision_energies, + "norm_collision_energies": norm_collision_energies, + "full_weight": full_weight, + } + return return_dict + + +class MolDataset(Dataset): + """MolDataset.""" + + def __init__(self, df, num_workers: int = 0, **kwargs): + + self.df = df + self.num_workers = num_workers + self.graph_featurizer = MassformerGraphFeaturizer() + self.name_to_adduct = dict(self.df[["spec", "ionization"]].values) + + # Read in all molecules & specs + self.graph_featurizer = MassformerGraphFeaturizer() + + def process_df(df_row): + smi, spec_name, ces = df_row["smiles"], df_row['spec'], df_row['collision_energies'] + mol = Chem.MolFromSmiles(smi) + mw = common.ExactMolWt(mol) + graph = self.graph_featurizer(mol) + + # load spectrum + all_spec_output = [] + for ce in eval(ces): + ce = int(ce) # collision energies are integers in NIST + all_spec_output.append((spec_name, smi, mol, mw, graph, ce)) + return all_spec_output + + dfrows = [i for _, i in self.df.iterrows()] + if self.num_workers == 0: + outputs = [process_df(i) for i in dfrows] + else: + outputs = common.chunked_parallel( + dfrows, + process_df, + chunks=100, + max_cpu=self.num_workers, + ) + outputs = [j for i in outputs for j in i] # unroll + + self.spec_names, self.smiles, self.mols, self.weights, self.mol_graphs, self.collision_energies = zip(*outputs) + + # Extract + self.adducts = [ + common.ion2onehot_pos[self.name_to_adduct[i]] for i in self.spec_names + ] + + # collision energy statistics + self.collision_energy_mean = common.NIST_COLLISION_ENERGY_MEAN + self.collision_energy_std = common.NIST_COLLISION_ENERGY_STD + + def __len__(self): + return len(self.spec_names) + + def __getitem__(self, idx: int): + smi = self.smiles[idx] + spec_name = self.spec_names[idx] + collision_energy = self.collision_energies[idx] + graph = self.mol_graphs[idx] + full_weight = self.weights[idx] + adduct = self.adducts[idx] + norm_collision_energy = (collision_energy - self.collision_energy_mean) / (self.collision_energy_std + 1e-6) # it's not "NCE" on Thermo instruments!! + + outdict = { + "smi": smi, + "gf_v2_data": graph, + "adduct": adduct, + "full_weight": full_weight, + "spec_name": spec_name, + "collision_energy": collision_energy, + "norm_collision_energy": norm_collision_energy, # it's not "NCE" on Thermo instruments!! + } + return outdict + + @classmethod + def get_collate_fn(cls): + return MolDataset.collate_fn + + @staticmethod + def collate_fn(input_list): + """collate_fn""" + names = [j["smi"] for j in input_list] + spec_names = [j["spec_name"] for j in input_list] + graphs = MassformerGraphFeaturizer.collate_func( + [j["gf_v2_data"] for j in input_list] + ) + full_weight = [j["full_weight"] for j in input_list] + adducts = [j["adduct"] for j in input_list] + collision_energies = [j["collision_energy"] for j in input_list] + norm_collision_energies = [j["norm_collision_energy"] for j in input_list] # it's not "NCE" on Thermo instruments!! + adducts = torch.FloatTensor(adducts) + collision_energies = torch.FloatTensor(collision_energies) + norm_collision_energies = torch.FloatTensor(norm_collision_energies) + + full_weight = torch.FloatTensor(full_weight) + return_dict = { + "gf_v2_data": graphs, + "spec_names": spec_names, + "names": names, + "full_weight": full_weight, + "adducts": adducts, + "collision_energies": collision_energies, + "norm_collision_energies": norm_collision_energies, + } + return return_dict diff --git a/shared/package-files/43/43b4c22e413af5aea0ee63e83c092a860fb4752b728800b48d594cef6286fd1f/blob b/shared/package-files/43/43b4c22e413af5aea0ee63e83c092a860fb4752b728800b48d594cef6286fd1f/blob new file mode 100644 index 0000000000000000000000000000000000000000..99d246baa35cb9c6f56d50adbec163452e2a47fa Binary files /dev/null and b/shared/package-files/43/43b4c22e413af5aea0ee63e83c092a860fb4752b728800b48d594cef6286fd1f/blob differ diff --git a/shared/package-files/43/43bb52d9c74667d6b8348ff5b201aea157120effeb224f80bf40691536ba1330/blob b/shared/package-files/43/43bb52d9c74667d6b8348ff5b201aea157120effeb224f80bf40691536ba1330/blob new file mode 100644 index 0000000000000000000000000000000000000000..5008b3dd4634d3cee10744a0a92b1204051f07cc --- /dev/null +++ b/shared/package-files/43/43bb52d9c74667d6b8348ff5b201aea157120effeb224f80bf40691536ba1330/blob @@ -0,0 +1,187 @@ +"""Tools to assist importing optional external modules.""" + +import sys +import re + +# Override these in the module to change the default warning behavior. +# For example, you might set both to False before running the tests so that +# warnings are not printed to the console, or set both to True for debugging. + +WARN_NOT_INSTALLED = None # Default is False +WARN_OLD_VERSION = None # Default is True + + +def __sympy_debug(): + # helper function from sympy/__init__.py + # We don't just import SYMPY_DEBUG from that file because we don't want to + # import all of SymPy just to use this module. + import os + debug_str = os.getenv('SYMPY_DEBUG', 'False') + if debug_str in ('True', 'False'): + return eval(debug_str) + else: + raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" % + debug_str) + +if __sympy_debug(): + WARN_OLD_VERSION = True + WARN_NOT_INSTALLED = True + + +_component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE) + +def version_tuple(vstring): + # Parse a version string to a tuple e.g. '1.2' -> (1, 2) + # Simplified from distutils.version.LooseVersion which was deprecated in + # Python 3.10. + components = [] + for x in _component_re.split(vstring): + if x and x != '.': + try: + x = int(x) + except ValueError: + pass + components.append(x) + return tuple(components) + + +def import_module(module, min_module_version=None, min_python_version=None, + warn_not_installed=None, warn_old_version=None, + module_version_attr='__version__', module_version_attr_call_args=None, + import_kwargs={}, catch=()): + """ + Import and return a module if it is installed. + + If the module is not installed, it returns None. + + A minimum version for the module can be given as the keyword argument + min_module_version. This should be comparable against the module version. + By default, module.__version__ is used to get the module version. To + override this, set the module_version_attr keyword argument. If the + attribute of the module to get the version should be called (e.g., + module.version()), then set module_version_attr_call_args to the args such + that module.module_version_attr(*module_version_attr_call_args) returns the + module's version. + + If the module version is less than min_module_version using the Python < + comparison, None will be returned, even if the module is installed. You can + use this to keep from importing an incompatible older version of a module. + + You can also specify a minimum Python version by using the + min_python_version keyword argument. This should be comparable against + sys.version_info. + + If the keyword argument warn_not_installed is set to True, the function will + emit a UserWarning when the module is not installed. + + If the keyword argument warn_old_version is set to True, the function will + emit a UserWarning when the library is installed, but cannot be imported + because of the min_module_version or min_python_version options. + + Note that because of the way warnings are handled, a warning will be + emitted for each module only once. You can change the default warning + behavior by overriding the values of WARN_NOT_INSTALLED and WARN_OLD_VERSION + in sympy.external.importtools. By default, WARN_NOT_INSTALLED is False and + WARN_OLD_VERSION is True. + + This function uses __import__() to import the module. To pass additional + options to __import__(), use the import_kwargs keyword argument. For + example, to import a submodule A.B, you must pass a nonempty fromlist option + to __import__. See the docstring of __import__(). + + This catches ImportError to determine if the module is not installed. To + catch additional errors, pass them as a tuple to the catch keyword + argument. + + Examples + ======== + + >>> from sympy.external import import_module + + >>> numpy = import_module('numpy') + + >>> numpy = import_module('numpy', min_python_version=(2, 7), + ... warn_old_version=False) + + >>> numpy = import_module('numpy', min_module_version='1.5', + ... warn_old_version=False) # numpy.__version__ is a string + + >>> # gmpy does not have __version__, but it does have gmpy.version() + + >>> gmpy = import_module('gmpy', min_module_version='1.14', + ... module_version_attr='version', module_version_attr_call_args=(), + ... warn_old_version=False) + + >>> # To import a submodule, you must pass a nonempty fromlist to + >>> # __import__(). The values do not matter. + >>> p3 = import_module('mpl_toolkits.mplot3d', + ... import_kwargs={'fromlist':['something']}) + + >>> # matplotlib.pyplot can raise RuntimeError when the display cannot be opened + >>> matplotlib = import_module('matplotlib', + ... import_kwargs={'fromlist':['pyplot']}, catch=(RuntimeError,)) + + """ + # keyword argument overrides default, and global variable overrides + # keyword argument. + warn_old_version = (WARN_OLD_VERSION if WARN_OLD_VERSION is not None + else warn_old_version or True) + warn_not_installed = (WARN_NOT_INSTALLED if WARN_NOT_INSTALLED is not None + else warn_not_installed or False) + + import warnings + + # Check Python first so we don't waste time importing a module we can't use + if min_python_version: + if sys.version_info < min_python_version: + if warn_old_version: + warnings.warn("Python version is too old to use %s " + "(%s or newer required)" % ( + module, '.'.join(map(str, min_python_version))), + UserWarning, stacklevel=2) + return + + try: + mod = __import__(module, **import_kwargs) + + ## there's something funny about imports with matplotlib and py3k. doing + ## from matplotlib import collections + ## gives python's stdlib collections module. explicitly re-importing + ## the module fixes this. + from_list = import_kwargs.get('fromlist', ()) + for submod in from_list: + if submod == 'collections' and mod.__name__ == 'matplotlib': + __import__(module + '.' + submod) + except ImportError: + if warn_not_installed: + warnings.warn("%s module is not installed" % module, UserWarning, + stacklevel=2) + return + except catch as e: + if warn_not_installed: + warnings.warn( + "%s module could not be used (%s)" % (module, repr(e)), + stacklevel=2) + return + + if min_module_version: + modversion = getattr(mod, module_version_attr) + if module_version_attr_call_args is not None: + modversion = modversion(*module_version_attr_call_args) + if version_tuple(modversion) < version_tuple(min_module_version): + if warn_old_version: + # Attempt to create a pretty string version of the version + if isinstance(min_module_version, str): + verstr = min_module_version + elif isinstance(min_module_version, (tuple, list)): + verstr = '.'.join(map(str, min_module_version)) + else: + # Either don't know what this is. Hopefully + # it's something that has a nice str version, like an int. + verstr = str(min_module_version) + warnings.warn("%s version is too old to use " + "(%s or newer required)" % (module, verstr), + UserWarning, stacklevel=2) + return + + return mod diff --git a/shared/package-files/43/43bbb4e266dba82a1ef55c6ca9172c5933f1807d82c78f5e596822db05326475/blob b/shared/package-files/43/43bbb4e266dba82a1ef55c6ca9172c5933f1807d82c78f5e596822db05326475/blob new file mode 100644 index 0000000000000000000000000000000000000000..4d9ab9ae49385e83515143ced8a04b01938fcab1 --- /dev/null +++ b/shared/package-files/43/43bbb4e266dba82a1ef55c6ca9172c5933f1807d82c78f5e596822db05326475/blob @@ -0,0 +1,780 @@ +# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license + +# Copyright (C) 2003-2017 Nominum, Inc. +# +# Permission to use, copy, modify, and distribute this software and its +# documentation for any purpose with or without fee is hereby granted, +# provided that the above copyright notice and this permission notice +# appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +"""Talk to a DNS server.""" + +import base64 +import contextlib +import socket +import struct +import time +from typing import Any, Dict, Optional, Tuple, Union + +import dns.asyncbackend +import dns.exception +import dns.inet +import dns.message +import dns.name +import dns.quic +import dns.rcode +import dns.rdataclass +import dns.rdatatype +import dns.transaction +from dns._asyncbackend import NullContext +from dns.query import ( + BadResponse, + NoDOH, + NoDOQ, + UDPMode, + _compute_times, + _make_dot_ssl_context, + _matches_destination, + _remaining, + have_doh, + ssl, +) + +if have_doh: + import httpx + +# for brevity +_lltuple = dns.inet.low_level_address_tuple + + +def _source_tuple(af, address, port): + # Make a high level source tuple, or return None if address and port + # are both None + if address or port: + if address is None: + if af == socket.AF_INET: + address = "0.0.0.0" + elif af == socket.AF_INET6: + address = "::" + else: + raise NotImplementedError(f"unknown address family {af}") + return (address, port) + else: + return None + + +def _timeout(expiration, now=None): + if expiration is not None: + if not now: + now = time.time() + return max(expiration - now, 0) + else: + return None + + +async def send_udp( + sock: dns.asyncbackend.DatagramSocket, + what: Union[dns.message.Message, bytes], + destination: Any, + expiration: Optional[float] = None, +) -> Tuple[int, float]: + """Send a DNS message to the specified UDP socket. + + *sock*, a ``dns.asyncbackend.DatagramSocket``. + + *what*, a ``bytes`` or ``dns.message.Message``, the message to send. + + *destination*, a destination tuple appropriate for the address family + of the socket, specifying where to send the query. + + *expiration*, a ``float`` or ``None``, the absolute time at which + a timeout exception should be raised. If ``None``, no timeout will + occur. The expiration value is meaningless for the asyncio backend, as + asyncio's transport sendto() never blocks. + + Returns an ``(int, float)`` tuple of bytes sent and the sent time. + """ + + if isinstance(what, dns.message.Message): + what = what.to_wire() + sent_time = time.time() + n = await sock.sendto(what, destination, _timeout(expiration, sent_time)) + return (n, sent_time) + + +async def receive_udp( + sock: dns.asyncbackend.DatagramSocket, + destination: Optional[Any] = None, + expiration: Optional[float] = None, + ignore_unexpected: bool = False, + one_rr_per_rrset: bool = False, + keyring: Optional[Dict[dns.name.Name, dns.tsig.Key]] = None, + request_mac: Optional[bytes] = b"", + ignore_trailing: bool = False, + raise_on_truncation: bool = False, + ignore_errors: bool = False, + query: Optional[dns.message.Message] = None, +) -> Any: + """Read a DNS message from a UDP socket. + + *sock*, a ``dns.asyncbackend.DatagramSocket``. + + See :py:func:`dns.query.receive_udp()` for the documentation of the other + parameters, and exceptions. + + Returns a ``(dns.message.Message, float, tuple)`` tuple of the received message, the + received time, and the address where the message arrived from. + """ + + wire = b"" + while True: + (wire, from_address) = await sock.recvfrom(65535, _timeout(expiration)) + if not _matches_destination( + sock.family, from_address, destination, ignore_unexpected + ): + continue + received_time = time.time() + try: + r = dns.message.from_wire( + wire, + keyring=keyring, + request_mac=request_mac, + one_rr_per_rrset=one_rr_per_rrset, + ignore_trailing=ignore_trailing, + raise_on_truncation=raise_on_truncation, + ) + except dns.message.Truncated as e: + # See the comment in query.py for details. + if ( + ignore_errors + and query is not None + and not query.is_response(e.message()) + ): + continue + else: + raise + except Exception: + if ignore_errors: + continue + else: + raise + if ignore_errors and query is not None and not query.is_response(r): + continue + return (r, received_time, from_address) + + +async def udp( + q: dns.message.Message, + where: str, + timeout: Optional[float] = None, + port: int = 53, + source: Optional[str] = None, + source_port: int = 0, + ignore_unexpected: bool = False, + one_rr_per_rrset: bool = False, + ignore_trailing: bool = False, + raise_on_truncation: bool = False, + sock: Optional[dns.asyncbackend.DatagramSocket] = None, + backend: Optional[dns.asyncbackend.Backend] = None, + ignore_errors: bool = False, +) -> dns.message.Message: + """Return the response obtained after sending a query via UDP. + + *sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``, + the socket to use for the query. If ``None``, the default, a + socket is created. Note that if a socket is provided, the + *source*, *source_port*, and *backend* are ignored. + + *backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``, + the default, then dnspython will use the default backend. + + See :py:func:`dns.query.udp()` for the documentation of the other + parameters, exceptions, and return type of this method. + """ + wire = q.to_wire() + (begin_time, expiration) = _compute_times(timeout) + af = dns.inet.af_for_address(where) + destination = _lltuple((where, port), af) + if sock: + cm: contextlib.AbstractAsyncContextManager = NullContext(sock) + else: + if not backend: + backend = dns.asyncbackend.get_default_backend() + stuple = _source_tuple(af, source, source_port) + if backend.datagram_connection_required(): + dtuple = (where, port) + else: + dtuple = None + cm = await backend.make_socket(af, socket.SOCK_DGRAM, 0, stuple, dtuple) + async with cm as s: + await send_udp(s, wire, destination, expiration) + (r, received_time, _) = await receive_udp( + s, + destination, + expiration, + ignore_unexpected, + one_rr_per_rrset, + q.keyring, + q.mac, + ignore_trailing, + raise_on_truncation, + ignore_errors, + q, + ) + r.time = received_time - begin_time + # We don't need to check q.is_response() if we are in ignore_errors mode + # as receive_udp() will have checked it. + if not (ignore_errors or q.is_response(r)): + raise BadResponse + return r + + +async def udp_with_fallback( + q: dns.message.Message, + where: str, + timeout: Optional[float] = None, + port: int = 53, + source: Optional[str] = None, + source_port: int = 0, + ignore_unexpected: bool = False, + one_rr_per_rrset: bool = False, + ignore_trailing: bool = False, + udp_sock: Optional[dns.asyncbackend.DatagramSocket] = None, + tcp_sock: Optional[dns.asyncbackend.StreamSocket] = None, + backend: Optional[dns.asyncbackend.Backend] = None, + ignore_errors: bool = False, +) -> Tuple[dns.message.Message, bool]: + """Return the response to the query, trying UDP first and falling back + to TCP if UDP results in a truncated response. + + *udp_sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``, + the socket to use for the UDP query. If ``None``, the default, a + socket is created. Note that if a socket is provided the *source*, + *source_port*, and *backend* are ignored for the UDP query. + + *tcp_sock*, a ``dns.asyncbackend.StreamSocket``, or ``None``, the + socket to use for the TCP query. If ``None``, the default, a + socket is created. Note that if a socket is provided *where*, + *source*, *source_port*, and *backend* are ignored for the TCP query. + + *backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``, + the default, then dnspython will use the default backend. + + See :py:func:`dns.query.udp_with_fallback()` for the documentation + of the other parameters, exceptions, and return type of this + method. + """ + try: + response = await udp( + q, + where, + timeout, + port, + source, + source_port, + ignore_unexpected, + one_rr_per_rrset, + ignore_trailing, + True, + udp_sock, + backend, + ignore_errors, + ) + return (response, False) + except dns.message.Truncated: + response = await tcp( + q, + where, + timeout, + port, + source, + source_port, + one_rr_per_rrset, + ignore_trailing, + tcp_sock, + backend, + ) + return (response, True) + + +async def send_tcp( + sock: dns.asyncbackend.StreamSocket, + what: Union[dns.message.Message, bytes], + expiration: Optional[float] = None, +) -> Tuple[int, float]: + """Send a DNS message to the specified TCP socket. + + *sock*, a ``dns.asyncbackend.StreamSocket``. + + See :py:func:`dns.query.send_tcp()` for the documentation of the other + parameters, exceptions, and return type of this method. + """ + + if isinstance(what, dns.message.Message): + tcpmsg = what.to_wire(prepend_length=True) + else: + # copying the wire into tcpmsg is inefficient, but lets us + # avoid writev() or doing a short write that would get pushed + # onto the net + tcpmsg = len(what).to_bytes(2, "big") + what + sent_time = time.time() + await sock.sendall(tcpmsg, _timeout(expiration, sent_time)) + return (len(tcpmsg), sent_time) + + +async def _read_exactly(sock, count, expiration): + """Read the specified number of bytes from stream. Keep trying until we + either get the desired amount, or we hit EOF. + """ + s = b"" + while count > 0: + n = await sock.recv(count, _timeout(expiration)) + if n == b"": + raise EOFError + count = count - len(n) + s = s + n + return s + + +async def receive_tcp( + sock: dns.asyncbackend.StreamSocket, + expiration: Optional[float] = None, + one_rr_per_rrset: bool = False, + keyring: Optional[Dict[dns.name.Name, dns.tsig.Key]] = None, + request_mac: Optional[bytes] = b"", + ignore_trailing: bool = False, +) -> Tuple[dns.message.Message, float]: + """Read a DNS message from a TCP socket. + + *sock*, a ``dns.asyncbackend.StreamSocket``. + + See :py:func:`dns.query.receive_tcp()` for the documentation of the other + parameters, exceptions, and return type of this method. + """ + + ldata = await _read_exactly(sock, 2, expiration) + (l,) = struct.unpack("!H", ldata) + wire = await _read_exactly(sock, l, expiration) + received_time = time.time() + r = dns.message.from_wire( + wire, + keyring=keyring, + request_mac=request_mac, + one_rr_per_rrset=one_rr_per_rrset, + ignore_trailing=ignore_trailing, + ) + return (r, received_time) + + +async def tcp( + q: dns.message.Message, + where: str, + timeout: Optional[float] = None, + port: int = 53, + source: Optional[str] = None, + source_port: int = 0, + one_rr_per_rrset: bool = False, + ignore_trailing: bool = False, + sock: Optional[dns.asyncbackend.StreamSocket] = None, + backend: Optional[dns.asyncbackend.Backend] = None, +) -> dns.message.Message: + """Return the response obtained after sending a query via TCP. + + *sock*, a ``dns.asyncbacket.StreamSocket``, or ``None``, the + socket to use for the query. If ``None``, the default, a socket + is created. Note that if a socket is provided + *where*, *port*, *source*, *source_port*, and *backend* are ignored. + + *backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``, + the default, then dnspython will use the default backend. + + See :py:func:`dns.query.tcp()` for the documentation of the other + parameters, exceptions, and return type of this method. + """ + + wire = q.to_wire() + (begin_time, expiration) = _compute_times(timeout) + if sock: + # Verify that the socket is connected, as if it's not connected, + # it's not writable, and the polling in send_tcp() will time out or + # hang forever. + await sock.getpeername() + cm: contextlib.AbstractAsyncContextManager = NullContext(sock) + else: + # These are simple (address, port) pairs, not family-dependent tuples + # you pass to low-level socket code. + af = dns.inet.af_for_address(where) + stuple = _source_tuple(af, source, source_port) + dtuple = (where, port) + if not backend: + backend = dns.asyncbackend.get_default_backend() + cm = await backend.make_socket( + af, socket.SOCK_STREAM, 0, stuple, dtuple, timeout + ) + async with cm as s: + await send_tcp(s, wire, expiration) + (r, received_time) = await receive_tcp( + s, expiration, one_rr_per_rrset, q.keyring, q.mac, ignore_trailing + ) + r.time = received_time - begin_time + if not q.is_response(r): + raise BadResponse + return r + + +async def tls( + q: dns.message.Message, + where: str, + timeout: Optional[float] = None, + port: int = 853, + source: Optional[str] = None, + source_port: int = 0, + one_rr_per_rrset: bool = False, + ignore_trailing: bool = False, + sock: Optional[dns.asyncbackend.StreamSocket] = None, + backend: Optional[dns.asyncbackend.Backend] = None, + ssl_context: Optional[ssl.SSLContext] = None, + server_hostname: Optional[str] = None, + verify: Union[bool, str] = True, +) -> dns.message.Message: + """Return the response obtained after sending a query via TLS. + + *sock*, an ``asyncbackend.StreamSocket``, or ``None``, the socket + to use for the query. If ``None``, the default, a socket is + created. Note that if a socket is provided, it must be a + connected SSL stream socket, and *where*, *port*, + *source*, *source_port*, *backend*, *ssl_context*, and *server_hostname* + are ignored. + + *backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``, + the default, then dnspython will use the default backend. + + See :py:func:`dns.query.tls()` for the documentation of the other + parameters, exceptions, and return type of this method. + """ + (begin_time, expiration) = _compute_times(timeout) + if sock: + cm: contextlib.AbstractAsyncContextManager = NullContext(sock) + else: + if ssl_context is None: + ssl_context = _make_dot_ssl_context(server_hostname, verify) + af = dns.inet.af_for_address(where) + stuple = _source_tuple(af, source, source_port) + dtuple = (where, port) + if not backend: + backend = dns.asyncbackend.get_default_backend() + cm = await backend.make_socket( + af, + socket.SOCK_STREAM, + 0, + stuple, + dtuple, + timeout, + ssl_context, + server_hostname, + ) + async with cm as s: + timeout = _timeout(expiration) + response = await tcp( + q, + where, + timeout, + port, + source, + source_port, + one_rr_per_rrset, + ignore_trailing, + s, + backend, + ) + end_time = time.time() + response.time = end_time - begin_time + return response + + +async def https( + q: dns.message.Message, + where: str, + timeout: Optional[float] = None, + port: int = 443, + source: Optional[str] = None, + source_port: int = 0, # pylint: disable=W0613 + one_rr_per_rrset: bool = False, + ignore_trailing: bool = False, + client: Optional["httpx.AsyncClient"] = None, + path: str = "/dns-query", + post: bool = True, + verify: Union[bool, str] = True, + bootstrap_address: Optional[str] = None, + resolver: Optional["dns.asyncresolver.Resolver"] = None, + family: Optional[int] = socket.AF_UNSPEC, +) -> dns.message.Message: + """Return the response obtained after sending a query via DNS-over-HTTPS. + + *client*, a ``httpx.AsyncClient``. If provided, the client to use for + the query. + + Unlike the other dnspython async functions, a backend cannot be provided + in this function because httpx always auto-detects the async backend. + + See :py:func:`dns.query.https()` for the documentation of the other + parameters, exceptions, and return type of this method. + """ + + if not have_doh: + raise NoDOH # pragma: no cover + if client and not isinstance(client, httpx.AsyncClient): + raise ValueError("session parameter must be an httpx.AsyncClient") + + wire = q.to_wire() + try: + af = dns.inet.af_for_address(where) + except ValueError: + af = None + transport = None + headers = {"accept": "application/dns-message"} + if af is not None and dns.inet.is_address(where): + if af == socket.AF_INET: + url = "https://{}:{}{}".format(where, port, path) + elif af == socket.AF_INET6: + url = "https://[{}]:{}{}".format(where, port, path) + else: + url = where + + backend = dns.asyncbackend.get_default_backend() + + if source is None: + local_address = None + local_port = 0 + else: + local_address = source + local_port = source_port + transport = backend.get_transport_class()( + local_address=local_address, + http1=True, + http2=True, + verify=verify, + local_port=local_port, + bootstrap_address=bootstrap_address, + resolver=resolver, + family=family, + ) + + if client: + cm: contextlib.AbstractAsyncContextManager = NullContext(client) + else: + cm = httpx.AsyncClient( + http1=True, http2=True, verify=verify, transport=transport + ) + + async with cm as the_client: + # see https://tools.ietf.org/html/rfc8484#section-4.1.1 for DoH + # GET and POST examples + if post: + headers.update( + { + "content-type": "application/dns-message", + "content-length": str(len(wire)), + } + ) + response = await backend.wait_for( + the_client.post(url, headers=headers, content=wire), timeout + ) + else: + wire = base64.urlsafe_b64encode(wire).rstrip(b"=") + twire = wire.decode() # httpx does a repr() if we give it bytes + response = await backend.wait_for( + the_client.get(url, headers=headers, params={"dns": twire}), timeout + ) + + # see https://tools.ietf.org/html/rfc8484#section-4.2.1 for info about DoH + # status codes + if response.status_code < 200 or response.status_code > 299: + raise ValueError( + "{} responded with status code {}" + "\nResponse body: {!r}".format( + where, response.status_code, response.content + ) + ) + r = dns.message.from_wire( + response.content, + keyring=q.keyring, + request_mac=q.request_mac, + one_rr_per_rrset=one_rr_per_rrset, + ignore_trailing=ignore_trailing, + ) + r.time = response.elapsed.total_seconds() + if not q.is_response(r): + raise BadResponse + return r + + +async def inbound_xfr( + where: str, + txn_manager: dns.transaction.TransactionManager, + query: Optional[dns.message.Message] = None, + port: int = 53, + timeout: Optional[float] = None, + lifetime: Optional[float] = None, + source: Optional[str] = None, + source_port: int = 0, + udp_mode: UDPMode = UDPMode.NEVER, + backend: Optional[dns.asyncbackend.Backend] = None, +) -> None: + """Conduct an inbound transfer and apply it via a transaction from the + txn_manager. + + *backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``, + the default, then dnspython will use the default backend. + + See :py:func:`dns.query.inbound_xfr()` for the documentation of + the other parameters, exceptions, and return type of this method. + """ + if query is None: + (query, serial) = dns.xfr.make_query(txn_manager) + else: + serial = dns.xfr.extract_serial_from_query(query) + rdtype = query.question[0].rdtype + is_ixfr = rdtype == dns.rdatatype.IXFR + origin = txn_manager.from_wire_origin() + wire = query.to_wire() + af = dns.inet.af_for_address(where) + stuple = _source_tuple(af, source, source_port) + dtuple = (where, port) + (_, expiration) = _compute_times(lifetime) + retry = True + while retry: + retry = False + if is_ixfr and udp_mode != UDPMode.NEVER: + sock_type = socket.SOCK_DGRAM + is_udp = True + else: + sock_type = socket.SOCK_STREAM + is_udp = False + if not backend: + backend = dns.asyncbackend.get_default_backend() + s = await backend.make_socket( + af, sock_type, 0, stuple, dtuple, _timeout(expiration) + ) + async with s: + if is_udp: + await s.sendto(wire, dtuple, _timeout(expiration)) + else: + tcpmsg = struct.pack("!H", len(wire)) + wire + await s.sendall(tcpmsg, expiration) + with dns.xfr.Inbound(txn_manager, rdtype, serial, is_udp) as inbound: + done = False + tsig_ctx = None + while not done: + (_, mexpiration) = _compute_times(timeout) + if mexpiration is None or ( + expiration is not None and mexpiration > expiration + ): + mexpiration = expiration + if is_udp: + destination = _lltuple((where, port), af) + while True: + timeout = _timeout(mexpiration) + (rwire, from_address) = await s.recvfrom(65535, timeout) + if _matches_destination( + af, from_address, destination, True + ): + break + else: + ldata = await _read_exactly(s, 2, mexpiration) + (l,) = struct.unpack("!H", ldata) + rwire = await _read_exactly(s, l, mexpiration) + is_ixfr = rdtype == dns.rdatatype.IXFR + r = dns.message.from_wire( + rwire, + keyring=query.keyring, + request_mac=query.mac, + xfr=True, + origin=origin, + tsig_ctx=tsig_ctx, + multi=(not is_udp), + one_rr_per_rrset=is_ixfr, + ) + try: + done = inbound.process_message(r) + except dns.xfr.UseTCP: + assert is_udp # should not happen if we used TCP! + if udp_mode == UDPMode.ONLY: + raise + done = True + retry = True + udp_mode = UDPMode.NEVER + continue + tsig_ctx = r.tsig_ctx + if not retry and query.keyring and not r.had_tsig: + raise dns.exception.FormError("missing TSIG") + + +async def quic( + q: dns.message.Message, + where: str, + timeout: Optional[float] = None, + port: int = 853, + source: Optional[str] = None, + source_port: int = 0, + one_rr_per_rrset: bool = False, + ignore_trailing: bool = False, + connection: Optional[dns.quic.AsyncQuicConnection] = None, + verify: Union[bool, str] = True, + backend: Optional[dns.asyncbackend.Backend] = None, + server_hostname: Optional[str] = None, +) -> dns.message.Message: + """Return the response obtained after sending an asynchronous query via + DNS-over-QUIC. + + *backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``, + the default, then dnspython will use the default backend. + + See :py:func:`dns.query.quic()` for the documentation of the other + parameters, exceptions, and return type of this method. + """ + + if not dns.quic.have_quic: + raise NoDOQ("DNS-over-QUIC is not available.") # pragma: no cover + + q.id = 0 + wire = q.to_wire() + the_connection: dns.quic.AsyncQuicConnection + if connection: + cfactory = dns.quic.null_factory + mfactory = dns.quic.null_factory + the_connection = connection + else: + (cfactory, mfactory) = dns.quic.factories_for_backend(backend) + + async with cfactory() as context: + async with mfactory( + context, verify_mode=verify, server_name=server_hostname + ) as the_manager: + if not connection: + the_connection = the_manager.connect(where, port, source, source_port) + (start, expiration) = _compute_times(timeout) + stream = await the_connection.make_stream(timeout) + async with stream: + await stream.send(wire, True) + wire = await stream.receive(_remaining(expiration)) + finish = time.time() + r = dns.message.from_wire( + wire, + keyring=q.keyring, + request_mac=q.request_mac, + one_rr_per_rrset=one_rr_per_rrset, + ignore_trailing=ignore_trailing, + ) + r.time = max(finish - start, 0.0) + if not q.is_response(r): + raise BadResponse + return r diff --git a/shared/package-files/43/43beef19f1f5a41fcb022618a0a480b7b8da04669b014b47c82c2f307984cf49/blob b/shared/package-files/43/43beef19f1f5a41fcb022618a0a480b7b8da04669b014b47c82c2f307984cf49/blob new file mode 100644 index 0000000000000000000000000000000000000000..88dc842a1d5fc4168a3cc9003c929f1770e839bb --- /dev/null +++ b/shared/package-files/43/43beef19f1f5a41fcb022618a0a480b7b8da04669b014b47c82c2f307984cf49/blob @@ -0,0 +1,234 @@ +from unittest.mock import Mock + +import numpy as np +import pytest +from numpy.testing import assert_allclose, assert_array_almost_equal, assert_equal + +from sklearn.datasets import load_digits +from sklearn.manifold import _mds as mds +from sklearn.metrics import euclidean_distances + + +def test_smacof(): + # test metric smacof using the data of "Modern Multidimensional Scaling", + # Borg & Groenen, p 154 + sim = np.array([[0, 5, 3, 4], [5, 0, 2, 2], [3, 2, 0, 1], [4, 2, 1, 0]]) + Z = np.array([[-0.266, -0.539], [0.451, 0.252], [0.016, -0.238], [-0.200, 0.524]]) + X, _ = mds.smacof(sim, init=Z, n_components=2, max_iter=1, n_init=1) + X_true = np.array( + [[-1.415, -2.471], [1.633, 1.107], [0.249, -0.067], [-0.468, 1.431]] + ) + assert_array_almost_equal(X, X_true, decimal=3) + + +def test_nonmetric_lower_normalized_stress(): + # Testing that nonmetric MDS results in lower normalized stress compared + # compared to metric MDS (non-regression test for issue 27028) + sim = np.array([[0, 5, 3, 4], [5, 0, 2, 2], [3, 2, 0, 1], [4, 2, 1, 0]]) + Z = np.array([[-0.266, -0.539], [0.451, 0.252], [0.016, -0.238], [-0.200, 0.524]]) + + _, stress1 = mds.smacof( + sim, init=Z, n_components=2, max_iter=1000, n_init=1, normalized_stress=True + ) + + _, stress2 = mds.smacof( + sim, + init=Z, + n_components=2, + max_iter=1000, + n_init=1, + normalized_stress=True, + metric=False, + ) + assert stress1 > stress2 + + +def test_nonmetric_mds_optimization(): + # Test that stress is decreasing during nonmetric MDS optimization + # (non-regression test for issue 27028) + X, _ = load_digits(return_X_y=True) + rng = np.random.default_rng(seed=42) + ind_subset = rng.choice(len(X), size=200, replace=False) + X = X[ind_subset] + + mds_est = mds.MDS( + n_components=2, + n_init=1, + max_iter=2, + metric=False, + random_state=42, + ).fit(X) + stress_after_2_iter = mds_est.stress_ + + mds_est = mds.MDS( + n_components=2, + n_init=1, + max_iter=3, + metric=False, + random_state=42, + ).fit(X) + stress_after_3_iter = mds_est.stress_ + + assert stress_after_2_iter > stress_after_3_iter + + +@pytest.mark.parametrize("metric", [True, False]) +def test_mds_recovers_true_data(metric): + X = np.array([[1, 1], [1, 4], [1, 5], [3, 3]]) + mds_est = mds.MDS( + n_components=2, + n_init=1, + eps=1e-15, + max_iter=1000, + metric=metric, + random_state=42, + ).fit(X) + stress = mds_est.stress_ + assert_allclose(stress, 0, atol=1e-6) + + +def test_smacof_error(): + # Not symmetric similarity matrix: + sim = np.array([[0, 5, 9, 4], [5, 0, 2, 2], [3, 2, 0, 1], [4, 2, 1, 0]]) + + with pytest.raises(ValueError): + mds.smacof(sim, n_init=1) + + # Not squared similarity matrix: + sim = np.array([[0, 5, 9, 4], [5, 0, 2, 2], [4, 2, 1, 0]]) + + with pytest.raises(ValueError): + mds.smacof(sim, n_init=1) + + # init not None and not correct format: + sim = np.array([[0, 5, 3, 4], [5, 0, 2, 2], [3, 2, 0, 1], [4, 2, 1, 0]]) + + Z = np.array([[-0.266, -0.539], [0.016, -0.238], [-0.200, 0.524]]) + with pytest.raises(ValueError): + mds.smacof(sim, init=Z, n_init=1) + + +def test_MDS(): + sim = np.array([[0, 5, 3, 4], [5, 0, 2, 2], [3, 2, 0, 1], [4, 2, 1, 0]]) + mds_clf = mds.MDS( + metric=False, + n_jobs=3, + n_init=3, + dissimilarity="precomputed", + ) + mds_clf.fit(sim) + + +# TODO(1.9): remove warning filter +@pytest.mark.filterwarnings("ignore::FutureWarning") +@pytest.mark.parametrize("k", [0.5, 1.5, 2]) +def test_normed_stress(k): + """Test that non-metric MDS normalized stress is scale-invariant.""" + sim = np.array([[0, 5, 3, 4], [5, 0, 2, 2], [3, 2, 0, 1], [4, 2, 1, 0]]) + + X1, stress1 = mds.smacof(sim, metric=False, max_iter=5, random_state=0) + X2, stress2 = mds.smacof(k * sim, metric=False, max_iter=5, random_state=0) + + assert_allclose(stress1, stress2, rtol=1e-5) + assert_allclose(X1, X2, rtol=1e-5) + + +# TODO(1.9): remove warning filter +@pytest.mark.filterwarnings("ignore::FutureWarning") +@pytest.mark.parametrize("metric", [True, False]) +def test_normalized_stress_auto(metric, monkeypatch): + rng = np.random.RandomState(0) + X = rng.randn(4, 3) + dist = euclidean_distances(X) + + mock = Mock(side_effect=mds._smacof_single) + monkeypatch.setattr("sklearn.manifold._mds._smacof_single", mock) + + est = mds.MDS(metric=metric, normalized_stress="auto", random_state=rng) + est.fit_transform(X) + assert mock.call_args[1]["normalized_stress"] != metric + + mds.smacof(dist, metric=metric, normalized_stress="auto", random_state=rng) + assert mock.call_args[1]["normalized_stress"] != metric + + +def test_isotonic_outofbounds(): + # This particular configuration can trigger out of bounds error + # in the isotonic regression (non-regression test for issue 26999) + dis = np.array( + [ + [0.0, 1.732050807568877, 1.7320508075688772], + [1.732050807568877, 0.0, 6.661338147750939e-16], + [1.7320508075688772, 6.661338147750939e-16, 0.0], + ] + ) + init = np.array( + [ + [0.08665881585055124, 0.7939114643387546], + [0.9959834154297658, 0.7555546025640025], + [0.8766008278401566, 0.4227358815811242], + ] + ) + mds.smacof(dis, init=init, metric=False, n_init=1) + + +# TODO(1.9): remove warning filter +@pytest.mark.filterwarnings("ignore::FutureWarning") +@pytest.mark.parametrize("normalized_stress", [True, False]) +def test_returned_stress(normalized_stress): + # Test that the final stress corresponds to the final embedding + # (non-regression test for issue 16846) + X = np.array([[1, 1], [1, 4], [1, 5], [3, 3]]) + D = euclidean_distances(X) + + mds_est = mds.MDS( + n_components=2, + random_state=42, + normalized_stress=normalized_stress, + ).fit(X) + + Z = mds_est.embedding_ + stress = mds_est.stress_ + + D_mds = euclidean_distances(Z) + stress_Z = ((D_mds.ravel() - D.ravel()) ** 2).sum() / 2 + + if normalized_stress: + stress_Z = np.sqrt(stress_Z / ((D_mds.ravel() ** 2).sum() / 2)) + + assert_allclose(stress, stress_Z) + + +# TODO(1.9): remove warning filter +@pytest.mark.filterwarnings("ignore::FutureWarning") +@pytest.mark.parametrize("metric", [True, False]) +def test_convergence_does_not_depend_on_scale(metric): + # Test that the number of iterations until convergence does not depend on + # the scale of the input data + X = np.array([[1, 1], [1, 4], [1, 5], [3, 3]]) + + mds_est = mds.MDS( + n_components=2, + random_state=42, + metric=metric, + ) + + mds_est.fit(X * 100) + n_iter1 = mds_est.n_iter_ + + mds_est.fit(X / 100) + n_iter2 = mds_est.n_iter_ + + assert_equal(n_iter1, n_iter2) + + +# TODO(1.9): delete this test +def test_future_warning_n_init(): + X = np.array([[1, 1], [1, 4], [1, 5], [3, 3]]) + sim = np.array([[0, 5, 3, 4], [5, 0, 2, 2], [3, 2, 0, 1], [4, 2, 1, 0]]) + + with pytest.warns(FutureWarning): + mds.smacof(sim) + + with pytest.warns(FutureWarning): + mds.MDS().fit(X) diff --git a/shared/package-files/43/43c06c3a50653871c048bf2d3cb1da5e34054754b8fbf35c08dbeb2c142bd861/blob b/shared/package-files/43/43c06c3a50653871c048bf2d3cb1da5e34054754b8fbf35c08dbeb2c142bd861/blob new file mode 100644 index 0000000000000000000000000000000000000000..1ed8304bc6378bb1fbd5e2d15369fe66969acae4 --- /dev/null +++ b/shared/package-files/43/43c06c3a50653871c048bf2d3cb1da5e34054754b8fbf35c08dbeb2c142bd861/blob @@ -0,0 +1,35 @@ +from typing import Dict, List + +import torch + +from ._distributed_c10d import Store +from ._distributed_rpc import _TensorPipeRpcBackendOptionsBase, TensorPipeAgent + +# This module is defined in torch/csrc/distributed/rpc/testing/init.cpp + +class FaultyTensorPipeRpcBackendOptions(_TensorPipeRpcBackendOptionsBase): + def __init__( + self, + num_worker_threads: int, + rpc_timeout: float, + init_method: str, + messages_to_fail: List[str], + messages_to_delay: Dict[str, float], + num_fail_sends: int, + ): ... + num_send_recv_threads: int + messages_to_fail: List[str] + messages_to_delay: Dict[str, float] + num_fail_sends: int + +class FaultyTensorPipeAgent(TensorPipeAgent): + def __init__( + self, + store: Store, + name: str, + rank: int, + world_size: int, + options: FaultyTensorPipeRpcBackendOptions, + reverse_device_maps: Dict[str, Dict[torch.device, torch.device]], + devices: List[torch.device], + ): ... diff --git a/shared/package-files/43/43c688b22a4c017494c28878041eae2ddd9dd84016fab9f6b9cf1bbb6884a7fb/blob b/shared/package-files/43/43c688b22a4c017494c28878041eae2ddd9dd84016fab9f6b9cf1bbb6884a7fb/blob new file mode 100644 index 0000000000000000000000000000000000000000..5e99cbb00f89ea26a37445fff1808c4f355827b7 Binary files /dev/null and b/shared/package-files/43/43c688b22a4c017494c28878041eae2ddd9dd84016fab9f6b9cf1bbb6884a7fb/blob differ diff --git a/shared/package-files/43/43c92c003dddf7b0abb9a629dc864571f2bb5890951bb0a22aaf8269c2d6af39/blob b/shared/package-files/43/43c92c003dddf7b0abb9a629dc864571f2bb5890951bb0a22aaf8269c2d6af39/blob new file mode 100644 index 0000000000000000000000000000000000000000..cdac1e43e8f4d5e5942fccd0bb261b6815fc1019 --- /dev/null +++ b/shared/package-files/43/43c92c003dddf7b0abb9a629dc864571f2bb5890951bb0a22aaf8269c2d6af39/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor cumsum(const at::Tensor & self, int64_t dim, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor & cumsum_(at::Tensor & self, int64_t dim, c10::optional dtype=c10::nullopt); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/shared/package-files/43/43cb2e798656c1dc646950da6ee8251ccdd7b8ffbe35ead882af14c6c5478056/blob b/shared/package-files/43/43cb2e798656c1dc646950da6ee8251ccdd7b8ffbe35ead882af14c6c5478056/blob new file mode 100644 index 0000000000000000000000000000000000000000..59c4276f4524cf5e124fe0bd2266579b5c28d06b --- /dev/null +++ b/shared/package-files/43/43cb2e798656c1dc646950da6ee8251ccdd7b8ffbe35ead882af14c6c5478056/blob @@ -0,0 +1,69 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include + +#include "arrow/type_fwd.h" +#include "arrow/util/type_fwd.h" + +namespace arrow { + +template +using AsyncGenerator = std::function()>; + +template +class MappingGenerator; + +template +class SequencingGenerator; + +template +class TransformingGenerator; + +template +class SerialReadaheadGenerator; + +template +class ReadaheadGenerator; + +template +class PushGenerator; + +template +class MergedGenerator; + +template +class EnumeratingGenerator; + +template +class TransferringGenerator; + +template +class BackgroundGenerator; + +template +class GeneratorIterator; + +template +struct CancellableGenerator; + +template +class DefaultIfEmptyGenerator; + +} // namespace arrow diff --git a/shared/package-files/43/43cc3648c375efb9594c9e476555ce2ad7f006d655fcfbff1f402bbadd4df112/blob b/shared/package-files/43/43cc3648c375efb9594c9e476555ce2ad7f006d655fcfbff1f402bbadd4df112/blob new file mode 100644 index 0000000000000000000000000000000000000000..142dca42e1dec43530c546d5c4b2aa4d90c5994c --- /dev/null +++ b/shared/package-files/43/43cc3648c375efb9594c9e476555ce2ad7f006d655fcfbff1f402bbadd4df112/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_threshold : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/43/43cfdf58e4762439c7bb44d34661f346323704e25ad21188025d1c8ed00b82c4/blob b/shared/package-files/43/43cfdf58e4762439c7bb44d34661f346323704e25ad21188025d1c8ed00b82c4/blob new file mode 100644 index 0000000000000000000000000000000000000000..e690e8103c7a47a01d719e746e6c98a9c7f6c8db --- /dev/null +++ b/shared/package-files/43/43cfdf58e4762439c7bb44d34661f346323704e25ad21188025d1c8ed00b82c4/blob @@ -0,0 +1,346 @@ +from typing import List, Optional, Tuple + +import torch +from torch import nn, Tensor + +from torchaudio._internal import load_state_dict_from_url +from torchaudio.models import wav2vec2_model, Wav2Vec2Model, wavlm_model + + +def _get_model(type_, params): + factories = { + "Wav2Vec2": wav2vec2_model, + "WavLM": wavlm_model, + } + if type_ not in factories: + raise ValueError(f"Supported model types are {tuple(factories.keys())}. Found: {type_}") + factory = factories[type_] + return factory(**params) + + +class _Wav2Vec2Model(nn.Module): + """Wrapper class for :py:class:`~torchaudio.models.Wav2Vec2Model`. + + This is used for layer normalization at the input + """ + + def __init__(self, model: Wav2Vec2Model, normalize_waveform: bool, apply_log_softmax: bool, append_star: bool): + super().__init__() + self.model = model + self.normalize_waveform = normalize_waveform + self.apply_log_softmax = apply_log_softmax + self.append_star = append_star + + def forward(self, waveforms: Tensor, lengths: Optional[Tensor] = None) -> Tuple[Tensor, Optional[Tensor]]: + if self.normalize_waveform: + waveforms = nn.functional.layer_norm(waveforms, waveforms.shape) + output, output_lengths = self.model(waveforms, lengths) + if self.apply_log_softmax: + output = torch.nn.functional.log_softmax(output, dim=-1) + if self.append_star: + star_dim = torch.zeros((1, output.size(1), 1), dtype=output.dtype, device=output.device) + output = torch.cat((output, star_dim), dim=-1) + return output, output_lengths + + @torch.jit.export + def extract_features( + self, + waveforms: Tensor, + lengths: Optional[Tensor] = None, + num_layers: Optional[int] = None, + ) -> Tuple[List[Tensor], Optional[Tensor]]: + if self.normalize_waveform: + waveforms = nn.functional.layer_norm(waveforms, waveforms.shape) + return self.model.extract_features(waveforms, lengths, num_layers) + + +def _extend_model(module, normalize_waveform, apply_log_softmax=False, append_star=False): + """Add extra transformations to the model""" + return _Wav2Vec2Model(module, normalize_waveform, apply_log_softmax, append_star) + + +def _remove_aux_axes(state_dict, axes): + # Remove the seemingly unnecessary axis + # For ASR task, the pretrained weights originated from fairseq has unrelated dimensions at index 1, 2, 3 + # It's originated from the Dictionary implementation of fairseq, which was intended for NLP tasks, + # but not used during the ASR training. + # https://github.com/pytorch/fairseq/blob/c5ff181125c7e6126b49a85e5ebdd5f5b6a07914/fairseq/data/dictionary.py#L21-L37 + # https://github.com/pytorch/fairseq/blob/c5ff181125c7e6126b49a85e5ebdd5f5b6a07914/fairseq/criterions/ctc.py#L126-L129 + # + # Also, some pretrained weights originated from voxpopuli has an extra dimensions that almost never used and + # that resembles mistake. + # The label `1` shows up in the training dataset of German (1 out of 16M), + # English (1 / 28M), Spanish (1 / 9.4M), Romanian (1 / 4.7M) and Polish (6 / 5.8M) + for key in ["aux.weight", "aux.bias"]: + mat = state_dict[key] + state_dict[key] = torch.stack([mat[i] for i in range(mat.size(0)) if i not in axes]) + + +def _get_state_dict(url, dl_kwargs, remove_axes=None): + if not url.startswith("https"): + url = f"https://download.pytorch.org/torchaudio/models/{url}" + dl_kwargs = {} if dl_kwargs is None else dl_kwargs + state_dict = load_state_dict_from_url(url, **dl_kwargs) + if remove_axes: + _remove_aux_axes(state_dict, remove_axes) + return state_dict + + +def _get_en_labels(): + return ( + "|", + "E", + "T", + "A", + "O", + "N", + "I", + "H", + "S", + "R", + "D", + "L", + "U", + "M", + "W", + "C", + "F", + "G", + "Y", + "P", + "B", + "V", + "K", + "'", + "X", + "J", + "Q", + "Z", + ) + + +def _get_de_labels(): + return ( + "|", + "e", + "n", + "i", + "r", + "s", + "t", + "a", + "d", + "h", + "u", + "l", + "g", + "c", + "m", + "o", + "b", + "w", + "f", + "k", + "z", + "p", + "v", + "ü", + "ä", + "ö", + "j", + "ß", + "y", + "x", + "q", + ) + + +def _get_vp_en_labels(): + return ( + "|", + "e", + "t", + "o", + "i", + "a", + "n", + "s", + "r", + "h", + "l", + "d", + "c", + "u", + "m", + "p", + "f", + "g", + "w", + "y", + "b", + "v", + "k", + "x", + "j", + "q", + "z", + ) + + +def _get_es_labels(): + return ( + "|", + "e", + "a", + "o", + "s", + "n", + "r", + "i", + "l", + "d", + "c", + "t", + "u", + "p", + "m", + "b", + "q", + "y", + "g", + "v", + "h", + "ó", + "f", + "í", + "á", + "j", + "z", + "ñ", + "é", + "x", + "ú", + "k", + "w", + "ü", + ) + + +def _get_fr_labels(): + return ( + "|", + "e", + "s", + "n", + "i", + "t", + "r", + "a", + "o", + "u", + "l", + "d", + "c", + "p", + "m", + "é", + "v", + "q", + "f", + "g", + "b", + "h", + "x", + "à", + "j", + "è", + "y", + "ê", + "z", + "ô", + "k", + "ç", + "œ", + "û", + "ù", + "î", + "â", + "w", + "ï", + "ë", + "ü", + "æ", + ) + + +def _get_it_labels(): + return ( + "|", + "e", + "i", + "a", + "o", + "n", + "t", + "r", + "l", + "s", + "c", + "d", + "u", + "p", + "m", + "g", + "v", + "h", + "z", + "f", + "b", + "q", + "à", + "è", + "ù", + "é", + "ò", + "ì", + "k", + "y", + "x", + "w", + "j", + "ó", + "í", + "ï", + ) + + +def _get_mms_labels(): + return ( + "a", + "i", + "e", + "n", + "o", + "u", + "t", + "s", + "r", + "m", + "k", + "l", + "d", + "g", + "h", + "y", + "b", + "p", + "w", + "c", + "v", + "j", + "z", + "f", + "'", + "q", + "x", + ) diff --git a/shared/package-files/43/43d4c47f73aec832316659a8cfd6b773e98332524ae98050f4a7189a2c0545b5/blob b/shared/package-files/43/43d4c47f73aec832316659a8cfd6b773e98332524ae98050f4a7189a2c0545b5/blob new file mode 100644 index 0000000000000000000000000000000000000000..b185f30f3a9a2978c1d4278b920f69969fe79b97 --- /dev/null +++ b/shared/package-files/43/43d4c47f73aec832316659a8cfd6b773e98332524ae98050f4a7189a2c0545b5/blob @@ -0,0 +1,13 @@ +from .otBase import BaseTTXConverter + + +class table_J_S_T_F_(BaseTTXConverter): + """Justification table + + The ``JSTF`` table contains glyph substitution and positioning + data used to perform text justification. + + See also https://learn.microsoft.com/en-us/typography/opentype/spec/jstf + """ + + pass diff --git a/shared/package-files/43/43d60df16d077753de7e51cbbcebd267e87178b5382aade75052d80c2d31d04f/blob b/shared/package-files/43/43d60df16d077753de7e51cbbcebd267e87178b5382aade75052d80c2d31d04f/blob new file mode 100644 index 0000000000000000000000000000000000000000..ae26fb0b2fa64e7f7318c51ce3fe5afaa276b48e --- /dev/null +++ b/shared/package-files/43/43d60df16d077753de7e51cbbcebd267e87178b5382aade75052d80c2d31d04f/blob @@ -0,0 +1,251 @@ +import pyglet.gl as pgl +from pyglet import font + +from sympy.core import S +from sympy.plotting.pygletplot.plot_object import PlotObject +from sympy.plotting.pygletplot.util import billboard_matrix, dot_product, \ + get_direction_vectors, strided_range, vec_mag, vec_sub +from sympy.utilities.iterables import is_sequence + + +class PlotAxes(PlotObject): + + def __init__(self, *args, + style='', none=None, frame=None, box=None, ordinate=None, + stride=0.25, + visible='', overlay='', colored='', label_axes='', label_ticks='', + tick_length=0.1, + font_face='Arial', font_size=28, + **kwargs): + # initialize style parameter + style = style.lower() + + # allow alias kwargs to override style kwarg + if none is not None: + style = 'none' + if frame is not None: + style = 'frame' + if box is not None: + style = 'box' + if ordinate is not None: + style = 'ordinate' + + if style in ['', 'ordinate']: + self._render_object = PlotAxesOrdinate(self) + elif style in ['frame', 'box']: + self._render_object = PlotAxesFrame(self) + elif style in ['none']: + self._render_object = None + else: + raise ValueError(("Unrecognized axes style %s.") % (style)) + + # initialize stride parameter + try: + stride = eval(stride) + except TypeError: + pass + if is_sequence(stride): + if len(stride) != 3: + raise ValueError("length should be equal to 3") + self._stride = stride + else: + self._stride = [stride, stride, stride] + self._tick_length = float(tick_length) + + # setup bounding box and ticks + self._origin = [0, 0, 0] + self.reset_bounding_box() + + def flexible_boolean(input, default): + if input in [True, False]: + return input + if input in ('f', 'F', 'false', 'False'): + return False + if input in ('t', 'T', 'true', 'True'): + return True + return default + + # initialize remaining parameters + self.visible = flexible_boolean(kwargs, True) + self._overlay = flexible_boolean(overlay, True) + self._colored = flexible_boolean(colored, False) + self._label_axes = flexible_boolean(label_axes, False) + self._label_ticks = flexible_boolean(label_ticks, True) + + # setup label font + self.font_face = font_face + self.font_size = font_size + + # this is also used to reinit the + # font on window close/reopen + self.reset_resources() + + def reset_resources(self): + self.label_font = None + + def reset_bounding_box(self): + self._bounding_box = [[None, None], [None, None], [None, None]] + self._axis_ticks = [[], [], []] + + def draw(self): + if self._render_object: + pgl.glPushAttrib(pgl.GL_ENABLE_BIT | pgl.GL_POLYGON_BIT | pgl.GL_DEPTH_BUFFER_BIT) + if self._overlay: + pgl.glDisable(pgl.GL_DEPTH_TEST) + self._render_object.draw() + pgl.glPopAttrib() + + def adjust_bounds(self, child_bounds): + b = self._bounding_box + c = child_bounds + for i in range(3): + if abs(c[i][0]) is S.Infinity or abs(c[i][1]) is S.Infinity: + continue + b[i][0] = c[i][0] if b[i][0] is None else min([b[i][0], c[i][0]]) + b[i][1] = c[i][1] if b[i][1] is None else max([b[i][1], c[i][1]]) + self._bounding_box = b + self._recalculate_axis_ticks(i) + + def _recalculate_axis_ticks(self, axis): + b = self._bounding_box + if b[axis][0] is None or b[axis][1] is None: + self._axis_ticks[axis] = [] + else: + self._axis_ticks[axis] = strided_range(b[axis][0], b[axis][1], + self._stride[axis]) + + def toggle_visible(self): + self.visible = not self.visible + + def toggle_colors(self): + self._colored = not self._colored + + +class PlotAxesBase(PlotObject): + + def __init__(self, parent_axes): + self._p = parent_axes + + def draw(self): + color = [([0.2, 0.1, 0.3], [0.2, 0.1, 0.3], [0.2, 0.1, 0.3]), + ([0.9, 0.3, 0.5], [0.5, 1.0, 0.5], [0.3, 0.3, 0.9])][self._p._colored] + self.draw_background(color) + self.draw_axis(2, color[2]) + self.draw_axis(1, color[1]) + self.draw_axis(0, color[0]) + + def draw_background(self, color): + pass # optional + + def draw_axis(self, axis, color): + raise NotImplementedError() + + def draw_text(self, text, position, color, scale=1.0): + if len(color) == 3: + color = (color[0], color[1], color[2], 1.0) + + if self._p.label_font is None: + self._p.label_font = font.load(self._p.font_face, + self._p.font_size, + bold=True, italic=False) + + label = font.Text(self._p.label_font, text, + color=color, + valign=font.Text.BASELINE, + halign=font.Text.CENTER) + + pgl.glPushMatrix() + pgl.glTranslatef(*position) + billboard_matrix() + scale_factor = 0.005 * scale + pgl.glScalef(scale_factor, scale_factor, scale_factor) + pgl.glColor4f(0, 0, 0, 0) + label.draw() + pgl.glPopMatrix() + + def draw_line(self, v, color): + o = self._p._origin + pgl.glBegin(pgl.GL_LINES) + pgl.glColor3f(*color) + pgl.glVertex3f(v[0][0] + o[0], v[0][1] + o[1], v[0][2] + o[2]) + pgl.glVertex3f(v[1][0] + o[0], v[1][1] + o[1], v[1][2] + o[2]) + pgl.glEnd() + + +class PlotAxesOrdinate(PlotAxesBase): + + def __init__(self, parent_axes): + super().__init__(parent_axes) + + def draw_axis(self, axis, color): + ticks = self._p._axis_ticks[axis] + radius = self._p._tick_length / 2.0 + if len(ticks) < 2: + return + + # calculate the vector for this axis + axis_lines = [[0, 0, 0], [0, 0, 0]] + axis_lines[0][axis], axis_lines[1][axis] = ticks[0], ticks[-1] + axis_vector = vec_sub(axis_lines[1], axis_lines[0]) + + # calculate angle to the z direction vector + pos_z = get_direction_vectors()[2] + d = abs(dot_product(axis_vector, pos_z)) + d = d / vec_mag(axis_vector) + + # don't draw labels if we're looking down the axis + labels_visible = abs(d - 1.0) > 0.02 + + # draw the ticks and labels + for tick in ticks: + self.draw_tick_line(axis, color, radius, tick, labels_visible) + + # draw the axis line and labels + self.draw_axis_line(axis, color, ticks[0], ticks[-1], labels_visible) + + def draw_axis_line(self, axis, color, a_min, a_max, labels_visible): + axis_line = [[0, 0, 0], [0, 0, 0]] + axis_line[0][axis], axis_line[1][axis] = a_min, a_max + self.draw_line(axis_line, color) + if labels_visible: + self.draw_axis_line_labels(axis, color, axis_line) + + def draw_axis_line_labels(self, axis, color, axis_line): + if not self._p._label_axes: + return + axis_labels = [axis_line[0][::], axis_line[1][::]] + axis_labels[0][axis] -= 0.3 + axis_labels[1][axis] += 0.3 + a_str = ['X', 'Y', 'Z'][axis] + self.draw_text("-" + a_str, axis_labels[0], color) + self.draw_text("+" + a_str, axis_labels[1], color) + + def draw_tick_line(self, axis, color, radius, tick, labels_visible): + tick_axis = {0: 1, 1: 0, 2: 1}[axis] + tick_line = [[0, 0, 0], [0, 0, 0]] + tick_line[0][axis] = tick_line[1][axis] = tick + tick_line[0][tick_axis], tick_line[1][tick_axis] = -radius, radius + self.draw_line(tick_line, color) + if labels_visible: + self.draw_tick_line_label(axis, color, radius, tick) + + def draw_tick_line_label(self, axis, color, radius, tick): + if not self._p._label_axes: + return + tick_label_vector = [0, 0, 0] + tick_label_vector[axis] = tick + tick_label_vector[{0: 1, 1: 0, 2: 1}[axis]] = [-1, 1, 1][ + axis] * radius * 3.5 + self.draw_text(str(tick), tick_label_vector, color, scale=0.5) + + +class PlotAxesFrame(PlotAxesBase): + + def __init__(self, parent_axes): + super().__init__(parent_axes) + + def draw_background(self, color): + pass + + def draw_axis(self, axis, color): + raise NotImplementedError() diff --git a/shared/package-files/43/43d8e6e85db3e0c0513ffc7a90b3574cb3847d64b5daf171845bafa9ad483bd5/blob b/shared/package-files/43/43d8e6e85db3e0c0513ffc7a90b3574cb3847d64b5daf171845bafa9ad483bd5/blob new file mode 100644 index 0000000000000000000000000000000000000000..c9eb2b66f3e0b2122639f6354dadf539819efc48 --- /dev/null +++ b/shared/package-files/43/43d8e6e85db3e0c0513ffc7a90b3574cb3847d64b5daf171845bafa9ad483bd5/blob @@ -0,0 +1,802 @@ +#pragma once + +#include +#include +#include +#include + +namespace torch { +namespace nn { + +/// Options for the `L1Loss` module. +/// +/// Example: +/// ``` +/// L1Loss model(L1LossOptions(torch::kNone)); +/// ``` +struct TORCH_API L1LossOptions { + typedef std::variant + reduction_t; + + TORCH_OPTIONS_CTOR_VARIANT_ARG3(L1LossOptions, reduction, kNone, kMean, kSum) + + /// Specifies the reduction to apply to the output. + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::l1_loss`. +/// +/// See the documentation for `torch::nn::L1LossOptions` class to learn what +/// arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::l1_loss(input, target, F::L1LossFuncOptions(torch::kNone)); +/// ``` +using L1LossFuncOptions = L1LossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `KLDivLoss` module. +/// +/// Example: +/// ``` +/// KLDivLoss +/// model(KLDivLossOptions().reduction(torch::kNone).log_target(false)); +/// ``` +struct TORCH_API KLDivLossOptions { + typedef std::variant< + enumtype::kNone, + enumtype::kBatchMean, + enumtype::kSum, + enumtype::kMean> + reduction_t; + + TORCH_OPTIONS_CTOR_VARIANT_ARG4( + KLDivLossOptions, + reduction, + kNone, + kBatchMean, + kSum, + kMean) + + /// Specifies the reduction to apply to the output. + /// ``'none'`` | ``'batchmean'`` | ``'sum'`` | ``'mean'``. Default: ``'mean'`` + TORCH_ARG(reduction_t, reduction) = torch::kMean; + + /// Specifies whether `target` is accepted in the log space. Default: False + TORCH_ARG(bool, log_target) = false; +}; + +namespace functional { +/// Options for `torch::nn::functional::kl_div`. +/// +/// See the documentation for `torch::nn::KLDivLossOptions` class to learn what +/// arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::kl_div(input, target, +/// F::KLDivFuncOptions().reduction(torch::kNone).log_target(false)); +/// ``` +using KLDivFuncOptions = KLDivLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `MSELoss` module. +/// +/// Example: +/// ``` +/// MSELoss model(MSELossOptions(torch::kNone)); +/// ``` +struct TORCH_API MSELossOptions { + typedef std::variant + reduction_t; + + TORCH_OPTIONS_CTOR_VARIANT_ARG3(MSELossOptions, reduction, kNone, kMean, kSum) + + /// Specifies the reduction to apply to the output. + /// ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'`` + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::mse_loss`. +/// +/// See the documentation for `torch::nn::MSELossOptions` class to learn what +/// arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::mse_loss(input, target, F::MSELossFuncOptions(torch::kNone)); +/// ``` +using MSELossFuncOptions = MSELossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `BCELoss` module. +/// +/// Example: +/// ``` +/// BCELoss model(BCELossOptions().reduction(torch::kNone).weight(weight)); +/// ``` +struct TORCH_API BCELossOptions { + typedef std::variant + reduction_t; + + /// A manual rescaling weight given to the loss of each batch element. + TORCH_ARG(Tensor, weight) = {}; + /// Specifies the reduction to apply to the output. + /// ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'`` + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::binary_cross_entropy`. +/// +/// See the documentation for `torch::nn::BCELossOptions` class to learn what +/// arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::binary_cross_entropy(input, target, +/// F::BinaryCrossEntropyFuncOptions().weight(weight)); +/// ``` +using BinaryCrossEntropyFuncOptions = BCELossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `HingeEmbeddingLoss` module. +/// +/// Example: +/// ``` +/// HingeEmbeddingLoss +/// model(HingeEmbeddingLossOptions().margin(4).reduction(torch::kNone)); +/// ``` +struct TORCH_API HingeEmbeddingLossOptions { + typedef std::variant + reduction_t; + + /// Specifies the threshold for which the distance of a negative sample must + /// reach in order to incur zero loss. Default: 1 + TORCH_ARG(double, margin) = 1.0; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::hinge_embedding_loss`. +/// +/// See the documentation for `torch::nn::HingeEmbeddingLossOptions` class to +/// learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::hinge_embedding_loss(input, target, +/// F::HingeEmbeddingLossFuncOptions().margin(2)); +/// ``` +using HingeEmbeddingLossFuncOptions = HingeEmbeddingLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `MultiMarginLoss` module. +/// +/// Example: +/// ``` +/// MultiMarginLoss model(MultiMarginLossOptions().margin(2).weight(weight)); +/// ``` +struct TORCH_API MultiMarginLossOptions { + typedef std::variant + reduction_t; + + /// Has a default value of :math:`1`. :math:`1` and :math:`2` + /// are the only supported values. + TORCH_ARG(int64_t, p) = 1; + /// Has a default value of :math:`1`. + TORCH_ARG(double, margin) = 1.0; + /// A manual rescaling weight given to each + /// class. If given, it has to be a Tensor of size `C`. Otherwise, it is + /// treated as if having all ones. + TORCH_ARG(Tensor, weight) = Tensor(); + /// Specifies the reduction to apply to the output: + /// ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be + /// applied, + /// ``'mean'``: the sum of the output will be divided by the number of + /// elements in the output, ``'sum'``: the output will be summed. Default: + /// ``'mean'`` + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::multi_margin_loss`. +/// +/// See the documentation for `torch::nn::MultiMarginLossOptions` class to learn +/// what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::multi_margin_loss(input, target, +/// F::MultiMarginLossFuncOptions().margin(2).weight(weight)); +/// ``` +using MultiMarginLossFuncOptions = MultiMarginLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `CosineEmbeddingLoss` module. +/// +/// Example: +/// ``` +/// CosineEmbeddingLoss model(CosineEmbeddingLossOptions().margin(0.5)); +/// ``` +struct TORCH_API CosineEmbeddingLossOptions { + typedef std::variant + reduction_t; + + /// Specifies the threshold for which the distance of a negative sample must + /// reach in order to incur zero loss. Should be a number from -1 to 1, 0 + /// to 0.5 is suggested. Default: 0.0 + TORCH_ARG(double, margin) = 0.0; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::cosine_embedding_loss`. +/// +/// See the documentation for `torch::nn::CosineEmbeddingLossOptions` class to +/// learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::cosine_embedding_loss(input1, input2, target, +/// F::CosineEmbeddingLossFuncOptions().margin(0.5)); +/// ``` +using CosineEmbeddingLossFuncOptions = CosineEmbeddingLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `MultiLabelMarginLoss` module. +/// +/// Example: +/// ``` +/// MultiLabelMarginLoss model(MultiLabelMarginLossOptions(torch::kNone)); +/// ``` +struct TORCH_API MultiLabelMarginLossOptions { + typedef std::variant + reduction_t; + + TORCH_OPTIONS_CTOR_VARIANT_ARG3( + MultiLabelMarginLossOptions, + reduction, + kNone, + kMean, + kSum) + + /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. + /// 'none': no reduction will be applied, 'mean': the sum of the output will + /// be divided by the number of elements in the output, 'sum': the output will + /// be summed. Default: 'mean' + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::multilabel_margin_loss`. +/// +/// See the documentation for `torch::nn::MultiLabelMarginLossOptions` class to +/// learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::multilabel_margin_loss(input, target, +/// F::MultilabelMarginLossFuncOptions(torch::kNone)); +/// ``` +using MultilabelMarginLossFuncOptions = MultiLabelMarginLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `SoftMarginLoss` module. +/// +/// Example: +/// ``` +/// SoftMarginLoss model(SoftMarginLossOptions(torch::kNone)); +/// ``` +struct TORCH_API SoftMarginLossOptions { + typedef std::variant + reduction_t; + + TORCH_OPTIONS_CTOR_VARIANT_ARG3( + SoftMarginLossOptions, + reduction, + kNone, + kMean, + kSum) + + /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. + /// 'none': no reduction will be applied, 'mean': the sum of the output will + /// be divided by the number of elements in the output, 'sum': the output will + /// be summed. Default: 'mean' + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::soft_margin_loss`. +/// +/// See the documentation for `torch::nn::SoftMarginLossOptions` class to learn +/// what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::soft_margin_loss(input, target, +/// F::SoftMarginLossFuncOptions(torch::kNone)); +/// ``` +using SoftMarginLossFuncOptions = SoftMarginLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `MultiLabelSoftMarginLoss` module. +/// +/// Example: +/// ``` +/// MultiLabelSoftMarginLoss +/// model(MultiLabelSoftMarginLossOptions().reduction(torch::kNone).weight(weight)); +/// ``` +struct TORCH_API MultiLabelSoftMarginLossOptions { + typedef std::variant + reduction_t; + + /// A manual rescaling weight given to each + /// class. If given, it has to be a Tensor of size `C`. Otherwise, it is + /// treated as if having all ones. + TORCH_ARG(Tensor, weight) = Tensor(); + + /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. + /// 'none': no reduction will be applied, 'mean': the sum of the output will + /// be divided by the number of elements in the output, 'sum': the output will + /// be summed. Default: 'mean' + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::multilabel_soft_margin_loss`. +/// +/// See the documentation for `torch::nn::MultiLabelSoftMarginLossOptions` class +/// to learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::multilabel_soft_margin_loss(input, target, +/// F::MultilabelSoftMarginLossFuncOptions().reduction(torch::kNone).weight(weight)); +/// ``` +using MultilabelSoftMarginLossFuncOptions = MultiLabelSoftMarginLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `TripletMarginLoss` module. +/// +/// Example: +/// ``` +/// TripletMarginLoss +/// model(TripletMarginLossOptions().margin(3).p(2).eps(1e-06).swap(false)); +/// ``` +struct TORCH_API TripletMarginLossOptions { + typedef std::variant + reduction_t; + + /// Specifies the threshold for which the distance of a negative sample must + /// reach in order to incur zero loss. Default: 1 + TORCH_ARG(double, margin) = 1.0; + /// Specifies the norm degree for pairwise distance. Default: 2 + TORCH_ARG(double, p) = 2.0; + TORCH_ARG(double, eps) = 1e-6; + /// The distance swap is described in detail in the paper Learning shallow + /// convolutional feature descriptors with triplet losses by V. Balntas, + /// E. Riba et al. Default: False + TORCH_ARG(bool, swap) = false; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::triplet_margin_loss`. +/// +/// See the documentation for `torch::nn::TripletMarginLossOptions` class to +/// learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::triplet_margin_loss(anchor, positive, negative, +/// F::TripletMarginLossFuncOptions().margin(1.0)); +/// ``` +using TripletMarginLossFuncOptions = TripletMarginLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `TripletMarginWithDistanceLoss` module. +/// +/// Example: +/// ``` +/// TripletMarginWithDistanceLoss +/// model(TripletMarginWithDistanceLossOptions().margin(3).swap(false)); +/// ``` +struct TORCH_API TripletMarginWithDistanceLossOptions { + typedef std::variant + reduction_t; + typedef std::function + distance_function_t; + + /// Specifies a nonnegative, real-valued function that quantifies the + /// closeness of two tensors. If not specified, `F::pairwise_distance` will + /// be used. Default: nullopt + TORCH_ARG(c10::optional, distance_function) = + c10::nullopt; + /// Specifies a nonnegative margin representing the minimum difference + /// between the positive and negative distances required for the loss to be 0. + /// Larger margins penalize cases where the negative examples are not distance + /// enough from the anchors, relative to the positives. Default: 1 + TORCH_ARG(double, margin) = 1.0; + /// Whether to use the distance swap described in the paper Learning shallow + /// convolutional feature descriptors with triplet losses by V. Balntas, + /// E. Riba et al. If True, and if the positive example is closer to the + /// negative example than the anchor is, swaps the positive example and the + /// anchor in the loss computation. Default: False + TORCH_ARG(bool, swap) = false; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::triplet_margin_with_distance_loss`. +/// +/// See the documentation for `torch::nn::TripletMarginWithDistanceLossOptions` +/// class to learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::triplet_margin_with_distance_loss(anchor, positive, negative, +/// F::TripletMarginWithDistanceLossFuncOptions().margin(1.0)); +/// ``` +using TripletMarginWithDistanceLossFuncOptions = + TripletMarginWithDistanceLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `CTCLoss` module. +/// +/// Example: +/// ``` +/// CTCLoss +/// model(CTCLossOptions().blank(42).zero_infinity(false).reduction(torch::kSum)); +/// ``` +struct TORCH_API CTCLossOptions { + typedef std::variant + reduction_t; + + /// blank label. Default `0`. + TORCH_ARG(int64_t, blank) = 0; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; + /// Whether to zero infinite losses and the associated gradients. + /// Default: `false`. Infinite losses mainly occur when the inputs are + /// too short to be aligned to the targets. + TORCH_ARG(bool, zero_infinity) = false; +}; + +namespace functional { +/// Options for `torch::nn::functional::ctc_loss`. +/// +/// See the documentation for `torch::nn::CTCLossOptions` class to learn what +/// arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::ctc_loss(log_probs, targets, input_lengths, target_lengths, +/// F::CTCLossFuncOptions().reduction(torch::kNone)); +/// ``` +using CTCLossFuncOptions = CTCLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `SmoothL1Loss` module. +/// +/// Example: +/// ``` +/// SmoothL1Loss model(SmoothL1LossOptions().reduction(torch::kNone).beta(0.5)); +/// ``` +struct TORCH_API SmoothL1LossOptions { + typedef std::variant + reduction_t; + + TORCH_OPTIONS_CTOR_VARIANT_ARG3( + SmoothL1LossOptions, + reduction, + kNone, + kMean, + kSum) + + /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. + /// 'none': no reduction will be applied, 'mean': the sum of the output will + /// be divided by the number of elements in the output, 'sum': the output will + /// be summed. Default: 'mean' + TORCH_ARG(reduction_t, reduction) = torch::kMean; + /// Specifies the threshold at which to change between L1 and L2 loss. + /// If beta is not specified, a value of 1.0 will be used. + /// Default: nullopt + TORCH_ARG(c10::optional, beta) = c10::nullopt; +}; + +namespace functional { +/// Options for `torch::nn::functional::smooth_l1_loss`. +/// +/// See the documentation for `torch::nn::SmoothL1LossOptions` class to learn +/// what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::smooth_l1_loss(input, target, F::SmoothL1LossFuncOptions(torch::kNone)); +/// ``` +using SmoothL1LossFuncOptions = SmoothL1LossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `HuberLoss` module. +/// +/// Example: +/// ``` +/// HuberLoss model(HuberLossOptions().reduction(torch::kNone).delta(0.5)); +/// ``` +struct TORCH_API HuberLossOptions { + typedef std::variant + reduction_t; + + TORCH_OPTIONS_CTOR_VARIANT_ARG3( + HuberLossOptions, + reduction, + kNone, + kMean, + kSum) + + /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. + /// 'none': no reduction will be applied, 'mean': the sum of the output will + /// be divided by the number of elements in the output, 'sum': the output will + /// be summed. Default: 'mean' + TORCH_ARG(reduction_t, reduction) = torch::kMean; + /// Specifies the threshold at which to change between L1 and L2 loss. + /// Default: 1.0 + TORCH_ARG(double, delta) = 1.0; +}; + +namespace functional { +/// Options for `torch::nn::functional::huber_loss`. +/// +/// See the documentation for `torch::nn::HuberLossOptions` class to learn what +/// arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::huber_loss(input, target, F::HuberLossFuncOptions(torch::kNone)); +/// ``` +using HuberLossFuncOptions = HuberLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `PoissonNLLLoss` module. +/// +/// Example: +/// ``` +/// PoissonNLLLoss +/// model(PoissonNLLLossOptions().log_input(false).full(true).eps(0.42).reduction(torch::kSum)); +/// ``` +struct TORCH_API PoissonNLLLossOptions { + typedef std::variant + reduction_t; + + /// if true the loss is computed as `exp(input) - target * input`, + /// if false the loss is `input - target * log(input + eps)`. + TORCH_ARG(bool, log_input) = true; + /// whether to compute full loss, i.e. to add the Stirling approximation term + /// target * log(target) - target + 0.5 * log(2 * pi * target). + TORCH_ARG(bool, full) = false; + /// Small value to avoid evaluation of `log(0)` when `log_input = false`. + /// Default: 1e-8 + TORCH_ARG(double, eps) = 1e-8; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::poisson_nll_loss`. +/// +/// See the documentation for `torch::nn::PoissonNLLLossOptions` class to learn +/// what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::poisson_nll_loss(input, target, +/// F::PoissonNLLLossFuncOptions().reduction(torch::kNone)); +/// ``` +using PoissonNLLLossFuncOptions = PoissonNLLLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `MarginRankingLoss` module. +/// +/// Example: +/// ``` +/// MarginRankingLoss +/// model(MarginRankingLossOptions().margin(0.5).reduction(torch::kSum)); +/// ``` +struct TORCH_API MarginRankingLossOptions { + typedef std::variant + reduction_t; + + /// Has a default value of `0`. + TORCH_ARG(double, margin) = 0; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::margin_ranking_loss`. +/// +/// See the documentation for `torch::nn::MarginRankingLossOptions` class to +/// learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::margin_ranking_loss(input1, input2, target, +/// F::MarginRankingLossFuncOptions().margin(0.5).reduction(torch::kSum)); +/// ``` +using MarginRankingLossFuncOptions = MarginRankingLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `NLLLoss` module. +/// +/// Example: +/// ``` +/// NLLLoss model(NLLLossOptions().ignore_index(-100).reduction(torch::kMean)); +/// ``` +struct TORCH_API NLLLossOptions { + typedef std::variant + reduction_t; + + /// A manual rescaling weight given to each + /// class. If given, it has to be a Tensor of size `C`. Otherwise, it is + /// treated as if having all ones. + TORCH_ARG(Tensor, weight) = {}; + /// Specifies a target value that is ignored + /// and does not contribute to the input gradient. + TORCH_ARG(int64_t, ignore_index) = -100; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; +}; + +namespace functional { +/// Options for `torch::nn::functional::nll_loss`. +/// +/// See the documentation for `torch::nn::NLLLossOptions` class to learn what +/// arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::nll_loss(input, target, +/// F::NLLLossFuncOptions().ignore_index(-100).reduction(torch::kMean)); +/// ``` +using NLLLossFuncOptions = NLLLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `CrossEntropyLoss` module. +/// +/// Example: +/// ``` +/// CrossEntropyLoss +/// model(CrossEntropyLossOptions().ignore_index(-100).reduction(torch::kMean)); +/// ``` +struct TORCH_API CrossEntropyLossOptions { + typedef std::variant + reduction_t; + + /// A manual rescaling weight given to each class. If given, has to be a + /// Tensor of size C + TORCH_ARG(Tensor, weight) = {}; + /// Specifies a target value that is ignored + /// and does not contribute to the input gradient. + TORCH_ARG(int64_t, ignore_index) = -100; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; + /// Specifies the amount of smoothing when computing the loss. Default: 0.0 + TORCH_ARG(double, label_smoothing) = 0.0; +}; + +namespace functional { +/// Options for `torch::nn::functional::cross_entropy`. +/// +/// See the documentation for `torch::nn::CrossEntropyLossOptions` class to +/// learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::cross_entropy(input, target, +/// F::CrossEntropyFuncOptions().ignore_index(-100).reduction(torch::kMean)); +/// ``` +using CrossEntropyFuncOptions = CrossEntropyLossOptions; +} // namespace functional + +// ============================================================================ + +/// Options for the `BCEWithLogitsLoss` module. +/// +/// Example: +/// ``` +/// BCEWithLogitsLoss +/// model(BCEWithLogitsLossOptions().reduction(torch::kNone).weight(weight)); +/// ``` +struct TORCH_API BCEWithLogitsLossOptions { + typedef std::variant + reduction_t; + /// A manual rescaling weight given to the loss of each batch element. + /// If given, has to be a Tensor of size `nbatch`. + TORCH_ARG(Tensor, weight) = {}; + /// Specifies the reduction to apply to the output. Default: Mean + TORCH_ARG(reduction_t, reduction) = torch::kMean; + /// A weight of positive examples. + /// Must be a vector with length equal to the number of classes. + TORCH_ARG(Tensor, pos_weight) = {}; +}; + +namespace functional { +/// Options for `torch::nn::functional::binary_cross_entropy_with_logits`. +/// +/// See the documentation for `torch::nn::BCEWithLogitsLossOptions` class to +/// learn what arguments are supported. +/// +/// Example: +/// ``` +/// namespace F = torch::nn::functional; +/// F::binary_cross_entropy_with_logits(input, target, +/// F::BinaryCrossEntropyWithLogitsFuncOptions().pos_weight(pos_weight).reduction(torch::kSum)); +/// ``` +using BinaryCrossEntropyWithLogitsFuncOptions = BCEWithLogitsLossOptions; +} // namespace functional + +} // namespace nn +} // namespace torch diff --git a/shared/package-files/43/43dae39173eb53df978bae3f7cc2cf6c16d6fdbca18c916cbc7a693f50ae99d0/blob b/shared/package-files/43/43dae39173eb53df978bae3f7cc2cf6c16d6fdbca18c916cbc7a693f50ae99d0/blob new file mode 100644 index 0000000000000000000000000000000000000000..88ec2fd2d0679b5c849549179aa652bec9b37b56 --- /dev/null +++ b/shared/package-files/43/43dae39173eb53df978bae3f7cc2cf6c16d6fdbca18c916cbc7a693f50ae99d0/blob @@ -0,0 +1,81 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// NOTE: API is EXPERIMENTAL and will change without going through a +// deprecation cycle. + +#pragma once + +#include "arrow/compute/type_fwd.h" +#include "arrow/result.h" +#include "arrow/status.h" +#include "arrow/type_fwd.h" +#include "arrow/util/visibility.h" + +namespace arrow { +namespace compute { + +/// \addtogroup compute-functions +/// @{ + +/// \brief Extension point for defining options outside libarrow (but +/// still within this project). +class ARROW_EXPORT FunctionOptionsType { + public: + virtual ~FunctionOptionsType() = default; + + virtual const char* type_name() const = 0; + virtual std::string Stringify(const FunctionOptions&) const = 0; + virtual bool Compare(const FunctionOptions&, const FunctionOptions&) const = 0; + virtual Result> Serialize(const FunctionOptions&) const; + virtual Result> Deserialize( + const Buffer& buffer) const; + virtual std::unique_ptr Copy(const FunctionOptions&) const = 0; +}; + +/// \brief Base class for specifying options configuring a function's behavior, +/// such as error handling. +class ARROW_EXPORT FunctionOptions : public util::EqualityComparable { + public: + virtual ~FunctionOptions() = default; + + const FunctionOptionsType* options_type() const { return options_type_; } + const char* type_name() const { return options_type()->type_name(); } + + bool Equals(const FunctionOptions& other) const; + std::string ToString() const; + std::unique_ptr Copy() const; + /// \brief Serialize an options struct to a buffer. + Result> Serialize() const; + /// \brief Deserialize an options struct from a buffer. + /// Note: this will only look for `type_name` in the default FunctionRegistry; + /// to use a custom FunctionRegistry, look up the FunctionOptionsType, then + /// call FunctionOptionsType::Deserialize(). + static Result> Deserialize( + const std::string& type_name, const Buffer& buffer); + + protected: + explicit FunctionOptions(const FunctionOptionsType* type) : options_type_(type) {} + const FunctionOptionsType* options_type_; +}; + +ARROW_EXPORT void PrintTo(const FunctionOptions&, std::ostream*); + +/// @} + +} // namespace compute +} // namespace arrow diff --git a/shared/package-files/43/43dbea555ad0a6958bbc6786013ae7ebafff2f2cc1c85c60590d2668d5296209/blob b/shared/package-files/43/43dbea555ad0a6958bbc6786013ae7ebafff2f2cc1c85c60590d2668d5296209/blob new file mode 100644 index 0000000000000000000000000000000000000000..ce9bbc1d4939649495995a695c9a2d64b64a69a5 --- /dev/null +++ b/shared/package-files/43/43dbea555ad0a6958bbc6786013ae7ebafff2f2cc1c85c60590d2668d5296209/blob @@ -0,0 +1,103 @@ +import os +import sys +from _typeshed import OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode +from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper +from types import TracebackType +from typing import IO, Any, BinaryIO, Generator, List, Optional, Sequence, Text, TextIO, Tuple, Type, TypeVar, Union, overload +from typing_extensions import Literal + +_P = TypeVar("_P", bound=PurePath) + +_PurePathBase = object +_PathLike = PurePath + +class PurePath(_PurePathBase): + parts: Tuple[str, ...] + drive: str + root: str + anchor: str + name: str + suffix: str + suffixes: List[str] + stem: str + def __new__(cls: Type[_P], *args: Union[str, _PathLike]) -> _P: ... + def __hash__(self) -> int: ... + def __lt__(self, other: PurePath) -> bool: ... + def __le__(self, other: PurePath) -> bool: ... + def __gt__(self, other: PurePath) -> bool: ... + def __ge__(self, other: PurePath) -> bool: ... + def __truediv__(self: _P, key: Union[str, _PathLike]) -> _P: ... + def __rtruediv__(self: _P, key: Union[str, _PathLike]) -> _P: ... + def __div__(self: _P, key: Union[str, PurePath]) -> _P: ... + def __bytes__(self) -> bytes: ... + def as_posix(self) -> str: ... + def as_uri(self) -> str: ... + def is_absolute(self) -> bool: ... + def is_reserved(self) -> bool: ... + def match(self, path_pattern: str) -> bool: ... + def relative_to(self: _P, *other: Union[str, _PathLike]) -> _P: ... + def with_name(self: _P, name: str) -> _P: ... + def with_suffix(self: _P, suffix: str) -> _P: ... + def joinpath(self: _P, *other: Union[str, _PathLike]) -> _P: ... + @property + def parents(self: _P) -> Sequence[_P]: ... + @property + def parent(self: _P) -> _P: ... + +class PurePosixPath(PurePath): ... +class PureWindowsPath(PurePath): ... + +class Path(PurePath): + def __new__(cls: Type[_P], *args: Union[str, _PathLike], **kwargs: Any) -> _P: ... + def __enter__(self) -> Path: ... + def __exit__( + self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType] + ) -> Optional[bool]: ... + @classmethod + def cwd(cls: Type[_P]) -> _P: ... + def stat(self) -> os.stat_result: ... + def chmod(self, mode: int) -> None: ... + def exists(self) -> bool: ... + def glob(self, pattern: str) -> Generator[Path, None, None]: ... + def group(self) -> str: ... + def is_dir(self) -> bool: ... + def is_file(self) -> bool: ... + def is_symlink(self) -> bool: ... + def is_socket(self) -> bool: ... + def is_fifo(self) -> bool: ... + def is_block_device(self) -> bool: ... + def is_char_device(self) -> bool: ... + def iterdir(self) -> Generator[Path, None, None]: ... + def lchmod(self, mode: int) -> None: ... + def lstat(self) -> os.stat_result: ... + def mkdir(self, mode: int = ..., parents: bool = ...) -> None: ... + # Adapted from _io.open + def open( + self, + mode: Text = ..., + buffering: int = ..., + encoding: Optional[Text] = ..., + errors: Optional[Text] = ..., + newline: Optional[Text] = ..., + ) -> IO[Any]: ... + def owner(self) -> str: ... + def rename(self, target: Union[str, PurePath]) -> None: ... + def replace(self, target: Union[str, PurePath]) -> None: ... + def resolve(self: _P) -> _P: ... + def rglob(self, pattern: str) -> Generator[Path, None, None]: ... + def rmdir(self) -> None: ... + def symlink_to(self, target: Union[str, Path], target_is_directory: bool = ...) -> None: ... + def touch(self, mode: int = ..., exist_ok: bool = ...) -> None: ... + def unlink(self) -> None: ... + @classmethod + def home(cls: Type[_P]) -> _P: ... + def absolute(self: _P) -> _P: ... + def expanduser(self: _P) -> _P: ... + def read_bytes(self) -> bytes: ... + def read_text(self, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ... + def samefile(self, other_path: Union[str, bytes, int, Path]) -> bool: ... + def write_bytes(self, data: bytes) -> int: ... + def write_text(self, data: str, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> int: ... + +class PosixPath(Path, PurePosixPath): ... +class WindowsPath(Path, PureWindowsPath): ... diff --git a/shared/package-files/43/43e17f87077c285a2471f6955ceb303965d58dd223890444a1044b691c65f5d6/blob b/shared/package-files/43/43e17f87077c285a2471f6955ceb303965d58dd223890444a1044b691c65f5d6/blob new file mode 100644 index 0000000000000000000000000000000000000000..13b2d872392b9941de18ebfce519e330960fcd22 --- /dev/null +++ b/shared/package-files/43/43e17f87077c285a2471f6955ceb303965d58dd223890444a1044b691c65f5d6/blob @@ -0,0 +1,93 @@ +from cython cimport floating + +cdef inline void dual_swap( + floating* darr, + intp_t *iarr, + intp_t a, + intp_t b, +) noexcept nogil: + """Swap the values at index a and b of both darr and iarr""" + cdef floating dtmp = darr[a] + darr[a] = darr[b] + darr[b] = dtmp + + cdef intp_t itmp = iarr[a] + iarr[a] = iarr[b] + iarr[b] = itmp + + +cdef int simultaneous_sort( + floating* values, + intp_t* indices, + intp_t size, +) noexcept nogil: + """ + Perform a recursive quicksort on the values array as to sort them ascendingly. + This simultaneously performs the swaps on both the values and the indices arrays. + + The numpy equivalent is: + + def simultaneous_sort(dist, idx): + i = np.argsort(dist) + return dist[i], idx[i] + + Notes + ----- + Arrays are manipulated via a pointer to there first element and their size + as to ease the processing of dynamically allocated buffers. + """ + # TODO: In order to support discrete distance metrics, we need to have a + # simultaneous sort which breaks ties on indices when distances are identical. + # The best might be using a std::stable_sort and a Comparator which might need + # an Array of Structures (AoS) instead of the Structure of Arrays (SoA) + # currently used. + cdef: + intp_t pivot_idx, i, store_idx + floating pivot_val + + # in the small-array case, do things efficiently + if size <= 1: + pass + elif size == 2: + if values[0] > values[1]: + dual_swap(values, indices, 0, 1) + elif size == 3: + if values[0] > values[1]: + dual_swap(values, indices, 0, 1) + if values[1] > values[2]: + dual_swap(values, indices, 1, 2) + if values[0] > values[1]: + dual_swap(values, indices, 0, 1) + else: + # Determine the pivot using the median-of-three rule. + # The smallest of the three is moved to the beginning of the array, + # the middle (the pivot value) is moved to the end, and the largest + # is moved to the pivot index. + pivot_idx = size // 2 + if values[0] > values[size - 1]: + dual_swap(values, indices, 0, size - 1) + if values[size - 1] > values[pivot_idx]: + dual_swap(values, indices, size - 1, pivot_idx) + if values[0] > values[size - 1]: + dual_swap(values, indices, 0, size - 1) + pivot_val = values[size - 1] + + # Partition indices about pivot. At the end of this operation, + # pivot_idx will contain the pivot value, everything to the left + # will be smaller, and everything to the right will be larger. + store_idx = 0 + for i in range(size - 1): + if values[i] < pivot_val: + dual_swap(values, indices, i, store_idx) + store_idx += 1 + dual_swap(values, indices, store_idx, size - 1) + pivot_idx = store_idx + + # Recursively sort each side of the pivot + if pivot_idx > 1: + simultaneous_sort(values, indices, pivot_idx) + if pivot_idx + 2 < size: + simultaneous_sort(values + pivot_idx + 1, + indices + pivot_idx + 1, + size - pivot_idx - 1) + return 0 diff --git a/shared/package-files/43/43e19ff39348bdd02d539d999207fbf2b5473e583ce71c8c7bd666f726e1d29a/blob b/shared/package-files/43/43e19ff39348bdd02d539d999207fbf2b5473e583ce71c8c7bd666f726e1d29a/blob new file mode 100644 index 0000000000000000000000000000000000000000..25a63ec8b9951c94fc00a8c6c9d18d2151b26dde Binary files /dev/null and b/shared/package-files/43/43e19ff39348bdd02d539d999207fbf2b5473e583ce71c8c7bd666f726e1d29a/blob differ diff --git a/shared/package-files/43/43e22c222c617ca31b0170fbb2ebb8250c02807d8801c4eaa46a4b94e380b1ab/blob b/shared/package-files/43/43e22c222c617ca31b0170fbb2ebb8250c02807d8801c4eaa46a4b94e380b1ab/blob new file mode 100644 index 0000000000000000000000000000000000000000..d85ac363c80dd169c26634ff8d14b2d5e4db72fb --- /dev/null +++ b/shared/package-files/43/43e22c222c617ca31b0170fbb2ebb8250c02807d8801c4eaa46a4b94e380b1ab/blob @@ -0,0 +1,31 @@ +import numpy as np +import pytest + +from statsmodels.datasets import randhie +from statsmodels.graphics.correlation import plot_corr, plot_corr_grid + + +@pytest.mark.thread_unsafe(reason="Uses matplotlib") +@pytest.mark.matplotlib +def test_plot_corr(close_figures): + hie_data = randhie.load_pandas() + corr_matrix = np.corrcoef(hie_data.data.values.T) + + plot_corr(corr_matrix, xnames=hie_data.names) + + plot_corr(corr_matrix, xnames=[], ynames=hie_data.names) + + plot_corr(corr_matrix, normcolor=True, title="", cmap="jet") + + +@pytest.mark.thread_unsafe(reason="Uses matplotlib") +@pytest.mark.matplotlib +def test_plot_corr_grid(close_figures): + hie_data = randhie.load_pandas() + corr_matrix = np.corrcoef(hie_data.data.values.T) + + plot_corr_grid([corr_matrix] * 2, xnames=hie_data.names) + + plot_corr_grid([corr_matrix] * 5, xnames=[], ynames=hie_data.names) + + plot_corr_grid([corr_matrix] * 3, normcolor=True, titles="", cmap="jet") diff --git a/shared/package-files/43/43e2bc3fd746cfd7e68cca4a9d8c4f226d2008a826fc479144ba2b18a06e593b/blob b/shared/package-files/43/43e2bc3fd746cfd7e68cca4a9d8c4f226d2008a826fc479144ba2b18a06e593b/blob new file mode 100644 index 0000000000000000000000000000000000000000..223a5b7b7ca57675dd0563425a448680acdccb68 --- /dev/null +++ b/shared/package-files/43/43e2bc3fd746cfd7e68cca4a9d8c4f226d2008a826fc479144ba2b18a06e593b/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & softmax_out(at::Tensor & out, const at::Tensor & self, int64_t dim, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor & softmax_outf(const at::Tensor & self, int64_t dim, c10::optional dtype, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/43/43eb1f8ad5620a6dfea104151d60f08ca2a26b566e517eb4efd7069afde2de85/blob b/shared/package-files/43/43eb1f8ad5620a6dfea104151d60f08ca2a26b566e517eb4efd7069afde2de85/blob new file mode 100644 index 0000000000000000000000000000000000000000..8fbb78737474c8abf34b8720603e32f6a93d83e7 --- /dev/null +++ b/shared/package-files/43/43eb1f8ad5620a6dfea104151d60f08ca2a26b566e517eb4efd7069afde2de85/blob @@ -0,0 +1,276 @@ +""" +Tests for statistical reductions of 2nd moment or higher: var, skew, kurt, ... +""" +import inspect + +import numpy as np +import pytest + +import pandas as pd +from pandas import ( + DataFrame, + Series, + date_range, +) +import pandas._testing as tm + + +class TestDatetimeLikeStatReductions: + @pytest.mark.parametrize("box", [Series, pd.Index, pd.array]) + def test_dt64_mean(self, tz_naive_fixture, box): + tz = tz_naive_fixture + + dti = date_range("2001-01-01", periods=11, tz=tz) + # shuffle so that we are not just working with monotone-increasing + dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6]) + dtarr = dti._data + + obj = box(dtarr) + assert obj.mean() == pd.Timestamp("2001-01-06", tz=tz) + assert obj.mean(skipna=False) == pd.Timestamp("2001-01-06", tz=tz) + + # dtarr[-2] will be the first date 2001-01-1 + dtarr[-2] = pd.NaT + + obj = box(dtarr) + assert obj.mean() == pd.Timestamp("2001-01-06 07:12:00", tz=tz) + assert obj.mean(skipna=False) is pd.NaT + + @pytest.mark.parametrize("box", [Series, pd.Index, pd.array]) + @pytest.mark.parametrize("freq", ["s", "h", "D", "W", "B"]) + def test_period_mean(self, box, freq): + # GH#24757 + dti = date_range("2001-01-01", periods=11) + # shuffle so that we are not just working with monotone-increasing + dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6]) + + warn = FutureWarning if freq == "B" else None + msg = r"PeriodDtype\[B\] is deprecated" + with tm.assert_produces_warning(warn, match=msg): + parr = dti._data.to_period(freq) + obj = box(parr) + with pytest.raises(TypeError, match="ambiguous"): + obj.mean() + with pytest.raises(TypeError, match="ambiguous"): + obj.mean(skipna=True) + + # parr[-2] will be the first date 2001-01-1 + parr[-2] = pd.NaT + + with pytest.raises(TypeError, match="ambiguous"): + obj.mean() + with pytest.raises(TypeError, match="ambiguous"): + obj.mean(skipna=True) + + @pytest.mark.parametrize("box", [Series, pd.Index, pd.array]) + def test_td64_mean(self, box): + m8values = np.array([0, 3, -2, -7, 1, 2, -1, 3, 5, -2, 4], "m8[D]") + tdi = pd.TimedeltaIndex(m8values).as_unit("ns") + + tdarr = tdi._data + obj = box(tdarr, copy=False) + + result = obj.mean() + expected = np.array(tdarr).mean() + assert result == expected + + tdarr[0] = pd.NaT + assert obj.mean(skipna=False) is pd.NaT + + result2 = obj.mean(skipna=True) + assert result2 == tdi[1:].mean() + + # exact equality fails by 1 nanosecond + assert result2.round("us") == (result * 11.0 / 10).round("us") + + +class TestSeriesStatReductions: + # Note: the name TestSeriesStatReductions indicates these tests + # were moved from a series-specific test file, _not_ that these tests are + # intended long-term to be series-specific + + def _check_stat_op( + self, name, alternate, string_series_, check_objects=False, check_allna=False + ): + with pd.option_context("use_bottleneck", False): + f = getattr(Series, name) + + # add some NaNs + string_series_[5:15] = np.nan + + # mean, idxmax, idxmin, min, and max are valid for dates + if name not in ["max", "min", "mean", "median", "std"]: + ds = Series(date_range("1/1/2001", periods=10)) + msg = f"does not support reduction '{name}'" + with pytest.raises(TypeError, match=msg): + f(ds) + + # skipna or no + assert pd.notna(f(string_series_)) + assert pd.isna(f(string_series_, skipna=False)) + + # check the result is correct + nona = string_series_.dropna() + tm.assert_almost_equal(f(nona), alternate(nona.values)) + tm.assert_almost_equal(f(string_series_), alternate(nona.values)) + + allna = string_series_ * np.nan + + if check_allna: + assert np.isnan(f(allna)) + + # dtype=object with None, it works! + s = Series([1, 2, 3, None, 5]) + f(s) + + # GH#2888 + items = [0] + items.extend(range(2**40, 2**40 + 1000)) + s = Series(items, dtype="int64") + tm.assert_almost_equal(float(f(s)), float(alternate(s.values))) + + # check date range + if check_objects: + s = Series(pd.bdate_range("1/1/2000", periods=10)) + res = f(s) + exp = alternate(s) + assert res == exp + + # check on string data + if name not in ["sum", "min", "max"]: + with pytest.raises(TypeError, match=None): + f(Series(list("abc"))) + + # Invalid axis. + msg = "No axis named 1 for object type Series" + with pytest.raises(ValueError, match=msg): + f(string_series_, axis=1) + + if "numeric_only" in inspect.getfullargspec(f).args: + # only the index is string; dtype is float + f(string_series_, numeric_only=True) + + def test_sum(self): + string_series = Series(range(20), dtype=np.float64, name="series") + self._check_stat_op("sum", np.sum, string_series, check_allna=False) + + def test_mean(self): + string_series = Series(range(20), dtype=np.float64, name="series") + self._check_stat_op("mean", np.mean, string_series) + + def test_median(self): + string_series = Series(range(20), dtype=np.float64, name="series") + self._check_stat_op("median", np.median, string_series) + + # test with integers, test failure + int_ts = Series(np.ones(10, dtype=int), index=range(10)) + tm.assert_almost_equal(np.median(int_ts), int_ts.median()) + + def test_prod(self): + string_series = Series(range(20), dtype=np.float64, name="series") + self._check_stat_op("prod", np.prod, string_series) + + def test_min(self): + string_series = Series(range(20), dtype=np.float64, name="series") + self._check_stat_op("min", np.min, string_series, check_objects=True) + + def test_max(self): + string_series = Series(range(20), dtype=np.float64, name="series") + self._check_stat_op("max", np.max, string_series, check_objects=True) + + def test_var_std(self): + string_series = Series(range(20), dtype=np.float64, name="series") + datetime_series = Series( + np.arange(10, dtype=np.float64), + index=date_range("2020-01-01", periods=10), + name="ts", + ) + + alt = lambda x: np.std(x, ddof=1) + self._check_stat_op("std", alt, string_series) + + alt = lambda x: np.var(x, ddof=1) + self._check_stat_op("var", alt, string_series) + + result = datetime_series.std(ddof=4) + expected = np.std(datetime_series.values, ddof=4) + tm.assert_almost_equal(result, expected) + + result = datetime_series.var(ddof=4) + expected = np.var(datetime_series.values, ddof=4) + tm.assert_almost_equal(result, expected) + + # 1 - element series with ddof=1 + s = datetime_series.iloc[[0]] + result = s.var(ddof=1) + assert pd.isna(result) + + result = s.std(ddof=1) + assert pd.isna(result) + + def test_sem(self): + string_series = Series(range(20), dtype=np.float64, name="series") + datetime_series = Series( + np.arange(10, dtype=np.float64), + index=date_range("2020-01-01", periods=10), + name="ts", + ) + + alt = lambda x: np.std(x, ddof=1) / np.sqrt(len(x)) + self._check_stat_op("sem", alt, string_series) + + result = datetime_series.sem(ddof=4) + expected = np.std(datetime_series.values, ddof=4) / np.sqrt( + len(datetime_series.values) + ) + tm.assert_almost_equal(result, expected) + + # 1 - element series with ddof=1 + s = datetime_series.iloc[[0]] + result = s.sem(ddof=1) + assert pd.isna(result) + + def test_skew(self): + sp_stats = pytest.importorskip("scipy.stats") + + string_series = Series(range(20), dtype=np.float64, name="series") + + alt = lambda x: sp_stats.skew(x, bias=False) + self._check_stat_op("skew", alt, string_series) + + # test corner cases, skew() returns NaN unless there's at least 3 + # values + min_N = 3 + for i in range(1, min_N + 1): + s = Series(np.ones(i)) + df = DataFrame(np.ones((i, i))) + if i < min_N: + assert np.isnan(s.skew()) + assert np.isnan(df.skew()).all() + else: + assert 0 == s.skew() + assert isinstance(s.skew(), np.float64) # GH53482 + assert (df.skew() == 0).all() + + def test_kurt(self): + sp_stats = pytest.importorskip("scipy.stats") + + string_series = Series(range(20), dtype=np.float64, name="series") + + alt = lambda x: sp_stats.kurtosis(x, bias=False) + self._check_stat_op("kurt", alt, string_series) + + def test_kurt_corner(self): + # test corner cases, kurt() returns NaN unless there's at least 4 + # values + min_N = 4 + for i in range(1, min_N + 1): + s = Series(np.ones(i)) + df = DataFrame(np.ones((i, i))) + if i < min_N: + assert np.isnan(s.kurt()) + assert np.isnan(df.kurt()).all() + else: + assert 0 == s.kurt() + assert isinstance(s.kurt(), np.float64) # GH53482 + assert (df.kurt() == 0).all() diff --git a/shared/package-files/43/43f3271c8292301bc8bc0e83a4c36472c412bfc694f438af527d66940ffdcc4b/blob b/shared/package-files/43/43f3271c8292301bc8bc0e83a4c36472c412bfc694f438af527d66940ffdcc4b/blob new file mode 100644 index 0000000000000000000000000000000000000000..b2d463a8c6c26f62ded5a06283f29275612c9b40 --- /dev/null +++ b/shared/package-files/43/43f3271c8292301bc8bc0e83a4c36472c412bfc694f438af527d66940ffdcc4b/blob @@ -0,0 +1,598 @@ +from __future__ import annotations + +from typing import ( + TYPE_CHECKING, + cast, +) +import warnings + +import numpy as np + +from pandas._libs import ( + NaT, + algos as libalgos, + internals as libinternals, + lib, +) +from pandas._libs.missing import NA +from pandas.util._decorators import cache_readonly +from pandas.util._exceptions import find_stack_level + +from pandas.core.dtypes.cast import ( + ensure_dtype_can_hold_na, + find_common_type, +) +from pandas.core.dtypes.common import ( + is_1d_only_ea_dtype, + is_scalar, + needs_i8_conversion, +) +from pandas.core.dtypes.concat import concat_compat +from pandas.core.dtypes.dtypes import ( + ExtensionDtype, + SparseDtype, +) +from pandas.core.dtypes.missing import ( + is_valid_na_for_dtype, + isna, + isna_all, +) + +from pandas.core.construction import ensure_wrapped_if_datetimelike +from pandas.core.internals.array_manager import ArrayManager +from pandas.core.internals.blocks import ( + ensure_block_shape, + new_block_2d, +) +from pandas.core.internals.managers import ( + BlockManager, + make_na_array, +) + +if TYPE_CHECKING: + from collections.abc import Sequence + + from pandas._typing import ( + ArrayLike, + AxisInt, + DtypeObj, + Manager2D, + Shape, + ) + + from pandas import Index + from pandas.core.internals.blocks import ( + Block, + BlockPlacement, + ) + + +def _concatenate_array_managers( + mgrs: list[ArrayManager], axes: list[Index], concat_axis: AxisInt +) -> Manager2D: + """ + Concatenate array managers into one. + + Parameters + ---------- + mgrs_indexers : list of (ArrayManager, {axis: indexer,...}) tuples + axes : list of Index + concat_axis : int + + Returns + ------- + ArrayManager + """ + if concat_axis == 1: + return mgrs[0].concat_vertical(mgrs, axes) + else: + # concatting along the columns -> combine reindexed arrays in a single manager + assert concat_axis == 0 + return mgrs[0].concat_horizontal(mgrs, axes) + + +def concatenate_managers( + mgrs_indexers, axes: list[Index], concat_axis: AxisInt, copy: bool +) -> Manager2D: + """ + Concatenate block managers into one. + + Parameters + ---------- + mgrs_indexers : list of (BlockManager, {axis: indexer,...}) tuples + axes : list of Index + concat_axis : int + copy : bool + + Returns + ------- + BlockManager + """ + + needs_copy = copy and concat_axis == 0 + + # TODO(ArrayManager) this assumes that all managers are of the same type + if isinstance(mgrs_indexers[0][0], ArrayManager): + mgrs = _maybe_reindex_columns_na_proxy(axes, mgrs_indexers, needs_copy) + # error: Argument 1 to "_concatenate_array_managers" has incompatible + # type "List[BlockManager]"; expected "List[Union[ArrayManager, + # SingleArrayManager, BlockManager, SingleBlockManager]]" + return _concatenate_array_managers( + mgrs, axes, concat_axis # type: ignore[arg-type] + ) + + # Assertions disabled for performance + # for tup in mgrs_indexers: + # # caller is responsible for ensuring this + # indexers = tup[1] + # assert concat_axis not in indexers + + if concat_axis == 0: + mgrs = _maybe_reindex_columns_na_proxy(axes, mgrs_indexers, needs_copy) + return mgrs[0].concat_horizontal(mgrs, axes) + + if len(mgrs_indexers) > 0 and mgrs_indexers[0][0].nblocks > 0: + first_dtype = mgrs_indexers[0][0].blocks[0].dtype + if first_dtype in [np.float64, np.float32]: + # TODO: support more dtypes here. This will be simpler once + # JoinUnit.is_na behavior is deprecated. + if ( + all(_is_homogeneous_mgr(mgr, first_dtype) for mgr, _ in mgrs_indexers) + and len(mgrs_indexers) > 1 + ): + # Fastpath! + # Length restriction is just to avoid having to worry about 'copy' + shape = tuple(len(x) for x in axes) + nb = _concat_homogeneous_fastpath(mgrs_indexers, shape, first_dtype) + return BlockManager((nb,), axes) + + mgrs = _maybe_reindex_columns_na_proxy(axes, mgrs_indexers, needs_copy) + + if len(mgrs) == 1: + mgr = mgrs[0] + out = mgr.copy(deep=False) + out.axes = axes + return out + + concat_plan = _get_combined_plan(mgrs) + + blocks = [] + values: ArrayLike + + for placement, join_units in concat_plan: + unit = join_units[0] + blk = unit.block + + if _is_uniform_join_units(join_units): + vals = [ju.block.values for ju in join_units] + + if not blk.is_extension: + # _is_uniform_join_units ensures a single dtype, so + # we can use np.concatenate, which is more performant + # than concat_compat + # error: Argument 1 to "concatenate" has incompatible type + # "List[Union[ndarray[Any, Any], ExtensionArray]]"; + # expected "Union[_SupportsArray[dtype[Any]], + # _NestedSequence[_SupportsArray[dtype[Any]]]]" + values = np.concatenate(vals, axis=1) # type: ignore[arg-type] + elif is_1d_only_ea_dtype(blk.dtype): + # TODO(EA2D): special-casing not needed with 2D EAs + values = concat_compat(vals, axis=0, ea_compat_axis=True) + values = ensure_block_shape(values, ndim=2) + else: + values = concat_compat(vals, axis=1) + + values = ensure_wrapped_if_datetimelike(values) + + fastpath = blk.values.dtype == values.dtype + else: + values = _concatenate_join_units(join_units, copy=copy) + fastpath = False + + if fastpath: + b = blk.make_block_same_class(values, placement=placement) + else: + b = new_block_2d(values, placement=placement) + + blocks.append(b) + + return BlockManager(tuple(blocks), axes) + + +def _maybe_reindex_columns_na_proxy( + axes: list[Index], + mgrs_indexers: list[tuple[BlockManager, dict[int, np.ndarray]]], + needs_copy: bool, +) -> list[BlockManager]: + """ + Reindex along columns so that all of the BlockManagers being concatenated + have matching columns. + + Columns added in this reindexing have dtype=np.void, indicating they + should be ignored when choosing a column's final dtype. + """ + new_mgrs = [] + + for mgr, indexers in mgrs_indexers: + # For axis=0 (i.e. columns) we use_na_proxy and only_slice, so this + # is a cheap reindexing. + for i, indexer in indexers.items(): + mgr = mgr.reindex_indexer( + axes[i], + indexers[i], + axis=i, + copy=False, + only_slice=True, # only relevant for i==0 + allow_dups=True, + use_na_proxy=True, # only relevant for i==0 + ) + if needs_copy and not indexers: + mgr = mgr.copy() + + new_mgrs.append(mgr) + return new_mgrs + + +def _is_homogeneous_mgr(mgr: BlockManager, first_dtype: DtypeObj) -> bool: + """ + Check if this Manager can be treated as a single ndarray. + """ + if mgr.nblocks != 1: + return False + blk = mgr.blocks[0] + if not (blk.mgr_locs.is_slice_like and blk.mgr_locs.as_slice.step == 1): + return False + + return blk.dtype == first_dtype + + +def _concat_homogeneous_fastpath( + mgrs_indexers, shape: Shape, first_dtype: np.dtype +) -> Block: + """ + With single-Block managers with homogeneous dtypes (that can already hold nan), + we avoid [...] + """ + # assumes + # all(_is_homogeneous_mgr(mgr, first_dtype) for mgr, _ in in mgrs_indexers) + + if all(not indexers for _, indexers in mgrs_indexers): + # https://github.com/pandas-dev/pandas/pull/52685#issuecomment-1523287739 + arrs = [mgr.blocks[0].values.T for mgr, _ in mgrs_indexers] + arr = np.concatenate(arrs).T + bp = libinternals.BlockPlacement(slice(shape[0])) + nb = new_block_2d(arr, bp) + return nb + + arr = np.empty(shape, dtype=first_dtype) + + if first_dtype == np.float64: + take_func = libalgos.take_2d_axis0_float64_float64 + else: + take_func = libalgos.take_2d_axis0_float32_float32 + + start = 0 + for mgr, indexers in mgrs_indexers: + mgr_len = mgr.shape[1] + end = start + mgr_len + + if 0 in indexers: + take_func( + mgr.blocks[0].values, + indexers[0], + arr[:, start:end], + ) + else: + # No reindexing necessary, we can copy values directly + arr[:, start:end] = mgr.blocks[0].values + + start += mgr_len + + bp = libinternals.BlockPlacement(slice(shape[0])) + nb = new_block_2d(arr, bp) + return nb + + +def _get_combined_plan( + mgrs: list[BlockManager], +) -> list[tuple[BlockPlacement, list[JoinUnit]]]: + plan = [] + + max_len = mgrs[0].shape[0] + + blknos_list = [mgr.blknos for mgr in mgrs] + pairs = libinternals.get_concat_blkno_indexers(blknos_list) + for ind, (blknos, bp) in enumerate(pairs): + # assert bp.is_slice_like + # assert len(bp) > 0 + + units_for_bp = [] + for k, mgr in enumerate(mgrs): + blkno = blknos[k] + + nb = _get_block_for_concat_plan(mgr, bp, blkno, max_len=max_len) + unit = JoinUnit(nb) + units_for_bp.append(unit) + + plan.append((bp, units_for_bp)) + + return plan + + +def _get_block_for_concat_plan( + mgr: BlockManager, bp: BlockPlacement, blkno: int, *, max_len: int +) -> Block: + blk = mgr.blocks[blkno] + # Assertions disabled for performance: + # assert bp.is_slice_like + # assert blkno != -1 + # assert (mgr.blknos[bp] == blkno).all() + + if len(bp) == len(blk.mgr_locs) and ( + blk.mgr_locs.is_slice_like and blk.mgr_locs.as_slice.step == 1 + ): + nb = blk + else: + ax0_blk_indexer = mgr.blklocs[bp.indexer] + + slc = lib.maybe_indices_to_slice(ax0_blk_indexer, max_len) + # TODO: in all extant test cases 2023-04-08 we have a slice here. + # Will this always be the case? + if isinstance(slc, slice): + nb = blk.slice_block_columns(slc) + else: + nb = blk.take_block_columns(slc) + + # assert nb.shape == (len(bp), mgr.shape[1]) + return nb + + +class JoinUnit: + def __init__(self, block: Block) -> None: + self.block = block + + def __repr__(self) -> str: + return f"{type(self).__name__}({repr(self.block)})" + + def _is_valid_na_for(self, dtype: DtypeObj) -> bool: + """ + Check that we are all-NA of a type/dtype that is compatible with this dtype. + Augments `self.is_na` with an additional check of the type of NA values. + """ + if not self.is_na: + return False + + blk = self.block + if blk.dtype.kind == "V": + return True + + if blk.dtype == object: + values = blk.values + return all(is_valid_na_for_dtype(x, dtype) for x in values.ravel(order="K")) + + na_value = blk.fill_value + if na_value is NaT and blk.dtype != dtype: + # e.g. we are dt64 and other is td64 + # fill_values match but we should not cast blk.values to dtype + # TODO: this will need updating if we ever have non-nano dt64/td64 + return False + + if na_value is NA and needs_i8_conversion(dtype): + # FIXME: kludge; test_append_empty_frame_with_timedelta64ns_nat + # e.g. blk.dtype == "Int64" and dtype is td64, we dont want + # to consider these as matching + return False + + # TODO: better to use can_hold_element? + return is_valid_na_for_dtype(na_value, dtype) + + @cache_readonly + def is_na(self) -> bool: + blk = self.block + if blk.dtype.kind == "V": + return True + + if not blk._can_hold_na: + return False + + values = blk.values + if values.size == 0: + # GH#39122 this case will return False once deprecation is enforced + return True + + if isinstance(values.dtype, SparseDtype): + return False + + if values.ndim == 1: + # TODO(EA2D): no need for special case with 2D EAs + val = values[0] + if not is_scalar(val) or not isna(val): + # ideally isna_all would do this short-circuiting + return False + return isna_all(values) + else: + val = values[0][0] + if not is_scalar(val) or not isna(val): + # ideally isna_all would do this short-circuiting + return False + return all(isna_all(row) for row in values) + + @cache_readonly + def is_na_after_size_and_isna_all_deprecation(self) -> bool: + """ + Will self.is_na be True after values.size == 0 deprecation and isna_all + deprecation are enforced? + """ + blk = self.block + if blk.dtype.kind == "V": + return True + return False + + def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike: + values: ArrayLike + + if upcasted_na is None and self.block.dtype.kind != "V": + # No upcasting is necessary + return self.block.values + else: + fill_value = upcasted_na + + if self._is_valid_na_for(empty_dtype): + # note: always holds when self.block.dtype.kind == "V" + blk_dtype = self.block.dtype + + if blk_dtype == np.dtype("object"): + # we want to avoid filling with np.nan if we are + # using None; we already know that we are all + # nulls + values = cast(np.ndarray, self.block.values) + if values.size and values[0, 0] is None: + fill_value = None + + return make_na_array(empty_dtype, self.block.shape, fill_value) + + return self.block.values + + +def _concatenate_join_units(join_units: list[JoinUnit], copy: bool) -> ArrayLike: + """ + Concatenate values from several join units along axis=1. + """ + empty_dtype, empty_dtype_future = _get_empty_dtype(join_units) + + has_none_blocks = any(unit.block.dtype.kind == "V" for unit in join_units) + upcasted_na = _dtype_to_na_value(empty_dtype, has_none_blocks) + + to_concat = [ + ju.get_reindexed_values(empty_dtype=empty_dtype, upcasted_na=upcasted_na) + for ju in join_units + ] + + if any(is_1d_only_ea_dtype(t.dtype) for t in to_concat): + # TODO(EA2D): special case not needed if all EAs used HybridBlocks + + # error: No overload variant of "__getitem__" of "ExtensionArray" matches + # argument type "Tuple[int, slice]" + to_concat = [ + t + if is_1d_only_ea_dtype(t.dtype) + else t[0, :] # type: ignore[call-overload] + for t in to_concat + ] + concat_values = concat_compat(to_concat, axis=0, ea_compat_axis=True) + concat_values = ensure_block_shape(concat_values, 2) + + else: + concat_values = concat_compat(to_concat, axis=1) + + if empty_dtype != empty_dtype_future: + if empty_dtype == concat_values.dtype: + # GH#39122, GH#40893 + warnings.warn( + "The behavior of DataFrame concatenation with empty or all-NA " + "entries is deprecated. In a future version, this will no longer " + "exclude empty or all-NA columns when determining the result dtypes. " + "To retain the old behavior, exclude the relevant entries before " + "the concat operation.", + FutureWarning, + stacklevel=find_stack_level(), + ) + return concat_values + + +def _dtype_to_na_value(dtype: DtypeObj, has_none_blocks: bool): + """ + Find the NA value to go with this dtype. + """ + if isinstance(dtype, ExtensionDtype): + return dtype.na_value + elif dtype.kind in "mM": + return dtype.type("NaT") + elif dtype.kind in "fc": + return dtype.type("NaN") + elif dtype.kind == "b": + # different from missing.na_value_for_dtype + return None + elif dtype.kind in "iu": + if not has_none_blocks: + # different from missing.na_value_for_dtype + return None + return np.nan + elif dtype.kind == "O": + return np.nan + raise NotImplementedError + + +def _get_empty_dtype(join_units: Sequence[JoinUnit]) -> tuple[DtypeObj, DtypeObj]: + """ + Return dtype and N/A values to use when concatenating specified units. + + Returned N/A value may be None which means there was no casting involved. + + Returns + ------- + dtype + """ + if lib.dtypes_all_equal([ju.block.dtype for ju in join_units]): + empty_dtype = join_units[0].block.dtype + return empty_dtype, empty_dtype + + has_none_blocks = any(unit.block.dtype.kind == "V" for unit in join_units) + + dtypes = [unit.block.dtype for unit in join_units if not unit.is_na] + if not len(dtypes): + dtypes = [ + unit.block.dtype for unit in join_units if unit.block.dtype.kind != "V" + ] + + dtype = find_common_type(dtypes) + if has_none_blocks: + dtype = ensure_dtype_can_hold_na(dtype) + + dtype_future = dtype + if len(dtypes) != len(join_units): + dtypes_future = [ + unit.block.dtype + for unit in join_units + if not unit.is_na_after_size_and_isna_all_deprecation + ] + if not len(dtypes_future): + dtypes_future = [ + unit.block.dtype for unit in join_units if unit.block.dtype.kind != "V" + ] + + if len(dtypes) != len(dtypes_future): + dtype_future = find_common_type(dtypes_future) + if has_none_blocks: + dtype_future = ensure_dtype_can_hold_na(dtype_future) + + return dtype, dtype_future + + +def _is_uniform_join_units(join_units: list[JoinUnit]) -> bool: + """ + Check if the join units consist of blocks of uniform type that can + be concatenated using Block.concat_same_type instead of the generic + _concatenate_join_units (which uses `concat_compat`). + + """ + first = join_units[0].block + if first.dtype.kind == "V": + return False + return ( + # exclude cases where a) ju.block is None or b) we have e.g. Int64+int64 + all(type(ju.block) is type(first) for ju in join_units) + and + # e.g. DatetimeLikeBlock can be dt64 or td64, but these are not uniform + all( + ju.block.dtype == first.dtype + # GH#42092 we only want the dtype_equal check for non-numeric blocks + # (for now, may change but that would need a deprecation) + or ju.block.dtype.kind in "iub" + for ju in join_units + ) + and + # no blocks that would get missing values (can lead to type upcasts) + # unless we're an extension dtype. + all(not ju.is_na or ju.block.is_extension for ju in join_units) + ) diff --git a/shared/package-files/43/43f42e8df0740be08859b713964b66074d9183109fef142c3a0124395ebb54fa/blob b/shared/package-files/43/43f42e8df0740be08859b713964b66074d9183109fef142c3a0124395ebb54fa/blob new file mode 100644 index 0000000000000000000000000000000000000000..9ec662a6cd3520aaa49fdc96142ad1b02bb518d8 --- /dev/null +++ b/shared/package-files/43/43f42e8df0740be08859b713964b66074d9183109fef142c3a0124395ebb54fa/blob @@ -0,0 +1,348 @@ +""" +Utility functions related to concat. +""" +from __future__ import annotations + +from typing import ( + TYPE_CHECKING, + cast, +) +import warnings + +import numpy as np + +from pandas._libs import lib +from pandas.util._exceptions import find_stack_level + +from pandas.core.dtypes.astype import astype_array +from pandas.core.dtypes.cast import ( + common_dtype_categorical_compat, + find_common_type, + np_find_common_type, +) +from pandas.core.dtypes.dtypes import CategoricalDtype +from pandas.core.dtypes.generic import ( + ABCCategoricalIndex, + ABCSeries, +) + +if TYPE_CHECKING: + from collections.abc import Sequence + + from pandas._typing import ( + ArrayLike, + AxisInt, + DtypeObj, + ) + + from pandas.core.arrays import ( + Categorical, + ExtensionArray, + ) + + +def _is_nonempty(x, axis) -> bool: + # filter empty arrays + # 1-d dtypes always are included here + if x.ndim <= axis: + return True + return x.shape[axis] > 0 + + +def concat_compat( + to_concat: Sequence[ArrayLike], axis: AxisInt = 0, ea_compat_axis: bool = False +) -> ArrayLike: + """ + provide concatenation of an array of arrays each of which is a single + 'normalized' dtypes (in that for example, if it's object, then it is a + non-datetimelike and provide a combined dtype for the resulting array that + preserves the overall dtype if possible) + + Parameters + ---------- + to_concat : sequence of arrays + axis : axis to provide concatenation + ea_compat_axis : bool, default False + For ExtensionArray compat, behave as if axis == 1 when determining + whether to drop empty arrays. + + Returns + ------- + a single array, preserving the combined dtypes + """ + if len(to_concat) and lib.dtypes_all_equal([obj.dtype for obj in to_concat]): + # fastpath! + obj = to_concat[0] + if isinstance(obj, np.ndarray): + to_concat_arrs = cast("Sequence[np.ndarray]", to_concat) + return np.concatenate(to_concat_arrs, axis=axis) + + to_concat_eas = cast("Sequence[ExtensionArray]", to_concat) + if ea_compat_axis: + # We have 1D objects, that don't support axis keyword + return obj._concat_same_type(to_concat_eas) + elif axis == 0: + return obj._concat_same_type(to_concat_eas) + else: + # e.g. DatetimeArray + # NB: We are assuming here that ensure_wrapped_if_arraylike has + # been called where relevant. + return obj._concat_same_type( + # error: Unexpected keyword argument "axis" for "_concat_same_type" + # of "ExtensionArray" + to_concat_eas, + axis=axis, # type: ignore[call-arg] + ) + + # If all arrays are empty, there's nothing to convert, just short-cut to + # the concatenation, #3121. + # + # Creating an empty array directly is tempting, but the winnings would be + # marginal given that it would still require shape & dtype calculation and + # np.concatenate which has them both implemented is compiled. + orig = to_concat + non_empties = [x for x in to_concat if _is_nonempty(x, axis)] + if non_empties and axis == 0 and not ea_compat_axis: + # ea_compat_axis see GH#39574 + to_concat = non_empties + + any_ea, kinds, target_dtype = _get_result_dtype(to_concat, non_empties) + + if len(to_concat) < len(orig): + _, _, alt_dtype = _get_result_dtype(orig, non_empties) + if alt_dtype != target_dtype: + # GH#39122 + warnings.warn( + "The behavior of array concatenation with empty entries is " + "deprecated. In a future version, this will no longer exclude " + "empty items when determining the result dtype. " + "To retain the old behavior, exclude the empty entries before " + "the concat operation.", + FutureWarning, + stacklevel=find_stack_level(), + ) + + if target_dtype is not None: + to_concat = [astype_array(arr, target_dtype, copy=False) for arr in to_concat] + + if not isinstance(to_concat[0], np.ndarray): + # i.e. isinstance(to_concat[0], ExtensionArray) + to_concat_eas = cast("Sequence[ExtensionArray]", to_concat) + cls = type(to_concat[0]) + # GH#53640: eg. for datetime array, axis=1 but 0 is default + # However, class method `_concat_same_type()` for some classes + # may not support the `axis` keyword + if ea_compat_axis or axis == 0: + return cls._concat_same_type(to_concat_eas) + else: + return cls._concat_same_type( + to_concat_eas, + axis=axis, # type: ignore[call-arg] + ) + else: + to_concat_arrs = cast("Sequence[np.ndarray]", to_concat) + result = np.concatenate(to_concat_arrs, axis=axis) + + if not any_ea and "b" in kinds and result.dtype.kind in "iuf": + # GH#39817 cast to object instead of casting bools to numeric + result = result.astype(object, copy=False) + return result + + +def _get_result_dtype( + to_concat: Sequence[ArrayLike], non_empties: Sequence[ArrayLike] +) -> tuple[bool, set[str], DtypeObj | None]: + target_dtype = None + + dtypes = {obj.dtype for obj in to_concat} + kinds = {obj.dtype.kind for obj in to_concat} + + any_ea = any(not isinstance(x, np.ndarray) for x in to_concat) + if any_ea: + # i.e. any ExtensionArrays + + # we ignore axis here, as internally concatting with EAs is always + # for axis=0 + if len(dtypes) != 1: + target_dtype = find_common_type([x.dtype for x in to_concat]) + target_dtype = common_dtype_categorical_compat(to_concat, target_dtype) + + elif not len(non_empties): + # we have all empties, but may need to coerce the result dtype to + # object if we have non-numeric type operands (numpy would otherwise + # cast this to float) + if len(kinds) != 1: + if not len(kinds - {"i", "u", "f"}) or not len(kinds - {"b", "i", "u"}): + # let numpy coerce + pass + else: + # coerce to object + target_dtype = np.dtype(object) + kinds = {"o"} + else: + # error: Argument 1 to "np_find_common_type" has incompatible type + # "*Set[Union[ExtensionDtype, Any]]"; expected "dtype[Any]" + target_dtype = np_find_common_type(*dtypes) # type: ignore[arg-type] + + return any_ea, kinds, target_dtype + + +def union_categoricals( + to_union, sort_categories: bool = False, ignore_order: bool = False +) -> Categorical: + """ + Combine list-like of Categorical-like, unioning categories. + + All categories must have the same dtype. + + Parameters + ---------- + to_union : list-like + Categorical, CategoricalIndex, or Series with dtype='category'. + sort_categories : bool, default False + If true, resulting categories will be lexsorted, otherwise + they will be ordered as they appear in the data. + ignore_order : bool, default False + If true, the ordered attribute of the Categoricals will be ignored. + Results in an unordered categorical. + + Returns + ------- + Categorical + + Raises + ------ + TypeError + - all inputs do not have the same dtype + - all inputs do not have the same ordered property + - all inputs are ordered and their categories are not identical + - sort_categories=True and Categoricals are ordered + ValueError + Empty list of categoricals passed + + Notes + ----- + To learn more about categories, see `link + `__ + + Examples + -------- + If you want to combine categoricals that do not necessarily have + the same categories, `union_categoricals` will combine a list-like + of categoricals. The new categories will be the union of the + categories being combined. + + >>> a = pd.Categorical(["b", "c"]) + >>> b = pd.Categorical(["a", "b"]) + >>> pd.api.types.union_categoricals([a, b]) + ['b', 'c', 'a', 'b'] + Categories (3, object): ['b', 'c', 'a'] + + By default, the resulting categories will be ordered as they appear + in the `categories` of the data. If you want the categories to be + lexsorted, use `sort_categories=True` argument. + + >>> pd.api.types.union_categoricals([a, b], sort_categories=True) + ['b', 'c', 'a', 'b'] + Categories (3, object): ['a', 'b', 'c'] + + `union_categoricals` also works with the case of combining two + categoricals of the same categories and order information (e.g. what + you could also `append` for). + + >>> a = pd.Categorical(["a", "b"], ordered=True) + >>> b = pd.Categorical(["a", "b", "a"], ordered=True) + >>> pd.api.types.union_categoricals([a, b]) + ['a', 'b', 'a', 'b', 'a'] + Categories (2, object): ['a' < 'b'] + + Raises `TypeError` because the categories are ordered and not identical. + + >>> a = pd.Categorical(["a", "b"], ordered=True) + >>> b = pd.Categorical(["a", "b", "c"], ordered=True) + >>> pd.api.types.union_categoricals([a, b]) + Traceback (most recent call last): + ... + TypeError: to union ordered Categoricals, all categories must be the same + + Ordered categoricals with different categories or orderings can be + combined by using the `ignore_ordered=True` argument. + + >>> a = pd.Categorical(["a", "b", "c"], ordered=True) + >>> b = pd.Categorical(["c", "b", "a"], ordered=True) + >>> pd.api.types.union_categoricals([a, b], ignore_order=True) + ['a', 'b', 'c', 'c', 'b', 'a'] + Categories (3, object): ['a', 'b', 'c'] + + `union_categoricals` also works with a `CategoricalIndex`, or `Series` + containing categorical data, but note that the resulting array will + always be a plain `Categorical` + + >>> a = pd.Series(["b", "c"], dtype='category') + >>> b = pd.Series(["a", "b"], dtype='category') + >>> pd.api.types.union_categoricals([a, b]) + ['b', 'c', 'a', 'b'] + Categories (3, object): ['b', 'c', 'a'] + """ + from pandas import Categorical + from pandas.core.arrays.categorical import recode_for_categories + + if len(to_union) == 0: + raise ValueError("No Categoricals to union") + + def _maybe_unwrap(x): + if isinstance(x, (ABCCategoricalIndex, ABCSeries)): + return x._values + elif isinstance(x, Categorical): + return x + else: + raise TypeError("all components to combine must be Categorical") + + to_union = [_maybe_unwrap(x) for x in to_union] + first = to_union[0] + + if not lib.dtypes_all_equal([obj.categories.dtype for obj in to_union]): + raise TypeError("dtype of categories must be the same") + + ordered = False + if all(first._categories_match_up_to_permutation(other) for other in to_union[1:]): + # identical categories - fastpath + categories = first.categories + ordered = first.ordered + + all_codes = [first._encode_with_my_categories(x)._codes for x in to_union] + new_codes = np.concatenate(all_codes) + + if sort_categories and not ignore_order and ordered: + raise TypeError("Cannot use sort_categories=True with ordered Categoricals") + + if sort_categories and not categories.is_monotonic_increasing: + categories = categories.sort_values() + indexer = categories.get_indexer(first.categories) + + from pandas.core.algorithms import take_nd + + new_codes = take_nd(indexer, new_codes, fill_value=-1) + elif ignore_order or all(not c.ordered for c in to_union): + # different categories - union and recode + cats = first.categories.append([c.categories for c in to_union[1:]]) + categories = cats.unique() + if sort_categories: + categories = categories.sort_values() + + new_codes = [ + recode_for_categories(c.codes, c.categories, categories) for c in to_union + ] + new_codes = np.concatenate(new_codes) + else: + # ordered - to show a proper error message + if all(c.ordered for c in to_union): + msg = "to union ordered Categoricals, all categories must be the same" + raise TypeError(msg) + raise TypeError("Categorical.ordered must be the same") + + if ignore_order: + ordered = False + + dtype = CategoricalDtype(categories=categories, ordered=ordered) + return Categorical._simple_new(new_codes, dtype=dtype) diff --git a/shared/package-files/43/43f44351530075474c762b19600d950a2f36a40c4dfdd8263527dcc13351e9d8/blob b/shared/package-files/43/43f44351530075474c762b19600d950a2f36a40c4dfdd8263527dcc13351e9d8/blob new file mode 100644 index 0000000000000000000000000000000000000000..7ac1e9aba7ed53b3239b5071e1e5474b13bb8d30 --- /dev/null +++ b/shared/package-files/43/43f44351530075474c762b19600d950a2f36a40c4dfdd8263527dcc13351e9d8/blob @@ -0,0 +1,38 @@ +""" +A simple utility to import something by its string name. +""" +# Copyright (c) IPython Development Team. +# Distributed under the terms of the Modified BSD License. + + +def import_item(name): + """Import and return ``bar`` given the string ``foo.bar``. + + Calling ``bar = import_item("foo.bar")`` is the functional equivalent of + executing the code ``from foo import bar``. + + Parameters + ---------- + name : string + The fully qualified name of the module/package being imported. + + Returns + ------- + mod : module object + The module that was imported. + """ + if not isinstance(name, str): + raise TypeError("import_item accepts strings, not '%s'." % type(name)) + parts = name.rsplit(".", 1) + if len(parts) == 2: + # called with 'foo.bar....' + package, obj = parts + module = __import__(package, fromlist=[obj]) + try: + pak = getattr(module, obj) + except AttributeError as e: + raise ImportError("No module named %s" % obj) from e + return pak + else: + # called with un-dotted string + return __import__(parts[0]) diff --git a/shared/package-files/43/43f46031a78a16fc0ea157567ddc272f40a6a50962fed9a2e303d0d91447c910/blob b/shared/package-files/43/43f46031a78a16fc0ea157567ddc272f40a6a50962fed9a2e303d0d91447c910/blob new file mode 100644 index 0000000000000000000000000000000000000000..0cde6b1927d2b35e34d4ab0e99124fde146e724d --- /dev/null +++ b/shared/package-files/43/43f46031a78a16fc0ea157567ddc272f40a6a50962fed9a2e303d0d91447c910/blob @@ -0,0 +1,317 @@ +import os +from functools import lru_cache +from typing import BinaryIO, Dict, Optional, Tuple, Type, Union + +import torch + +from torchaudio._extension import lazy_import_sox_ext +from torchaudio.io import CodecConfig +from torio._extension import lazy_import_ffmpeg_ext + +from . import soundfile_backend + +from .backend import Backend +from .common import AudioMetaData +from .ffmpeg import FFmpegBackend +from .soundfile import SoundfileBackend +from .sox import SoXBackend + + +@lru_cache(None) +def get_available_backends() -> Dict[str, Type[Backend]]: + backend_specs: Dict[str, Type[Backend]] = {} + if lazy_import_ffmpeg_ext().is_available(): + backend_specs["ffmpeg"] = FFmpegBackend + if lazy_import_sox_ext().is_available(): + backend_specs["sox"] = SoXBackend + if soundfile_backend._IS_SOUNDFILE_AVAILABLE: + backend_specs["soundfile"] = SoundfileBackend + return backend_specs + + +def get_backend(backend_name, backends) -> Backend: + if backend := backends.get(backend_name): + return backend + else: + raise ValueError( + f"Unsupported backend '{backend_name}' specified; ", + f"please select one of {list(backends.keys())} instead.", + ) + + +def get_info_func(): + backends = get_available_backends() + + def dispatcher( + uri: Union[BinaryIO, str, os.PathLike], format: Optional[str], backend_name: Optional[str] + ) -> Backend: + if backend_name is not None: + return get_backend(backend_name, backends) + + for backend in backends.values(): + if backend.can_decode(uri, format): + return backend + raise RuntimeError(f"Couldn't find appropriate backend to handle uri {uri} and format {format}.") + + def info( + uri: Union[BinaryIO, str, os.PathLike], + format: Optional[str] = None, + buffer_size: int = 4096, + backend: Optional[str] = None, + ) -> AudioMetaData: + """Get signal information of an audio file. + + Note: + When the input type is file-like object, this function cannot + get the correct length (``num_samples``) for certain formats, + such as ``vorbis``. + In this case, the value of ``num_samples`` is ``0``. + + Args: + uri (path-like object or file-like object): + Source of audio data. The following types are accepted: + + * ``path-like``: File path or URL. + * ``file-like``: Object with ``read(size: int) -> bytes`` method, + which returns byte string of at most ``size`` length. + + format (str or None, optional): + If not ``None``, interpreted as hint that may allow backend to override the detected format. + (Default: ``None``) + + buffer_size (int, optional): + Size of buffer to use when processing file-like objects, in bytes. (Default: ``4096``) + + backend (str or None, optional): + I/O backend to use. + If ``None``, function selects backend given input and available backends. + Otherwise, must be one of [``"ffmpeg"``, ``"sox"``, ``"soundfile"``], + with the corresponding backend available. + (Default: ``None``) + + .. seealso:: + :ref:`backend` + + Returns: + AudioMetaData + """ + backend = dispatcher(uri, format, backend) + return backend.info(uri, format, buffer_size) + + return info + + +def get_load_func(): + backends = get_available_backends() + + def dispatcher( + uri: Union[BinaryIO, str, os.PathLike], format: Optional[str], backend_name: Optional[str] + ) -> Backend: + if backend_name is not None: + return get_backend(backend_name, backends) + + for backend in backends.values(): + if backend.can_decode(uri, format): + return backend + raise RuntimeError(f"Couldn't find appropriate backend to handle uri {uri} and format {format}.") + + def load( + uri: Union[BinaryIO, str, os.PathLike], + frame_offset: int = 0, + num_frames: int = -1, + normalize: bool = True, + channels_first: bool = True, + format: Optional[str] = None, + buffer_size: int = 4096, + backend: Optional[str] = None, + ) -> Tuple[torch.Tensor, int]: + """Load audio data from source. + + By default (``normalize=True``, ``channels_first=True``), this function returns Tensor with + ``float32`` dtype, and the shape of `[channel, time]`. + + Note: + The formats this function can handle depend on the availability of backends. + Please use the following functions to fetch the supported formats. + + - FFmpeg: :py:func:`torchaudio.utils.ffmpeg_utils.get_audio_decoders` + - Sox: :py:func:`torchaudio.utils.sox_utils.list_read_formats` + - SoundFile: Refer to `the official document `__. + + .. warning:: + + ``normalize`` argument does not perform volume normalization. + It only converts the sample type to `torch.float32` from the native sample + type. + + When the input format is WAV with integer type, such as 32-bit signed integer, 16-bit + signed integer, 24-bit signed integer, and 8-bit unsigned integer, by providing ``normalize=False``, + this function can return integer Tensor, where the samples are expressed within the whole range + of the corresponding dtype, that is, ``int32`` tensor for 32-bit signed PCM, + ``int16`` for 16-bit signed PCM and ``uint8`` for 8-bit unsigned PCM. Since torch does not + support ``int24`` dtype, 24-bit signed PCM are converted to ``int32`` tensors. + + ``normalize`` argument has no effect on 32-bit floating-point WAV and other formats, such as + ``flac`` and ``mp3``. + + For these formats, this function always returns ``float32`` Tensor with values. + + + Args: + uri (path-like object or file-like object): + Source of audio data. + frame_offset (int, optional): + Number of frames to skip before start reading data. + num_frames (int, optional): + Maximum number of frames to read. ``-1`` reads all the remaining samples, + starting from ``frame_offset``. + This function may return the less number of frames if there is not enough + frames in the given file. + normalize (bool, optional): + When ``True``, this function converts the native sample type to ``float32``. + Default: ``True``. + + If input file is integer WAV, giving ``False`` will change the resulting Tensor type to + integer type. + This argument has no effect for formats other than integer WAV type. + + channels_first (bool, optional): + When True, the returned Tensor has dimension `[channel, time]`. + Otherwise, the returned Tensor's dimension is `[time, channel]`. + + format (str or None, optional): + If not ``None``, interpreted as hint that may allow backend to override the detected format. + (Default: ``None``) + + buffer_size (int, optional): + Size of buffer to use when processing file-like objects, in bytes. (Default: ``4096``) + + backend (str or None, optional): + I/O backend to use. + If ``None``, function selects backend given input and available backends. + Otherwise, must be one of [``"ffmpeg"``, ``"sox"``, ``"soundfile"``], + with the corresponding backend being available. (Default: ``None``) + + .. seealso:: + :ref:`backend` + + Returns: + (torch.Tensor, int): Resulting Tensor and sample rate. + If the input file has integer wav format and normalization is off, then it has + integer type, else ``float32`` type. If ``channels_first=True``, it has + `[channel, time]` else `[time, channel]`. + """ + backend = dispatcher(uri, format, backend) + return backend.load(uri, frame_offset, num_frames, normalize, channels_first, format, buffer_size) + + return load + + +def get_save_func(): + backends = get_available_backends() + + def dispatcher( + uri: Union[BinaryIO, str, os.PathLike], format: Optional[str], backend_name: Optional[str] + ) -> Backend: + if backend_name is not None: + return get_backend(backend_name, backends) + + for backend in backends.values(): + if backend.can_encode(uri, format): + return backend + raise RuntimeError(f"Couldn't find appropriate backend to handle uri {uri} and format {format}.") + + def save( + uri: Union[BinaryIO, str, os.PathLike], + src: torch.Tensor, + sample_rate: int, + channels_first: bool = True, + format: Optional[str] = None, + encoding: Optional[str] = None, + bits_per_sample: Optional[int] = None, + buffer_size: int = 4096, + backend: Optional[str] = None, + compression: Optional[Union[CodecConfig, float, int]] = None, + ): + """Save audio data to file. + + Note: + The formats this function can handle depend on the availability of backends. + Please use the following functions to fetch the supported formats. + + - FFmpeg: :py:func:`torchaudio.utils.ffmpeg_utils.get_audio_encoders` + - Sox: :py:func:`torchaudio.utils.sox_utils.list_write_formats` + - SoundFile: Refer to `the official document `__. + + Args: + uri (str or pathlib.Path): Path to audio file. + src (torch.Tensor): Audio data to save. must be 2D tensor. + sample_rate (int): sampling rate + channels_first (bool, optional): If ``True``, the given tensor is interpreted as `[channel, time]`, + otherwise `[time, channel]`. + format (str or None, optional): Override the audio format. + When ``uri`` argument is path-like object, audio format is + inferred from file extension. If the file extension is missing or + different, you can specify the correct format with this argument. + + When ``uri`` argument is file-like object, + this argument is required. + + Valid values are ``"wav"``, ``"ogg"``, and ``"flac"``. + encoding (str or None, optional): Changes the encoding for supported formats. + This argument is effective only for supported formats, i.e. + ``"wav"`` and ``""flac"```. Valid values are + + - ``"PCM_S"`` (signed integer Linear PCM) + - ``"PCM_U"`` (unsigned integer Linear PCM) + - ``"PCM_F"`` (floating point PCM) + - ``"ULAW"`` (mu-law) + - ``"ALAW"`` (a-law) + + bits_per_sample (int or None, optional): Changes the bit depth for the + supported formats. + When ``format`` is one of ``"wav"`` and ``"flac"``, + you can change the bit depth. + Valid values are ``8``, ``16``, ``24``, ``32`` and ``64``. + + buffer_size (int, optional): + Size of buffer to use when processing file-like objects, in bytes. (Default: ``4096``) + + backend (str or None, optional): + I/O backend to use. + If ``None``, function selects backend given input and available backends. + Otherwise, must be one of [``"ffmpeg"``, ``"sox"``, ``"soundfile"``], + with the corresponding backend being available. + (Default: ``None``) + + .. seealso:: + :ref:`backend` + + compression (CodecConfig, float, int, or None, optional): + Compression configuration to apply. + + If the selected backend is FFmpeg, an instance of :py:class:`CodecConfig` must be provided. + + Otherwise, if the selected backend is SoX, a float or int value corresponding to option ``-C`` of the + ``sox`` command line interface must be provided. For instance: + + ``"mp3"`` + Either bitrate (in ``kbps``) with quality factor, such as ``128.2``, or + VBR encoding with quality factor such as ``-4.2``. Default: ``-4.5``. + + ``"flac"`` + Whole number from ``0`` to ``8``. ``8`` is default and highest compression. + + ``"ogg"``, ``"vorbis"`` + Number from ``-1`` to ``10``; ``-1`` is the highest compression + and lowest quality. Default: ``3``. + + Refer to http://sox.sourceforge.net/soxformat.html for more details. + + """ + backend = dispatcher(uri, format, backend) + return backend.save( + uri, src, sample_rate, channels_first, format, encoding, bits_per_sample, buffer_size, compression + ) + + return save diff --git a/shared/package-files/43/43f49e12f0258cf67ae3c20dec2aa8d02174aa10ab4a7549177f0f987a812002/blob b/shared/package-files/43/43f49e12f0258cf67ae3c20dec2aa8d02174aa10ab4a7549177f0f987a812002/blob new file mode 100644 index 0000000000000000000000000000000000000000..1f7cafa51b7d8c5b4a6d0ea5edbb74b38bd2616c Binary files /dev/null and b/shared/package-files/43/43f49e12f0258cf67ae3c20dec2aa8d02174aa10ab4a7549177f0f987a812002/blob differ diff --git a/shared/package-files/43/43f659f8e772f6cf2b499941cc8c0d72070f8a45ed9c072fe3be600a0a91939a/blob b/shared/package-files/43/43f659f8e772f6cf2b499941cc8c0d72070f8a45ed9c072fe3be600a0a91939a/blob new file mode 100644 index 0000000000000000000000000000000000000000..335f5b92154b389babb15ac644b6d3b51076fcaa --- /dev/null +++ b/shared/package-files/43/43f659f8e772f6cf2b499941cc8c0d72070f8a45ed9c072fe3be600a0a91939a/blob @@ -0,0 +1,355 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +#pragma once + +#include "parquet/level_conversion.h" + +#include +#include +#include + +#include "arrow/util/bit_run_reader.h" +#include "arrow/util/bit_util.h" +#include "arrow/util/bitmap_writer.h" +#include "arrow/util/logging.h" +#include "arrow/util/simd.h" +#include "parquet/exception.h" +#include "parquet/level_comparison.h" + +#ifndef PARQUET_IMPL_NAMESPACE +# error "PARQUET_IMPL_NAMESPACE must be defined" +#endif + +namespace parquet::internal::PARQUET_IMPL_NAMESPACE { + +// clang-format off +/* Python code to generate lookup table: + +kLookupBits = 5 +count = 0 +print('constexpr int kLookupBits = {};'.format(kLookupBits)) +print('constexpr uint8_t kPextTable[1 << kLookupBits][1 << kLookupBits] = {') +print(' ', end = '') +for mask in range(1 << kLookupBits): + for data in range(1 << kLookupBits): + bit_value = 0 + bit_len = 0 + for i in range(kLookupBits): + if mask & (1 << i): + bit_value |= (((data >> i) & 1) << bit_len) + bit_len += 1 + out = '0x{:02X},'.format(bit_value) + count += 1 + if count % (1 << kLookupBits) == 1: + print(' {') + if count % 8 == 1: + print(' ', end = '') + if count % 8 == 0: + print(out, end = '\n') + else: + print(out, end = ' ') + if count % (1 << kLookupBits) == 0: + print(' },', end = '') +print('\n};') + +*/ +// clang-format on + +constexpr int kLookupBits = 5; +constexpr uint8_t kPextTable[1 << kLookupBits][1 << kLookupBits] = { + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, + 0x03, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, + 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, + }, + { + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, + 0x01, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, + 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x00, 0x00, 0x01, + 0x01, 0x02, 0x02, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, + 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + }, + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, + 0x03, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, + 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, + 0x03, 0x02, 0x02, 0x03, 0x03, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, + 0x07, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, + 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07, + }, + { + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, + 0x02, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x04, 0x05, 0x04, + 0x05, 0x06, 0x07, 0x06, 0x07, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, + 0x02, 0x03, 0x04, 0x05, 0x04, 0x05, 0x06, 0x07, 0x06, 0x07, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, + 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, + 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + }, + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, + 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, + 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, + 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x04, 0x05, + 0x06, 0x07, 0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07, + }, + { + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x00, + 0x01, 0x02, 0x03, 0x02, 0x03, 0x04, 0x05, 0x04, 0x05, 0x06, 0x07, + 0x06, 0x07, 0x04, 0x05, 0x04, 0x05, 0x06, 0x07, 0x06, 0x07, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x00, 0x00, 0x01, + 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, + 0x07, 0x07, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, + 0x0E, 0x0F, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + }, + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, + 0x03, 0x02, 0x03, 0x02, 0x03, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, + 0x04, 0x05, 0x06, 0x07, 0x06, 0x07, 0x06, 0x07, 0x06, 0x07, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, + 0x03, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, + 0x07, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x0C, 0x0D, 0x0E, 0x0F, + }, + { + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, + 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, + 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, + }, + { + 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x04, 0x05, 0x04, + 0x05, 0x06, 0x07, 0x06, 0x07, 0x08, 0x09, 0x08, 0x09, 0x0A, 0x0B, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0C, 0x0D, 0x0E, 0x0F, 0x0E, 0x0F, + }, + { + 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x0A, 0x0A, + 0x0B, 0x0B, 0x0C, 0x0C, 0x0D, 0x0D, 0x0E, 0x0E, 0x0F, 0x0F, + }, + { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, + 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + }, +}; + +inline uint64_t ExtractBitsSoftware(uint64_t bitmap, uint64_t select_bitmap) { + // A software emulation of _pext_u64 + + // These checks should be inline and are likely to be common cases. + if (select_bitmap == ~uint64_t{0}) { + return bitmap; + } else if (select_bitmap == 0) { + return 0; + } + + // Fallback to lookup table method + uint64_t bit_value = 0; + int bit_len = 0; + constexpr uint8_t kLookupMask = (1U << kLookupBits) - 1; + while (select_bitmap != 0) { + const auto mask_len = ARROW_POPCOUNT32(select_bitmap & kLookupMask); + const uint64_t value = kPextTable[select_bitmap & kLookupMask][bitmap & kLookupMask]; + bit_value |= (value << bit_len); + bit_len += mask_len; + bitmap >>= kLookupBits; + select_bitmap >>= kLookupBits; + } + return bit_value; +} + +#ifdef ARROW_HAVE_BMI2 + +// Use _pext_u64 on 64-bit builds, _pext_u32 on 32-bit builds, +# if UINTPTR_MAX == 0xFFFFFFFF + +using extract_bitmap_t = uint32_t; +inline extract_bitmap_t ExtractBits(extract_bitmap_t bitmap, + extract_bitmap_t select_bitmap) { + return _pext_u32(bitmap, select_bitmap); +} + +# else + +using extract_bitmap_t = uint64_t; +inline extract_bitmap_t ExtractBits(extract_bitmap_t bitmap, + extract_bitmap_t select_bitmap) { + return _pext_u64(bitmap, select_bitmap); +} + +# endif + +#else // !defined(ARROW_HAVE_BMI2) + +// Use 64-bit pext emulation when BMI2 isn't available. +using extract_bitmap_t = uint64_t; +inline extract_bitmap_t ExtractBits(extract_bitmap_t bitmap, + extract_bitmap_t select_bitmap) { + return ExtractBitsSoftware(bitmap, select_bitmap); +} + +#endif + +static constexpr int64_t kExtractBitsSize = 8 * sizeof(extract_bitmap_t); + +template +int64_t DefLevelsBatchToBitmap(const int16_t* def_levels, const int64_t batch_size, + int64_t upper_bound_remaining, LevelInfo level_info, + ::arrow::internal::FirstTimeBitmapWriter* writer) { + ARROW_DCHECK_LE(batch_size, kExtractBitsSize); + + // Greater than level_info.def_level - 1 implies >= the def_level + auto defined_bitmap = static_cast(::arrow::bit_util::FromLittleEndian( + internal::GreaterThanBitmap(def_levels, batch_size, level_info.def_level - 1))); + + if (has_repeated_parent) { + // Greater than level_info.repeated_ancestor_def_level - 1 implies >= the + // repeated_ancestor_def_level + auto present_bitmap = static_cast( + ::arrow::bit_util::FromLittleEndian(internal::GreaterThanBitmap( + def_levels, batch_size, level_info.repeated_ancestor_def_level - 1))); + auto selected_bits = ExtractBits(defined_bitmap, present_bitmap); + int64_t selected_count = ::arrow::bit_util::PopCount(present_bitmap); + if (ARROW_PREDICT_FALSE(selected_count > upper_bound_remaining)) { + throw ParquetException("Values read exceeded upper bound"); + } + writer->AppendWord(selected_bits, selected_count); + return ::arrow::bit_util::PopCount(selected_bits); + } else { + if (ARROW_PREDICT_FALSE(batch_size > upper_bound_remaining)) { + std::stringstream ss; + ss << "Values read exceeded upper bound"; + throw ParquetException(ss.str()); + } + + writer->AppendWord(defined_bitmap, batch_size); + return ::arrow::bit_util::PopCount(defined_bitmap); + } +} + +template +void DefLevelsToBitmapSimd(const int16_t* def_levels, int64_t num_def_levels, + LevelInfo level_info, ValidityBitmapInputOutput* output) { + ::arrow::internal::FirstTimeBitmapWriter writer( + output->valid_bits, + /*start_offset=*/output->valid_bits_offset, + /*length=*/output->values_read_upper_bound); + int64_t set_count = 0; + output->values_read = 0; + int64_t values_read_remaining = output->values_read_upper_bound; + while (num_def_levels > kExtractBitsSize) { + set_count += DefLevelsBatchToBitmap( + def_levels, kExtractBitsSize, values_read_remaining, level_info, &writer); + def_levels += kExtractBitsSize; + num_def_levels -= kExtractBitsSize; + values_read_remaining = output->values_read_upper_bound - writer.position(); + } + set_count += DefLevelsBatchToBitmap( + def_levels, num_def_levels, values_read_remaining, level_info, &writer); + + output->values_read = writer.position(); + output->null_count += output->values_read - set_count; + writer.Finish(); +} + +} // namespace parquet::internal::PARQUET_IMPL_NAMESPACE diff --git a/shared/package-files/43/43f7483da076bb9e246df350333aa66de97e81b1ba442e6f5b33ba3921431aa3/blob b/shared/package-files/43/43f7483da076bb9e246df350333aa66de97e81b1ba442e6f5b33ba3921431aa3/blob new file mode 100644 index 0000000000000000000000000000000000000000..b933afb35fd6168ee783a2049dcb87aaa6e75aeb --- /dev/null +++ b/shared/package-files/43/43f7483da076bb9e246df350333aa66de97e81b1ba442e6f5b33ba3921431aa3/blob @@ -0,0 +1,17 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import annotations + +__all__ = [ + "__version__", + "__author__", + "__copyright__", +] + +__version__ = "42.0.5" + + +__author__ = "The Python Cryptographic Authority and individual contributors" +__copyright__ = f"Copyright 2013-2024 {__author__}" diff --git a/shared/package-files/43/43f7702535ed4ae5584e53269c6862346091aea1ce36ef70bb6379c20670e296/blob b/shared/package-files/43/43f7702535ed4ae5584e53269c6862346091aea1ce36ef70bb6379c20670e296/blob new file mode 100644 index 0000000000000000000000000000000000000000..f7fc64d4b01633edc011349441b1f75dd2f00cb9 --- /dev/null +++ b/shared/package-files/43/43f7702535ed4ae5584e53269c6862346091aea1ce36ef70bb6379c20670e296/blob @@ -0,0 +1,216 @@ +import datetime as dt +from datetime import date +import re + +import numpy as np +import pytest + +from pandas.compat.numpy import np_long + +import pandas as pd +from pandas import ( + DataFrame, + DatetimeIndex, + Index, + Timestamp, + date_range, + offsets, +) +import pandas._testing as tm + + +class TestDatetimeIndex: + def test_is_(self): + dti = date_range(start="1/1/2005", end="12/1/2005", freq="ME") + assert dti.is_(dti) + assert dti.is_(dti.view()) + assert not dti.is_(dti.copy()) + + def test_time_overflow_for_32bit_machines(self): + # GH8943. On some machines NumPy defaults to np.int32 (for example, + # 32-bit Linux machines). In the function _generate_regular_range + # found in tseries/index.py, `periods` gets multiplied by `strides` + # (which has value 1e9) and since the max value for np.int32 is ~2e9, + # and since those machines won't promote np.int32 to np.int64, we get + # overflow. + periods = np_long(1000) + + idx1 = date_range(start="2000", periods=periods, freq="s") + assert len(idx1) == periods + + idx2 = date_range(end="2000", periods=periods, freq="s") + assert len(idx2) == periods + + def test_nat(self): + assert DatetimeIndex([np.nan])[0] is pd.NaT + + def test_week_of_month_frequency(self): + # GH 5348: "ValueError: Could not evaluate WOM-1SUN" shouldn't raise + d1 = date(2002, 9, 1) + d2 = date(2013, 10, 27) + d3 = date(2012, 9, 30) + idx1 = DatetimeIndex([d1, d2]) + idx2 = DatetimeIndex([d3]) + result_append = idx1.append(idx2) + expected = DatetimeIndex([d1, d2, d3]) + tm.assert_index_equal(result_append, expected) + result_union = idx1.union(idx2) + expected = DatetimeIndex([d1, d3, d2]) + tm.assert_index_equal(result_union, expected) + + def test_append_nondatetimeindex(self): + rng = date_range("1/1/2000", periods=10) + idx = Index(["a", "b", "c", "d"]) + + result = rng.append(idx) + assert isinstance(result[0], Timestamp) + + def test_misc_coverage(self): + rng = date_range("1/1/2000", periods=5) + result = rng.groupby(rng.day) + assert isinstance(next(iter(result.values()))[0], Timestamp) + + # TODO: belongs in frame groupby tests? + def test_groupby_function_tuple_1677(self): + df = DataFrame( + np.random.default_rng(2).random(100), + index=date_range("1/1/2000", periods=100), + ) + monthly_group = df.groupby(lambda x: (x.year, x.month)) + + result = monthly_group.mean() + assert isinstance(result.index[0], tuple) + + def assert_index_parameters(self, index): + assert index.freq == "40960ns" + assert index.inferred_freq == "40960ns" + + def test_ns_index(self): + nsamples = 400 + ns = int(1e9 / 24414) + dtstart = np.datetime64("2012-09-20T00:00:00") + + dt = dtstart + np.arange(nsamples) * np.timedelta64(ns, "ns") + freq = ns * offsets.Nano() + index = DatetimeIndex(dt, freq=freq, name="time") + self.assert_index_parameters(index) + + new_index = date_range(start=index[0], end=index[-1], freq=index.freq) + self.assert_index_parameters(new_index) + + def test_asarray_tz_naive(self): + # This shouldn't produce a warning. + idx = date_range("2000", periods=2) + # M8[ns] by default + result = np.asarray(idx) + + expected = np.array(["2000-01-01", "2000-01-02"], dtype="M8[ns]") + tm.assert_numpy_array_equal(result, expected) + + # optionally, object + result = np.asarray(idx, dtype=object) + + expected = np.array([Timestamp("2000-01-01"), Timestamp("2000-01-02")]) + tm.assert_numpy_array_equal(result, expected) + + def test_asarray_tz_aware(self): + tz = "US/Central" + idx = date_range("2000", periods=2, tz=tz) + expected = np.array(["2000-01-01T06", "2000-01-02T06"], dtype="M8[ns]") + result = np.asarray(idx, dtype="datetime64[ns]") + + tm.assert_numpy_array_equal(result, expected) + + # Old behavior with no warning + result = np.asarray(idx, dtype="M8[ns]") + + tm.assert_numpy_array_equal(result, expected) + + # Future behavior with no warning + expected = np.array( + [Timestamp("2000-01-01", tz=tz), Timestamp("2000-01-02", tz=tz)] + ) + result = np.asarray(idx, dtype=object) + + tm.assert_numpy_array_equal(result, expected) + + def test_CBH_deprecated(self): + msg = "'CBH' is deprecated and will be removed in a future version." + + with tm.assert_produces_warning(FutureWarning, match=msg): + expected = date_range( + dt.datetime(2022, 12, 11), dt.datetime(2022, 12, 13), freq="CBH" + ) + result = DatetimeIndex( + [ + "2022-12-12 09:00:00", + "2022-12-12 10:00:00", + "2022-12-12 11:00:00", + "2022-12-12 12:00:00", + "2022-12-12 13:00:00", + "2022-12-12 14:00:00", + "2022-12-12 15:00:00", + "2022-12-12 16:00:00", + ], + dtype="datetime64[ns]", + freq="cbh", + ) + + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "freq_depr, expected_values, expected_freq", + [ + ( + "AS-AUG", + ["2021-08-01", "2022-08-01", "2023-08-01"], + "YS-AUG", + ), + ( + "1BAS-MAY", + ["2021-05-03", "2022-05-02", "2023-05-01"], + "1BYS-MAY", + ), + ], + ) + def test_AS_BAS_deprecated(self, freq_depr, expected_values, expected_freq): + # GH#55479 + freq_msg = re.split("[0-9]*", freq_depr, maxsplit=1)[1] + msg = f"'{freq_msg}' is deprecated and will be removed in a future version." + + with tm.assert_produces_warning(FutureWarning, match=msg): + expected = date_range( + dt.datetime(2020, 12, 1), dt.datetime(2023, 12, 1), freq=freq_depr + ) + result = DatetimeIndex( + expected_values, + dtype="datetime64[ns]", + freq=expected_freq, + ) + + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "freq, expected_values, freq_depr", + [ + ("2BYE-MAR", ["2016-03-31"], "2BA-MAR"), + ("2BYE-JUN", ["2016-06-30"], "2BY-JUN"), + ("2BME", ["2016-02-29", "2016-04-29", "2016-06-30"], "2BM"), + ("2BQE", ["2016-03-31"], "2BQ"), + ("1BQE-MAR", ["2016-03-31", "2016-06-30"], "1BQ-MAR"), + ], + ) + def test_BM_BQ_BY_deprecated(self, freq, expected_values, freq_depr): + # GH#52064 + msg = f"'{freq_depr[1:]}' is deprecated and will be removed " + f"in a future version, please use '{freq[1:]}' instead." + + with tm.assert_produces_warning(FutureWarning, match=msg): + expected = date_range(start="2016-02-21", end="2016-08-21", freq=freq_depr) + result = DatetimeIndex( + data=expected_values, + dtype="datetime64[ns]", + freq=freq, + ) + + tm.assert_index_equal(result, expected) diff --git a/shared/package-files/43/43f8091f014358761d806c4f7a69347afec116f37093c0a01991a9d58cf59b5d/blob b/shared/package-files/43/43f8091f014358761d806c4f7a69347afec116f37093c0a01991a9d58cf59b5d/blob new file mode 100644 index 0000000000000000000000000000000000000000..c7783b858d583b03fc77516e7532db2524c88f57 --- /dev/null +++ b/shared/package-files/43/43f8091f014358761d806c4f7a69347afec116f37093c0a01991a9d58cf59b5d/blob @@ -0,0 +1,124 @@ +"""Tests for distutils.file_util.""" +import unittest +import os +import errno +from unittest.mock import patch + +from distutils.file_util import move_file, copy_file +from distutils import log +from distutils.tests import support +from distutils.errors import DistutilsFileError +from test.support import run_unittest +from test.support.os_helper import unlink + + +class FileUtilTestCase(support.TempdirManager, unittest.TestCase): + + def _log(self, msg, *args): + if len(args) > 0: + self._logs.append(msg % args) + else: + self._logs.append(msg) + + def setUp(self): + super(FileUtilTestCase, self).setUp() + self._logs = [] + self.old_log = log.info + log.info = self._log + tmp_dir = self.mkdtemp() + self.source = os.path.join(tmp_dir, 'f1') + self.target = os.path.join(tmp_dir, 'f2') + self.target_dir = os.path.join(tmp_dir, 'd1') + + def tearDown(self): + log.info = self.old_log + super(FileUtilTestCase, self).tearDown() + + def test_move_file_verbosity(self): + f = open(self.source, 'w') + try: + f.write('some content') + finally: + f.close() + + move_file(self.source, self.target, verbose=0) + wanted = [] + self.assertEqual(self._logs, wanted) + + # back to original state + move_file(self.target, self.source, verbose=0) + + move_file(self.source, self.target, verbose=1) + wanted = ['moving %s -> %s' % (self.source, self.target)] + self.assertEqual(self._logs, wanted) + + # back to original state + move_file(self.target, self.source, verbose=0) + + self._logs = [] + # now the target is a dir + os.mkdir(self.target_dir) + move_file(self.source, self.target_dir, verbose=1) + wanted = ['moving %s -> %s' % (self.source, self.target_dir)] + self.assertEqual(self._logs, wanted) + + def test_move_file_exception_unpacking_rename(self): + # see issue 22182 + with patch("os.rename", side_effect=OSError("wrong", 1)), \ + self.assertRaises(DistutilsFileError): + with open(self.source, 'w') as fobj: + fobj.write('spam eggs') + move_file(self.source, self.target, verbose=0) + + def test_move_file_exception_unpacking_unlink(self): + # see issue 22182 + with patch("os.rename", side_effect=OSError(errno.EXDEV, "wrong")), \ + patch("os.unlink", side_effect=OSError("wrong", 1)), \ + self.assertRaises(DistutilsFileError): + with open(self.source, 'w') as fobj: + fobj.write('spam eggs') + move_file(self.source, self.target, verbose=0) + + def test_copy_file_hard_link(self): + with open(self.source, 'w') as f: + f.write('some content') + # Check first that copy_file() will not fall back on copying the file + # instead of creating the hard link. + try: + os.link(self.source, self.target) + except OSError as e: + self.skipTest('os.link: %s' % e) + else: + unlink(self.target) + st = os.stat(self.source) + copy_file(self.source, self.target, link='hard') + st2 = os.stat(self.source) + st3 = os.stat(self.target) + self.assertTrue(os.path.samestat(st, st2), (st, st2)) + self.assertTrue(os.path.samestat(st2, st3), (st2, st3)) + with open(self.source, 'r') as f: + self.assertEqual(f.read(), 'some content') + + def test_copy_file_hard_link_failure(self): + # If hard linking fails, copy_file() falls back on copying file + # (some special filesystems don't support hard linking even under + # Unix, see issue #8876). + with open(self.source, 'w') as f: + f.write('some content') + st = os.stat(self.source) + with patch("os.link", side_effect=OSError(0, "linking unsupported")): + copy_file(self.source, self.target, link='hard') + st2 = os.stat(self.source) + st3 = os.stat(self.target) + self.assertTrue(os.path.samestat(st, st2), (st, st2)) + self.assertFalse(os.path.samestat(st2, st3), (st2, st3)) + for fn in (self.source, self.target): + with open(fn, 'r') as f: + self.assertEqual(f.read(), 'some content') + + +def test_suite(): + return unittest.makeSuite(FileUtilTestCase) + +if __name__ == "__main__": + run_unittest(test_suite()) diff --git a/shared/package-files/43/43fb26945d1b60b49727c3bd4c7f7712b426227587d12f1daa26f16d71ba00f2/blob b/shared/package-files/43/43fb26945d1b60b49727c3bd4c7f7712b426227587d12f1daa26f16d71ba00f2/blob new file mode 100644 index 0000000000000000000000000000000000000000..67bf6798b737a65310e8c2953f491831bd7da8dd --- /dev/null +++ b/shared/package-files/43/43fb26945d1b60b49727c3bd4c7f7712b426227587d12f1daa26f16d71ba00f2/blob @@ -0,0 +1,18 @@ +from yaml.composer import Composer +from yaml.constructor import BaseConstructor, Constructor, FullConstructor, SafeConstructor +from yaml.parser import Parser +from yaml.reader import Reader +from yaml.resolver import BaseResolver, Resolver +from yaml.scanner import Scanner + +class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): + def __init__(self, stream) -> None: ... + +class FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver): + def __init__(self, stream) -> None: ... + +class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): + def __init__(self, stream) -> None: ... + +class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + def __init__(self, stream) -> None: ... diff --git a/shared/package-files/43/43fd32e37a94eff1aa01a6c9f32dcf59584e8acbab9c202adc6cee0aed38579f/blob b/shared/package-files/43/43fd32e37a94eff1aa01a6c9f32dcf59584e8acbab9c202adc6cee0aed38579f/blob new file mode 100644 index 0000000000000000000000000000000000000000..add975b005d9c6fdab5c24c369edb0c7c4cf397c Binary files /dev/null and b/shared/package-files/43/43fd32e37a94eff1aa01a6c9f32dcf59584e8acbab9c202adc6cee0aed38579f/blob differ diff --git a/shared/package-files/44/44032c38f92cde99cfcb6ba1de5be8dab4801f08d66899211daf117387a677c8/blob b/shared/package-files/44/44032c38f92cde99cfcb6ba1de5be8dab4801f08d66899211daf117387a677c8/blob new file mode 100644 index 0000000000000000000000000000000000000000..03800f36ac4da33236693323fc9f4b49c7076911 --- /dev/null +++ b/shared/package-files/44/44032c38f92cde99cfcb6ba1de5be8dab4801f08d66899211daf117387a677c8/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor sparse_bsr_tensor(const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::IntArrayRef size, at::TensorOptions options); +TORCH_API at::Tensor sparse_bsr_tensor(const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::IntArrayRef size, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor sparse_bsr_tensor(const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::TensorOptions options); +TORCH_API at::Tensor sparse_bsr_tensor(const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/44/440397a121ffa414af3da565c793d94b2d2659b25cdf6ffc94acdc226d3957af/blob b/shared/package-files/44/440397a121ffa414af3da565c793d94b2d2659b25cdf6ffc94acdc226d3957af/blob new file mode 100644 index 0000000000000000000000000000000000000000..448c9377cc550fcabefb50526b6b1213b0b47cdb --- /dev/null +++ b/shared/package-files/44/440397a121ffa414af3da565c793d94b2d2659b25cdf6ffc94acdc226d3957af/blob @@ -0,0 +1,153 @@ +import torch +from torch.nn import functional as F +from functools import reduce +from typing import Any, List, Optional, Tuple + +from .base_data_sparsifier import BaseDataSparsifier +import operator + +__all__ = ['DataNormSparsifier'] + + +class DataNormSparsifier(BaseDataSparsifier): + r"""L1-Norm Sparsifier + This sparsifier computes the *L1-norm* of every sparse block and "zeroes-out" the + ones with the lowest norm. The level of sparsity defines how many of the + blocks is removed. + This sparsifier is controlled by three variables: + 1. `sparsity_level` defines the number of *sparse blocks* that are zeroed-out + 2. `sparse_block_shape` defines the shape of the sparse blocks. Note that + the sparse blocks originate at the zero-index of the tensor. + 3. `zeros_per_block` is the number of zeros that we are expecting in each + sparse block. By default we assume that all elements within a block are + zeroed-out. However, setting this variable sets the target number of + zeros per block. The zeros within each block are chosen as the *smallest + absolute values*. + Args: + sparsity_level: The target level of sparsity + sparse_block_shape: The shape of a sparse block + zeros_per_block: Number of zeros in a sparse block + Note:: + All arguments to the DataNormSparsifier constructor are "default" + arguments and could be overriden by the configuration provided in the + `add_data` step. + """ + def __init__(self, data_list: Optional[List[Tuple[str, Any]]] = None, sparsity_level: float = 0.5, + sparse_block_shape: Tuple[int, int] = (1, 4), + zeros_per_block: Optional[int] = None, norm: str = 'L1'): + if zeros_per_block is None: + zeros_per_block = reduce(operator.mul, sparse_block_shape) + + assert norm in ['L1', 'L2'], "only L1 and L2 norm supported at the moment" + + defaults = {'sparsity_level': sparsity_level, 'sparse_block_shape': sparse_block_shape, + 'zeros_per_block': zeros_per_block} + self.norm = norm + super().__init__(data_list=data_list, **defaults) + + def __get_scatter_folded_mask(self, data, dim, indices, output_size, sparse_block_shape): + mask = torch.ones_like(data) + mask.scatter_(dim=dim, index=indices, value=0) # zeroing out + mask = F.fold(mask, output_size=output_size, kernel_size=sparse_block_shape, + stride=sparse_block_shape) + mask = mask.to(torch.int8) + return mask + + def __get_block_level_mask(self, data, + sparse_block_shape, zeros_per_block): + + # Assume data is a squeezed tensor + height, width = data.shape[-2], data.shape[-1] + block_height, block_width = sparse_block_shape + values_per_block = block_height * block_width + + # just return zeros if zeroing all elements in block + if values_per_block == zeros_per_block: + return torch.zeros_like(data, dtype=torch.int8) + + # creating additional height and width to support padding + dh = (block_height - height % block_height) % block_height + dw = (block_width - width % block_width) % block_width + + # create a new padded tensor like data (to match the block_shape) + padded_data = torch.ones(height + dh, width + dw, dtype=data.dtype, device=data.device) + padded_data = padded_data * torch.nan # can also be replaced with 0 to stop the removal of edge data + padded_data[0:height, 0:width] = data + unfolded_data = F.unfold(padded_data[None, None, :], kernel_size=sparse_block_shape, + stride=sparse_block_shape) + + _, sorted_idx = torch.sort(unfolded_data, dim=1) + sorted_idx = sorted_idx[:, :zeros_per_block, :] # zero out zeros_per_block number of elements + + mask = self.__get_scatter_folded_mask(data=unfolded_data, dim=1, indices=sorted_idx, output_size=padded_data.shape, + sparse_block_shape=sparse_block_shape) + + mask = mask.squeeze(0).squeeze(0)[:height, :width].contiguous() # remove padding and make contiguous + return mask + + def __get_data_level_mask(self, data, sparsity_level, + sparse_block_shape): + + height, width = data.shape[-2], data.shape[-1] + block_height, block_width = sparse_block_shape + dh = (block_height - height % block_height) % block_height + dw = (block_width - width % block_width) % block_width + + data_norm = F.avg_pool2d(data[None, None, :], kernel_size=sparse_block_shape, + stride=sparse_block_shape, ceil_mode=True) + + values_per_block = reduce(operator.mul, sparse_block_shape) + + data_norm = data_norm.flatten() + num_blocks = len(data_norm) + + data_norm = data_norm.repeat(1, values_per_block, 1) # get similar shape after unfold + _, sorted_idx = torch.sort(data_norm, dim=2) + + threshold_idx = round(sparsity_level * num_blocks) # number of blocks to remove + sorted_idx = sorted_idx[:, :, :threshold_idx] + + mask = self.__get_scatter_folded_mask(data=data_norm, dim=2, indices=sorted_idx, + output_size=(height + dh, width + dw), + sparse_block_shape=sparse_block_shape) + + mask = mask.squeeze(0).squeeze(0)[:height, :width] # squeeze only the first 2 dimension + return mask + + def update_mask(self, name, data, sparsity_level, + sparse_block_shape, zeros_per_block, **kwargs): + + values_per_block = reduce(operator.mul, sparse_block_shape) + if zeros_per_block > values_per_block: + raise ValueError("Number of zeros per block cannot be more than " + "the total number of elements in that block.") + if zeros_per_block < 0: + raise ValueError("Number of zeros per block should be positive.") + + if self.norm == 'L1': + data_norm = torch.abs(data).squeeze() # absolute value based (L1) + else: + data_norm = (data * data).squeeze() # square every element for L2 + + if len(data_norm.shape) > 2: # only supports 2 dimensional data at the moment + raise ValueError("only supports 2-D at the moment") + + elif len(data_norm.shape) == 1: # in case the data is bias (or 1D) + data_norm = data_norm[None, :] + + mask = self.get_mask(name) + if sparsity_level <= 0 or zeros_per_block == 0: + mask.data = torch.ones_like(mask) + elif sparsity_level >= 1.0 and (zeros_per_block == values_per_block): + mask.data = torch.zeros_like(mask) + + # Fetch the high level mask that zeros out entire blocks + data_lvl_mask = self.__get_data_level_mask(data=data_norm, sparsity_level=sparsity_level, + sparse_block_shape=sparse_block_shape) + + # Fetch block level mask that zeros out 'zeros_per_block' number of elements in every block + block_lvl_mask = self.__get_block_level_mask(data=data_norm, sparse_block_shape=sparse_block_shape, + zeros_per_block=zeros_per_block) + + # zero out the entries inside those blocks whose block is sparsified + mask.data = torch.where(data_lvl_mask == 1, data_lvl_mask, block_lvl_mask) diff --git a/shared/package-files/44/4403ebcbc34a2ccfe965b170ac3ee98f288d1167330eb668b0430258b565a988/blob b/shared/package-files/44/4403ebcbc34a2ccfe965b170ac3ee98f288d1167330eb668b0430258b565a988/blob new file mode 100644 index 0000000000000000000000000000000000000000..17c79a35c1d5dd608fddc86ff05155464e0d670c Binary files /dev/null and b/shared/package-files/44/4403ebcbc34a2ccfe965b170ac3ee98f288d1167330eb668b0430258b565a988/blob differ diff --git a/shared/package-files/44/440824e2c5bb3ec86f1e71a6be79b6ceafb396cb0496c953c45e429a54aa545b/blob b/shared/package-files/44/440824e2c5bb3ec86f1e71a6be79b6ceafb396cb0496c953c45e429a54aa545b/blob new file mode 100644 index 0000000000000000000000000000000000000000..9b888b39acfd26226d114835f37d818cf7a3e1e6 Binary files /dev/null and b/shared/package-files/44/440824e2c5bb3ec86f1e71a6be79b6ceafb396cb0496c953c45e429a54aa545b/blob differ diff --git a/shared/package-files/44/440a9391886a4ce020584a9c6e866a354c015aef04a71935236c3975f0ae3d7d/blob b/shared/package-files/44/440a9391886a4ce020584a9c6e866a354c015aef04a71935236c3975f0ae3d7d/blob new file mode 100644 index 0000000000000000000000000000000000000000..17ca87648733025f8d9a4fd897e07660c38ac132 --- /dev/null +++ b/shared/package-files/44/440a9391886a4ce020584a9c6e866a354c015aef04a71935236c3975f0ae3d7d/blob @@ -0,0 +1,384 @@ +import numpy as np +import pytest + +from pandas.compat import PY311 + +from pandas.core.dtypes.dtypes import DatetimeTZDtype + +import pandas as pd +from pandas import ( + CategoricalIndex, + MultiIndex, +) +import pandas._testing as tm + + +def assert_matching(actual, expected, check_dtype=False): + # avoid specifying internal representation + # as much as possible + assert len(actual) == len(expected) + for act, exp in zip(actual, expected): + act = np.asarray(act) + exp = np.asarray(exp) + tm.assert_numpy_array_equal(act, exp, check_dtype=check_dtype) + + +def test_get_level_number_integer(idx): + idx.names = [1, 0] + assert idx._get_level_number(1) == 0 + assert idx._get_level_number(0) == 1 + msg = "Too many levels: Index has only 2 levels, not 3" + with pytest.raises(IndexError, match=msg): + idx._get_level_number(2) + with pytest.raises(KeyError, match="Level fourth not found"): + idx._get_level_number("fourth") + + +def test_get_dtypes(using_infer_string): + # Test MultiIndex.dtypes (# Gh37062) + idx_multitype = MultiIndex.from_product( + [[1, 2, 3], ["a", "b", "c"], pd.date_range("20200101", periods=2, tz="UTC")], + names=["int", "string", "dt"], + ) + + exp = "object" if not using_infer_string else pd.StringDtype(na_value=np.nan) + expected = pd.Series( + { + "int": np.dtype("int64"), + "string": exp, + "dt": DatetimeTZDtype(tz="utc"), + } + ) + tm.assert_series_equal(expected, idx_multitype.dtypes) + + +def test_get_dtypes_no_level_name(using_infer_string): + # Test MultiIndex.dtypes (# GH38580 ) + idx_multitype = MultiIndex.from_product( + [ + [1, 2, 3], + ["a", "b", "c"], + pd.date_range("20200101", periods=2, tz="UTC"), + ], + ) + exp = "object" if not using_infer_string else pd.StringDtype(na_value=np.nan) + expected = pd.Series( + { + "level_0": np.dtype("int64"), + "level_1": exp, + "level_2": DatetimeTZDtype(tz="utc"), + } + ) + tm.assert_series_equal(expected, idx_multitype.dtypes) + + +def test_get_dtypes_duplicate_level_names(using_infer_string): + # Test MultiIndex.dtypes with non-unique level names (# GH45174) + result = MultiIndex.from_product( + [ + [1, 2, 3], + ["a", "b", "c"], + pd.date_range("20200101", periods=2, tz="UTC"), + ], + names=["A", "A", "A"], + ).dtypes + exp = "object" if not using_infer_string else pd.StringDtype(na_value=np.nan) + expected = pd.Series( + [np.dtype("int64"), exp, DatetimeTZDtype(tz="utc")], + index=["A", "A", "A"], + ) + tm.assert_series_equal(result, expected) + + +def test_get_level_number_out_of_bounds(multiindex_dataframe_random_data): + frame = multiindex_dataframe_random_data + + with pytest.raises(IndexError, match="Too many levels"): + frame.index._get_level_number(2) + with pytest.raises(IndexError, match="not a valid level number"): + frame.index._get_level_number(-3) + + +def test_set_name_methods(idx): + # so long as these are synonyms, we don't need to test set_names + index_names = ["first", "second"] + assert idx.rename == idx.set_names + new_names = [name + "SUFFIX" for name in index_names] + ind = idx.set_names(new_names) + assert idx.names == index_names + assert ind.names == new_names + msg = "Length of names must match number of levels in MultiIndex" + with pytest.raises(ValueError, match=msg): + ind.set_names(new_names + new_names) + new_names2 = [name + "SUFFIX2" for name in new_names] + res = ind.set_names(new_names2, inplace=True) + assert res is None + assert ind.names == new_names2 + + # set names for specific level (# GH7792) + ind = idx.set_names(new_names[0], level=0) + assert idx.names == index_names + assert ind.names == [new_names[0], index_names[1]] + + res = ind.set_names(new_names2[0], level=0, inplace=True) + assert res is None + assert ind.names == [new_names2[0], index_names[1]] + + # set names for multiple levels + ind = idx.set_names(new_names, level=[0, 1]) + assert idx.names == index_names + assert ind.names == new_names + + res = ind.set_names(new_names2, level=[0, 1], inplace=True) + assert res is None + assert ind.names == new_names2 + + +def test_set_levels_codes_directly(idx): + # setting levels/codes directly raises AttributeError + + levels = idx.levels + new_levels = [[lev + "a" for lev in level] for level in levels] + + codes = idx.codes + major_codes, minor_codes = codes + major_codes = [(x + 1) % 3 for x in major_codes] + minor_codes = [(x + 1) % 1 for x in minor_codes] + new_codes = [major_codes, minor_codes] + + msg = "Can't set attribute" + with pytest.raises(AttributeError, match=msg): + idx.levels = new_levels + + msg = ( + "property 'codes' of 'MultiIndex' object has no setter" + if PY311 + else "can't set attribute" + ) + with pytest.raises(AttributeError, match=msg): + idx.codes = new_codes + + +def test_set_levels(idx): + # side note - you probably wouldn't want to use levels and codes + # directly like this - but it is possible. + levels = idx.levels + new_levels = [[lev + "a" for lev in level] for level in levels] + + # level changing [w/o mutation] + ind2 = idx.set_levels(new_levels) + assert_matching(ind2.levels, new_levels) + assert_matching(idx.levels, levels) + + # level changing specific level [w/o mutation] + ind2 = idx.set_levels(new_levels[0], level=0) + assert_matching(ind2.levels, [new_levels[0], levels[1]]) + assert_matching(idx.levels, levels) + + ind2 = idx.set_levels(new_levels[1], level=1) + assert_matching(ind2.levels, [levels[0], new_levels[1]]) + assert_matching(idx.levels, levels) + + # level changing multiple levels [w/o mutation] + ind2 = idx.set_levels(new_levels, level=[0, 1]) + assert_matching(ind2.levels, new_levels) + assert_matching(idx.levels, levels) + + # illegal level changing should not change levels + # GH 13754 + original_index = idx.copy() + with pytest.raises(ValueError, match="^On"): + idx.set_levels(["c"], level=0) + assert_matching(idx.levels, original_index.levels, check_dtype=True) + + with pytest.raises(ValueError, match="^On"): + idx.set_codes([0, 1, 2, 3, 4, 5], level=0) + assert_matching(idx.codes, original_index.codes, check_dtype=True) + + with pytest.raises(TypeError, match="^Levels"): + idx.set_levels("c", level=0) + assert_matching(idx.levels, original_index.levels, check_dtype=True) + + with pytest.raises(TypeError, match="^Codes"): + idx.set_codes(1, level=0) + assert_matching(idx.codes, original_index.codes, check_dtype=True) + + +def test_set_codes(idx): + # side note - you probably wouldn't want to use levels and codes + # directly like this - but it is possible. + codes = idx.codes + major_codes, minor_codes = codes + major_codes = [(x + 1) % 3 for x in major_codes] + minor_codes = [(x + 1) % 1 for x in minor_codes] + new_codes = [major_codes, minor_codes] + + # changing codes w/o mutation + ind2 = idx.set_codes(new_codes) + assert_matching(ind2.codes, new_codes) + assert_matching(idx.codes, codes) + + # codes changing specific level w/o mutation + ind2 = idx.set_codes(new_codes[0], level=0) + assert_matching(ind2.codes, [new_codes[0], codes[1]]) + assert_matching(idx.codes, codes) + + ind2 = idx.set_codes(new_codes[1], level=1) + assert_matching(ind2.codes, [codes[0], new_codes[1]]) + assert_matching(idx.codes, codes) + + # codes changing multiple levels w/o mutation + ind2 = idx.set_codes(new_codes, level=[0, 1]) + assert_matching(ind2.codes, new_codes) + assert_matching(idx.codes, codes) + + # label changing for levels of different magnitude of categories + ind = MultiIndex.from_tuples([(0, i) for i in range(130)]) + new_codes = range(129, -1, -1) + expected = MultiIndex.from_tuples([(0, i) for i in new_codes]) + + # [w/o mutation] + result = ind.set_codes(codes=new_codes, level=1) + assert result.equals(expected) + + +def test_set_levels_codes_names_bad_input(idx): + levels, codes = idx.levels, idx.codes + names = idx.names + + with pytest.raises(ValueError, match="Length of levels"): + idx.set_levels([levels[0]]) + + with pytest.raises(ValueError, match="Length of codes"): + idx.set_codes([codes[0]]) + + with pytest.raises(ValueError, match="Length of names"): + idx.set_names([names[0]]) + + # shouldn't scalar data error, instead should demand list-like + with pytest.raises(TypeError, match="list of lists-like"): + idx.set_levels(levels[0]) + + # shouldn't scalar data error, instead should demand list-like + with pytest.raises(TypeError, match="list of lists-like"): + idx.set_codes(codes[0]) + + # shouldn't scalar data error, instead should demand list-like + with pytest.raises(TypeError, match="list-like"): + idx.set_names(names[0]) + + # should have equal lengths + with pytest.raises(TypeError, match="list of lists-like"): + idx.set_levels(levels[0], level=[0, 1]) + + with pytest.raises(TypeError, match="list-like"): + idx.set_levels(levels, level=0) + + # should have equal lengths + with pytest.raises(TypeError, match="list of lists-like"): + idx.set_codes(codes[0], level=[0, 1]) + + with pytest.raises(TypeError, match="list-like"): + idx.set_codes(codes, level=0) + + # should have equal lengths + with pytest.raises(ValueError, match="Length of names"): + idx.set_names(names[0], level=[0, 1]) + + with pytest.raises(TypeError, match="Names must be a"): + idx.set_names(names, level=0) + + +@pytest.mark.parametrize("inplace", [True, False]) +def test_set_names_with_nlevel_1(inplace): + # GH 21149 + # Ensure that .set_names for MultiIndex with + # nlevels == 1 does not raise any errors + expected = MultiIndex(levels=[[0, 1]], codes=[[0, 1]], names=["first"]) + m = MultiIndex.from_product([[0, 1]]) + result = m.set_names("first", level=0, inplace=inplace) + + if inplace: + result = m + + tm.assert_index_equal(result, expected) + + +@pytest.mark.parametrize("ordered", [True, False]) +def test_set_levels_categorical(ordered): + # GH13854 + index = MultiIndex.from_arrays([list("xyzx"), [0, 1, 2, 3]]) + + cidx = CategoricalIndex(list("bac"), ordered=ordered) + result = index.set_levels(cidx, level=0) + expected = MultiIndex(levels=[cidx, [0, 1, 2, 3]], codes=index.codes) + tm.assert_index_equal(result, expected) + + result_lvl = result.get_level_values(0) + expected_lvl = CategoricalIndex( + list("bacb"), categories=cidx.categories, ordered=cidx.ordered + ) + tm.assert_index_equal(result_lvl, expected_lvl) + + +def test_set_value_keeps_names(): + # motivating example from #3742 + lev1 = ["hans", "hans", "hans", "grethe", "grethe", "grethe"] + lev2 = ["1", "2", "3"] * 2 + idx = MultiIndex.from_arrays([lev1, lev2], names=["Name", "Number"]) + df = pd.DataFrame( + np.random.default_rng(2).standard_normal((6, 4)), + columns=["one", "two", "three", "four"], + index=idx, + ) + df = df.sort_index() + assert df._is_copy is None + assert df.index.names == ("Name", "Number") + df.at[("grethe", "4"), "one"] = 99.34 + assert df._is_copy is None + assert df.index.names == ("Name", "Number") + + +def test_set_levels_with_iterable(): + # GH23273 + sizes = [1, 2, 3] + colors = ["black"] * 3 + index = MultiIndex.from_arrays([sizes, colors], names=["size", "color"]) + + result = index.set_levels(map(int, ["3", "2", "1"]), level="size") + + expected_sizes = [3, 2, 1] + expected = MultiIndex.from_arrays([expected_sizes, colors], names=["size", "color"]) + tm.assert_index_equal(result, expected) + + +def test_set_empty_level(): + # GH#48636 + midx = MultiIndex.from_arrays([[]], names=["A"]) + result = midx.set_levels(pd.DatetimeIndex([]), level=0) + expected = MultiIndex.from_arrays([pd.DatetimeIndex([])], names=["A"]) + tm.assert_index_equal(result, expected) + + +def test_set_levels_pos_args_removal(): + # https://github.com/pandas-dev/pandas/issues/41485 + idx = MultiIndex.from_tuples( + [ + (1, "one"), + (3, "one"), + ], + names=["foo", "bar"], + ) + with pytest.raises(TypeError, match="positional arguments"): + idx.set_levels(["a", "b", "c"], 0) + + with pytest.raises(TypeError, match="positional arguments"): + idx.set_codes([[0, 1], [1, 0]], 0) + + +def test_set_levels_categorical_keep_dtype(): + # GH#52125 + midx = MultiIndex.from_arrays([[5, 6]]) + result = midx.set_levels(levels=pd.Categorical([1, 2]), level=0) + expected = MultiIndex.from_arrays([pd.Categorical([1, 2])]) + tm.assert_index_equal(result, expected) diff --git a/shared/package-files/44/440db16ccec6845ab77553539dade87654c9607a8d7abc6335e6759308a01e2c/blob b/shared/package-files/44/440db16ccec6845ab77553539dade87654c9607a8d7abc6335e6759308a01e2c/blob new file mode 100644 index 0000000000000000000000000000000000000000..bf08e1f7a383eb09cac9400f772c487cf6176375 --- /dev/null +++ b/shared/package-files/44/440db16ccec6845ab77553539dade87654c9607a8d7abc6335e6759308a01e2c/blob @@ -0,0 +1,59 @@ +# Names exposed by 'from sympy.physics.quantum import *' + +__all__ = [ + 'AntiCommutator', + + 'qapply', + + 'Commutator', + + 'Dagger', + + 'HilbertSpaceError', 'HilbertSpace', 'TensorProductHilbertSpace', + 'TensorPowerHilbertSpace', 'DirectSumHilbertSpace', 'ComplexSpace', 'L2', + 'FockSpace', + + 'InnerProduct', + + 'Operator', 'HermitianOperator', 'UnitaryOperator', 'IdentityOperator', + 'OuterProduct', 'DifferentialOperator', + + 'represent', 'rep_innerproduct', 'rep_expectation', 'integrate_result', + 'get_basis', 'enumerate_states', + + 'KetBase', 'BraBase', 'StateBase', 'State', 'Ket', 'Bra', 'TimeDepState', + 'TimeDepBra', 'TimeDepKet', 'OrthogonalKet', 'OrthogonalBra', + 'OrthogonalState', 'Wavefunction', + + 'TensorProduct', 'tensor_product_simp', + + 'hbar', 'HBar', + +] +from .anticommutator import AntiCommutator + +from .qapply import qapply + +from .commutator import Commutator + +from .dagger import Dagger + +from .hilbert import (HilbertSpaceError, HilbertSpace, + TensorProductHilbertSpace, TensorPowerHilbertSpace, + DirectSumHilbertSpace, ComplexSpace, L2, FockSpace) + +from .innerproduct import InnerProduct + +from .operator import (Operator, HermitianOperator, UnitaryOperator, + IdentityOperator, OuterProduct, DifferentialOperator) + +from .represent import (represent, rep_innerproduct, rep_expectation, + integrate_result, get_basis, enumerate_states) + +from .state import (KetBase, BraBase, StateBase, State, Ket, Bra, + TimeDepState, TimeDepBra, TimeDepKet, OrthogonalKet, + OrthogonalBra, OrthogonalState, Wavefunction) + +from .tensorproduct import TensorProduct, tensor_product_simp + +from .constants import hbar, HBar diff --git a/shared/package-files/44/440de38fa01657aa6d3705dfa55adbbb2c7179df0fee75b0f1b2ec0f4899220c/blob b/shared/package-files/44/440de38fa01657aa6d3705dfa55adbbb2c7179df0fee75b0f1b2ec0f4899220c/blob new file mode 100644 index 0000000000000000000000000000000000000000..299ebed781b00a1f1f35e96c54f4c20d9bd9d0fc --- /dev/null +++ b/shared/package-files/44/440de38fa01657aa6d3705dfa55adbbb2c7179df0fee75b0f1b2ec0f4899220c/blob @@ -0,0 +1,21 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.signal` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + +__all__ = [ # noqa: F822 + 'periodogram', 'welch', 'lombscargle', 'csd', 'coherence', + 'spectrogram', 'stft', 'istft', 'check_COLA', 'check_NOLA', + 'get_window', +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="signal", module="spectral", + private_modules=["_spectral_py"], all=__all__, + attribute=name) diff --git a/shared/package-files/44/440f3dd3fdf940f9d917b2b6dfddc8dea86bd0ccb553ad8b54ad948d7caff45c/blob b/shared/package-files/44/440f3dd3fdf940f9d917b2b6dfddc8dea86bd0ccb553ad8b54ad948d7caff45c/blob new file mode 100644 index 0000000000000000000000000000000000000000..6f9a89996dc02076c9a6679b1758ca0a20b6ba16 --- /dev/null +++ b/shared/package-files/44/440f3dd3fdf940f9d917b2b6dfddc8dea86bd0ccb553ad8b54ad948d7caff45c/blob @@ -0,0 +1,121 @@ +import sys +from typing import Iterable, Optional, SupportsFloat, SupportsInt, Tuple, overload + +e: float +pi: float +if sys.version_info >= (3, 5): + inf: float + nan: float +if sys.version_info >= (3, 6): + tau: float + +def acos(__x: SupportsFloat) -> float: ... +def acosh(__x: SupportsFloat) -> float: ... +def asin(__x: SupportsFloat) -> float: ... +def asinh(__x: SupportsFloat) -> float: ... +def atan(__x: SupportsFloat) -> float: ... +def atan2(__y: SupportsFloat, __x: SupportsFloat) -> float: ... +def atanh(__x: SupportsFloat) -> float: ... + +if sys.version_info >= (3,): + def ceil(__x: SupportsFloat) -> int: ... + +else: + def ceil(__x: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 8): + def comb(__n: int, __k: int) -> int: ... + +def copysign(__x: SupportsFloat, __y: SupportsFloat) -> float: ... +def cos(__x: SupportsFloat) -> float: ... +def cosh(__x: SupportsFloat) -> float: ... +def degrees(__x: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 8): + def dist(__p: Iterable[SupportsFloat], __q: Iterable[SupportsFloat]) -> float: ... + +def erf(__x: SupportsFloat) -> float: ... +def erfc(__x: SupportsFloat) -> float: ... +def exp(__x: SupportsFloat) -> float: ... +def expm1(__x: SupportsFloat) -> float: ... +def fabs(__x: SupportsFloat) -> float: ... +def factorial(__x: SupportsInt) -> int: ... + +if sys.version_info >= (3,): + def floor(__x: SupportsFloat) -> int: ... + +else: + def floor(__x: SupportsFloat) -> float: ... + +def fmod(__x: SupportsFloat, __y: SupportsFloat) -> float: ... +def frexp(__x: SupportsFloat) -> Tuple[float, int]: ... +def fsum(__seq: Iterable[float]) -> float: ... +def gamma(__x: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 9): + def gcd(*integers: int) -> int: ... + +elif sys.version_info >= (3, 5): + def gcd(__x: int, __y: int) -> int: ... + +if sys.version_info >= (3, 8): + def hypot(*coordinates: SupportsFloat) -> float: ... + +else: + def hypot(__x: SupportsFloat, __y: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 5): + def isclose(a: SupportsFloat, b: SupportsFloat, *, rel_tol: SupportsFloat = ..., abs_tol: SupportsFloat = ...) -> bool: ... + +def isinf(__x: SupportsFloat) -> bool: ... + +if sys.version_info >= (3,): + def isfinite(__x: SupportsFloat) -> bool: ... + +def isnan(__x: SupportsFloat) -> bool: ... + +if sys.version_info >= (3, 8): + def isqrt(__n: int) -> int: ... + +if sys.version_info >= (3, 9): + def lcm(*integers: int) -> int: ... + +def ldexp(__x: SupportsFloat, __i: int) -> float: ... +def lgamma(__x: SupportsFloat) -> float: ... +def log(x: SupportsFloat, base: SupportsFloat = ...) -> float: ... +def log10(__x: SupportsFloat) -> float: ... +def log1p(__x: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 3): + def log2(__x: SupportsFloat) -> float: ... + +def modf(__x: SupportsFloat) -> Tuple[float, float]: ... + +if sys.version_info >= (3, 9): + def nextafter(__x: SupportsFloat, __y: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 8): + def perm(__n: int, __k: Optional[int] = ...) -> int: ... + +def pow(__x: SupportsFloat, __y: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 8): + @overload + def prod(__iterable: Iterable[int], *, start: int = ...) -> int: ... # type: ignore + @overload + def prod(__iterable: Iterable[SupportsFloat], *, start: SupportsFloat = ...) -> float: ... + +def radians(__x: SupportsFloat) -> float: ... + +if sys.version_info >= (3, 7): + def remainder(__x: SupportsFloat, __y: SupportsFloat) -> float: ... + +def sin(__x: SupportsFloat) -> float: ... +def sinh(__x: SupportsFloat) -> float: ... +def sqrt(__x: SupportsFloat) -> float: ... +def tan(__x: SupportsFloat) -> float: ... +def tanh(__x: SupportsFloat) -> float: ... +def trunc(__x: SupportsFloat) -> int: ... + +if sys.version_info >= (3, 9): + def ulp(__x: SupportsFloat) -> float: ... diff --git a/shared/package-files/44/441055b2a85d75f337ea06fccf33bf1281c7b25cdb5918e3822784612ecad1e3/blob b/shared/package-files/44/441055b2a85d75f337ea06fccf33bf1281c7b25cdb5918e3822784612ecad1e3/blob new file mode 100644 index 0000000000000000000000000000000000000000..d276c070bc059328346f2a6257a0df810f58dafd --- /dev/null +++ b/shared/package-files/44/441055b2a85d75f337ea06fccf33bf1281c7b25cdb5918e3822784612ecad1e3/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::heaviside.out(Tensor self, Tensor values, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & heaviside_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & values) { + return at::_ops::heaviside_out::call(self, values, out); +} +// aten::heaviside.out(Tensor self, Tensor values, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & heaviside_outf(const at::Tensor & self, const at::Tensor & values, at::Tensor & out) { + return at::_ops::heaviside_out::call(self, values, out); +} + +// aten::heaviside(Tensor self, Tensor values) -> Tensor +inline at::Tensor heaviside(const at::Tensor & self, const at::Tensor & values) { + return at::_ops::heaviside::call(self, values); +} + +} diff --git a/shared/package-files/44/4410fdfbd1682c6ca58d0287c58f8a74fb09f02a483a5d6789cfa96dddddf180/blob b/shared/package-files/44/4410fdfbd1682c6ca58d0287c58f8a74fb09f02a483a5d6789cfa96dddddf180/blob new file mode 100644 index 0000000000000000000000000000000000000000..fde2ef5bad13a446e1b0be0ff343dc9eb1cbf509 --- /dev/null +++ b/shared/package-files/44/4410fdfbd1682c6ca58d0287c58f8a74fb09f02a483a5d6789cfa96dddddf180/blob @@ -0,0 +1,42 @@ +""" +Exception-compatible adapter from conda_package_streaming. +""" + +from __future__ import annotations + +from tarfile import TarError +from zipfile import BadZipFile + +from conda_package_streaming.extract import exceptions as cps_exceptions +from conda_package_streaming.extract import extract_stream, package_streaming + +from . import exceptions + + +def _extract(filename: str, dest_dir: str, components: list[str]): + """ + Extract .conda or .tar.bz2 package to dest_dir. + + If it's a conda package, components may be ["pkg", "info"] + + If it's a .tar.bz2 package, components must equal ["pkg"] + + Internal. Skip directly to conda-package-streaming if you don't need + exception compatibility. + """ + + if str(filename).endswith(".tar.bz2"): + assert components == ["pkg"] + + try: + with open(filename, "rb") as fileobj: + for component in components: + # will parse zipfile twice + stream = package_streaming.stream_conda_component( + filename, fileobj, component=component + ) + extract_stream(stream, dest_dir) + except cps_exceptions.CaseInsensitiveFileSystemError as e: + raise exceptions.CaseInsensitiveFileSystemError(filename, dest_dir) from e + except (OSError, TarError, BadZipFile) as e: + raise exceptions.InvalidArchiveError(filename, f"failed with error: {str(e)}") from e diff --git a/shared/package-files/44/441116b7879f57d5098cedc99e2845bae03a6450098f89f81b99dc9213883625/blob b/shared/package-files/44/441116b7879f57d5098cedc99e2845bae03a6450098f89f81b99dc9213883625/blob new file mode 100644 index 0000000000000000000000000000000000000000..25eff36471019f97dcdb88e094381053d59bb64e --- /dev/null +++ b/shared/package-files/44/441116b7879f57d5098cedc99e2845bae03a6450098f89f81b99dc9213883625/blob @@ -0,0 +1,188 @@ +""" +Tests for platutils.py +""" + +#----------------------------------------------------------------------------- +# Copyright (C) 2008-2011 The IPython Development Team +# +# Distributed under the terms of the BSD License. The full license is in +# the file COPYING, distributed as part of this software. +#----------------------------------------------------------------------------- + +#----------------------------------------------------------------------------- +# Imports +#----------------------------------------------------------------------------- + +import sys +import signal +import os +import time +from _thread import interrupt_main # Py 3 +import threading + +import pytest + +from IPython.utils.process import (find_cmd, FindCmdError, arg_split, + system, getoutput, getoutputerror, + get_output_error_code) +from IPython.utils.capture import capture_output +from IPython.testing import decorators as dec +from IPython.testing import tools as tt + +python = os.path.basename(sys.executable) + +#----------------------------------------------------------------------------- +# Tests +#----------------------------------------------------------------------------- + + +@dec.skip_win32 +def test_find_cmd_ls(): + """Make sure we can find the full path to ls.""" + path = find_cmd("ls") + assert path.endswith("ls") + + +@dec.skip_if_not_win32 +def test_find_cmd_pythonw(): + """Try to find pythonw on Windows.""" + path = find_cmd('pythonw') + assert path.lower().endswith('pythonw.exe'), path + + +def test_find_cmd_fail(): + """Make sure that FindCmdError is raised if we can't find the cmd.""" + pytest.raises(FindCmdError, find_cmd, "asdfasdf") + + +@dec.skip_win32 +@pytest.mark.parametrize( + "argstr, argv", + [ + ("hi", ["hi"]), + ("hello there", ["hello", "there"]), + # \u01ce == \N{LATIN SMALL LETTER A WITH CARON} + # Do not use \N because the tests crash with syntax error in + # some cases, for example windows python2.6. + ("h\u01cello", ["h\u01cello"]), + ('something "with quotes"', ["something", '"with quotes"']), + ], +) +def test_arg_split(argstr, argv): + """Ensure that argument lines are correctly split like in a shell.""" + assert arg_split(argstr) == argv + + +@dec.skip_if_not_win32 +@pytest.mark.parametrize( + "argstr,argv", + [ + ("hi", ["hi"]), + ("hello there", ["hello", "there"]), + ("h\u01cello", ["h\u01cello"]), + ('something "with quotes"', ["something", "with quotes"]), + ], +) +def test_arg_split_win32(argstr, argv): + """Ensure that argument lines are correctly split like in a shell.""" + assert arg_split(argstr) == argv + + +class SubProcessTestCase(tt.TempFileMixin): + def setUp(self): + """Make a valid python temp file.""" + lines = [ "import sys", + "print('on stdout', end='', file=sys.stdout)", + "print('on stderr', end='', file=sys.stderr)", + "sys.stdout.flush()", + "sys.stderr.flush()"] + self.mktmp('\n'.join(lines)) + + def test_system(self): + status = system(f'{python} "{self.fname}"') + self.assertEqual(status, 0) + + def test_system_quotes(self): + status = system('%s -c "import sys"' % python) + self.assertEqual(status, 0) + + def assert_interrupts(self, command): + """ + Interrupt a subprocess after a second. + """ + if threading.main_thread() != threading.current_thread(): + raise pytest.skip("Can't run this test if not in main thread.") + + # Some tests can overwrite SIGINT handler (by using pdb for example), + # which then breaks this test, so just make sure it's operating + # normally. + signal.signal(signal.SIGINT, signal.default_int_handler) + + def interrupt(): + # Wait for subprocess to start: + time.sleep(0.5) + interrupt_main() + + threading.Thread(target=interrupt).start() + start = time.time() + try: + result = command() + except KeyboardInterrupt: + # Success! + pass + end = time.time() + self.assertTrue( + end - start < 2, "Process didn't die quickly: %s" % (end - start) + ) + return result + + def test_system_interrupt(self): + """ + When interrupted in the way ipykernel interrupts IPython, the + subprocess is interrupted. + """ + def command(): + return system('%s -c "import time; time.sleep(5)"' % python) + + status = self.assert_interrupts(command) + self.assertNotEqual( + status, 0, f"The process wasn't interrupted. Status: {status}" + ) + + def test_getoutput(self): + out = getoutput(f'{python} "{self.fname}"') + # we can't rely on the order the line buffered streams are flushed + try: + self.assertEqual(out, 'on stderron stdout') + except AssertionError: + self.assertEqual(out, 'on stdouton stderr') + + def test_getoutput_quoted(self): + out = getoutput('%s -c "print (1)"' % python) + self.assertEqual(out.strip(), '1') + + #Invalid quoting on windows + @dec.skip_win32 + def test_getoutput_quoted2(self): + out = getoutput("%s -c 'print (1)'" % python) + self.assertEqual(out.strip(), '1') + out = getoutput("%s -c 'print (\"1\")'" % python) + self.assertEqual(out.strip(), '1') + + def test_getoutput_error(self): + out, err = getoutputerror(f'{python} "{self.fname}"') + self.assertEqual(out, 'on stdout') + self.assertEqual(err, 'on stderr') + + def test_get_output_error_code(self): + quiet_exit = '%s -c "import sys; sys.exit(1)"' % python + out, err, code = get_output_error_code(quiet_exit) + self.assertEqual(out, '') + self.assertEqual(err, '') + self.assertEqual(code, 1) + out, err, code = get_output_error_code(f'{python} "{self.fname}"') + self.assertEqual(out, 'on stdout') + self.assertEqual(err, 'on stderr') + self.assertEqual(code, 0) + + diff --git a/shared/package-files/44/4412c970faf5457a0afa5156572020c5c9906b44ad557df089f8d83abdd792c2/blob b/shared/package-files/44/4412c970faf5457a0afa5156572020c5c9906b44ad557df089f8d83abdd792c2/blob new file mode 100644 index 0000000000000000000000000000000000000000..133acc500276d2c0577e863f5bdad4ca6528cc14 --- /dev/null +++ b/shared/package-files/44/4412c970faf5457a0afa5156572020c5c9906b44ad557df089f8d83abdd792c2/blob @@ -0,0 +1,236 @@ +#pragma once + +#include +#include +#include +#include + +namespace torch { +namespace nn { + +namespace detail { + +/// Common options for RNN, LSTM and GRU modules. +struct TORCH_API RNNOptionsBase { + typedef std::variant< + enumtype::kLSTM, + enumtype::kGRU, + enumtype::kRNN_TANH, + enumtype::kRNN_RELU> + rnn_options_base_mode_t; + + RNNOptionsBase( + rnn_options_base_mode_t mode, + int64_t input_size, + int64_t hidden_size); + + TORCH_ARG(rnn_options_base_mode_t, mode); + /// The number of features of a single sample in the input sequence `x`. + TORCH_ARG(int64_t, input_size); + /// The number of features in the hidden state `h`. + TORCH_ARG(int64_t, hidden_size); + /// The number of recurrent layers (cells) to use. + TORCH_ARG(int64_t, num_layers) = 1; + /// Whether a bias term should be added to all linear operations. + TORCH_ARG(bool, bias) = true; + /// If true, the input sequence should be provided as `(batch, sequence, + /// features)`. If false (default), the expected layout is `(sequence, batch, + /// features)`. + TORCH_ARG(bool, batch_first) = false; + /// If non-zero, adds dropout with the given probability to the output of each + /// RNN layer, except the final layer. + TORCH_ARG(double, dropout) = 0.0; + /// Whether to make the RNN bidirectional. + TORCH_ARG(bool, bidirectional) = false; + /// Cell projection dimension. If 0, projections are not added. Can only be + /// used for LSTMs. + TORCH_ARG(int64_t, proj_size) = 0; +}; + +} // namespace detail + +/// Options for the `RNN` module. +/// +/// Example: +/// ``` +/// RNN model(RNNOptions(128, +/// 64).num_layers(3).dropout(0.2).nonlinearity(torch::kTanh)); +/// ``` +struct TORCH_API RNNOptions { + typedef std::variant nonlinearity_t; + + RNNOptions(int64_t input_size, int64_t hidden_size); + + /// The number of expected features in the input `x` + TORCH_ARG(int64_t, input_size); + /// The number of features in the hidden state `h` + TORCH_ARG(int64_t, hidden_size); + /// Number of recurrent layers. E.g., setting ``num_layers=2`` + /// would mean stacking two RNNs together to form a `stacked RNN`, + /// with the second RNN taking in outputs of the first RNN and + /// computing the final results. Default: 1 + TORCH_ARG(int64_t, num_layers) = 1; + /// The non-linearity to use. Can be either ``torch::kTanh`` or + /// ``torch::kReLU``. Default: ``torch::kTanh`` + TORCH_ARG(nonlinearity_t, nonlinearity) = torch::kTanh; + /// If ``false``, then the layer does not use bias weights `b_ih` and `b_hh`. + /// Default: ``true`` + TORCH_ARG(bool, bias) = true; + /// If ``true``, then the input and output tensors are provided + /// as `(batch, seq, feature)`. Default: ``false`` + TORCH_ARG(bool, batch_first) = false; + /// If non-zero, introduces a `Dropout` layer on the outputs of each + /// RNN layer except the last layer, with dropout probability equal to + /// `dropout`. Default: 0 + TORCH_ARG(double, dropout) = 0.0; + /// If ``true``, becomes a bidirectional RNN. Default: ``false`` + TORCH_ARG(bool, bidirectional) = false; +}; + +/// Options for the `LSTM` module. +/// +/// Example: +/// ``` +/// LSTM model(LSTMOptions(2, +/// 4).num_layers(3).batch_first(false).bidirectional(true)); +/// ``` +struct TORCH_API LSTMOptions { + LSTMOptions(int64_t input_size, int64_t hidden_size); + + /// The number of expected features in the input `x` + TORCH_ARG(int64_t, input_size); + /// The number of features in the hidden state `h` + TORCH_ARG(int64_t, hidden_size); + /// Number of recurrent layers. E.g., setting ``num_layers=2`` + /// would mean stacking two LSTMs together to form a `stacked LSTM`, + /// with the second LSTM taking in outputs of the first LSTM and + /// computing the final results. Default: 1 + TORCH_ARG(int64_t, num_layers) = 1; + /// If ``false``, then the layer does not use bias weights `b_ih` and `b_hh`. + /// Default: ``true`` + TORCH_ARG(bool, bias) = true; + /// If ``true``, then the input and output tensors are provided + /// as (batch, seq, feature). Default: ``false`` + TORCH_ARG(bool, batch_first) = false; + /// If non-zero, introduces a `Dropout` layer on the outputs of each + /// LSTM layer except the last layer, with dropout probability equal to + /// `dropout`. Default: 0 + TORCH_ARG(double, dropout) = 0.0; + /// If ``true``, becomes a bidirectional LSTM. Default: ``false`` + TORCH_ARG(bool, bidirectional) = false; + /// Cell projection dimension. If 0, projections are not added + TORCH_ARG(int64_t, proj_size) = 0; +}; + +/// Options for the `GRU` module. +/// +/// Example: +/// ``` +/// GRU model(GRUOptions(2, +/// 4).num_layers(3).batch_first(false).bidirectional(true)); +/// ``` +struct TORCH_API GRUOptions { + GRUOptions(int64_t input_size, int64_t hidden_size); + + /// The number of expected features in the input `x` + TORCH_ARG(int64_t, input_size); + /// The number of features in the hidden state `h` + TORCH_ARG(int64_t, hidden_size); + /// Number of recurrent layers. E.g., setting ``num_layers=2`` + /// would mean stacking two GRUs together to form a `stacked GRU`, + /// with the second GRU taking in outputs of the first GRU and + /// computing the final results. Default: 1 + TORCH_ARG(int64_t, num_layers) = 1; + /// If ``false``, then the layer does not use bias weights `b_ih` and `b_hh`. + /// Default: ``true`` + TORCH_ARG(bool, bias) = true; + /// If ``true``, then the input and output tensors are provided + /// as (batch, seq, feature). Default: ``false`` + TORCH_ARG(bool, batch_first) = false; + /// If non-zero, introduces a `Dropout` layer on the outputs of each + /// GRU layer except the last layer, with dropout probability equal to + /// `dropout`. Default: 0 + TORCH_ARG(double, dropout) = 0.0; + /// If ``true``, becomes a bidirectional GRU. Default: ``false`` + TORCH_ARG(bool, bidirectional) = false; +}; + +namespace detail { + +/// Common options for RNNCell, LSTMCell and GRUCell modules +struct TORCH_API RNNCellOptionsBase { + RNNCellOptionsBase( + int64_t input_size, + int64_t hidden_size, + bool bias, + int64_t num_chunks); + TORCH_ARG(int64_t, input_size); + TORCH_ARG(int64_t, hidden_size); + TORCH_ARG(bool, bias); + TORCH_ARG(int64_t, num_chunks); +}; + +} // namespace detail + +/// Options for the `RNNCell` module. +/// +/// Example: +/// ``` +/// RNNCell model(RNNCellOptions(20, +/// 10).bias(false).nonlinearity(torch::kReLU)); +/// ``` +struct TORCH_API RNNCellOptions { + typedef std::variant nonlinearity_t; + + RNNCellOptions(int64_t input_size, int64_t hidden_size); + + /// The number of expected features in the input `x` + TORCH_ARG(int64_t, input_size); + /// The number of features in the hidden state `h` + TORCH_ARG(int64_t, hidden_size); + /// If ``false``, then the layer does not use bias weights `b_ih` and `b_hh`. + /// Default: ``true`` + TORCH_ARG(bool, bias) = true; + /// The non-linearity to use. Can be either ``torch::kTanh`` or + /// ``torch::kReLU``. Default: ``torch::kTanh`` + TORCH_ARG(nonlinearity_t, nonlinearity) = torch::kTanh; +}; + +/// Options for the `LSTMCell` module. +/// +/// Example: +/// ``` +/// LSTMCell model(LSTMCellOptions(20, 10).bias(false)); +/// ``` +struct TORCH_API LSTMCellOptions { + LSTMCellOptions(int64_t input_size, int64_t hidden_size); + + /// The number of expected features in the input `x` + TORCH_ARG(int64_t, input_size); + /// The number of features in the hidden state `h` + TORCH_ARG(int64_t, hidden_size); + /// If ``false``, then the layer does not use bias weights `b_ih` and `b_hh`. + /// Default: ``true`` + TORCH_ARG(bool, bias) = true; +}; + +/// Options for the `GRUCell` module. +/// +/// Example: +/// ``` +/// GRUCell model(GRUCellOptions(20, 10).bias(false)); +/// ``` +struct TORCH_API GRUCellOptions { + GRUCellOptions(int64_t input_size, int64_t hidden_size); + + /// The number of expected features in the input `x` + TORCH_ARG(int64_t, input_size); + /// The number of features in the hidden state `h` + TORCH_ARG(int64_t, hidden_size); + /// If ``false``, then the layer does not use bias weights `b_ih` and `b_hh`. + /// Default: ``true`` + TORCH_ARG(bool, bias) = true; +}; + +} // namespace nn +} // namespace torch diff --git a/shared/package-files/44/4412ce853477cf5d64681f6ee2191462993c8abaf0bc3cfceb94d4540128897a/blob b/shared/package-files/44/4412ce853477cf5d64681f6ee2191462993c8abaf0bc3cfceb94d4540128897a/blob new file mode 100644 index 0000000000000000000000000000000000000000..8b09858283e169c2f4e86d63565572a38ed939ab --- /dev/null +++ b/shared/package-files/44/4412ce853477cf5d64681f6ee2191462993c8abaf0bc3cfceb94d4540128897a/blob @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor norm(const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype); +TORCH_API at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype); +TORCH_API at::Tensor & norm_outf(const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype, at::Tensor & out); +TORCH_API at::Tensor norm(const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim=false); +TORCH_API at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim=false); +TORCH_API at::Tensor & norm_outf(const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/44/44138e36d0183680d0440f8bf1d3abced20218f72be8291cee0741dd13485236/blob b/shared/package-files/44/44138e36d0183680d0440f8bf1d3abced20218f72be8291cee0741dd13485236/blob new file mode 100644 index 0000000000000000000000000000000000000000..0764997ad00895c0df79c2b47429a595d73e1256 --- /dev/null +++ b/shared/package-files/44/44138e36d0183680d0440f8bf1d3abced20218f72be8291cee0741dd13485236/blob @@ -0,0 +1,106 @@ +""" Provides a function for computing the extendability of a graph which is +undirected, simple, connected and bipartite and contains at least one perfect matching.""" + + +import networkx as nx +from networkx.utils import not_implemented_for + +__all__ = ["maximal_extendability"] + + +@not_implemented_for("directed") +@not_implemented_for("multigraph") +@nx._dispatchable +def maximal_extendability(G): + """Computes the extendability of a graph. + + The extendability of a graph is defined as the maximum $k$ for which `G` + is $k$-extendable. Graph `G` is $k$-extendable if and only if `G` has a + perfect matching and every set of $k$ independent edges can be extended + to a perfect matching in `G`. + + Parameters + ---------- + G : NetworkX Graph + A fully-connected bipartite graph without self-loops + + Returns + ------- + extendability : int + + Raises + ------ + NetworkXError + If the graph `G` is disconnected. + If the graph `G` is not bipartite. + If the graph `G` does not contain a perfect matching. + If the residual graph of `G` is not strongly connected. + + Notes + ----- + Definition: + Let `G` be a simple, connected, undirected and bipartite graph with a perfect + matching M and bipartition (U,V). The residual graph of `G`, denoted by $G_M$, + is the graph obtained from G by directing the edges of M from V to U and the + edges that do not belong to M from U to V. + + Lemma [1]_ : + Let M be a perfect matching of `G`. `G` is $k$-extendable if and only if its residual + graph $G_M$ is strongly connected and there are $k$ vertex-disjoint directed + paths between every vertex of U and every vertex of V. + + Assuming that input graph `G` is undirected, simple, connected, bipartite and contains + a perfect matching M, this function constructs the residual graph $G_M$ of G and + returns the minimum value among the maximum vertex-disjoint directed paths between + every vertex of U and every vertex of V in $G_M$. By combining the definitions + and the lemma, this value represents the extendability of the graph `G`. + + Time complexity O($n^3$ $m^2$)) where $n$ is the number of vertices + and $m$ is the number of edges. + + References + ---------- + .. [1] "A polynomial algorithm for the extendability problem in bipartite graphs", + J. Lakhal, L. Litzler, Information Processing Letters, 1998. + .. [2] "On n-extendible graphs", M. D. Plummer, Discrete Mathematics, 31:201–210, 1980 + https://doi.org/10.1016/0012-365X(80)90037-0 + + """ + if not nx.is_connected(G): + raise nx.NetworkXError("Graph G is not connected") + + if not nx.bipartite.is_bipartite(G): + raise nx.NetworkXError("Graph G is not bipartite") + + U, V = nx.bipartite.sets(G) + + maximum_matching = nx.bipartite.hopcroft_karp_matching(G) + + if not nx.is_perfect_matching(G, maximum_matching): + raise nx.NetworkXError("Graph G does not contain a perfect matching") + + # list of edges in perfect matching, directed from V to U + pm = [(node, maximum_matching[node]) for node in V & maximum_matching.keys()] + + # Direct all the edges of G, from V to U if in matching, else from U to V + directed_edges = [ + (x, y) if (x in V and (x, y) in pm) or (x in U and (y, x) not in pm) else (y, x) + for x, y in G.edges + ] + + # Construct the residual graph of G + residual_G = nx.DiGraph() + residual_G.add_nodes_from(G) + residual_G.add_edges_from(directed_edges) + + if not nx.is_strongly_connected(residual_G): + raise nx.NetworkXError("The residual graph of G is not strongly connected") + + # For node-pairs between V & U, keep min of max number of node-disjoint paths + # Variable $k$ stands for the extendability of graph G + k = float("inf") + for u in U: + for v in V: + num_paths = sum(1 for _ in nx.node_disjoint_paths(residual_G, u, v)) + k = k if k < num_paths else num_paths + return k diff --git a/shared/package-files/44/4414f968bc0fdaa0e6ed406586efca109cca0c8faf04431a44b133a8108d68fc/blob b/shared/package-files/44/4414f968bc0fdaa0e6ed406586efca109cca0c8faf04431a44b133a8108d68fc/blob new file mode 100644 index 0000000000000000000000000000000000000000..b997bc3616c879b817d343ddeffe6290b92799de --- /dev/null +++ b/shared/package-files/44/4414f968bc0fdaa0e6ed406586efca109cca0c8faf04431a44b133a8108d68fc/blob @@ -0,0 +1,105 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API float_power_Tensor_Tensor_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Tensor_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power.Tensor_Tensor_out(Tensor self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Tensor & exponent, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & exponent, at::Tensor & out); +}; + +struct TORCH_API float_power_Tensor_Tensor { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Tensor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power.Tensor_Tensor(Tensor self, Tensor exponent) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Tensor & exponent); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & exponent); +}; + +struct TORCH_API float_power_Scalar_out { + using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power.Scalar_out(Scalar self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Scalar & self, const at::Tensor & exponent, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & exponent, at::Tensor & out); +}; + +struct TORCH_API float_power_Scalar { + using schema = at::Tensor (const at::Scalar &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power.Scalar(Scalar self, Tensor exponent) -> Tensor") + static at::Tensor call(const at::Scalar & self, const at::Tensor & exponent); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & exponent); +}; + +struct TORCH_API float_power_Tensor_Scalar_out { + using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Scalar_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power.Tensor_Scalar_out(Tensor self, Scalar exponent, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Scalar & exponent, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & exponent, at::Tensor & out); +}; + +struct TORCH_API float_power_Tensor_Scalar { + using schema = at::Tensor (const at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Scalar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power.Tensor_Scalar(Tensor self, Scalar exponent) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Scalar & exponent); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & exponent); +}; + +struct TORCH_API float_power__Scalar { + using schema = at::Tensor & (at::Tensor &, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power_.Scalar(Tensor(a!) self, Scalar exponent) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self, const at::Scalar & exponent); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & exponent); +}; + +struct TORCH_API float_power__Tensor { + using schema = at::Tensor & (at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::float_power_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "float_power_.Tensor(Tensor(a!) self, Tensor exponent) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self, const at::Tensor & exponent); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & exponent); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/44/441676b0c4043fb34a48aaae712f228fe74e399ae61e258cfea54b54fd693ded/blob b/shared/package-files/44/441676b0c4043fb34a48aaae712f228fe74e399ae61e258cfea54b54fd693ded/blob new file mode 100644 index 0000000000000000000000000000000000000000..3bc3359e90ec5403f4eb3fd6e4be121a1a7228ce --- /dev/null +++ b/shared/package-files/44/441676b0c4043fb34a48aaae712f228fe74e399ae61e258cfea54b54fd693ded/blob @@ -0,0 +1 @@ +from .jitclass import jitclass \ No newline at end of file diff --git a/shared/package-files/44/4418a18ca03accf0fc83b55c22ffc2be471a409a7dcac3059aa097ee1ed937a9/blob b/shared/package-files/44/4418a18ca03accf0fc83b55c22ffc2be471a409a7dcac3059aa097ee1ed937a9/blob new file mode 100644 index 0000000000000000000000000000000000000000..849454a30bb3d72858cfe1713a4095fa489a03d4 Binary files /dev/null and b/shared/package-files/44/4418a18ca03accf0fc83b55c22ffc2be471a409a7dcac3059aa097ee1ed937a9/blob differ diff --git a/shared/package-files/44/441a4f8b4d1978df68662e7ed887b01cc44bee74f497092d9e46e88b03f53843/blob b/shared/package-files/44/441a4f8b4d1978df68662e7ed887b01cc44bee74f497092d9e46e88b03f53843/blob new file mode 100644 index 0000000000000000000000000000000000000000..5cc33e505a8059a4145696fd95b773bdeb1de5fd --- /dev/null +++ b/shared/package-files/44/441a4f8b4d1978df68662e7ed887b01cc44bee74f497092d9e46e88b03f53843/blob @@ -0,0 +1,30 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_functional_assert_async.msg(Tensor self, str assert_msg, Tensor dep_token) -> Tensor +inline at::Tensor _functional_assert_async(const at::Tensor & self, c10::string_view assert_msg, const at::Tensor & dep_token) { + return at::_ops::_functional_assert_async_msg::call(self, assert_msg, dep_token); +} + +} diff --git a/shared/package-files/44/441a5d7750bc07db39b7bc0372bf3f38e7b7e2a11c5b8e6bd3e83534ee5a5eea/blob b/shared/package-files/44/441a5d7750bc07db39b7bc0372bf3f38e7b7e2a11c5b8e6bd3e83534ee5a5eea/blob new file mode 100644 index 0000000000000000000000000000000000000000..57cf81739101aa3300057beb0a77330640fb4df6 --- /dev/null +++ b/shared/package-files/44/441a5d7750bc07db39b7bc0372bf3f38e7b7e2a11c5b8e6bd3e83534ee5a5eea/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:441a5d7750bc07db39b7bc0372bf3f38e7b7e2a11c5b8e6bd3e83534ee5a5eea +size 5761616 diff --git a/shared/package-files/44/441b03042d6424711ce4eb83688ba9e3c36e2f1152388656b6a18e01926f8fb8/blob b/shared/package-files/44/441b03042d6424711ce4eb83688ba9e3c36e2f1152388656b6a18e01926f8fb8/blob new file mode 100644 index 0000000000000000000000000000000000000000..fbcfa309d29c701c615c094387c1770cd2ed4e45 --- /dev/null +++ b/shared/package-files/44/441b03042d6424711ce4eb83688ba9e3c36e2f1152388656b6a18e01926f8fb8/blob @@ -0,0 +1,262 @@ +# +# The Python Imaging Library. +# $Id$ +# +# image palette object +# +# History: +# 1996-03-11 fl Rewritten. +# 1997-01-03 fl Up and running. +# 1997-08-23 fl Added load hack +# 2001-04-16 fl Fixed randint shadow bug in random() +# +# Copyright (c) 1997-2001 by Secret Labs AB +# Copyright (c) 1996-1997 by Fredrik Lundh +# +# See the README file for information on usage and redistribution. +# +from __future__ import annotations + +import array + +from . import GimpGradientFile, GimpPaletteFile, ImageColor, PaletteFile + + +class ImagePalette: + """ + Color palette for palette mapped images + + :param mode: The mode to use for the palette. See: + :ref:`concept-modes`. Defaults to "RGB" + :param palette: An optional palette. If given, it must be a bytearray, + an array or a list of ints between 0-255. The list must consist of + all channels for one color followed by the next color (e.g. RGBRGBRGB). + Defaults to an empty palette. + """ + + def __init__(self, mode="RGB", palette=None): + self.mode = mode + self.rawmode = None # if set, palette contains raw data + self.palette = palette or bytearray() + self.dirty = None + + @property + def palette(self): + return self._palette + + @palette.setter + def palette(self, palette): + self._colors = None + self._palette = palette + + @property + def colors(self): + if self._colors is None: + mode_len = len(self.mode) + self._colors = {} + for i in range(0, len(self.palette), mode_len): + color = tuple(self.palette[i : i + mode_len]) + if color in self._colors: + continue + self._colors[color] = i // mode_len + return self._colors + + @colors.setter + def colors(self, colors): + self._colors = colors + + def copy(self): + new = ImagePalette() + + new.mode = self.mode + new.rawmode = self.rawmode + if self.palette is not None: + new.palette = self.palette[:] + new.dirty = self.dirty + + return new + + def getdata(self): + """ + Get palette contents in format suitable for the low-level + ``im.putpalette`` primitive. + + .. warning:: This method is experimental. + """ + if self.rawmode: + return self.rawmode, self.palette + return self.mode, self.tobytes() + + def tobytes(self): + """Convert palette to bytes. + + .. warning:: This method is experimental. + """ + if self.rawmode: + msg = "palette contains raw palette data" + raise ValueError(msg) + if isinstance(self.palette, bytes): + return self.palette + arr = array.array("B", self.palette) + return arr.tobytes() + + # Declare tostring as an alias for tobytes + tostring = tobytes + + def _new_color_index(self, image=None, e=None): + if not isinstance(self.palette, bytearray): + self._palette = bytearray(self.palette) + index = len(self.palette) // 3 + special_colors = () + if image: + special_colors = ( + image.info.get("background"), + image.info.get("transparency"), + ) + while index in special_colors: + index += 1 + if index >= 256: + if image: + # Search for an unused index + for i, count in reversed(list(enumerate(image.histogram()))): + if count == 0 and i not in special_colors: + index = i + break + if index >= 256: + msg = "cannot allocate more than 256 colors" + raise ValueError(msg) from e + return index + + def getcolor(self, color, image=None): + """Given an rgb tuple, allocate palette entry. + + .. warning:: This method is experimental. + """ + if self.rawmode: + msg = "palette contains raw palette data" + raise ValueError(msg) + if isinstance(color, tuple): + if self.mode == "RGB": + if len(color) == 4: + if color[3] != 255: + msg = "cannot add non-opaque RGBA color to RGB palette" + raise ValueError(msg) + color = color[:3] + elif self.mode == "RGBA": + if len(color) == 3: + color += (255,) + try: + return self.colors[color] + except KeyError as e: + # allocate new color slot + index = self._new_color_index(image, e) + self.colors[color] = index + if index * 3 < len(self.palette): + self._palette = ( + self.palette[: index * 3] + + bytes(color) + + self.palette[index * 3 + 3 :] + ) + else: + self._palette += bytes(color) + self.dirty = 1 + return index + else: + msg = f"unknown color specifier: {repr(color)}" + raise ValueError(msg) + + def save(self, fp): + """Save palette to text file. + + .. warning:: This method is experimental. + """ + if self.rawmode: + msg = "palette contains raw palette data" + raise ValueError(msg) + if isinstance(fp, str): + fp = open(fp, "w") + fp.write("# Palette\n") + fp.write(f"# Mode: {self.mode}\n") + for i in range(256): + fp.write(f"{i}") + for j in range(i * len(self.mode), (i + 1) * len(self.mode)): + try: + fp.write(f" {self.palette[j]}") + except IndexError: + fp.write(" 0") + fp.write("\n") + fp.close() + + +# -------------------------------------------------------------------- +# Internal + + +def raw(rawmode, data): + palette = ImagePalette() + palette.rawmode = rawmode + palette.palette = data + palette.dirty = 1 + return palette + + +# -------------------------------------------------------------------- +# Factories + + +def make_linear_lut(black, white): + if black == 0: + return [white * i // 255 for i in range(256)] + + msg = "unavailable when black is non-zero" + raise NotImplementedError(msg) # FIXME + + +def make_gamma_lut(exp): + return [int(((i / 255.0) ** exp) * 255.0 + 0.5) for i in range(256)] + + +def negative(mode="RGB"): + palette = list(range(256 * len(mode))) + palette.reverse() + return ImagePalette(mode, [i // len(mode) for i in palette]) + + +def random(mode="RGB"): + from random import randint + + palette = [randint(0, 255) for _ in range(256 * len(mode))] + return ImagePalette(mode, palette) + + +def sepia(white="#fff0c0"): + bands = [make_linear_lut(0, band) for band in ImageColor.getrgb(white)] + return ImagePalette("RGB", [bands[i % 3][i // 3] for i in range(256 * 3)]) + + +def wedge(mode="RGB"): + palette = list(range(256 * len(mode))) + return ImagePalette(mode, [i // len(mode) for i in palette]) + + +def load(filename): + # FIXME: supports GIMP gradients only + + with open(filename, "rb") as fp: + for paletteHandler in [ + GimpPaletteFile.GimpPaletteFile, + GimpGradientFile.GimpGradientFile, + PaletteFile.PaletteFile, + ]: + try: + fp.seek(0) + lut = paletteHandler(fp).getpalette() + if lut: + break + except (SyntaxError, ValueError): + pass + else: + msg = "cannot load palette" + raise OSError(msg) + + return lut # data, rawmode diff --git a/shared/package-files/44/441fb1950b972aefd1f304f0e1bd79d2a4ebacdbd5289ac69e6f4c86f44f12cf/blob b/shared/package-files/44/441fb1950b972aefd1f304f0e1bd79d2a4ebacdbd5289ac69e6f4c86f44f12cf/blob new file mode 100644 index 0000000000000000000000000000000000000000..acba4eaa50d8e54b3d87e1467b355df743065c74 --- /dev/null +++ b/shared/package-files/44/441fb1950b972aefd1f304f0e1bd79d2a4ebacdbd5289ac69e6f4c86f44f12cf/blob @@ -0,0 +1,440 @@ +error(0.007592751760562909541) D0 +error(0.005201238943280783733) D0 D1 +error(0.02203591443676204339) D0 D4 +error(0.002357950234062284461) D0 D4 ^ D5 +error(0.002290766330283289937) D0 D7 +error(0.001916866622424801729) D0 D7 ^ D5 +error(0.001314881717245916471) D0 D8 +error(0.002769420176498432491) D0 D8 ^ D5 +error(0.007986997456750350236) D1 D2 +error(0.005433600653085677787) D1 D2 ^ D10 +error(0.02548506131147600107) D1 D7 +error(0.001452372920425618052) D1 D7 ^ D9 +error(0.003568279197650216662) D1 D7 ^ D9 D10 +error(0.002485007304060496847) D1 D7 ^ D10 +error(0.002742307337456661824) D1 D8 +error(0.0002262717534630565431) D1 D8 ^ D9 +error(0.0001825767196066598996) D1 D8 ^ D10 +error(0.0007071754550273671221) D1 D8 ^ D10 ^ D9 +error(0.002656250963120629881) D1 D11 +error(0.003308072434678306379) D1 D11 ^ D10 +error(0.01489655549920582481) D1 L0 +error(0.006410405516027400594) D1 L0 ^ D9 +error(0.01059472558884368837) D2 +error(0.01139699508113406479) D2 D3 +error(0.01644559965671338678) D2 D8 +error(0.003998613852471653851) D2 D8 ^ D10 +error(0.012359027924897922) D2 D11 +error(0.006838792646474678265) D2 D11 ^ D10 +error(0.02663026889722797108) D3 D11 +error(0.009706160056114871565) D3 L0 +error(0.01100258279902184902) D4 +error(0.01336326578412388999) D4 D7 +error(0.01293233969670195757) D4 D7 ^ D5 +error(0.02020216446917192515) D4 D12 +error(0.002199322860023935396) D4 D12 ^ D13 +error(0.002189438347068962693) D4 D15 +error(0.002311939610813036703) D4 D15 ^ D5 +error(0.001914360464039917319) D4 D15 ^ D13 +error(0.0006371972034096348844) D4 D15 ^ D13 ^ D5 +error(0.00253435661992259826) D4 D16 +error(0.001994128845382244202) D4 D16 ^ D5 D13 +error(0.005895460109042562243) D4 ^ D5 +error(0.003601801379827148427) D4 ^ D13 +error(0.002854654490573347442) D5 D13 ^ D4 +error(0.02830437215225232658) D5 +error(0.006727621346049378857) D5 D6 +error(0.001025525261140942425) D5 D6 ^ D4 +error(0.01340873323831139052) D5 D6 ^ D8 +error(0.001370458776576407092) D5 D6 ^ D8 D16 +error(0.001415814666578600525) D5 D6 ^ D16 +error(0.0003564322737099771062) D5 D6 ^ D16 ^ D4 +error(0.01656761526245324398) D5 D10 +error(0.01014406473593612752) D5 D10 ^ D7 D8 +error(0.03610022212504324784) D5 D13 +error(0.001436562714346872405) D5 D13 ^ D15 D16 +error(0.00120171249355131046) D5 D13 ^ D16 +error(0.001164397002357756309) D5 D17 +error(0.002199892265035710125) D5 D17 ^ D7 D15 +error(0.0003447763067211021101) D5 D17 ^ D7 D16 +error(0.0002296245505507356658) D5 D17 ^ D15 D16 +error(0.005927023497288577518) D5 D18 +error(0.001755655722396575998) D5 D18 ^ D7 D8 +error(0.001423864549265496096) D5 D18 ^ D7 D15 +error(0.0007586253783040229496) D5 D18 ^ D7 D16 +error(6.627277110149178842e-06) D5 D18 ^ D8 D16 +error(0.001806965095818935689) D5 D18 ^ D15 D16 +error(0.004091148850973927789) D5 ^ D0 +error(0.0006850047532043295438) D5 ^ D8 +error(0.0007146197475499093408) D5 ^ D15 L0 +error(0.001579474129444302481) D7 D15 ^ D5 +error(0.03894956366612126186) D6 +error(0.001086847981726183146) D6 D13 +error(0.0001611534419475430218) D6 D13 ^ D4 +error(0.001096882251336390047) D6 D13 ^ D16 +error(0.0002800897744095835729) D6 D13 ^ D16 ^ D4 +error(0.03351480314878754752) D6 D14 +error(0.00285915164077798177) D6 D14 ^ D16 +error(0.0002528151521404119607) D6 D18 ^ D7 D8 +error(0.0006041119901846543801) D6 D18 ^ D7 D16 +error(0.001229266370598511423) D6 D18 ^ D8 D16 +error(0.02196457769161393528) D6 ^ D8 +error(2.968220076744845746e-05) D6 ^ D16 +error(0.001958019466985956494) D6 ^ D16 ^ D8 +error(0.02241555077320568287) D7 D8 +error(0.001278669018414643147) D7 D8 ^ D5 +error(0.0006959791541313529702) D7 D8 ^ D9 +error(0.00399047535677482957) D7 D8 ^ D10 +error(0.001538869193277376092) D7 D8 ^ D10 D18 +error(0.001027008861194350685) D7 D8 ^ D10 ^ D9 +error(0.002909762388809605371) D7 D8 ^ D18 +error(0.03835760964774096587) D7 D15 +error(0.002600894655011698822) D7 D15 ^ D17 D18 +error(0.002724009470969173709) D7 D16 +error(0.0001420244780088774153) D7 D16 ^ D17 D18 +error(0.0006720224975856690496) D7 D19 +error(0.0001731609387448335244) D7 D19 ^ D10 +error(0.001515517429452719125) D7 D19 ^ D10 D18 +error(0.001775284440288589461) D7 D19 ^ D18 +error(0.01000000000000000021) D7 L0 +error(0.009553341870179846498) D7 L0 ^ D9 +error(0.002995599830747468478) D9 D17 ^ D7 L0 +error(0.0244156362678341482) D8 +error(0.01787221172697869495) D8 D11 +error(0.01809066860640358085) D8 D11 ^ D10 +error(0.01301856977997668113) D8 D16 +error(0.003858045733294246122) D8 D16 ^ D18 +error(0.006380123909502799159) D8 D19 +error(0.005744401601309003132) D8 D19 ^ D10 +error(0.007361967592904819502) D8 D19 ^ D18 +error(0.0002270110188581541592) D8 D19 ^ D18 ^ D10 +error(0.03810305271950164413) D9 +error(0.01322306559387608112) D9 D10 +error(0.002933952254023387916) D9 D10 ^ D1 L0 +error(0.0161159459648473509) D9 D10 ^ D7 L0 +error(0.01964153537693690693) D9 D17 +error(0.05280003997875199612) D10 +error(0.004067793978315414893) D10 D17 +error(0.002599929736851371975) D10 D17 ^ D7 L0 +error(0.000295483230693712102) D10 D17 ^ D19 L0 +error(0.0004714672778330290348) D10 D17 ^ D19 L0 ^ D7 L0 +error(0.01904025714840528252) D10 D18 +error(0.004912080207481450515) D10 D18 ^ D19 L0 +error(0.0007787766527021844137) D10 ^ D2 +error(0.01206134953930096051) D10 ^ D11 L0 +error(9.0280909023815703e-05) D10 ^ D11 L0 ^ D1 L0 ^ D9 +error(0.001974351662986553301) D10 ^ D19 L0 +error(0.004245941207523092932) D11 D19 ^ D10 +error(0.02333341271102808839) D11 D19 +error(0.01249050441854263928) D11 L0 +error(0.0009253753547214031662) D11 L0 ^ D9 +error(0.006466575227100140356) D12 +error(0.01314395964648494911) D12 D15 +error(0.01208525607114230987) D12 D15 ^ D13 +error(0.02020216446917192515) D12 D20 +error(0.002199322860023935396) D12 D20 ^ D21 +error(0.002189438347068962693) D12 D23 +error(0.002311939610813036703) D12 D23 ^ D13 +error(0.001914360464039917319) D12 D23 ^ D21 +error(0.0006371972034096348844) D12 D23 ^ D21 ^ D13 +error(0.00253435661992259826) D12 D24 +error(0.001994128845382244202) D12 D24 ^ D13 D21 +error(0.008887773680608607521) D12 ^ D13 +error(0.003601801379827148427) D12 ^ D21 +error(0.002854654490573347442) D13 D21 ^ D12 +error(0.01000000000000000021) D13 +error(0.007489977724297124106) D13 D14 +error(0.0004358103099677155742) D13 D14 ^ D15 D16 +error(0.0113155567906784698) D13 D14 ^ D16 +error(0.001370458776576407092) D13 D14 ^ D16 D24 +error(0.001415814666578600525) D13 D14 ^ D24 +error(0.0003564322737099771062) D13 D14 ^ D24 ^ D12 +error(0.0145843843580518006) D13 D18 +error(0.01051585789660760065) D13 D18 ^ D15 D16 +error(0.03610022212504324784) D13 D21 +error(0.001436562714346872405) D13 D21 ^ D23 D24 +error(0.00120171249355131046) D13 D21 ^ D24 +error(0.001164397002357756309) D13 D25 +error(0.002199892265035710125) D13 D25 ^ D15 D23 +error(0.0003447763067211021101) D13 D25 ^ D15 D24 +error(0.0002296245505507356658) D13 D25 ^ D23 D24 +error(0.005927023497288577518) D13 D26 +error(0.001755655722396575998) D13 D26 ^ D15 D16 +error(0.001423864549265496096) D13 D26 ^ D15 D23 +error(0.0007586253783040229496) D13 D26 ^ D15 D24 +error(6.627277110149178842e-06) D13 D26 ^ D16 D24 +error(0.001806965095818935689) D13 D26 ^ D23 D24 +error(0.0007146197475499093408) D13 ^ D23 L0 +error(0.001579474129444302481) D15 D23 ^ D13 +error(0.01573712770932159111) D14 +error(0.001086847981726183146) D14 D21 +error(0.0001611534419475430218) D14 D21 ^ D12 +error(0.001096882251336390047) D14 D21 ^ D24 +error(0.0002800897744095835729) D14 D21 ^ D24 ^ D12 +error(0.03351480314878754752) D14 D22 +error(0.00285915164077798177) D14 D22 ^ D24 +error(0.0002528151521404119607) D14 D26 ^ D15 D16 +error(0.0006041119901846543801) D14 D26 ^ D15 D24 +error(0.001229266370598511423) D14 D26 ^ D16 D24 +error(0.01521547623360885136) D14 ^ D16 +error(2.968220076744845746e-05) D14 ^ D24 +error(0.001958019466985956494) D14 ^ D24 ^ D16 +error(0.01713471235819119531) D15 D16 +error(0.0002604047632578641337) D15 D16 ^ D5 +error(0.001384576421868720071) D15 D16 ^ D18 +error(0.001538869193277376092) D15 D16 ^ D18 D26 +error(0.002909762388809605371) D15 D16 ^ D26 +error(0.03835760964774096587) D15 D23 +error(0.002600894655011698822) D15 D23 ^ D25 D26 +error(0.002724009470969173709) D15 D24 +error(0.0001420244780088774153) D15 D24 ^ D25 D26 +error(0.0006720224975856690496) D15 D27 +error(0.0001731609387448335244) D15 D27 ^ D18 +error(0.001515517429452719125) D15 D27 ^ D18 D26 +error(0.001775284440288589461) D15 D27 ^ D26 +error(0.01172402532875652104) D15 L0 +error(0.0128431469064208964) D15 L0 ^ D17 +error(0.002995599830747468478) D17 D25 ^ D15 L0 +error(0.02373262250678289179) D16 +error(0.02014155949419157293) D16 D19 +error(0.02053080376071224344) D16 D19 ^ D18 +error(0.01301856977997668113) D16 D24 +error(0.003858045733294246122) D16 D24 ^ D26 +error(0.006380123909502799159) D16 D27 +error(0.005744401601309003132) D16 D27 ^ D18 +error(0.007361967592904819502) D16 D27 ^ D26 +error(0.0002270110188581541592) D16 D27 ^ D26 ^ D18 +error(0.007457619003024312104) D17 +error(0.01732104147399688918) D17 D18 +error(0.003433612300511704012) D17 D18 ^ D7 L0 +error(0.01619998158922418205) D17 D18 ^ D15 L0 +error(0.0002879164418750150794) D17 D18 ^ D19 L0 ^ D7 L0 +error(0.01964153537693690693) D17 D25 +error(0.0006663330409879571333) D17 ^ D5 ^ D7 L0 +error(0.0004730670003356436519) D17 ^ D5 ^ D15 L0 +error(0.0009088063723529440094) D17 ^ D15 L0 ^ D7 L0 +error(0.0274740695463731241) D18 +error(0.004067793978315414893) D18 D25 +error(0.002599929736851371975) D18 D25 ^ D15 L0 +error(0.000295483230693712102) D18 D25 ^ D27 L0 +error(0.0004714672778330290348) D18 D25 ^ D27 L0 ^ D15 L0 +error(0.01904025714840528252) D18 D26 +error(0.004912080207481450515) D18 D26 ^ D27 L0 +error(1.281741113159744296e-05) D18 ^ D6 ^ D16 +error(0.001953567929653801227) D18 ^ D16 +error(0.009523102431688622652) D18 ^ D19 L0 +error(0.001974351662986553301) D18 ^ D27 L0 +error(0.004245941207523092932) D19 D27 ^ D18 +error(0.02333341271102808839) D19 D27 +error(0.006029563810247337043) D19 L0 +error(0.006466575227100140356) D20 +error(0.01314395964648494911) D20 D23 +error(0.01208525607114230987) D20 D23 ^ D21 +error(0.02020216446917192515) D20 D28 +error(0.002199322860023935396) D20 D28 ^ D29 +error(0.002189438347068962693) D20 D31 +error(0.002311939610813036703) D20 D31 ^ D21 +error(0.001914360464039917319) D20 D31 ^ D29 +error(0.0006371972034096348844) D20 D31 ^ D29 ^ D21 +error(0.00253435661992259826) D20 D32 +error(0.001994128845382244202) D20 D32 ^ D21 D29 +error(0.008887773680608607521) D20 ^ D21 +error(0.003601801379827148427) D20 ^ D29 +error(0.002854654490573347442) D21 D29 ^ D20 +error(0.01000000000000000021) D21 +error(0.007489977724297124106) D21 D22 +error(0.0004358103099677155742) D21 D22 ^ D23 D24 +error(0.0113155567906784698) D21 D22 ^ D24 +error(0.001370458776576407092) D21 D22 ^ D24 D32 +error(0.001415814666578600525) D21 D22 ^ D32 +error(0.0003564322737099771062) D21 D22 ^ D32 ^ D20 +error(0.0145843843580518006) D21 D26 +error(0.01051585789660760065) D21 D26 ^ D23 D24 +error(0.03610022212504324784) D21 D29 +error(0.001436562714346872405) D21 D29 ^ D31 D32 +error(0.00120171249355131046) D21 D29 ^ D32 +error(0.001164397002357756309) D21 D33 +error(0.002199892265035710125) D21 D33 ^ D23 D31 +error(0.0003447763067211021101) D21 D33 ^ D23 D32 +error(0.0002296245505507356658) D21 D33 ^ D31 D32 +error(0.005927023497288577518) D21 D34 +error(0.001755655722396575998) D21 D34 ^ D23 D24 +error(0.001423864549265496096) D21 D34 ^ D23 D31 +error(0.0007586253783040229496) D21 D34 ^ D23 D32 +error(6.627277110149178842e-06) D21 D34 ^ D24 D32 +error(0.001806965095818935689) D21 D34 ^ D31 D32 +error(0.0007146197475499093408) D21 ^ D31 L0 +error(0.001579474129444302481) D23 D31 ^ D21 +error(0.01573712770932159111) D22 +error(0.001086847981726183146) D22 D29 +error(0.0001611534419475430218) D22 D29 ^ D20 +error(0.001096882251336390047) D22 D29 ^ D32 +error(0.0002800897744095835729) D22 D29 ^ D32 ^ D20 +error(0.03351480314878754752) D22 D30 +error(0.00285915164077798177) D22 D30 ^ D32 +error(0.0002528151521404119607) D22 D34 ^ D23 D24 +error(0.0006041119901846543801) D22 D34 ^ D23 D32 +error(0.001229266370598511423) D22 D34 ^ D24 D32 +error(0.01521547623360885136) D22 ^ D24 +error(2.968220076744845746e-05) D22 ^ D32 +error(0.001958019466985956494) D22 ^ D32 ^ D24 +error(0.01713471235819119531) D23 D24 +error(0.0002604047632578641337) D23 D24 ^ D13 +error(0.001384576421868720071) D23 D24 ^ D26 +error(0.001538869193277376092) D23 D24 ^ D26 D34 +error(0.002909762388809605371) D23 D24 ^ D34 +error(0.03835760964774096587) D23 D31 +error(0.002600894655011698822) D23 D31 ^ D33 D34 +error(0.002724009470969173709) D23 D32 +error(0.0001420244780088774153) D23 D32 ^ D33 D34 +error(0.0006720224975856690496) D23 D35 +error(0.0001731609387448335244) D23 D35 ^ D26 +error(0.001515517429452719125) D23 D35 ^ D26 D34 +error(0.001775284440288589461) D23 D35 ^ D34 +error(0.01172402532875652104) D23 L0 +error(0.0128431469064208964) D23 L0 ^ D25 +error(0.002995599830747468478) D25 D33 ^ D23 L0 +error(0.02373262250678289179) D24 +error(0.02014155949419157293) D24 D27 +error(0.02053080376071224344) D24 D27 ^ D26 +error(0.01301856977997668113) D24 D32 +error(0.003858045733294246122) D24 D32 ^ D34 +error(0.006380123909502799159) D24 D35 +error(0.005744401601309003132) D24 D35 ^ D26 +error(0.007361967592904819502) D24 D35 ^ D34 +error(0.0002270110188581541592) D24 D35 ^ D34 ^ D26 +error(0.007457619003024312104) D25 +error(0.01732104147399688918) D25 D26 +error(0.003433612300511704012) D25 D26 ^ D15 L0 +error(0.01619998158922418205) D25 D26 ^ D23 L0 +error(0.0002879164418750150794) D25 D26 ^ D27 L0 ^ D15 L0 +error(0.01964153537693690693) D25 D33 +error(0.0006663330409879571333) D25 ^ D13 ^ D15 L0 +error(0.0004730670003356436519) D25 ^ D13 ^ D23 L0 +error(0.0009088063723529440094) D25 ^ D23 L0 ^ D15 L0 +error(0.0274740695463731241) D26 +error(0.004067793978315414893) D26 D33 +error(0.002599929736851371975) D26 D33 ^ D23 L0 +error(0.000295483230693712102) D26 D33 ^ D35 L0 +error(0.0004714672778330290348) D26 D33 ^ D35 L0 ^ D23 L0 +error(0.01904025714840528252) D26 D34 +error(0.004912080207481450515) D26 D34 ^ D35 L0 +error(1.281741113159744296e-05) D26 ^ D14 ^ D24 +error(0.001953567929653801227) D26 ^ D24 +error(0.009523102431688622652) D26 ^ D27 L0 +error(0.001974351662986553301) D26 ^ D35 L0 +error(0.004245941207523092932) D27 D35 ^ D26 +error(0.02333341271102808839) D27 D35 +error(0.006029563810247337043) D27 L0 +error(0.01184176228412850244) D28 +error(0.01331851990615362524) D28 D31 +error(0.01101881183088292832) D28 D31 ^ D29 +error(0.02205898686209462056) D28 D36 +error(0.003954449370933123264) D28 D37 +error(0.004943580325001869537) D28 D37 ^ D29 +error(0.001231552813786393431) D28 D38 +error(0.002183350884188704159) D28 D38 ^ D29 +error(0.009761875809024407949) D28 ^ D29 +error(0.000284390838151665781) D28 ^ D30 +error(0.05521540982709156192) D29 +error(0.006407629681380076249) D29 D30 +error(0.01044859042511467329) D29 D30 ^ D32 +error(0.00209236904602443834) D29 D30 ^ D32 D38 +error(0.001145897666559682988) D29 D30 ^ D38 +error(0.01156178347884406245) D29 D34 +error(0.01244148839867704331) D29 D34 ^ D31 D32 +error(0.001810033566583623939) D29 ^ D28 ^ D30 +error(0.0004601068037124779746) D29 ^ D37 L0 +error(0.0058050451829360682) D31 D37 ^ D29 +error(0.000166872889529260537) D29 ^ D38 +error(0.04312958053661297697) D30 +error(0.01418063797992764365) D30 ^ D32 +error(0.003224251419371055704) D30 ^ D38 +error(0.003790587865598854089) D32 D38 ^ D30 +error(0.01905818528779996274) D31 D32 +error(0.0002604047632578641337) D31 D32 ^ D21 +error(0.00178155514148267257) D31 D32 ^ D29 +error(0.0002077769017477856112) D31 D32 ^ D30 ^ D29 +error(0.0002687194589586536881) D31 D32 ^ D33 D34 +error(0.004581902514835871527) D31 D32 ^ D34 +error(0.04497049881089179579) D31 D37 +error(0.002722253935462430607) D31 D38 +error(0.003178694989723358528) D31 D38 ^ D29 +error(0.0003444898045439944291) D31 D38 ^ D30 +error(0.0002391119965040946224) D31 D38 ^ D30 ^ D29 +error(0.001653360148739776341) D31 D39 +error(0.003039101289582896073) D31 D39 ^ D34 +error(0.02072651652296408561) D31 L0 +error(0.0140565343029624059) D31 L0 ^ D33 +error(0.004388833468126207039) D31 L0 ^ D34 +error(0.03134999785997951566) D32 +error(0.01721736225691261613) D32 D35 +error(0.02000673786535060381) D32 D35 ^ D34 +error(0.01558818468733058973) D32 D38 +error(0.0007137526374387767906) D32 D38 ^ D29 +error(0.01368557707214998302) D32 D39 +error(0.006626813765635532899) D32 D39 ^ D34 +error(0.02692229743636522996) D33 +error(0.01570304597411748687) D33 D34 +error(0.003433612300511704012) D33 D34 ^ D23 L0 +error(0.01940414595669791298) D33 D34 ^ D31 L0 +error(0.0002879164418750150794) D33 D34 ^ D35 L0 ^ D23 L0 +error(0.0006663330409879571333) D33 ^ D21 ^ D23 L0 +error(0.0004730670003356436519) D33 ^ D21 ^ D31 L0 +error(0.0009088063723529440094) D33 ^ D31 L0 ^ D23 L0 +error(0.05149547077941405565) D34 +error(1.281741113159744296e-05) D34 ^ D22 ^ D32 +error(0.01335517478669751533) D34 ^ D35 L0 +error(0.005831682711285030365) D34 ^ D39 L0 +error(0.003526636078389881919) D35 D39 ^ D34 +error(0.02366226570501584608) D35 D39 +error(0.01034306954098248785) D35 L0 +error(0.01444306578425014198) D36 +error(0.01134922256782422423) D36 D37 +error(0.01590241977702373799) D37 D38 +error(0.002593327631556704375) D37 D38 ^ D29 +error(0.0375333599226334233) D37 L0 +error(0.02582464880780582783) D38 +error(0.01355282925061046528) D38 D39 +error(0.0002709385561156671071) D38 ^ D28 ^ D30 +error(0.01668887829260855965) D39 L0 +detector(3, 2, 0) D0 +detector(5, 2, 0) D1 +detector(5, 4, 0) D2 +detector(7, 4, 0) D3 +detector(3, 2, 1) D4 +detector(4, 3, 1) D5 +detector(4, 5, 1) D6 +detector(5, 2, 1) D7 +detector(5, 4, 1) D8 +detector(6, 1, 1) D9 +detector(6, 3, 1) D10 +detector(7, 4, 1) D11 +detector(3, 2, 2) D12 +detector(4, 3, 2) D13 +detector(4, 5, 2) D14 +detector(5, 2, 2) D15 +detector(5, 4, 2) D16 +detector(6, 1, 2) D17 +detector(6, 3, 2) D18 +detector(7, 4, 2) D19 +detector(3, 2, 3) D20 +detector(4, 3, 3) D21 +detector(4, 5, 3) D22 +detector(5, 2, 3) D23 +detector(5, 4, 3) D24 +detector(6, 1, 3) D25 +detector(6, 3, 3) D26 +detector(7, 4, 3) D27 +detector(3, 2, 4) D28 +detector(4, 3, 4) D29 +detector(4, 5, 4) D30 +detector(5, 2, 4) D31 +detector(5, 4, 4) D32 +detector(6, 1, 4) D33 +detector(6, 3, 4) D34 +detector(7, 4, 4) D35 +detector(3, 2, 5) D36 +detector(5, 2, 5) D37 +detector(5, 4, 5) D38 +detector(7, 4, 5) D39 diff --git a/shared/package-files/44/4420dafec29ec89caadf98d5081c7ff6beca446c574c8e416ffdc407343fbee3/blob b/shared/package-files/44/4420dafec29ec89caadf98d5081c7ff6beca446c574c8e416ffdc407343fbee3/blob new file mode 100644 index 0000000000000000000000000000000000000000..adcc708e554830b430db0d4374f4494482ce0b39 --- /dev/null +++ b/shared/package-files/44/4420dafec29ec89caadf98d5081c7ff6beca446c574c8e416ffdc407343fbee3/blob @@ -0,0 +1,26 @@ +import torch +from torch.fx.passes.infra.pass_base import PassBase, PassResult + + +class _RemoveRuntimeAssertionsPass(PassBase): + """ + Remove runtime assertions inserted by the + _AddRuntimeAssertionsForInlineConstraintsPass. + """ + + def call(self, graph_module) -> PassResult: + modified = False + for module in graph_module.modules(): + if not isinstance(module, torch.fx.GraphModule): + continue + for node in module.graph.nodes: + if node.target == torch.ops.aten._assert_async.msg: + assert_async_node = node + if len(assert_async_node.users) > 0: + continue + module.graph.erase_node(assert_async_node) + # the upstream scalar_tensor <- {le, ge} <- sym_size + # linear chain of nodes of nodes is removed by the + # downstream dead code elimination + modified = True + return PassResult(graph_module, modified) diff --git a/shared/package-files/44/4423ef3ef3e0bf2645869c6feb6cda0a51ee9e07ec22654e4728f146d7cc89a6/blob b/shared/package-files/44/4423ef3ef3e0bf2645869c6feb6cda0a51ee9e07ec22654e4728f146d7cc89a6/blob new file mode 100644 index 0000000000000000000000000000000000000000..9ab686ee56e9849376fd1362dd3505328ef2c2d4 --- /dev/null +++ b/shared/package-files/44/4423ef3ef3e0bf2645869c6feb6cda0a51ee9e07ec22654e4728f146d7cc89a6/blob @@ -0,0 +1,201 @@ +"gau_support","gau_cdf","gau_sf","gau_icdf" +-2.68152605273,7.12453500123e-06,0.999992875465,-1.92239380805 +-2.65264335001,1.03614510491e-05,0.999989638549,-1.83481887477 +-2.62376064729,1.48981138496e-05,0.999985101886,-1.66559158491 +-2.59487794457,2.11808786682e-05,0.999978819121,-1.56659053339 +-2.56599524184,2.9779634697e-05,0.999970220365,-1.50058530994 +-2.53711253912,4.14118032414e-05,0.999958588197,-1.47690389521 +-2.5082298364,5.69680635397e-05,0.999943031936,-1.46168307444 +-2.47934713368,7.75392361456e-05,0.999922460764,-1.44845259548 +-2.45046443096,0.000104443676332,0.999895556324,-1.42766325442 +-2.42158172824,0.000139254535672,0.999860745464,-1.40536290954 +-2.39269902552,0.000183826365085,0.999816173635,-1.37866311169 +-2.3638163228,0.000240320773946,0.999759679226,-1.36579794775 +-2.33493362008,0.00031123122816,0.999688768772,-1.35265484882 +-2.30605091736,0.000399407544263,0.999600592456,-1.32901026057 +-2.27716821463,0.000508081169423,0.999491918831,-1.30106487224 +-2.24828551191,0.000640892854306,0.999359107146,-1.28136096561 +-2.21940280919,0.000801924728885,0.999198075271,-1.25726223282 +-2.19052010647,0.000995738966457,0.999004261034,-1.22164742554 +-2.16163740375,0.00122742505181,0.998772574948,-1.20289552418 +-2.13275470103,0.00150265705413,0.998497342946,-1.19191755697 +-2.10387199831,0.00182776117665,0.998172238823,-1.18497917426 +-2.07498929559,0.00220979219983,0.9977902078,-1.16319147447 +-2.04610659287,0.00265661531023,0.99734338469,-1.13360212315 +-2.01722389015,0.00317698734885,0.996823012651,-1.08857803448 +-1.98834118743,0.0037806289367,0.996219371063,-1.0566876793 +-1.9594584847,0.00447827652522,0.995521723475,-0.955362977516 +-1.93057578198,0.00528170150428,0.994718298496,-0.869792860819 +-1.90169307926,0.00620368242214,0.993796317578,-0.81920325724 +-1.87281037654,0.00725791644137,0.992742083559,-0.701066521873 +-1.84392767382,0.00845885761346,0.991541142387,-0.637628066122 +-1.8150449711,0.00982147252774,0.990178527472,-0.630778352753 +-1.78616226838,0.0113609083588,0.988639091641,-0.599684109971 +-1.75727956566,0.0130920741175,0.986907925882,-0.559204189372 +-1.72839686294,0.0150291426553,0.984970857345,-0.50409751561 +-1.69951416022,0.0171849881865,0.982815011813,-0.452368216125 +-1.6706314575,0.0195705811838,0.980429418816,-0.411105699189 +-1.64174875477,0.0221943688053,0.977805631195,-0.391965032785 +-1.61286605205,0.0250616739082,0.974938326092,-0.387707123794 +-1.58398334933,0.0281741486146,0.971825851385,-0.372893827555 +-1.55510064661,0.0315293189218,0.968470681078,-0.356545158913 +-1.52621794389,0.0351202547592,0.964879745241,-0.332786057938 +-1.49733524117,0.0389353951857,0.961064604814,-0.311814408556 +-1.46845253845,0.0429585513184,0.957041448682,-0.289013049456 +-1.43956983573,0.0471691005226,0.952830899477,-0.279290538797 +-1.41068713301,0.0515423749777,0.948457625022,-0.233179373219 +-1.38180443029,0.0560502366881,0.943949763312,-0.157880129667 +-1.35292172757,0.0606618201148,0.939338179885,-0.125623058356 +-1.32403902484,0.0653444136218,0.934655586378,-0.0658329449305 +-1.29515632212,0.0700644425601,0.92993555744,0.0113848858649 +-1.2662736194,0.0747885106074,0.925211489393,0.071488110126 +-1.23739091668,0.0794844523597,0.92051554764,0.104992234356 +-1.20850821396,0.0841223493209,0.915877650679,0.124303616388 +-1.17962551124,0.0886754633918,0.911324536608,0.216941732529 +-1.15074280852,0.0931210465275,0.906878953472,0.282893609898 +-1.1218601058,0.0974409920565,0.902559007943,0.295183064405 +-1.09297740308,0.101622301739,0.898377698261,0.310619106128 +-1.06409470036,0.105657352372,0.894342647628,0.343255816677 +-1.03521199764,0.109543955957,0.890456044043,0.365451688188 +-1.00632929491,0.113285217451,0.886714782549,0.381126483039 +-0.977446592194,0.116889203315,0.883110796685,0.392002699295 +-0.948563889473,0.120368441888,0.879631558112,0.408204151711 +-0.919681186752,0.12373928272,0.87626071728,0.414956360095 +-0.890798484031,0.127021146109,0.872978853891,0.419763888359 +-0.86191578131,0.130235696253,0.869764303747,0.421129156541 +-0.83303307859,0.133405971762,0.866594028238,0.423716078066 +-0.804150375869,0.136555506071,0.863444493929,0.430449824149 +-0.775267673148,0.13970746794,0.86029253206,0.453185249066 +-0.746384970427,0.142883849256,0.857116150744,0.461023419554 +-0.717502267706,0.146104723985,0.853895276015,0.464262111108 +-0.688619564985,0.149387598899,0.850612401101,0.4681076662 +-0.659736862264,0.152746873648,0.847253126352,0.472976110966 +-0.630854159543,0.156193425004,0.843806574996,0.504645634711 +-0.601971456822,0.159734327549,0.840265672451,0.517843851484 +-0.573088754101,0.16337272047,0.83662727953,0.532269255316 +-0.54420605138,0.167107827268,0.832892172732,0.54131815485 +-0.51532334866,0.170935131728,0.829064868272,0.545431410123 +-0.486440645939,0.174846709353,0.825153290647,0.550387206707 +-0.457557943218,0.17883170849,0.82116829151,0.552393771415 +-0.428675240497,0.182876969761,0.817123030239,0.555948075102 +-0.399792537776,0.186967766403,0.813032233597,0.557291047195 +-0.370909835055,0.191088642145,0.808911357855,0.563583508135 +-0.342027132334,0.19522431782,0.80477568218,0.566206214553 +-0.313144429613,0.199360633562,0.800639366438,0.575503561923 +-0.284261726892,0.203485490543,0.796514509457,0.586403875658 +-0.255379024171,0.207589755151,0.792410244849,0.594508611782 +-0.22649632145,0.211668089305,0.788331910695,0.621520674499 +-0.19761361873,0.215719673198,0.784280326802,0.624162758573 +-0.168730916009,0.219748790832,0.780251209168,0.640464899498 +-0.139848213288,0.223765253906,0.776234746094,0.654406422753 +-0.110965510567,0.227784645391,0.772215354609,0.677297780111 +-0.0820828078459,0.231828370253,0.768171629747,0.707435356718 +-0.053200105125,0.235923506788,0.764076493212,0.711198052444 +-0.0243174024041,0.240102457964,0.759897542036,0.711869666677 +0.00456530031684,0.244402407968,0.755597592032,0.715664551119 +0.0334480030378,0.248864595068,0.751135404932,0.729880328503 +0.0623307057587,0.253533417979,0.746466582021,0.752493098192 +0.0912134084796,0.25845539951,0.74154460049,0.753217686309 +0.1200961112,0.263678038027,0.736321961973,0.760407899163 +0.148978813921,0.269248584214,0.730751415786,0.777005316568 +0.177861516642,0.275212786932,0.724787213068,0.781471865227 +0.206744219363,0.281613657057,0.718386342943,0.782657697599 +0.235626922084,0.288490301083,0.711509698917,0.799888301702 +0.264509624805,0.295876876039,0.704123123961,0.805889525352 +0.293392327526,0.30380171336,0.69619828664,0.806762106813 +0.322275030247,0.312286651307,0.687713348693,0.811252311378 +0.351157732968,0.321346603679,0.678653396321,0.824638242173 +0.380040435689,0.330989377517,0.669010622483,0.825029707612 +0.40892313841,0.341215735688,0.658784264312,0.827409870175 +0.43780584113,0.352019683206,0.647980316794,0.835052774878 +0.466688543851,0.363388940859,0.636611059141,0.852256835835 +0.495571246572,0.375305557974,0.624694442026,0.866655685818 +0.524453949293,0.38774660931,0.61225339069,0.870683613571 +0.553336652014,0.400684920201,0.599315079799,0.872980860901 +0.582219354735,0.414089769064,0.585910230936,0.882323680129 +0.611102057456,0.427927526712,0.572072473288,0.888683252754 +0.639984760177,0.44216220614,0.55783779386,0.903999249921 +0.668867462898,0.456755912511,0.543244087489,0.907096981621 +0.697750165619,0.471669198932,0.528330801068,0.915473469977 +0.72663286834,0.486861347018,0.513138652982,0.921841400505 +0.75551557106,0.502290600491,0.497709399509,0.923590056594 +0.784398273781,0.51791438419,0.48208561581,0.924673004983 +0.813280976502,0.533689539393,0.466310460607,0.928400788971 +0.842163679223,0.549572600106,0.450427399894,0.931598877585 +0.871046381944,0.565520124935,0.434479875065,0.932359491314 +0.899929084665,0.581489087278,0.418510912722,0.934965652592 +0.928811787386,0.597437314602,0.402562685398,0.942390609454 +0.957694490107,0.613323957354,0.386676042646,0.943621322729 +0.986577192828,0.629109960898,0.370890039102,0.951456223822 +1.01545989555,0.644758510524,0.355241489476,0.97458235827 +1.04434259827,0.660235420182,0.339764579818,0.987638377835 +1.07322530099,0.675509439608,0.324490560392,1.00450100681 +1.10210800371,0.690552460971,0.309447539029,1.02380786661 +1.13099070643,0.70533961403,0.29466038597,1.03053936708 +1.15987340915,0.719849246695,0.280150753305,1.03376510764 +1.18875611187,0.734062795218,0.265937204782,1.03976167382 +1.2176388146,0.747964554098,0.252035445902,1.04591598843 +1.24652151732,0.761541360363,0.238458639637,1.0484937859 +1.27540422004,0.774782210005,0.225217789995,1.05827359918 +1.30428692276,0.787677826721,0.212322173279,1.08367547542 +1.33316962548,0.800220204831,0.199779795169,1.0979466208 +1.3620523282,0.812402149857,0.187597850143,1.11134931455 +1.39093503092,0.824216841625,0.175783158375,1.12507749105 +1.41981773364,0.835657445696,0.164342554304,1.14690537208 +1.44870043636,0.846716798971,0.153283201029,1.15705960279 +1.47758313908,0.857387193809,0.142612806191,1.16643090396 +1.5064658418,0.867660281338,0.132339718662,1.17529005462 +1.53534854453,0.87752710857,0.12247289143,1.18236505563 +1.56423124725,0.886978295317,0.113021704683,1.19053546662 +1.59311394997,0.896004346392,0.103995653608,1.19413289166 +1.62199665269,0.904596082887,0.0954039171135,1.20072357031 +1.65087935541,0.912745164833,0.0872548351669,1.20519268608 +1.67976205813,0.920444667611,0.0795553323893,1.21172435612 +1.70864476085,0.927689667446,0.0723103325545,1.2178781763 +1.73752746357,0.934477788326,0.065522211674,1.2273105068 +1.76641016629,0.940809664238,0.0591903357615,1.23291048584 +1.79529286901,0.946689276842,0.0533107231584,1.23668856164 +1.82417557173,0.952124138955,0.0478758610448,1.25661562821 +1.85305827446,0.957125307428,0.0428746925719,1.29112217335 +1.88194097718,0.961707223588,0.0382927764122,1.30273987398 +1.9108236799,0.965887393908,0.0341126060916,1.30568306018 +1.93970638262,0.969685936201,0.0303140637995,1.30930056925 +1.96858908534,0.973125026231,0.026874973769,1.31434768084 +1.99747178806,0.976228285389,0.0237717146112,1.31750401124 +2.02635449078,0.979020151504,0.0209798484965,1.3182844513 +2.0552371935,0.981525272415,0.0184747275854,1.31944699448 +2.08411989622,0.983767956039,0.0162320439612,1.32613337423 +2.11300259894,0.98577170248,0.0142282975196,1.34058357969 +2.14188530166,0.987558834298,0.012441165702,1.37133815533 +2.17076800439,0.989150231519,0.0108497684806,1.41486821975 +2.19965070711,0.990565169338,0.00943483066206,1.43820914866 +2.22853340983,0.991821249363,0.00817875063676,1.45246724833 +2.25741611255,0.992934410239,0.00706558976132,1.46554006199 +2.28629881527,0.993919000511,0.00608099948871,1.47558739071 +2.31518151799,0.9947878957,0.00521210429991,1.49497745292 +2.34406422071,0.995552642241,0.00444735775918,1.51102828466 +2.37294692343,0.996223612958,0.00377638704238,1.51537589482 +2.40182962615,0.996810161468,0.00318983853188,1.52170540714 +2.43071232887,0.997320766041,0.0026792339588,1.53700823237 +2.45959503159,0.997763156541,0.00223684345855,1.5529683089 +2.48847773432,0.998144420951,0.00185557904874,1.56182024317 +2.51736043704,0.998471090392,0.00152890960795,1.58116331894 +2.54624313976,0.998749203488,0.00125079651199,1.60592585242 +2.57512584248,0.99898435231,0.00101564768974,1.62489105616 +2.6040085452,0.999181713034,0.000818286966037,1.63082074259 +2.63289124792,0.999346064892,0.000653935107924,1.64183461965 +2.66177395064,0.999481801086,0.000518198913617,1.65673582096 +2.69065665336,0.999592935098,0.000407064902069,1.66854161392 +2.71953935608,0.9996831054,0.000316894600095,1.67501439497 +2.7484220588,0.999755580993,0.000244419007479,1.68682986366 +2.77730476152,0.99981326952,0.000186730479607,1.70122753371 +2.80618746425,0.999858729061,0.000141270938532,1.71037890223 +2.83507016697,0.999894184047,0.000105815953374,1.71683094214 +2.86395286969,0.999921545223,7.84547768758e-05,1.72407364916 +2.89283557241,0.999942433143,5.75668571107e-05,1.74415197038 +2.92171827513,0.999958204354,4.17956463222e-05,1.82308608579 +2.95060097785,0.999969979299,3.0020700535e-05,1.94938997751 +2.97948368057,0.999978670886,2.13291140611e-05,2.02918767946 +3.00836638329,0.999985012718,1.49872816497e-05,2.05697781436 +3.03724908601,0.999989586147,1.0413853017e-05,2.20848591097 +3.06613178873,0.999992845433,7.15456734524e-06,2.30699954406 diff --git a/shared/package-files/44/4424e77879e8cb0f5a02c8d155db0a911858380922cb2654255ba7b9aea1223f/blob b/shared/package-files/44/4424e77879e8cb0f5a02c8d155db0a911858380922cb2654255ba7b9aea1223f/blob new file mode 100644 index 0000000000000000000000000000000000000000..417baeac721fd097b7701b63b6329f1b3163e07b Binary files /dev/null and b/shared/package-files/44/4424e77879e8cb0f5a02c8d155db0a911858380922cb2654255ba7b9aea1223f/blob differ diff --git a/shared/package-files/44/44257160643f089eb00bbbff1e4aa8a2e5363e1b5cbe52757df232c73002faca/blob b/shared/package-files/44/44257160643f089eb00bbbff1e4aa8a2e5363e1b5cbe52757df232c73002faca/blob new file mode 100644 index 0000000000000000000000000000000000000000..607501a275c67941e2a67883dc9c99a887ac0581 --- /dev/null +++ b/shared/package-files/44/44257160643f089eb00bbbff1e4aa8a2e5363e1b5cbe52757df232c73002faca/blob @@ -0,0 +1,33 @@ +import os +from typing import Generic, IO, Literal, TypeVar, overload + +from matplotlib.font_manager import FontProperties +from matplotlib.typing import ColorType + +# Re-exported API from _mathtext. +from ._mathtext import ( + RasterParse as RasterParse, + VectorParse as VectorParse, + get_unicode_index as get_unicode_index, +) + +_ParseType = TypeVar("_ParseType", RasterParse, VectorParse) + +class MathTextParser(Generic[_ParseType]): + @overload + def __init__(self: MathTextParser[VectorParse], output: Literal["path"]) -> None: ... + @overload + def __init__(self: MathTextParser[RasterParse], output: Literal["agg", "raster", "macosx"]) -> None: ... + def parse( + self, s: str, dpi: float = ..., prop: FontProperties | None = ..., *, antialiased: bool | None = ... + ) -> _ParseType: ... + +def math_to_image( + s: str, + filename_or_obj: str | os.PathLike | IO, + prop: FontProperties | None = ..., + dpi: float | None = ..., + format: str | None = ..., + *, + color: ColorType | None = ... +) -> float: ... diff --git a/shared/package-files/44/442f9c6caf31cc31a3aea33271ea1ed9de877b05a34de561fa7dbeddc19dd2c7/blob b/shared/package-files/44/442f9c6caf31cc31a3aea33271ea1ed9de877b05a34de561fa7dbeddc19dd2c7/blob new file mode 100644 index 0000000000000000000000000000000000000000..51296d3a95b36f023939e933c6bdd1eb97eed1ce --- /dev/null +++ b/shared/package-files/44/442f9c6caf31cc31a3aea33271ea1ed9de877b05a34de561fa7dbeddc19dd2c7/blob @@ -0,0 +1,14 @@ +# LZ4 - Fast LZ compression algorithm +# Copyright (C) 2011-2020, Yann Collet. +# BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + +prefix=/opt/conda +libdir=${prefix}/lib +includedir=${prefix}/include + +Name: lz4 +Description: extremely fast lossless compression algorithm library +URL: http://www.lz4.org/ +Version: 1.9.4 +Libs: -L${libdir} -llz4 +Cflags: -I${includedir} diff --git a/shared/package-files/44/443a989ec334a433c4879f61ab4047ae5e9834b14147bc3c80b21dc5559dcef6/blob b/shared/package-files/44/443a989ec334a433c4879f61ab4047ae5e9834b14147bc3c80b21dc5559dcef6/blob new file mode 100644 index 0000000000000000000000000000000000000000..ccbfd45f8141c35d909cd46f7df03ccd55dc0b20 --- /dev/null +++ b/shared/package-files/44/443a989ec334a433c4879f61ab4047ae5e9834b14147bc3c80b21dc5559dcef6/blob @@ -0,0 +1,138 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + +from narwhals._constants import ( + MS_PER_MINUTE, + MS_PER_SECOND, + NS_PER_SECOND, + SECONDS_PER_MINUTE, + US_PER_MINUTE, + US_PER_SECOND, +) +from narwhals._duckdb.utils import UNITS_DICT, F, fetch_rel_time_zone, lit, sql_expression +from narwhals._duration import Interval +from narwhals._sql.expr_dt import SQLExprDateTimeNamesSpace +from narwhals._utils import not_implemented, requires + +if TYPE_CHECKING: + from collections.abc import Sequence + + from duckdb import Expression + + from narwhals._duckdb.dataframe import DuckDBLazyFrame + from narwhals._duckdb.expr import DuckDBExpr + + +class DuckDBExprDateTimeNamespace(SQLExprDateTimeNamesSpace["DuckDBExpr"]): + def millisecond(self) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: F("millisecond", expr) - F("second", expr) * lit(MS_PER_SECOND) + ) + + def microsecond(self) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: F("microsecond", expr) - F("second", expr) * lit(US_PER_SECOND) + ) + + def nanosecond(self) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: F("nanosecond", expr) - F("second", expr) * lit(NS_PER_SECOND) + ) + + def to_string(self, format: str) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: F("strftime", expr, lit(format)) + ) + + def weekday(self) -> DuckDBExpr: + return self.compliant._with_elementwise(lambda expr: F("isodow", expr)) + + def date(self) -> DuckDBExpr: + return self.compliant._with_elementwise(lambda expr: expr.cast("date")) + + def total_minutes(self) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: F("datepart", lit("minute"), expr) + ) + + def total_seconds(self) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: ( + lit(SECONDS_PER_MINUTE) * F("datepart", lit("minute"), expr) + + F("datepart", lit("second"), expr) + ) + ) + + def total_milliseconds(self) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: ( + lit(MS_PER_MINUTE) * F("datepart", lit("minute"), expr) + + F("datepart", lit("millisecond"), expr) + ) + ) + + def total_microseconds(self) -> DuckDBExpr: + return self.compliant._with_elementwise( + lambda expr: ( + lit(US_PER_MINUTE) * F("datepart", lit("minute"), expr) + + F("datepart", lit("microsecond"), expr) + ) + ) + + def truncate(self, every: str) -> DuckDBExpr: + interval = Interval.parse(every) + multiple, unit = interval.multiple, interval.unit + if multiple != 1: + # https://github.com/duckdb/duckdb/issues/17554 + msg = f"Only multiple 1 is currently supported for DuckDB.\nGot {multiple!s}." + raise ValueError(msg) + if unit == "ns": + msg = "Truncating to nanoseconds is not yet supported for DuckDB." + raise NotImplementedError(msg) + format = lit(UNITS_DICT[unit]) + + def _truncate(expr: Expression) -> Expression: + return F("date_trunc", format, expr) + + return self.compliant._with_elementwise(_truncate) + + @requires.backend_version((1, 3)) + def offset_by(self, by: str) -> DuckDBExpr: + interval = Interval.parse_no_constraints(by) + format = lit(f"{interval.multiple!s} {UNITS_DICT[interval.unit]}") + + def _offset_by(expr: Expression) -> Expression: + return expr + sql_expression(f"interval {format}") + + return self.compliant._with_elementwise(_offset_by) + + def _no_op_time_zone(self, time_zone: str) -> DuckDBExpr: + def func(df: DuckDBLazyFrame) -> Sequence[Expression]: + native_series_list = self.compliant(df) + if (conn_time_zone := fetch_rel_time_zone(df.native)) != time_zone: + msg = ( + "DuckDB stores the time zone in the connection, rather than in the " + f"data type, so changing the timezone to anything other than {conn_time_zone} " + " (the current connection time zone) is not supported." + ) + raise NotImplementedError(msg) + return native_series_list + + return self.compliant.__class__( + func, + evaluate_output_names=self.compliant._evaluate_output_names, + alias_output_names=self.compliant._alias_output_names, + version=self.compliant._version, + ) + + def convert_time_zone(self, time_zone: str) -> DuckDBExpr: + return self._no_op_time_zone(time_zone) + + def replace_time_zone(self, time_zone: str | None) -> DuckDBExpr: + if time_zone is None: + return self.compliant._with_elementwise(lambda expr: expr.cast("timestamp")) + return self._no_op_time_zone(time_zone) + + total_nanoseconds = not_implemented() + timestamp = not_implemented() diff --git a/shared/package-files/44/443cd7913e9e1b820af68adf49f3132af33655358deed0bb394a85abee3d3ff3/blob b/shared/package-files/44/443cd7913e9e1b820af68adf49f3132af33655358deed0bb394a85abee3d3ff3/blob new file mode 100644 index 0000000000000000000000000000000000000000..7db21cc96886de75269042053c508712e8f89d0e --- /dev/null +++ b/shared/package-files/44/443cd7913e9e1b820af68adf49f3132af33655358deed0bb394a85abee3d3ff3/blob @@ -0,0 +1,6 @@ +name: pip +dependencies: + - pip + - pip: + - foo + - baz diff --git a/shared/package-files/44/443d4c5249602c1b4136f26ee49f7671565bacede7dfc533750be1e0102f02a2/blob b/shared/package-files/44/443d4c5249602c1b4136f26ee49f7671565bacede7dfc533750be1e0102f02a2/blob new file mode 100644 index 0000000000000000000000000000000000000000..1bae2317a2fc602a436d17e80bc8d4bfdcd7fe5f --- /dev/null +++ b/shared/package-files/44/443d4c5249602c1b4136f26ee49f7671565bacede7dfc533750be1e0102f02a2/blob @@ -0,0 +1,36 @@ +import numpy as np +import pytest + +from pandas.errors import DtypeWarning + +import pandas._testing as tm +from pandas.core.arrays import ArrowExtensionArray + +from pandas.io.parsers.c_parser_wrapper import _concatenate_chunks + + +def test_concatenate_chunks_pyarrow(): + # GH#51876 + pa = pytest.importorskip("pyarrow") + chunks = [ + {0: ArrowExtensionArray(pa.array([1.5, 2.5]))}, + {0: ArrowExtensionArray(pa.array([1, 2]))}, + ] + result = _concatenate_chunks(chunks) + expected = ArrowExtensionArray(pa.array([1.5, 2.5, 1.0, 2.0])) + tm.assert_extension_array_equal(result[0], expected) + + +def test_concatenate_chunks_pyarrow_strings(): + # GH#51876 + pa = pytest.importorskip("pyarrow") + chunks = [ + {0: ArrowExtensionArray(pa.array([1.5, 2.5]))}, + {0: ArrowExtensionArray(pa.array(["a", "b"]))}, + ] + with tm.assert_produces_warning(DtypeWarning, match="have mixed types"): + result = _concatenate_chunks(chunks) + expected = np.concatenate( + [np.array([1.5, 2.5], dtype=object), np.array(["a", "b"])] + ) + tm.assert_numpy_array_equal(result[0], expected) diff --git a/shared/package-files/44/44402114d31204f0e930ffa7ed63dae2b2b408b35dcc0c2b4ff7db2e3133b07b/blob b/shared/package-files/44/44402114d31204f0e930ffa7ed63dae2b2b408b35dcc0c2b4ff7db2e3133b07b/blob new file mode 100644 index 0000000000000000000000000000000000000000..083818c0062d1b47f44d7df9db161c6e14ee227d --- /dev/null +++ b/shared/package-files/44/44402114d31204f0e930ffa7ed63dae2b2b408b35dcc0c2b4ff7db2e3133b07b/blob @@ -0,0 +1,217 @@ +""" +Created on Fri Jan 29 19:19:45 2021 + +Author: Josef Perktold +License: BSD-3 + +""" + +from statsmodels.compat.pandas import deprecate_kwarg + +import numpy as np +from scipy import stats + +from statsmodels.distributions.copula.copulas import Copula +from statsmodels.tools.rng_qrng import check_random_state + + +class IndependenceCopula(Copula): + r"""Independence copula. + + Copula with independent random variables. + + .. math:: + + C_\theta(u,v) = uv + + Parameters + ---------- + k_dim : int, optional + Dimension, number of components in the multivariate random variable. + + Notes + ----- + IndependenceCopula does not have copula parameters. + If non-empty ``args`` are provided in methods, then a ValueError is raised. + The ``args`` keyword is provided for a consistent interface across + copulas. + + """ + + def __init__(self, k_dim=2): + super().__init__(k_dim=k_dim) + + def _handle_args(self, args): + if args != () and args is not None: + msg = "Independence copula does not use copula parameters." + raise ValueError(msg) + else: + return args + + @deprecate_kwarg("random_state", "rng") + def rvs(self, nobs=1, args=(), rng=None): + """Generate random variates from the copula. + + Parameters + ---------- + nobs : int, optional + Number of samples to generate from the copula. Default is 1. + args : tuple, optional + Arguments for copula parameters. Not used by ``IndependenceCopula``. + rng : int, array_like of int, numpy.random.Generator, or numpy.random.RandomState, optional + If `rng` is None, a new ``Generator`` is created using fresh + entropy from the operating system. If `rng` is an int or array + of ints, a new ``Generator`` is created, seeded with `rng`. If + `rng` is already a ``Generator`` or ``RandomState`` instance, + that instance is used. + rng : int, array_like of int, numpy.random.Generator, or numpy.random.RandomState, optional + .. deprecated:: 0.15 + + random_state has been deprecated. In-line with SPEC-007, use + rng for passing a random number generator or seed. + + Returns + ------- + sample : array_like (nobs, k_dim) + Sample from the copula. + """ + self._handle_args(args) + rng = check_random_state(rng) + x = rng.random((nobs, self.k_dim)) + return x + + def pdf(self, u, args=()): + """Probability density function of the independence copula. + + Parameters + ---------- + u : array_like, 2-D + Points of random variables in unit hypercube at which method is + evaluated. + The second (or last) dimension should be the same as the + dimension of the random variable, e.g., 2 for bivariate copula. + args : tuple, optional + Not used by ``IndependenceCopula``. + + Returns + ------- + ndarray + Copula pdf evaluated at points ``u``. Constant equal to 1. + """ + u = np.asarray(u) + return np.ones(u.shape[:-1]) + + def cdf(self, u, args=()): + """Cumulative distribution function of the independence copula. + + Parameters + ---------- + u : array_like, 2-D + Points of random variables in unit hypercube at which method is + evaluated. + The second (or last) dimension should be the same as the + dimension of the random variable, e.g., 2 for bivariate copula. + args : tuple, optional + Not used by ``IndependenceCopula``. + + Returns + ------- + ndarray + Copula cdf evaluated at points ``u``, i.e., the product of the + components of ``u``. + """ + return np.prod(u, axis=-1) + + def tau(self): + """Kendall's tau of the independence copula. + + Returns + ------- + float + Kendall's tau, which is always 0 for the independence copula. + """ + return 0 + + def plot_pdf(self, *args): + """Not implemented. + + Raises + ------ + NotImplementedError + The independence copula's pdf is constant over the domain and + is not plotted. + """ + raise NotImplementedError("PDF is constant over the domain.") + + +def rvs_kernel(sample, size, bw=1, k_func=None, return_extras=False, rng=None): + """Random sampling from empirical copula using Beta distribution + + Parameters + ---------- + sample : ndarray + Sample of multivariate observations in (0, 1) interval. + size : int + Number of observations to simulate. + bw : float, optional + Bandwidth for Beta sampling. The beta copula corresponds to a kernel + estimate of the distribution. bw=1 corresponds to the empirical beta + copula. A small bandwidth like bw=0.001 corresponds to small noise + added to the empirical distribution. Larger bw, e.g., bw=10 corresponds + to kernel estimate with more smoothing. + k_func : callable, optional + The default kernel function is currently a beta function with 1 added + to the first beta parameter. + return_extras : bool, optional + If this is False, then only the random sample will be returned. + If true, then extra information is returned that is mainly of interest + for verification. + rng : int, array_like of int, numpy.random.Generator, or numpy.random.RandomState, optional + If `rng` is None, a new ``Generator`` is created using fresh + entropy from the operating system. If `rng` is an int or array + of ints, a new ``Generator`` is created, seeded with `rng`. If + `rng` is already a ``Generator`` or ``RandomState`` instance, + that instance is used. + + Returns + ------- + rvs : ndarray + Multivariate sample with ``size`` observations drawn from the Beta + Copula. + + Notes + ----- + Status: experimental, API will change. + """ + # vectorized for observations + n = sample.shape[0] + rng = check_random_state(rng) + if k_func is None: + + def kfunc(x, bw): + return _kernel_rvs_beta1(x, bw, rng=rng) + + else: + kfunc = k_func + if isinstance(rng, np.random.RandomState): + idx = rng.randint(0, n, size=size) + else: + idx = rng.integers(0, n, size=size) + xi = sample[idx] + krvs = np.column_stack([kfunc(xii, bw) for xii in xi.T]) + + if return_extras: + return krvs, idx, xi + else: + return krvs + + +def _kernel_rvs_beta(x, bw, rng=None): + # Beta kernel for density, pdf, estimation + return stats.beta.rvs(x / bw + 1, (1 - x) / bw + 1, size=x.shape, random_state=rng) + + +def _kernel_rvs_beta1(x, bw, rng=None): + # Beta kernel for density, pdf, estimation + # Kiriliouk, Segers, Tsukuhara 2020 arxiv, using bandwith 1/nobs sample + return stats.beta.rvs(x / bw, (1 - x) / bw + 1, random_state=rng) diff --git a/shared/package-files/44/44415aefd0f500e2088e9d887b3ef78b0e60127cc6f5169cf6df16c2218bb2e2/blob b/shared/package-files/44/44415aefd0f500e2088e9d887b3ef78b0e60127cc6f5169cf6df16c2218bb2e2/blob new file mode 100644 index 0000000000000000000000000000000000000000..94c03daaa7a6957a2f8d5db77b7def1f8394d301 --- /dev/null +++ b/shared/package-files/44/44415aefd0f500e2088e9d887b3ef78b0e60127cc6f5169cf6df16c2218bb2e2/blob @@ -0,0 +1,76 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// These utilities are for internal / unit test use only. +// They allow for the construction of simple Substrait plans +// programmatically without first requiring the construction +// of an ExecPlan + +// These utilities have to be here, and not in a test_util.cc +// file (or in a unit test) because only one .so is allowed +// to include each .pb.h file or else protobuf will encounter +// global namespace conflicts. + +#include +#include +#include +#include + +#include "arrow/engine/substrait/visibility.h" +#include "arrow/result.h" +#include "arrow/type_fwd.h" + +namespace arrow { +namespace engine { + +struct Id; + +namespace internal { + +/// \brief Create a scan->project->sink plan for tests +/// +/// The plan will project one additional column using the function +/// defined by `function_id`, `arguments`, and data_types. `arguments` +/// and `data_types` should have the same length but only one of each +/// should be defined at each index. +/// +/// If `data_types` is defined at an index then the plan will create a +/// direct reference (starting at index 0 and increasing by 1 for each +/// argument of this type). +/// +/// If `arguments` is defined at an index then the plan will create an +/// enum argument with that value. +ARROW_ENGINE_EXPORT Result> CreateScanProjectSubstrait( + Id function_id, const std::shared_ptr
& input_table, + const std::vector& arguments, + const std::unordered_map>& options, + const std::vector>& data_types, + const DataType& output_type); + +/// \brief Create a scan->aggregate->sink plan for tests +/// +/// The plan will create an aggregate with one grouping set (defined by +/// key_idxs) and one measure. The measure will be a function +/// defined by `function_id` and direct references to `arg_idxs`. +ARROW_ENGINE_EXPORT Result> CreateScanAggSubstrait( + Id function_id, const std::shared_ptr
& input_table, + const std::vector& key_idxs, const std::vector& arg_idxs, + const DataType& output_type); + +} // namespace internal +} // namespace engine +} // namespace arrow diff --git a/shared/package-files/44/444160bdff0762713e5ec89ea6f3cb8ddd876723169542430b620bb540d2d16b/blob b/shared/package-files/44/444160bdff0762713e5ec89ea6f3cb8ddd876723169542430b620bb540d2d16b/blob new file mode 100644 index 0000000000000000000000000000000000000000..7f94850eadc79bfb0493e3379e32ac24e2f00646 --- /dev/null +++ b/shared/package-files/44/444160bdff0762713e5ec89ea6f3cb8ddd876723169542430b620bb540d2d16b/blob @@ -0,0 +1,16 @@ +from typing import Any, Iterator, List, Optional, Tuple, Type, Union + +ESCAPE_MAPPINGS: Any + +class Choice(list): ... +class Group(list): ... +class NonCapture(list): ... + +def normalize(pattern: str) -> List[Tuple[str, List[str]]]: ... +def next_char(input_iter: Any) -> None: ... +def walk_to_end(ch: str, input_iter: Iterator[Any]) -> None: ... +def get_quantifier(ch: str, input_iter: Iterator[Any]) -> Tuple[int, Optional[str]]: ... +def contains(source: Union[Group, NonCapture, str], inst: Type[Group]) -> bool: ... +def flatten_result( + source: Optional[Union[List[Union[Choice, Group, str]], Group, NonCapture]] +) -> Tuple[List[str], List[List[str]]]: ... diff --git a/shared/package-files/44/4441958c2da76644a939c53754e8d3af0eb317f799c19271bacaf6f546104ec9/blob b/shared/package-files/44/4441958c2da76644a939c53754e8d3af0eb317f799c19271bacaf6f546104ec9/blob new file mode 100644 index 0000000000000000000000000000000000000000..c2dbacdc4ddab7a18f495cfc9f8dc34640f65902 --- /dev/null +++ b/shared/package-files/44/4441958c2da76644a939c53754e8d3af0eb317f799c19271bacaf6f546104ec9/blob @@ -0,0 +1,16 @@ +#pragma once + +#include + +namespace torch { +namespace jit { + +// Inline Fork and Wait calls. This is used, for example, in ONNX export, where +// we do not support the explicit parallelism structures and would rather +// just have a flat graph. This inlines the forked section in the fork() +// callsite and replaces uses of the result of wait() calls with the values +// produced from the (now-inlined) forked section. +TORCH_API void InlineForkWait(const std::shared_ptr& graph); + +} // namespace jit +} // namespace torch diff --git a/shared/package-files/44/444376de46bbeaa015b62bae3fe592ac7003e257a2714b0507f0150837d17bc5/blob b/shared/package-files/44/444376de46bbeaa015b62bae3fe592ac7003e257a2714b0507f0150837d17bc5/blob new file mode 100644 index 0000000000000000000000000000000000000000..68e19a260a3ec3abb3176be94c5144833d89aa42 --- /dev/null +++ b/shared/package-files/44/444376de46bbeaa015b62bae3fe592ac7003e257a2714b0507f0150837d17bc5/blob @@ -0,0 +1 @@ +import sys, types, os;has_mfs = sys.version_info > (3, 5);p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('ruamel',));importlib = has_mfs and __import__('importlib.util');has_mfs and __import__('importlib.machinery');m = has_mfs and sys.modules.setdefault('ruamel', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('ruamel', [os.path.dirname(p)])));m = m or sys.modules.setdefault('ruamel', types.ModuleType('ruamel'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p) diff --git a/shared/package-files/44/44482ca5769a4af1775d4c2a7b8d1a6dedd7fc4efe59b04fd7722a2d45012c2c/blob b/shared/package-files/44/44482ca5769a4af1775d4c2a7b8d1a6dedd7fc4efe59b04fd7722a2d45012c2c/blob new file mode 100644 index 0000000000000000000000000000000000000000..73be8fa98e59c15af3a00f3aa51cd561ae19b92b --- /dev/null +++ b/shared/package-files/44/44482ca5769a4af1775d4c2a7b8d1a6dedd7fc4efe59b04fd7722a2d45012c2c/blob @@ -0,0 +1,433 @@ +from __future__ import annotations + +from fontTools.pens.basePen import AbstractPen, DecomposingPen +from fontTools.pens.pointPen import ( + AbstractPointPen, + DecomposingPointPen, + ReverseFlipped, +) +from fontTools.pens.recordingPen import RecordingPen + + +class _PassThruComponentsMixin(object): + def addComponent(self, glyphName, transformation, **kwargs): + self._outPen.addComponent(glyphName, transformation, **kwargs) + + +class FilterPen(_PassThruComponentsMixin, AbstractPen): + """Base class for pens that apply some transformation to the coordinates + they receive and pass them to another pen. + + You can override any of its methods. The default implementation does + nothing, but passes the commands unmodified to the other pen. + + >>> from fontTools.pens.recordingPen import RecordingPen + >>> rec = RecordingPen() + >>> pen = FilterPen(rec) + >>> v = iter(rec.value) + + >>> pen.moveTo((0, 0)) + >>> next(v) + ('moveTo', ((0, 0),)) + + >>> pen.lineTo((1, 1)) + >>> next(v) + ('lineTo', ((1, 1),)) + + >>> pen.curveTo((2, 2), (3, 3), (4, 4)) + >>> next(v) + ('curveTo', ((2, 2), (3, 3), (4, 4))) + + >>> pen.qCurveTo((5, 5), (6, 6), (7, 7), (8, 8)) + >>> next(v) + ('qCurveTo', ((5, 5), (6, 6), (7, 7), (8, 8))) + + >>> pen.closePath() + >>> next(v) + ('closePath', ()) + + >>> pen.moveTo((9, 9)) + >>> next(v) + ('moveTo', ((9, 9),)) + + >>> pen.endPath() + >>> next(v) + ('endPath', ()) + + >>> pen.addComponent('foo', (1, 0, 0, 1, 0, 0)) + >>> next(v) + ('addComponent', ('foo', (1, 0, 0, 1, 0, 0))) + """ + + def __init__(self, outPen): + self._outPen = outPen + self.current_pt = None + + def moveTo(self, pt): + self._outPen.moveTo(pt) + self.current_pt = pt + + def lineTo(self, pt): + self._outPen.lineTo(pt) + self.current_pt = pt + + def curveTo(self, *points): + self._outPen.curveTo(*points) + self.current_pt = points[-1] + + def qCurveTo(self, *points): + self._outPen.qCurveTo(*points) + self.current_pt = points[-1] + + def closePath(self): + self._outPen.closePath() + self.current_pt = None + + def endPath(self): + self._outPen.endPath() + self.current_pt = None + + +class ContourFilterPen(_PassThruComponentsMixin, RecordingPen): + """A "buffered" filter pen that accumulates contour data, passes + it through a ``filterContour`` method when the contour is closed or ended, + and finally draws the result with the output pen. + + Components are passed through unchanged. + """ + + def __init__(self, outPen): + super(ContourFilterPen, self).__init__() + self._outPen = outPen + + def closePath(self): + super(ContourFilterPen, self).closePath() + self._flushContour() + + def endPath(self): + super(ContourFilterPen, self).endPath() + self._flushContour() + + def _flushContour(self): + result = self.filterContour(self.value) + if result is not None: + self.value = result + self.replay(self._outPen) + self.value = [] + + def filterContour(self, contour): + """Subclasses must override this to perform the filtering. + + The contour is a list of pen (operator, operands) tuples. + Operators are strings corresponding to the AbstractPen methods: + "moveTo", "lineTo", "curveTo", "qCurveTo", "closePath" and + "endPath". The operands are the positional arguments that are + passed to each method. + + If the method doesn't return a value (i.e. returns None), it's + assumed that the argument was modified in-place. + Otherwise, the return value is drawn with the output pen. + """ + return # or return contour + + +class FilterPointPen(_PassThruComponentsMixin, AbstractPointPen): + """Baseclass for point pens that apply some transformation to the + coordinates they receive and pass them to another point pen. + + You can override any of its methods. The default implementation does + nothing, but passes the commands unmodified to the other pen. + + >>> from fontTools.pens.recordingPen import RecordingPointPen + >>> rec = RecordingPointPen() + >>> pen = FilterPointPen(rec) + >>> v = iter(rec.value) + >>> pen.beginPath(identifier="abc") + >>> next(v) + ('beginPath', (), {'identifier': 'abc'}) + >>> pen.addPoint((1, 2), "line", False) + >>> next(v) + ('addPoint', ((1, 2), 'line', False, None), {}) + >>> pen.addComponent("a", (2, 0, 0, 2, 10, -10), identifier="0001") + >>> next(v) + ('addComponent', ('a', (2, 0, 0, 2, 10, -10)), {'identifier': '0001'}) + >>> pen.endPath() + >>> next(v) + ('endPath', (), {}) + """ + + def __init__(self, outPen): + self._outPen = outPen + + def beginPath(self, identifier=None, **kwargs): + kwargs = dict(kwargs) + if identifier is not None: + kwargs["identifier"] = identifier + self._outPen.beginPath(**kwargs) + + def endPath(self): + self._outPen.endPath() + + def addPoint( + self, + pt, + segmentType=None, + smooth=False, + name=None, + identifier=None, + **kwargs, + ): + kwargs = dict(kwargs) + if identifier is not None: + kwargs["identifier"] = identifier + self._outPen.addPoint(pt, segmentType, smooth, name, **kwargs) + + +class _DecomposingFilterMixinBase: + """Base mixin class with common `addComponent` logic for decomposing filter pens.""" + + def addComponent(self, baseGlyphName, transformation, **kwargs): + # only decompose the component if it's included in the set + if self.include is None or baseGlyphName in self.include: + # if we're decomposing nested components, temporarily set include to None + include_bak = self.include + if self.decomposeNested and self.include: + self.include = None + try: + super().addComponent(baseGlyphName, transformation, **kwargs) + finally: + if self.include != include_bak: + self.include = include_bak + else: + _PassThruComponentsMixin.addComponent( + self, baseGlyphName, transformation, **kwargs + ) + + +class _DecomposingFilterPenMixin(_DecomposingFilterMixinBase): + """Mixin class that decomposes components as regular contours for segment pens. + + Used by DecomposingFilterPen. + + Takes two required parameters, another segment pen 'outPen' to draw + with, and a 'glyphSet' dict of drawable glyph objects to draw components from. + + The 'skipMissingComponents' and 'reverseFlipped' optional arguments work the + same as in the DecomposingPen. reverseFlipped is bool only (True/False). + + In addition, the decomposing filter pens also take the following two options: + + 'include' is an optional set of component base glyph names to consider for + decomposition; the default include=None means decompose all components no matter + the base glyph name). + + 'decomposeNested' (bool) controls whether to recurse decomposition into nested + components of components (this only matters when 'include' was also provided); + if False, only decompose top-level components included in the set, but not + also their children. + """ + + # raises MissingComponentError if base glyph is not found in glyphSet + skipMissingComponents = False + + def __init__( + self, + outPen, + glyphSet, + skipMissingComponents=None, + reverseFlipped: bool = False, + include: set[str] | None = None, + decomposeNested: bool = True, + **kwargs, + ): + assert isinstance( + reverseFlipped, bool + ), f"Expected bool, got {type(reverseFlipped).__name__}" + super().__init__( + outPen=outPen, + glyphSet=glyphSet, + skipMissingComponents=skipMissingComponents, + reverseFlipped=reverseFlipped, + **kwargs, + ) + self.include = include + self.decomposeNested = decomposeNested + + +class _DecomposingFilterPointPenMixin(_DecomposingFilterMixinBase): + """Mixin class that decomposes components as regular contours for point pens. + + Takes two required parameters, another point pen 'outPen' to draw + with, and a 'glyphSet' dict of drawable glyph objects to draw components from. + + The 'skipMissingComponents' and 'reverseFlipped' optional arguments work the + same as in the DecomposingPointPen. reverseFlipped accepts bool | ReverseFlipped + (see DecomposingPointPen). + + In addition, the decomposing filter pens also take the following two options: + + 'include' is an optional set of component base glyph names to consider for + decomposition; the default include=None means decompose all components no matter + the base glyph name). + + 'decomposeNested' (bool) controls whether to recurse decomposition into nested + components of components (this only matters when 'include' was also provided); + if False, only decompose top-level components included in the set, but not + also their children. + """ + + # raises MissingComponentError if base glyph is not found in glyphSet + skipMissingComponents = False + + def __init__( + self, + outPen, + glyphSet, + skipMissingComponents=None, + reverseFlipped: bool | ReverseFlipped = False, + include: set[str] | None = None, + decomposeNested: bool = True, + **kwargs, + ): + super().__init__( + outPen=outPen, + glyphSet=glyphSet, + skipMissingComponents=skipMissingComponents, + reverseFlipped=reverseFlipped, + **kwargs, + ) + self.include = include + self.decomposeNested = decomposeNested + + +class DecomposingFilterPen(_DecomposingFilterPenMixin, DecomposingPen, FilterPen): + """Filter pen that draws components as regular contours.""" + + pass + + +class DecomposingFilterPointPen( + _DecomposingFilterPointPenMixin, DecomposingPointPen, FilterPointPen +): + """Filter point pen that draws components as regular contours.""" + + pass + + +class ContourFilterPointPen(_PassThruComponentsMixin, AbstractPointPen): + """A "buffered" filter point pen that accumulates contour data, passes + it through a ``filterContour`` method when the contour is closed or ended, + and finally draws the result with the output point pen. + + Components are passed through unchanged. + + The ``filterContour`` method can modify the contour in-place (return None) + or return a new contour to replace it. + """ + + def __init__(self, outPen): + self._outPen = outPen + self.currentContour = None + self.currentContourKwargs = None + + def beginPath(self, identifier=None, **kwargs): + if self.currentContour is not None: + raise ValueError("Path already begun") + kwargs = dict(kwargs) + if identifier is not None: + kwargs["identifier"] = identifier + self.currentContour = [] + self.currentContourKwargs = kwargs + + def endPath(self): + if self.currentContour is None: + raise ValueError("Path not begun") + self._flushContour() + self.currentContour = None + self.currentContourKwargs = None + + def _flushContour(self): + """Flush the current contour to the output pen.""" + result = self.filterContour(self.currentContour) + if result is not None: + self.currentContour = result + + # Draw the filtered contour + self._outPen.beginPath(**self.currentContourKwargs) + for pt, segmentType, smooth, name, kwargs in self.currentContour: + self._outPen.addPoint(pt, segmentType, smooth, name, **kwargs) + self._outPen.endPath() + + def filterContour(self, contour): + """Subclasses must override this to perform the filtering. + + The contour is a list of (pt, segmentType, smooth, name, kwargs) tuples. + If the method doesn't return a value (i.e. returns None), it's + assumed that the contour was modified in-place. + Otherwise, the return value replaces the original contour. + """ + return # or return contour + + def addPoint( + self, + pt, + segmentType=None, + smooth=False, + name=None, + identifier=None, + **kwargs, + ): + if self.currentContour is None: + raise ValueError("Path not begun") + kwargs = dict(kwargs) + if identifier is not None: + kwargs["identifier"] = identifier + self.currentContour.append((pt, segmentType, smooth, name, kwargs)) + + +class OnCurveFirstPointPen(ContourFilterPointPen): + """Filter point pen that ensures closed contours start with an on-curve point. + + If a closed contour starts with an off-curve point (segmentType=None), it rotates + the points list so that the first on-curve point (segmentType != None) becomes + the start point. Open contours and contours already starting with on-curve points + are passed through unchanged. + + >>> from fontTools.pens.recordingPen import RecordingPointPen + >>> rec = RecordingPointPen() + >>> pen = OnCurveFirstPointPen(rec) + >>> # Closed contour starting with off-curve - will be rotated + >>> pen.beginPath() + >>> pen.addPoint((0, 0), None) # off-curve + >>> pen.addPoint((100, 100), "line") # on-curve - will become start + >>> pen.addPoint((200, 0), None) # off-curve + >>> pen.addPoint((300, 100), "curve") # on-curve + >>> pen.endPath() + >>> # The contour should now start with (100, 100) "line" + >>> rec.value[0] + ('beginPath', (), {}) + >>> rec.value[1] + ('addPoint', ((100, 100), 'line', False, None), {}) + >>> rec.value[2] + ('addPoint', ((200, 0), None, False, None), {}) + >>> rec.value[3] + ('addPoint', ((300, 100), 'curve', False, None), {}) + >>> rec.value[4] + ('addPoint', ((0, 0), None, False, None), {}) + """ + + def filterContour(self, contour): + """Rotate closed contour to start with first on-curve point if needed.""" + if not contour: + return + + # Check if it's a closed contour (no "move" segmentType) + is_closed = contour[0][1] != "move" + + if is_closed and contour[0][1] is None: + # Closed contour starting with off-curve - need to rotate + # Find the first on-curve point + for i, (pt, segmentType, smooth, name, kwargs) in enumerate(contour): + if segmentType is not None: + # Rotate the points list so it starts with the first on-curve point + return contour[i:] + contour[:i] diff --git a/shared/package-files/44/444a0c620855d2ee571c0a1f674e5f05e2a1ad3889bc75724783a540c5a0e6d9/blob b/shared/package-files/44/444a0c620855d2ee571c0a1f674e5f05e2a1ad3889bc75724783a540c5a0e6d9/blob new file mode 100644 index 0000000000000000000000000000000000000000..b26b6824f9596b82f234d6b45bc245b6ee9b0cf6 --- /dev/null +++ b/shared/package-files/44/444a0c620855d2ee571c0a1f674e5f05e2a1ad3889bc75724783a540c5a0e6d9/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & flip_out(const at::Tensor & self, at::IntArrayRef dims, at::Tensor & out); +TORCH_API at::Tensor flip(const at::Tensor & self, at::IntArrayRef dims); +} // namespace native +} // namespace at diff --git a/shared/package-files/44/444d629ffa812e653dabe77209a3c5884ce200bce489f270d642c38982f7b767/blob b/shared/package-files/44/444d629ffa812e653dabe77209a3c5884ce200bce489f270d642c38982f7b767/blob new file mode 100644 index 0000000000000000000000000000000000000000..8f175dda35f6f5e5b698632e691d955249d6f23a --- /dev/null +++ b/shared/package-files/44/444d629ffa812e653dabe77209a3c5884ce200bce489f270d642c38982f7b767/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API ::std::tuple choose_qparams_optimized(const at::Tensor & input, int64_t numel, int64_t n_bins, double ratio, int64_t bit_width); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/44/444fc9695948ed2aebef35676e0dc746641f0953351a0d4c531093a24e36ac44/blob b/shared/package-files/44/444fc9695948ed2aebef35676e0dc746641f0953351a0d4c531093a24e36ac44/blob new file mode 100644 index 0000000000000000000000000000000000000000..6bc1eeb56dcd53c224002aa60b311ba6e833b98a --- /dev/null +++ b/shared/package-files/44/444fc9695948ed2aebef35676e0dc746641f0953351a0d4c531093a24e36ac44/blob @@ -0,0 +1,394 @@ +""" +SARIMAX parameters class + +Author: Chad Fulton +License: BSD-3 +""" +import numpy as np +from numpy.polynomial import Polynomial +import pandas as pd + +from statsmodels.tsa.arima.tools import validate_basic +from statsmodels.tsa.statespace.tools import is_invertible + + +class SARIMAXParams: + """ + SARIMAX parameters + + Parameters + ---------- + spec : SARIMAXSpecification + Specification of the SARIMAX model. + + Attributes + ---------- + spec : SARIMAXSpecification + Specification of the SARIMAX model. + exog_names : list of str + Names associated with exogenous parameters. + ar_names : list of str + Names associated with (non-seasonal) autoregressive parameters. + ma_names : list of str + Names associated with (non-seasonal) moving average parameters. + seasonal_ar_names : list of str + Names associated with seasonal autoregressive parameters. + seasonal_ma_names : list of str + Names associated with seasonal moving average parameters. + param_names : list of str + Names of all model parameters. + k_exog_params : int + Number of parameters associated with exogenous variables. + k_ar_params : int + Number of parameters associated with (non-seasonal) autoregressive + lags. + k_ma_params : int + Number of parameters associated with (non-seasonal) moving average + lags. + k_seasonal_ar_params : int + Number of parameters associated with seasonal autoregressive lags. + k_seasonal_ma_params : int + Number of parameters associated with seasonal moving average lags. + k_params : int + Total number of model parameters. + """ + + def __init__(self, spec): + self.spec = spec + + # Local copies of relevant attributes + self.exog_names = spec.exog_names + self.ar_names = spec.ar_names + self.ma_names = spec.ma_names + self.seasonal_ar_names = spec.seasonal_ar_names + self.seasonal_ma_names = spec.seasonal_ma_names + self.param_names = spec.param_names + + self.k_exog_params = spec.k_exog_params + self.k_ar_params = spec.k_ar_params + self.k_ma_params = spec.k_ma_params + self.k_seasonal_ar_params = spec.k_seasonal_ar_params + self.k_seasonal_ma_params = spec.k_seasonal_ma_params + self.k_params = spec.k_params + + # Cache for holding parameter values + self._params_split = spec.split_params( + np.zeros(self.k_params) * np.nan, allow_infnan=True) + self._params = None + + @property + def exog_params(self): + """(array) Parameters associated with exogenous variables""" + return self._params_split["exog_params"] + + @exog_params.setter + def exog_params(self, value): + if np.isscalar(value): + value = [value] * self.k_exog_params + self._params_split["exog_params"] = validate_basic( + value, self.k_exog_params, title="exogenous coefficients") + self._params = None + + @property + def ar_params(self): + """(array) Autoregressive (non-seasonal) parameters""" + return self._params_split["ar_params"] + + @ar_params.setter + def ar_params(self, value): + if np.isscalar(value): + value = [value] * self.k_ar_params + self._params_split["ar_params"] = validate_basic( + value, self.k_ar_params, title="AR coefficients") + self._params = None + + @property + def ar_poly(self): + """(Polynomial) Autoregressive (non-seasonal) lag polynomial""" + coef = np.zeros(self.spec.max_ar_order + 1) + coef[0] = 1 + ix = self.spec.ar_lags + coef[ix] = -self._params_split["ar_params"] + return Polynomial(coef) + + @ar_poly.setter + def ar_poly(self, value): + # Convert from the polynomial to the parameters, and set that way + if isinstance(value, Polynomial): + value = value.coef + value = validate_basic(value, self.spec.max_ar_order + 1, + title="AR polynomial") + if value[0] != 1: + raise ValueError("AR polynomial constant must be equal to 1.") + ar_params = [] + for i in range(1, self.spec.max_ar_order + 1): + if i in self.spec.ar_lags: + ar_params.append(-value[i]) + elif value[i] != 0: + raise ValueError("AR polynomial includes non-zero values" + " for lags that are excluded in the" + " specification.") + self.ar_params = ar_params + + @property + def ma_params(self): + """(array) Moving average (non-seasonal) parameters""" + return self._params_split["ma_params"] + + @ma_params.setter + def ma_params(self, value): + if np.isscalar(value): + value = [value] * self.k_ma_params + self._params_split["ma_params"] = validate_basic( + value, self.k_ma_params, title="MA coefficients") + self._params = None + + @property + def ma_poly(self): + """(Polynomial) Moving average (non-seasonal) lag polynomial""" + coef = np.zeros(self.spec.max_ma_order + 1) + coef[0] = 1 + ix = self.spec.ma_lags + coef[ix] = self._params_split["ma_params"] + return Polynomial(coef) + + @ma_poly.setter + def ma_poly(self, value): + # Convert from the polynomial to the parameters, and set that way + if isinstance(value, Polynomial): + value = value.coef + value = validate_basic(value, self.spec.max_ma_order + 1, + title="MA polynomial") + if value[0] != 1: + raise ValueError("MA polynomial constant must be equal to 1.") + ma_params = [] + for i in range(1, self.spec.max_ma_order + 1): + if i in self.spec.ma_lags: + ma_params.append(value[i]) + elif value[i] != 0: + raise ValueError("MA polynomial includes non-zero values" + " for lags that are excluded in the" + " specification.") + self.ma_params = ma_params + + @property + def seasonal_ar_params(self): + """(array) Seasonal autoregressive parameters""" + return self._params_split["seasonal_ar_params"] + + @seasonal_ar_params.setter + def seasonal_ar_params(self, value): + if np.isscalar(value): + value = [value] * self.k_seasonal_ar_params + self._params_split["seasonal_ar_params"] = validate_basic( + value, self.k_seasonal_ar_params, title="seasonal AR coefficients") + self._params = None + + @property + def seasonal_ar_poly(self): + """(Polynomial) Seasonal autoregressive lag polynomial""" + # Need to expand the polynomial according to the season + s = self.spec.seasonal_periods + coef = [1] + if s > 0: + expanded = np.zeros(self.spec.max_seasonal_ar_order) + ix = np.array(self.spec.seasonal_ar_lags, dtype=int) - 1 + expanded[ix] = -self._params_split["seasonal_ar_params"] + coef = np.r_[1, np.pad(np.reshape(expanded, (-1, 1)), + [(0, 0), (s - 1, 0)], "constant").flatten()] + return Polynomial(coef) + + @seasonal_ar_poly.setter + def seasonal_ar_poly(self, value): + s = self.spec.seasonal_periods + # Note: assume that we are given coefficients from the full polynomial + # Convert from the polynomial to the parameters, and set that way + if isinstance(value, Polynomial): + value = value.coef + value = validate_basic(value, 1 + s * self.spec.max_seasonal_ar_order, + title="seasonal AR polynomial") + if value[0] != 1: + raise ValueError("Polynomial constant must be equal to 1.") + seasonal_ar_params = [] + for i in range(1, self.spec.max_seasonal_ar_order + 1): + if i in self.spec.seasonal_ar_lags: + seasonal_ar_params.append(-value[s * i]) + elif value[s * i] != 0: + raise ValueError("AR polynomial includes non-zero values" + " for lags that are excluded in the" + " specification.") + self.seasonal_ar_params = seasonal_ar_params + + @property + def seasonal_ma_params(self): + """(array) Seasonal moving average parameters""" + return self._params_split["seasonal_ma_params"] + + @seasonal_ma_params.setter + def seasonal_ma_params(self, value): + if np.isscalar(value): + value = [value] * self.k_seasonal_ma_params + self._params_split["seasonal_ma_params"] = validate_basic( + value, self.k_seasonal_ma_params, title="seasonal MA coefficients") + self._params = None + + @property + def seasonal_ma_poly(self): + """(Polynomial) Seasonal moving average lag polynomial""" + # Need to expand the polynomial according to the season + s = self.spec.seasonal_periods + coef = np.array([1]) + if s > 0: + expanded = np.zeros(self.spec.max_seasonal_ma_order) + ix = np.array(self.spec.seasonal_ma_lags, dtype=int) - 1 + expanded[ix] = self._params_split["seasonal_ma_params"] + coef = np.r_[1, np.pad(np.reshape(expanded, (-1, 1)), + [(0, 0), (s - 1, 0)], "constant").flatten()] + return Polynomial(coef) + + @seasonal_ma_poly.setter + def seasonal_ma_poly(self, value): + s = self.spec.seasonal_periods + # Note: assume that we are given coefficients from the full polynomial + # Convert from the polynomial to the parameters, and set that way + if isinstance(value, Polynomial): + value = value.coef + value = validate_basic(value, 1 + s * self.spec.max_seasonal_ma_order, + title="seasonal MA polynomial",) + if value[0] != 1: + raise ValueError("Polynomial constant must be equal to 1.") + seasonal_ma_params = [] + for i in range(1, self.spec.max_seasonal_ma_order + 1): + if i in self.spec.seasonal_ma_lags: + seasonal_ma_params.append(value[s * i]) + elif value[s * i] != 0: + raise ValueError("MA polynomial includes non-zero values" + " for lags that are excluded in the" + " specification.") + self.seasonal_ma_params = seasonal_ma_params + + @property + def sigma2(self): + """(float) Innovation variance""" + return self._params_split["sigma2"] + + @sigma2.setter + def sigma2(self, params): + length = int(not self.spec.concentrate_scale) + self._params_split["sigma2"] = validate_basic( + params, length, title="sigma2").item() + self._params = None + + @property + def reduced_ar_poly(self): + """(Polynomial) Reduced form autoregressive lag polynomial""" + return self.ar_poly * self.seasonal_ar_poly + + @property + def reduced_ma_poly(self): + """(Polynomial) Reduced form moving average lag polynomial""" + return self.ma_poly * self.seasonal_ma_poly + + @property + def params(self): + """(array) Complete parameter vector""" + if self._params is None: + self._params = self.spec.join_params(**self._params_split) + return self._params.copy() + + @params.setter + def params(self, value): + self._params_split = self.spec.split_params(value) + self._params = None + + @property + def is_complete(self): + """(bool) Are current parameter values all filled in (i.e., not NaN)""" + return not np.any(np.isnan(self.params)) + + @property + def is_valid(self): + """(bool) Are current parameter values valid (e.g., variance > 0)""" + valid = True + try: + self.spec.validate_params(self.params) + except ValueError: + valid = False + return valid + + @property + def is_stationary(self): + """(bool) Is the reduced autoregressive lag polynomial stationary""" + validate_basic(self.ar_params, self.k_ar_params, + title="AR coefficients") + validate_basic(self.seasonal_ar_params, self.k_seasonal_ar_params, + title="seasonal AR coefficients") + + ar_stationary = True + seasonal_ar_stationary = True + if self.k_ar_params > 0: + ar_stationary = is_invertible(self.ar_poly.coef) + if self.k_seasonal_ar_params > 0: + seasonal_ar_stationary = is_invertible(self.seasonal_ar_poly.coef) + + return ar_stationary and seasonal_ar_stationary + + @property + def is_invertible(self): + """(bool) Is the reduced moving average lag polynomial invertible""" + # Short-circuit if there is no MA component + validate_basic(self.ma_params, self.k_ma_params, + title="MA coefficients") + validate_basic(self.seasonal_ma_params, self.k_seasonal_ma_params, + title="seasonal MA coefficients") + + ma_stationary = True + seasonal_ma_stationary = True + if self.k_ma_params > 0: + ma_stationary = is_invertible(self.ma_poly.coef) + if self.k_seasonal_ma_params > 0: + seasonal_ma_stationary = is_invertible(self.seasonal_ma_poly.coef) + + return ma_stationary and seasonal_ma_stationary + + def to_dict(self): + """ + Return the parameters split by type into a dictionary + + Returns + ------- + split_params : dict + Dictionary with keys 'exog_params', 'ar_params', 'ma_params', + 'seasonal_ar_params', 'seasonal_ma_params', and (unless + `concentrate_scale=True`) 'sigma2'. Values are the parameters + associated with the key, based on the `params` argument. + """ + return self._params_split.copy() + + def to_pandas(self): + """ + Return the parameters as a Pandas series + + Returns + ------- + series : Series + Pandas series with index set to the parameter names. + """ + return pd.Series(self.params, index=self.param_names) + + def __repr__(self): + """Represent SARIMAXParams object as a string""" + components = [] + if self.k_exog_params: + components.append(f"exog={self.exog_params!s}") + if self.k_ar_params: + components.append(f"ar={self.ar_params!s}") + if self.k_ma_params: + components.append(f"ma={self.ma_params!s}") + if self.k_seasonal_ar_params: + components.append(f"seasonal_ar={self.seasonal_ar_params!s}") + if self.k_seasonal_ma_params: + components.append(f"seasonal_ma={self.seasonal_ma_params!s}") + if not self.spec.concentrate_scale: + components.append(f"sigma2={self.sigma2}") + return "SARIMAXParams({})".format(", ".join(components)) diff --git a/shared/package-files/44/4452847a44c1d9623ea6c29c4cfb360355e8f87a20640e96099a1f2188c85194/blob b/shared/package-files/44/4452847a44c1d9623ea6c29c4cfb360355e8f87a20640e96099a1f2188c85194/blob new file mode 100644 index 0000000000000000000000000000000000000000..b098ebbf07e4f3909ebef2a2284e0512d65a1f67 --- /dev/null +++ b/shared/package-files/44/4452847a44c1d9623ea6c29c4cfb360355e8f87a20640e96099a1f2188c85194/blob @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API ::std::tuple quantized_lstm_cell(const at::Tensor & input, at::TensorList hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const at::Tensor & b_ih, const at::Tensor & b_hh, const at::Tensor & packed_ih, const at::Tensor & packed_hh, const at::Tensor & col_offsets_ih, const at::Tensor & col_offsets_hh, const at::Scalar & scale_ih, const at::Scalar & scale_hh, const at::Scalar & zero_point_ih, const at::Scalar & zero_point_hh); +} // namespace native +} // namespace at diff --git a/shared/package-files/44/4452c55a12da527ed4504e1e4ed9c96fdfe7e5b4c9974837804a94043799755f/blob b/shared/package-files/44/4452c55a12da527ed4504e1e4ed9c96fdfe7e5b4c9974837804a94043799755f/blob new file mode 100644 index 0000000000000000000000000000000000000000..474e542551ae90348d8f7e0a856e210ae24d022a --- /dev/null +++ b/shared/package-files/44/4452c55a12da527ed4504e1e4ed9c96fdfe7e5b4c9974837804a94043799755f/blob @@ -0,0 +1,96 @@ +from typing import Any, List, Tuple + +import torch.nn as nn +from torch.distributed.tensor.parallel._data_parallel_utils import ( + _flatten_tensor, + _unflatten_tensor, +) + +__all__ = [] # type: ignore[var-annotated] + + +def _get_submodule_n_params(module: nn.Module, path: str): + """ + Get submodule and the direct path of parameter from the module + """ + if "." in path: + path_list = path.split(".") + parent_module_path = ".".join(path_list[:-1]) + module = module.get_submodule(parent_module_path) + path = path_list[-1] + return module, path + + +def _update_module_param(param_list: List[Tuple[nn.Module, str, nn.Parameter]]): + """ + Update parameters within the module + """ + for item in param_list: + parent_module, module_path, t = item + assert hasattr(parent_module, module_path) + delattr(parent_module, module_path) + setattr(parent_module, module_path, t) + + +def _reconstruct_dtensor(module: nn.Module, _input: Any): + """ + Recontruct DTensor parameters from local tensors + """ + param_list = [] + # TODO: To add perf optimizations to this iterations + for name, t in module.named_parameters(): + if hasattr(t, "_st_info"): + dtensor = _unflatten_tensor(t, t._st_info) + param_list.append((*_get_submodule_n_params(module, name), dtensor)) + _update_module_param(param_list) # type: ignore[arg-type] + + +def _localize_dtensor(module: nn.Module, *_: Any): + """ + Convert DTensor parameters to local tensors + """ + param_list = [] + for name, param in module.named_parameters(): + t, sharding_info = _flatten_tensor(param) + if sharding_info is not None: + t = nn.Parameter(t) + t._st_info = sharding_info # type: ignore[attr-defined] + param_list.append((*_get_submodule_n_params(module, name), t)) + _update_module_param(param_list) # type: ignore[arg-type] + + +def _pre_dp_module_transform(module: nn.Module): + """ + Enable the composability between Tensor Parallelism (TP) and Data + Parallelism(DP) in PyTorch when using DDP. We need to convert Parameters which + are DTensors to local tensors before wrapping with data parallelism API. + We then register two hooks, one for converting local tensors back to DTensor + preforward and one to convert DTensors back to tensors after Forward. By + integrating this way, we avoid any special handling of DTensor parameters by DDP + and get DTensor's gradients propagated back to DP, e.g. gradient buckets of DDP. + + For now, this API only works with ``DistributedDataParallel``. It will later support + other DP methods such as FSDP. + + Args: + module (:class:`nn.Module`): + Module which has been applied TP on. + + Example:: + >>> # xdoctest: +SKIP("distributed") + >>> from torch.distributed.tensor.parallel import parallelize_module, PairwiseParallel + >>> from torch.nn.parallel import DistributedDataParallel as DDP + >>> from torch.distributed.tensor.parallel.ddp import pre_dp_module_transform + >>> + >>> # Define the module. + >>> m = module(...) + >>> parallelize_module(m, PairwiseParallel()) + >>> m = pre_dp_module_transform(m) + >>> m = DDP(m) + >>> + """ + + _localize_dtensor(module, None, None) + # TODO: To add test cases and ensure that it works for nested modules + module.register_forward_pre_hook(_reconstruct_dtensor) + module.register_forward_hook(_localize_dtensor) diff --git a/shared/package-files/44/44560be8774216c1dff5646972f8b7c3e7e98fef0ee5d319f16f7a55d28d75b2/blob b/shared/package-files/44/44560be8774216c1dff5646972f8b7c3e7e98fef0ee5d319f16f7a55d28d75b2/blob new file mode 100644 index 0000000000000000000000000000000000000000..849356ea9a03a031abce367b955a30fce26c9845 --- /dev/null +++ b/shared/package-files/44/44560be8774216c1dff5646972f8b7c3e7e98fef0ee5d319f16f7a55d28d75b2/blob @@ -0,0 +1,443 @@ +from abc import ABC, abstractmethod +from itertools import islice +from operator import itemgetter +from threading import RLock +from typing import ( + TYPE_CHECKING, + Dict, + Iterable, + List, + NamedTuple, + Optional, + Sequence, + Tuple, + Union, +) + +from ._ratio import ratio_resolve +from .align import Align +from .console import Console, ConsoleOptions, RenderableType, RenderResult +from .highlighter import ReprHighlighter +from .panel import Panel +from .pretty import Pretty +from .region import Region +from .repr import Result, rich_repr +from .segment import Segment +from .style import StyleType + +if TYPE_CHECKING: + from pip._vendor.rich.tree import Tree + + +class LayoutRender(NamedTuple): + """An individual layout render.""" + + region: Region + render: List[List[Segment]] + + +RegionMap = Dict["Layout", Region] +RenderMap = Dict["Layout", LayoutRender] + + +class LayoutError(Exception): + """Layout related error.""" + + +class NoSplitter(LayoutError): + """Requested splitter does not exist.""" + + +class _Placeholder: + """An internal renderable used as a Layout placeholder.""" + + highlighter = ReprHighlighter() + + def __init__(self, layout: "Layout", style: StyleType = "") -> None: + self.layout = layout + self.style = style + + def __rich_console__( + self, console: Console, options: ConsoleOptions + ) -> RenderResult: + width = options.max_width + height = options.height or options.size.height + layout = self.layout + title = ( + f"{layout.name!r} ({width} x {height})" + if layout.name + else f"({width} x {height})" + ) + yield Panel( + Align.center(Pretty(layout), vertical="middle"), + style=self.style, + title=self.highlighter(title), + border_style="blue", + height=height, + ) + + +class Splitter(ABC): + """Base class for a splitter.""" + + name: str = "" + + @abstractmethod + def get_tree_icon(self) -> str: + """Get the icon (emoji) used in layout.tree""" + + @abstractmethod + def divide( + self, children: Sequence["Layout"], region: Region + ) -> Iterable[Tuple["Layout", Region]]: + """Divide a region amongst several child layouts. + + Args: + children (Sequence(Layout)): A number of child layouts. + region (Region): A rectangular region to divide. + """ + + +class RowSplitter(Splitter): + """Split a layout region in to rows.""" + + name = "row" + + def get_tree_icon(self) -> str: + return "[layout.tree.row]⬌" + + def divide( + self, children: Sequence["Layout"], region: Region + ) -> Iterable[Tuple["Layout", Region]]: + x, y, width, height = region + render_widths = ratio_resolve(width, children) + offset = 0 + _Region = Region + for child, child_width in zip(children, render_widths): + yield child, _Region(x + offset, y, child_width, height) + offset += child_width + + +class ColumnSplitter(Splitter): + """Split a layout region in to columns.""" + + name = "column" + + def get_tree_icon(self) -> str: + return "[layout.tree.column]â¬" + + def divide( + self, children: Sequence["Layout"], region: Region + ) -> Iterable[Tuple["Layout", Region]]: + x, y, width, height = region + render_heights = ratio_resolve(height, children) + offset = 0 + _Region = Region + for child, child_height in zip(children, render_heights): + yield child, _Region(x, y + offset, width, child_height) + offset += child_height + + +@rich_repr +class Layout: + """A renderable to divide a fixed height in to rows or columns. + + Args: + renderable (RenderableType, optional): Renderable content, or None for placeholder. Defaults to None. + name (str, optional): Optional identifier for Layout. Defaults to None. + size (int, optional): Optional fixed size of layout. Defaults to None. + minimum_size (int, optional): Minimum size of layout. Defaults to 1. + ratio (int, optional): Optional ratio for flexible layout. Defaults to 1. + visible (bool, optional): Visibility of layout. Defaults to True. + """ + + splitters = {"row": RowSplitter, "column": ColumnSplitter} + + def __init__( + self, + renderable: Optional[RenderableType] = None, + *, + name: Optional[str] = None, + size: Optional[int] = None, + minimum_size: int = 1, + ratio: int = 1, + visible: bool = True, + ) -> None: + self._renderable = renderable or _Placeholder(self) + self.size = size + self.minimum_size = minimum_size + self.ratio = ratio + self.name = name + self.visible = visible + self.splitter: Splitter = self.splitters["column"]() + self._children: List[Layout] = [] + self._render_map: RenderMap = {} + self._lock = RLock() + + def __rich_repr__(self) -> Result: + yield "name", self.name, None + yield "size", self.size, None + yield "minimum_size", self.minimum_size, 1 + yield "ratio", self.ratio, 1 + + @property + def renderable(self) -> RenderableType: + """Layout renderable.""" + return self if self._children else self._renderable + + @property + def children(self) -> List["Layout"]: + """Gets (visible) layout children.""" + return [child for child in self._children if child.visible] + + @property + def map(self) -> RenderMap: + """Get a map of the last render.""" + return self._render_map + + def get(self, name: str) -> Optional["Layout"]: + """Get a named layout, or None if it doesn't exist. + + Args: + name (str): Name of layout. + + Returns: + Optional[Layout]: Layout instance or None if no layout was found. + """ + if self.name == name: + return self + else: + for child in self._children: + named_layout = child.get(name) + if named_layout is not None: + return named_layout + return None + + def __getitem__(self, name: str) -> "Layout": + layout = self.get(name) + if layout is None: + raise KeyError(f"No layout with name {name!r}") + return layout + + @property + def tree(self) -> "Tree": + """Get a tree renderable to show layout structure.""" + from pip._vendor.rich.styled import Styled + from pip._vendor.rich.table import Table + from pip._vendor.rich.tree import Tree + + def summary(layout: "Layout") -> Table: + + icon = layout.splitter.get_tree_icon() + + table = Table.grid(padding=(0, 1, 0, 0)) + + text: RenderableType = ( + Pretty(layout) if layout.visible else Styled(Pretty(layout), "dim") + ) + table.add_row(icon, text) + _summary = table + return _summary + + layout = self + tree = Tree( + summary(layout), + guide_style=f"layout.tree.{layout.splitter.name}", + highlight=True, + ) + + def recurse(tree: "Tree", layout: "Layout") -> None: + for child in layout._children: + recurse( + tree.add( + summary(child), + guide_style=f"layout.tree.{child.splitter.name}", + ), + child, + ) + + recurse(tree, self) + return tree + + def split( + self, + *layouts: Union["Layout", RenderableType], + splitter: Union[Splitter, str] = "column", + ) -> None: + """Split the layout in to multiple sub-layouts. + + Args: + *layouts (Layout): Positional arguments should be (sub) Layout instances. + splitter (Union[Splitter, str]): Splitter instance or name of splitter. + """ + _layouts = [ + layout if isinstance(layout, Layout) else Layout(layout) + for layout in layouts + ] + try: + self.splitter = ( + splitter + if isinstance(splitter, Splitter) + else self.splitters[splitter]() + ) + except KeyError: + raise NoSplitter(f"No splitter called {splitter!r}") + self._children[:] = _layouts + + def add_split(self, *layouts: Union["Layout", RenderableType]) -> None: + """Add a new layout(s) to existing split. + + Args: + *layouts (Union[Layout, RenderableType]): Positional arguments should be renderables or (sub) Layout instances. + + """ + _layouts = ( + layout if isinstance(layout, Layout) else Layout(layout) + for layout in layouts + ) + self._children.extend(_layouts) + + def split_row(self, *layouts: Union["Layout", RenderableType]) -> None: + """Split the layout in to a row (layouts side by side). + + Args: + *layouts (Layout): Positional arguments should be (sub) Layout instances. + """ + self.split(*layouts, splitter="row") + + def split_column(self, *layouts: Union["Layout", RenderableType]) -> None: + """Split the layout in to a column (layouts stacked on top of each other). + + Args: + *layouts (Layout): Positional arguments should be (sub) Layout instances. + """ + self.split(*layouts, splitter="column") + + def unsplit(self) -> None: + """Reset splits to initial state.""" + del self._children[:] + + def update(self, renderable: RenderableType) -> None: + """Update renderable. + + Args: + renderable (RenderableType): New renderable object. + """ + with self._lock: + self._renderable = renderable + + def refresh_screen(self, console: "Console", layout_name: str) -> None: + """Refresh a sub-layout. + + Args: + console (Console): Console instance where Layout is to be rendered. + layout_name (str): Name of layout. + """ + with self._lock: + layout = self[layout_name] + region, _lines = self._render_map[layout] + (x, y, width, height) = region + lines = console.render_lines( + layout, console.options.update_dimensions(width, height) + ) + self._render_map[layout] = LayoutRender(region, lines) + console.update_screen_lines(lines, x, y) + + def _make_region_map(self, width: int, height: int) -> RegionMap: + """Create a dict that maps layout on to Region.""" + stack: List[Tuple[Layout, Region]] = [(self, Region(0, 0, width, height))] + push = stack.append + pop = stack.pop + layout_regions: List[Tuple[Layout, Region]] = [] + append_layout_region = layout_regions.append + while stack: + append_layout_region(pop()) + layout, region = layout_regions[-1] + children = layout.children + if children: + for child_and_region in layout.splitter.divide(children, region): + push(child_and_region) + + region_map = { + layout: region + for layout, region in sorted(layout_regions, key=itemgetter(1)) + } + return region_map + + def render(self, console: Console, options: ConsoleOptions) -> RenderMap: + """Render the sub_layouts. + + Args: + console (Console): Console instance. + options (ConsoleOptions): Console options. + + Returns: + RenderMap: A dict that maps Layout on to a tuple of Region, lines + """ + render_width = options.max_width + render_height = options.height or console.height + region_map = self._make_region_map(render_width, render_height) + layout_regions = [ + (layout, region) + for layout, region in region_map.items() + if not layout.children + ] + render_map: Dict["Layout", "LayoutRender"] = {} + render_lines = console.render_lines + update_dimensions = options.update_dimensions + + for layout, region in layout_regions: + lines = render_lines( + layout.renderable, update_dimensions(region.width, region.height) + ) + render_map[layout] = LayoutRender(region, lines) + return render_map + + def __rich_console__( + self, console: Console, options: ConsoleOptions + ) -> RenderResult: + with self._lock: + width = options.max_width or console.width + height = options.height or console.height + render_map = self.render(console, options.update_dimensions(width, height)) + self._render_map = render_map + layout_lines: List[List[Segment]] = [[] for _ in range(height)] + _islice = islice + for (region, lines) in render_map.values(): + _x, y, _layout_width, layout_height = region + for row, line in zip( + _islice(layout_lines, y, y + layout_height), lines + ): + row.extend(line) + + new_line = Segment.line() + for layout_row in layout_lines: + yield from layout_row + yield new_line + + +if __name__ == "__main__": + from pip._vendor.rich.console import Console + + console = Console() + layout = Layout() + + layout.split_column( + Layout(name="header", size=3), + Layout(ratio=1, name="main"), + Layout(size=10, name="footer"), + ) + + layout["main"].split_row(Layout(name="side"), Layout(name="body", ratio=2)) + + layout["body"].split_row(Layout(name="content", ratio=2), Layout(name="s2")) + + layout["s2"].split_column( + Layout(name="top"), Layout(name="middle"), Layout(name="bottom") + ) + + layout["side"].split_column(Layout(layout.tree, name="left1"), Layout(name="left2")) + + layout["content"].update("foo") + + console.print(layout) diff --git a/shared/package-files/44/4456c29dbbc9c2b56486193093e39433843b842231f3c1124a9b47deaa901a11/blob b/shared/package-files/44/4456c29dbbc9c2b56486193093e39433843b842231f3c1124a9b47deaa901a11/blob new file mode 100644 index 0000000000000000000000000000000000000000..5211356a5addbdd7dc68c9fe3a6d4a6a5cbfeae4 --- /dev/null +++ b/shared/package-files/44/4456c29dbbc9c2b56486193093e39433843b842231f3c1124a9b47deaa901a11/blob @@ -0,0 +1,31 @@ +from typing import Any + +from .utils import ( + DEFAULT_DB_ALIAS as DEFAULT_DB_ALIAS, + DJANGO_VERSION_PICKLE_KEY as DJANGO_VERSION_PICKLE_KEY, + ProgrammingError as ProgrammingError, + IntegrityError as IntegrityError, + OperationalError as OperationalError, + DatabaseError as DatabaseError, + DataError as DataError, + NotSupportedError as NotSupportedError, + InternalError as InternalError, + InterfaceError as InterfaceError, + ConnectionHandler as ConnectionHandler, + Error as Error, + ConnectionDoesNotExist as ConnectionDoesNotExist, +) + +from . import migrations + +connections: Any +router: Any +connection: Any + +class DefaultConnectionProxy: + def __getattr__(self, item: str) -> Any: ... + def __setattr__(self, name: str, value: Any) -> None: ... + def __delattr__(self, name: str) -> None: ... + +def close_old_connections(**kwargs: Any) -> None: ... +def reset_queries(**kwargs: Any) -> None: ... diff --git a/shared/package-files/44/4457245f009082f0257773b075b21a00ac3fe376225e4ad873277f0ec4c0eaf2/blob b/shared/package-files/44/4457245f009082f0257773b075b21a00ac3fe376225e4ad873277f0ec4c0eaf2/blob new file mode 100644 index 0000000000000000000000000000000000000000..2d93102417c5cc39fc9e2b2c7ef7e41ae293235e Binary files /dev/null and b/shared/package-files/44/4457245f009082f0257773b075b21a00ac3fe376225e4ad873277f0ec4c0eaf2/blob differ diff --git a/shared/package-files/44/445a628b35cc76185c8e2f7ca48b1c7c75b8afa8bd28bcccd83d79800ebf7a8c/blob b/shared/package-files/44/445a628b35cc76185c8e2f7ca48b1c7c75b8afa8bd28bcccd83d79800ebf7a8c/blob new file mode 100644 index 0000000000000000000000000000000000000000..018339733df0792c0d9282819136391efab069ee --- /dev/null +++ b/shared/package-files/44/445a628b35cc76185c8e2f7ca48b1c7c75b8afa8bd28bcccd83d79800ebf7a8c/blob @@ -0,0 +1,14 @@ +from typing import Optional, Sequence, Tuple + +def copy_file( + src: str, + dst: str, + preserve_mode: bool = ..., + preserve_times: bool = ..., + update: bool = ..., + link: Optional[str] = ..., + verbose: bool = ..., + dry_run: bool = ..., +) -> Tuple[str, str]: ... +def move_file(src: str, dst: str, verbose: bool = ..., dry_run: bool = ...) -> str: ... +def write_file(filename: str, contents: Sequence[str]) -> None: ... diff --git a/shared/package-files/44/445be65ebca8d4c0deb70230c6fce159d0e25ca6dd0102a2110e9918acd8a8ab/blob b/shared/package-files/44/445be65ebca8d4c0deb70230c6fce159d0e25ca6dd0102a2110e9918acd8a8ab/blob new file mode 100644 index 0000000000000000000000000000000000000000..0e2d3167f9780c160391fc7e88c1d725e67a01b9 --- /dev/null +++ b/shared/package-files/44/445be65ebca8d4c0deb70230c6fce159d0e25ca6dd0102a2110e9918acd8a8ab/blob @@ -0,0 +1,260 @@ +# mypy: ignore-errors + +MAX_CYCLE = 3000 + +import itertools +import operator + +from typing import Dict, List, Optional + +from .. import polyfill, variables +from ..exc import unimplemented + +from .base import MutableLocal, VariableTracker +from .constant import ConstantVariable + + +class ItertoolsVariable(VariableTracker): + def __init__(self, value, **kwargs): + super().__init__(**kwargs) + self.value = value + + def __repr__(self): + return f"ItertoolsVariable({self.value})" + + def python_type(self): + return type(self.value) + + def as_python_constant(self): + return self.value + + def call_function( + self, tx, args: "List[VariableTracker]", kwargs: "Dict[str, VariableTracker]" + ) -> "VariableTracker": + if ( + self.value is itertools.product + and not kwargs + and all(arg.has_unpack_var_sequence(tx) for arg in args) + ): + seqs = [arg.unpack_var_sequence(tx) for arg in args] + items = [] + for item in itertools.product(*seqs): + items.append(variables.TupleVariable(list(item))) + return variables.ListIteratorVariable(items, mutable_local=MutableLocal()) + elif ( + self.value is itertools.chain + and not kwargs + and all(arg.has_unpack_var_sequence(tx) for arg in args) + ): + seqs = [arg.unpack_var_sequence(tx) for arg in args] + items = list(itertools.chain.from_iterable(seqs)) + return variables.ListIteratorVariable(items, mutable_local=MutableLocal()) + elif self.value is itertools.accumulate: + from .builtin import BuiltinVariable + + if any(key not in ["initial", "func"] for key in kwargs.keys()): + unimplemented( + "Unsupported kwargs for itertools.accumulate: " + f"{','.join(set(kwargs.keys()) - {'initial', 'func'})}" + ) + + acc = kwargs.get("initial") + + if len(args) in [1, 2] and args[0].has_unpack_var_sequence(tx): + seq = args[0].unpack_var_sequence(tx) + + if "func" in kwargs and len(args) == 1: + func = kwargs["func"].call_function + elif len(args) == 2: + func = args[1].call_function + elif len(args) == 1: + # Default to operator.add + func = BuiltinVariable(operator.add).call_function + else: + unimplemented( + "itertools.accumulate can only accept one of: `func` kwarg, pos 2 arg" + ) + else: + unimplemented("Unsupported arguments for itertools.accumulate") + + items = [] + if acc is not None: + items.append(acc) + for item in seq: + if acc is None: + acc = item + else: + try: + acc = func(tx, [acc, item], {}) + except Exception: + raise unimplemented( # noqa: TRY200 + f"Unexpected failure in invoking function during accumulate. Failed running func {func}({item}{acc})" + ) + items.append(acc) + + return variables.ListIteratorVariable(items, mutable_local=MutableLocal()) + elif ( + self.value is itertools.combinations + and not kwargs + and len(args) == 2 + and args[0].has_unpack_var_sequence(tx) + and args[1].is_python_constant() + ): + iterable = args[0].unpack_var_sequence(tx) + r = args[1].as_python_constant() + + items = [] + for item in itertools.combinations(iterable, r): + items.append(variables.TupleVariable(list(item))) + return variables.ListIteratorVariable(items, mutable_local=MutableLocal()) + elif self.value is itertools.groupby: + if any(kw != "key" for kw in kwargs.keys()): + unimplemented( + "Unsupported kwargs for itertools.groupby: " + f"{','.join(set(kwargs.keys()) - {'key'})}" + ) + + def retrieve_const_key(key): + if isinstance(key, variables.SymNodeVariable): + return key.evaluate_expr() + elif isinstance(key, variables.ConstantVariable): + return key.as_python_constant() + else: + raise unimplemented( + "Unsupported key type for itertools.groupby: " + str(type(key)) + ) + + if len(args) == 1 and args[0].has_unpack_var_sequence(tx): + seq = args[0].unpack_var_sequence(tx) + keyfunc = ( + ( + lambda x: ( + retrieve_const_key( + kwargs.get("key").call_function(tx, [x], {}) + ) + ) + ) + if "key" in kwargs + else None + ) + else: + unimplemented("Unsupported arguments for itertools.groupby") + + result = [] + try: + for k, v in itertools.groupby(seq, key=keyfunc): + result.append( + variables.TupleVariable( + [ + variables.ConstantVariable.create(k) + if variables.ConstantVariable.is_literal(k) + else k, + variables.ListIteratorVariable( + list(v), mutable_local=MutableLocal() + ), + ], + mutable_local=MutableLocal(), + ) + ) + except Exception: + raise unimplemented( # noqa: TRY200 + "Unexpected failure when calling itertools.groupby" + ) + return variables.ListIteratorVariable(result, mutable_local=MutableLocal()) + elif self.value is itertools.repeat: + if len(args) < 2: + return variables.RepeatIteratorVariable( + *args, mutable_local=MutableLocal() + ) + + from .builder import SourcelessBuilder + + return tx.inline_user_function_return( + SourcelessBuilder()(tx, polyfill.repeat), args, kwargs + ) + elif self.value is itertools.count: + return variables.CountIteratorVariable(*args, mutable_local=MutableLocal()) + elif self.value is itertools.cycle: + return variables.CycleIteratorVariable(*args, mutable_local=MutableLocal()) + else: + return super().call_function(tx, args, kwargs) + + +class IteratorVariable(VariableTracker): + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def next_variables(self, tx): + unimplemented("abstract method, must implement") + + +class RepeatIteratorVariable(IteratorVariable): + def __init__(self, item: VariableTracker, **kwargs): + super().__init__(**kwargs) + self.item = item + + # Repeat needs no mutation, clone self + def next_variables(self, tx): + return self.item, self + + +class CountIteratorVariable(IteratorVariable): + def __init__(self, item: int = 0, step: int = 1, **kwargs): + super().__init__(**kwargs) + if not isinstance(item, VariableTracker): + item = ConstantVariable.create(item) + if not isinstance(step, VariableTracker): + step = ConstantVariable.create(step) + self.item = item + self.step = step + + def next_variables(self, tx): + assert self.mutable_local + tx.output.side_effects.mutation(self) + next_item = self.item.call_method(tx, "__add__", [self.step], {}) + self.item = next_item + return self.item, self + + +class CycleIteratorVariable(IteratorVariable): + def __init__( + self, + iterator: IteratorVariable, + saved: List[VariableTracker] = None, + saved_index: int = 0, + item: Optional[VariableTracker] = None, + **kwargs, + ): + if saved is None: + saved = [] + super().__init__(**kwargs) + self.iterator = iterator + self.saved = saved + self.saved_index = saved_index + self.item = item + + def next_variables(self, tx): + assert self.mutable_local + + if self.iterator is not None: + try: + new_item, _ = self.iterator.next_variables(tx) + if len(self.saved) > MAX_CYCLE: + unimplemented( + "input iterator to itertools.cycle has too many items" + ) + tx.output.side_effects.mutation(self) + self.saved.append(new_item) + self.item = new_item + if self.item is None: + return self.next_variables(tx) + return self.item, self + except StopIteration: + self.iterator = None + return self.next_variables(tx) + elif len(self.saved) > 0: + tx.output.side_effects.mutation(self) + self.saved_index = (self.saved_index + 1) % len(self.saved) + return self.item, self + else: + raise StopIteration diff --git a/shared/package-files/44/445c6060dbfe7645a1f8d30fbc1b9cf73399fd8da9933aa3dffedad4d74beb7f/blob b/shared/package-files/44/445c6060dbfe7645a1f8d30fbc1b9cf73399fd8da9933aa3dffedad4d74beb7f/blob new file mode 100644 index 0000000000000000000000000000000000000000..bb0cff50b91ef5d5db51c55fabc7769b0f1d2931 --- /dev/null +++ b/shared/package-files/44/445c6060dbfe7645a1f8d30fbc1b9cf73399fd8da9933aa3dffedad4d74beb7f/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API ::std::tuple _unique2_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, bool sorted=true, bool return_inverse=false, bool return_counts=false); +TORCH_API ::std::tuple _unique2_outf(const at::Tensor & self, bool sorted, bool return_inverse, bool return_counts, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/44/4464a0ce235fedc66761d10fb28a8bd41d88ebc4d4269d49984415c5b87faf20/blob b/shared/package-files/44/4464a0ce235fedc66761d10fb28a8bd41d88ebc4d4269d49984415c5b87faf20/blob new file mode 100644 index 0000000000000000000000000000000000000000..e4c179e9d8869474eeadbf8221ffc325af62ffc4 --- /dev/null +++ b/shared/package-files/44/4464a0ce235fedc66761d10fb28a8bd41d88ebc4d4269d49984415c5b87faf20/blob @@ -0,0 +1,144 @@ +import pytest + +from bs4.element import ( + CData, + Comment, + Declaration, + Doctype, + NavigableString, + RubyParenthesisString, + RubyTextString, + Script, + Stylesheet, + TemplateString, +) + +from . import SoupTest + +class TestNavigableString(SoupTest): + + def test_text_acquisition_methods(self): + # These methods are intended for use against Tag, but they + # work on NavigableString as well, + + s = NavigableString("fee ") + cdata = CData("fie ") + comment = Comment("foe ") + + assert "fee " == s.get_text() + assert "fee" == s.get_text(strip=True) + assert ["fee "] == list(s.strings) + assert ["fee"] == list(s.stripped_strings) + assert ["fee "] == list(s._all_strings()) + + assert "fie " == cdata.get_text() + assert "fie" == cdata.get_text(strip=True) + assert ["fie "] == list(cdata.strings) + assert ["fie"] == list(cdata.stripped_strings) + assert ["fie "] == list(cdata._all_strings()) + + # Since a Comment isn't normally considered 'text', + # these methods generally do nothing. + assert "" == comment.get_text() + assert [] == list(comment.strings) + assert [] == list(comment.stripped_strings) + assert [] == list(comment._all_strings()) + + # Unless you specifically say that comments are okay. + assert "foe" == comment.get_text(strip=True, types=Comment) + assert "foe " == comment.get_text(types=(Comment, NavigableString)) + + def test_string_has_immutable_name_property(self): + # string.name is defined as None and can't be modified + string = self.soup("s").string + assert None == string.name + with pytest.raises(AttributeError): + string.name = 'foo' + +class TestNavigableStringSubclasses(SoupTest): + + def test_cdata(self): + # None of the current builders turn CDATA sections into CData + # objects, but you can create them manually. + soup = self.soup("") + cdata = CData("foo") + soup.insert(1, cdata) + assert str(soup) == "" + assert soup.find(string="foo") == "foo" + assert soup.contents[0] == "foo" + + def test_cdata_is_never_formatted(self): + """Text inside a CData object is passed into the formatter. + + But the return value is ignored. + """ + + self.count = 0 + def increment(*args): + self.count += 1 + return "BITTER FAILURE" + + soup = self.soup("") + cdata = CData("<><><>") + soup.insert(1, cdata) + assert b"<><>]]>" == soup.encode(formatter=increment) + assert 1 == self.count + + def test_doctype_ends_in_newline(self): + # Unlike other NavigableString subclasses, a DOCTYPE always ends + # in a newline. + doctype = Doctype("foo") + soup = self.soup("") + soup.insert(1, doctype) + assert soup.encode() == b"\n" + + def test_declaration(self): + d = Declaration("foo") + assert "" == d.output_ready() + + def test_default_string_containers(self): + # In some cases, we use different NavigableString subclasses for + # the same text in different tags. + soup = self.soup( + "
text
" + ) + assert [NavigableString, Script, Stylesheet] == [ + x.__class__ for x in soup.find_all(string=True) + ] + + # The TemplateString is a little unusual because it's generally found + # _inside_ children of a