sinter 1.14.dev1727164676__tar.gz → 1.15.0__tar.gz

{sinter-1.14.dev1727164676/src/sinter.egg-info → sinter-1.15.0}/PKG-INFO

@@ -1,16 +1,24 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sinter
-Version: 1.14.dev1727164676
+Version: 1.15.0
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com
 License: Apache 2
 Requires-Python: >=3.7.0
 Description-Content-Type: text/markdown
-Requires-Dist: matplotlib~=3.5
-Requires-Dist: numpy~=1.22
+Requires-Dist: matplotlib
+Requires-Dist: numpy
 Requires-Dist: stim
-Requires-Dist: scipy~=1.9
+Requires-Dist: scipy
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # sinter: fast QEC sampling
 

sinter-1.15.0/requirements.txt

@@ -0,0 +1,4 @@
+matplotlib
+numpy
+stim
+scipy

{sinter-1.14.dev1727164676 → sinter-1.15.0}/setup.py

@@ -19,7 +19,7 @@ with open('README.md', encoding='UTF-8') as f:
 with open('requirements.txt', encoding='UTF-8') as f:
     requirements = f.read().splitlines()
 
-__version__ = '1.14.dev1727164676'
+__version__ = '1.15.0'
 
 setup(
     name='sinter',

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.14.dev1727164676'
+__version__ = '1.15.0'
 
 from sinter._collection import (
     collect,

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_collection/_collection_manager.py

@@ -129,6 +129,10 @@ class CollectionManager:
     def start_workers(self, *, actually_start_worker_processes: bool = True):
         assert not self.started
 
+        # Use max_batch_size from collection_options if provided, otherwise default to 1024 as large
+        # batch sizes can lead to thrashing
+        max_batch_shots = self.collection_options.max_batch_size or 1024
+
         sampler = RampThrottledSampler(
             sub_sampler=MuxSampler(
                 custom_decoders=self.custom_decoders,
@@ -137,7 +141,7 @@ class CollectionManager:
                 tmp_dir=self.tmp_dir,
             ),
             target_batch_seconds=1,
-            max_batch_shots=1024,
+            max_batch_shots=max_batch_shots,
         )
 
         self.started = True

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_collection/_collection_test.py

@@ -1,14 +1,13 @@
 import collections
-import math
+import multiprocessing
 import pathlib
-import sys
 import tempfile
 import time
 
 import pytest
-import stim
 
 import sinter
+import stim
 
 
 def test_iter_collect():
@@ -272,3 +271,47 @@ def test_mock_timing_sampler():
         custom_decoders={'MockTimingSampler': MockTimingSampler()},
     )
     assert 1_000_000 <= results[0].shots <= 1_000_000 + 12000
+
+class BatchSizeTrackingSampler(sinter.Sampler, sinter.CompiledSampler):
+    """A sampler that tracks the suggested batch size requests it receives."""
+
+    def __init__(self, batch_sizes: list[int]):
+        self.batch_sizes = batch_sizes
+
+    def compiled_sampler_for_task(self, task: sinter.Task) -> sinter.CompiledSampler:
+        return self
+
+    def sample(self, suggested_shots: int) -> sinter.AnonTaskStats:
+        self.batch_sizes.append(suggested_shots)
+        return sinter.AnonTaskStats(
+            shots=suggested_shots,
+            errors=1,
+            seconds=0.001,
+        )
+
+
+def test_ramp_throttled_sampler_respects_max_batch_size():
+    """Test that the CollectionManager instantiated RampThrottledSampler respects the `max_batch_size`
+    parameter."""
+
+    # since the RampThrottledSampler and batch sizing happens in the worker process, we need a
+    # shared list to track what goes on with the sampler
+    with multiprocessing.Manager() as manager:
+        tracking_sampler = BatchSizeTrackingSampler(manager.list())
+
+        sinter.collect(
+            num_workers=1,
+            tasks=[
+                sinter.Task(
+                    circuit=stim.Circuit(),
+                    decoder='tracking_sampler',
+                    json_metadata={'test': 'small_batch'},
+                )
+            ],
+            max_shots=10_000,
+            max_batch_size=128,  # Set a small max batch size
+            custom_decoders={'tracking_sampler': tracking_sampler},
+        )
+        # batch size should start at one and then maximum seen should be at most 128
+        assert tracking_sampler.batch_sizes[0] == 1
+        assert 1 < max(tracking_sampler.batch_sizes) <= 128

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_collection/_collection_worker_test.py

@@ -163,7 +163,15 @@ def test_worker_finish_work():
     handler.expected_task = ta
     _put_wait_not_empty(inp, ('change_job', (ta, sinter.CollectionOptions(max_errors=100_000_000), 100_000_000)))
     _put_wait_not_empty(inp, ('accept_shots', (ta.strong_id(), 10000)))
-    assert worker.process_messages() == 2
+    t0 = time.monotonic()
+    num_processed = 0
+    while True:
+        num_processed += worker.process_messages()
+        if num_processed >= 2:
+            break
+        if time.monotonic() - t0 > 1:
+            raise ValueError("Messages not processed")
+    assert num_processed == 2
     _assert_drain_queue(out, [
         ('changed_job', 5, (ta.strong_id(),)),
         ('accepted_shots', 5, (ta.strong_id(), 10000)),

sinter-1.15.0/src/sinter/_collection/_sampler_ramp_throttled_test.py

@@ -0,0 +1,144 @@
+from unittest import mock
+
+import pytest
+
+import sinter
+import stim
+from sinter._collection._sampler_ramp_throttled import (
+    CompiledRampThrottledSampler,
+    RampThrottledSampler,
+)
+from sinter._data import AnonTaskStats, Task
+
+
+class MockSampler(sinter.Sampler, sinter.CompiledSampler):
+    """Mock sampler that tracks `suggested_shots` parameter in `sample` calls."""
+
+    def __init__(self):
+        self.calls = []
+
+    def compiled_sampler_for_task(self, task: Task) -> sinter.CompiledSampler:
+        return self
+
+    def sample(self, suggested_shots: int) -> AnonTaskStats:
+        self.calls.append(suggested_shots)
+        return AnonTaskStats(
+            shots=suggested_shots,
+            errors=1,
+            seconds=0.001 * suggested_shots,  # Simulate time proportional to shots
+        )
+
+
+@pytest.fixture
+def mock_sampler():
+    return MockSampler()
+
+
+def test_initial_batch_size(mock_sampler):
+    """Test that the sampler starts with a batch size of 1."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=1024,
+    )
+
+    # First call should use batch_size=1
+    sampler.sample(100)
+    assert mock_sampler.calls[0] == 1
+
+
+def test_batch_size_ramps_up(mock_sampler):
+    """Test that the batch size increases when execution is fast."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=1024,
+    )
+
+    # Mock time.monotonic to simulate fast execution
+    # two calls per sample for tic/toc
+    with mock.patch(
+        "time.monotonic", side_effect=[0.0, 0.001, 0.02, 0.021, 0.03, 0.031]
+    ):
+        sampler.sample(100)  # First call, batch_size=1
+        sampler.sample(100)  # Should double 4 times to 16
+        sampler.sample(100)  # Should double 4 times again but hit limit of 100
+
+    assert mock_sampler.calls == [1, 16, 100]
+
+
+def test_batch_size_decreases(mock_sampler):
+    """Test that the batch size decreases when execution is slow."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=0.1,
+        max_batch_shots=1024,
+    )
+
+    # Set initial batch size higher for this test
+    sampler.batch_shots = 64
+
+    # Mock time.monotonic to simulate slow execution (>1.3x target)
+    with mock.patch("time.monotonic", side_effect=[0.0, 0.15, 0.5, 0.65]):
+        sampler.sample(100)  # First call, batch_size=64
+        sampler.sample(100)  # Should halve to 32
+
+    assert mock_sampler.calls == [64, 32]
+
+
+def test_respects_max_batch_shots(mock_sampler):
+    """Test that the batch size never exceeds max_batch_shots."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=16,  # Small max for testing
+    )
+
+    # Set initial batch size close to max
+    sampler.batch_shots = 8
+
+    # Mock time.monotonic to simulate very fast execution
+    # two calls per sample for tic/toc
+    with mock.patch(
+        "time.monotonic", side_effect=[0.0, 0.001, 0.02, 0.021, 0.03, 0.031]
+    ):
+        sampler.sample(100)  # First call, batch_size=8
+        sampler.sample(100)  # Should double to 16
+        sampler.sample(100)  # Should stay at 16 (max)
+
+    assert mock_sampler.calls == [8, 16, 16]
+
+
+def test_respects_max_shots_parameter(mock_sampler):
+    """Test that the sampler respects the max_shots parameter."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=1024,
+    )
+
+    # Set batch size higher than max_shots
+    sampler.batch_shots = 100
+
+    # Call with max_shots=10
+    sampler.sample(10)
+
+    # Should only request 10 shots, not 100
+    assert mock_sampler.calls[0] == 10
+
+
+def test_sub_sampler_parameter_pass_through(mock_sampler):
+    """Test that parameters are passed through to compiled sub sampler."""
+    factory = RampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=0.5,
+        max_batch_shots=512,
+    )
+
+    task = Task(circuit=stim.Circuit(), decoder="test")
+    compiled = factory.compiled_sampler_for_task(task)
+
+    assert isinstance(compiled, CompiledRampThrottledSampler)
+    assert compiled.target_batch_seconds == 0.5
+    assert compiled.max_batch_shots == 512
+    assert compiled.batch_shots == 1  # Initial batch size

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_decoding/_decoding_decoder_class.py

@@ -55,7 +55,7 @@ class CompiledDecoder(metaclass=abc.ABCMeta):
         pass
 
 
-class Decoder(metaclass=abc.ABCMeta):
+class Decoder:
     """Abstract base class for custom decoders.
 
     Custom decoders can be explained to sinter by inheriting from this class and
@@ -63,6 +63,10 @@ class Decoder(metaclass=abc.ABCMeta):
 
     Decoder classes MUST be serializable (e.g. via pickling), so that they can
     be given to worker processes when using python multiprocessing.
+
+    Child classes should implement `compile_decoder_for_dem`, but (for legacy
+    reasons) can alternatively implement `decode_via_files`. At least one of
+    the two methods must be implemented.
     """
 
     def compile_decoder_for_dem(
@@ -95,7 +99,6 @@ class Decoder(metaclass=abc.ABCMeta):
         """
         raise NotImplementedError('compile_decoder_for_dem')
 
-    @abc.abstractmethod
     def decode_via_files(self,
                          *,
                          num_shots: int,
@@ -141,4 +144,18 @@ class Decoder(metaclass=abc.ABCMeta):
                 temporary objects. All cleanup should be done via sinter
                 deleting this directory after killing the decoder.
         """
-        pass
+        dem = stim.DetectorErrorModel.from_file(dem_path)
+
+        try:
+            compiled = self.compile_decoder_for_dem(dem=dem)
+        except NotImplementedError as ex:
+            raise NotImplementedError(f"{type(self).__qualname__} didn't implement `compile_decoder_for_dem` or `decode_via_files`.") from ex
+
+        num_det_bytes = -(-num_dets // 8)
+        num_obs_bytes = -(-num_obs // 8)
+        dets = np.fromfile(dets_b8_in_path, dtype=np.uint8, count=num_shots * num_det_bytes)
+        dets = dets.reshape(num_shots, num_det_bytes)
+        obs = compiled.decode_shots_bit_packed(bit_packed_detection_event_data=dets)
+        if obs.dtype != np.uint8 or obs.shape != (num_shots, num_obs_bytes):
+            raise ValueError(f"Got a numpy array with dtype={obs.dtype},shape={obs.shape} instead of dtype={np.uint8},shape={(num_shots, num_obs_bytes)} from {type(self).__qualname__}(...).compile_decoder_for_dem(...).decode_shots_bit_packed(...).")
+        obs.tofile(obs_predictions_b8_out_path)

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_decoding/_decoding_fusion_blossom.py

@@ -24,14 +24,17 @@ class FusionBlossomCompiledDecoder(CompiledDecoder):
             bit_packed_detection_event_data: 'np.ndarray',
     ) -> 'np.ndarray':
         num_shots = bit_packed_detection_event_data.shape[0]
-        predictions = np.zeros(shape=(num_shots, self.num_obs), dtype=np.uint8)
+        predictions = np.zeros(shape=(num_shots, (self.num_obs + 7) // 8), dtype=np.uint8)
         import fusion_blossom
         for shot in range(num_shots):
             dets_sparse = np.flatnonzero(np.unpackbits(bit_packed_detection_event_data[shot], count=self.num_dets, bitorder='little'))
             syndrome = fusion_blossom.SyndromePattern(syndrome_vertices=dets_sparse)
             self.solver.solve(syndrome)
             prediction = int(np.bitwise_xor.reduce(self.fault_masks[self.solver.subgraph()]))
-            predictions[shot] = np.packbits(prediction, bitorder='little')
+            predictions[shot] = np.packbits(
+                np.array(list(np.binary_repr(prediction, width=self.num_obs))[::-1],dtype=np.uint8),
+                bitorder="little",
+            )
             self.solver.clear()
         return predictions
 

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_decoding/_decoding_mwpf.py

@@ -15,7 +15,7 @@ def mwpf_import_error() -> ImportError:
     return ImportError(
         "The decoder 'MWPF' isn't installed\n"
         "To fix this, install the python package 'MWPF' into your environment.\n"
-        "For example, if you are using pip, run `pip install MWPF~=0.1.1`.\n"
+        "For example, if you are using pip, run `pip install MWPF~=0.1.5`.\n"
     )
 
 
@@ -38,7 +38,9 @@ class MwpfCompiledDecoder(CompiledDecoder):
         bit_packed_detection_event_data: "np.ndarray",
     ) -> "np.ndarray":
         num_shots = bit_packed_detection_event_data.shape[0]
-        predictions = np.zeros(shape=(num_shots, self.num_obs), dtype=np.uint8)
+        predictions = np.zeros(
+            shape=(num_shots, (self.num_obs + 7) // 8), dtype=np.uint8
+        )
         import mwpf
 
         for shot in range(num_shots):
@@ -58,29 +60,48 @@ class MwpfCompiledDecoder(CompiledDecoder):
                     np.bitwise_xor.reduce(self.fault_masks[self.solver.subgraph()])
                 )
                 self.solver.clear()
-            predictions[shot] = np.packbits(prediction, bitorder="little")
+            predictions[shot] = np.packbits(
+                np.array(
+                    list(np.binary_repr(prediction, width=self.num_obs))[::-1],
+                    dtype=np.uint8,
+                ),
+                bitorder="little",
+            )
         return predictions
 
 
 class MwpfDecoder(Decoder):
     """Use MWPF to predict observables from detection events."""
 
-    def compile_decoder_for_dem(
+    def __init__(
         self,
-        *,
-        dem: "stim.DetectorErrorModel",
         decoder_cls: Any = None,  # decoder class used to construct the MWPF decoder.
         # in the Rust implementation, all of them inherits from the class of `SolverSerialPlugins`
         # but just provide different plugins for optimizing the primal and/or dual solutions.
         # For example, `SolverSerialUnionFind` is the most basic solver without any plugin: it only
         # grows the clusters until the first valid solution appears; some more optimized solvers uses
         # one or more plugins to further optimize the solution, which requires longer decoding time.
+        cluster_node_limit: int = 50,  # The maximum number of nodes in a cluster,
+    ):
+        self.decoder_cls = decoder_cls
+        self.cluster_node_limit = cluster_node_limit
+        super().__init__()
+
+    def compile_decoder_for_dem(
+        self,
+        *,
+        dem: "stim.DetectorErrorModel",
     ) -> CompiledDecoder:
         solver, fault_masks = detector_error_model_to_mwpf_solver_and_fault_masks(
-            dem, decoder_cls=decoder_cls
+            dem,
+            decoder_cls=self.decoder_cls,
+            cluster_node_limit=self.cluster_node_limit,
         )
         return MwpfCompiledDecoder(
-            solver, fault_masks, dem.num_detectors, dem.num_observables
+            solver,
+            fault_masks,
+            dem.num_detectors,
+            dem.num_observables,
         )
 
     def decode_via_files(
@@ -93,13 +114,14 @@ class MwpfDecoder(Decoder):
         dets_b8_in_path: pathlib.Path,
         obs_predictions_b8_out_path: pathlib.Path,
         tmp_dir: pathlib.Path,
-        decoder_cls: Any = None,
     ) -> None:
         import mwpf
 
         error_model = stim.DetectorErrorModel.from_file(dem_path)
         solver, fault_masks = detector_error_model_to_mwpf_solver_and_fault_masks(
-            error_model, decoder_cls=decoder_cls
+            error_model,
+            decoder_cls=self.decoder_cls,
+            cluster_node_limit=self.cluster_node_limit,
         )
         num_det_bytes = math.ceil(num_dets / 8)
         with open(dets_b8_in_path, "rb") as dets_in_f:
@@ -130,44 +152,8 @@ class MwpfDecoder(Decoder):
 
 
 class HyperUFDecoder(MwpfDecoder):
-    def compile_decoder_for_dem(
-        self, *, dem: "stim.DetectorErrorModel"
-    ) -> CompiledDecoder:
-        try:
-            import mwpf
-        except ImportError as ex:
-            raise mwpf_import_error() from ex
-
-        return super().compile_decoder_for_dem(
-            dem=dem, decoder_cls=mwpf.SolverSerialUnionFind
-        )
-
-    def decode_via_files(
-        self,
-        *,
-        num_shots: int,
-        num_dets: int,
-        num_obs: int,
-        dem_path: pathlib.Path,
-        dets_b8_in_path: pathlib.Path,
-        obs_predictions_b8_out_path: pathlib.Path,
-        tmp_dir: pathlib.Path,
-    ) -> None:
-        try:
-            import mwpf
-        except ImportError as ex:
-            raise mwpf_import_error() from ex
-
-        return super().decode_via_files(
-            num_shots=num_shots,
-            num_dets=num_dets,
-            num_obs=num_obs,
-            dem_path=dem_path,
-            dets_b8_in_path=dets_b8_in_path,
-            obs_predictions_b8_out_path=obs_predictions_b8_out_path,
-            tmp_dir=tmp_dir,
-            decoder_cls=mwpf.SolverSerialUnionFind,
-        )
+    def __init__(self):
+        super().__init__(decoder_cls="SolverSerialUnionFind", cluster_node_limit=0)
 
 
 def iter_flatten_model(
@@ -187,16 +173,16 @@ def iter_flatten_model(
                     _helper(instruction.body_copy(), instruction.repeat_count)
                 elif isinstance(instruction, stim.DemInstruction):
                     if instruction.type == "error":
-                        dets: List[int] = []
-                        frames: List[int] = []
+                        dets: set[int] = set()
+                        frames: set[int] = set()
                         t: stim.DemTarget
                         p = instruction.args_copy()[0]
                         for t in instruction.targets_copy():
                             if t.is_relative_detector_id():
-                                dets.append(t.val + det_offset)
+                                dets ^= {t.val + det_offset}
                             elif t.is_logical_observable_id():
-                                frames.append(t.val)
-                        handle_error(p, dets, frames)
+                                frames ^= {t.val}
+                        handle_error(p, list(dets), list(frames))
                     elif instruction.type == "shift_detectors":
                         det_offset += instruction.targets_copy()[0]
                         a = np.array(instruction.args_copy())
@@ -220,26 +206,31 @@ def iter_flatten_model(
 def deduplicate_hyperedges(
     hyperedges: List[Tuple[List[int], float, int]]
 ) -> List[Tuple[List[int], float, int]]:
-    indices: dict[frozenset[int], int] = dict()
+    indices: dict[frozenset[int], Tuple[int, float]] = dict()
     result: List[Tuple[List[int], float, int]] = []
     for dets, weight, mask in hyperedges:
         dets_set = frozenset(dets)
         if dets_set in indices:
-            idx = indices[dets_set]
+            idx, min_weight = indices[dets_set]
             p1 = 1 / (1 + math.exp(weight))
             p2 = 1 / (1 + math.exp(result[idx][1]))
             p = p1 * (1 - p2) + p2 * (1 - p1)
-            # not sure why would this fail? two hyperedges with different masks?
-            # assert mask == result[idx][2], (result[idx], (dets, weight, mask))
-            result[idx] = (dets, math.log((1 - p) / p), result[idx][2])
+            # choosing the mask from the most likely error
+            new_mask = result[idx][2]
+            if weight < min_weight:
+                indices[dets_set] = (idx, weight)
+                new_mask = mask
+            result[idx] = (dets, math.log((1 - p) / p), new_mask)
         else:
-            indices[dets_set] = len(result)
+            indices[dets_set] = (len(result), weight)
             result.append((dets, weight, mask))
     return result
 
 
 def detector_error_model_to_mwpf_solver_and_fault_masks(
-    model: stim.DetectorErrorModel, decoder_cls: Any = None
+    model: stim.DetectorErrorModel,
+    decoder_cls: Any = None,
+    cluster_node_limit: int = 50,
 ) -> Tuple[Optional["mwpf.SolverSerialJointSingleHair"], np.ndarray]:
     """Convert a stim error model into a NetworkX graph."""
 
@@ -261,7 +252,7 @@ def detector_error_model_to_mwpf_solver_and_fault_masks(
             # Accept it and keep going, though of course decoding will probably perform terribly.
             return
         if p > 0.5:
-            # mwpf doesn't support negative edge weights.
+            # mwpf doesn't support negative edge weights (yet, will be supported in the next version).
             # approximate them as weight 0.
             p = 0.5
         weight = math.log((1 - p) / p)
@@ -280,7 +271,7 @@ def detector_error_model_to_mwpf_solver_and_fault_masks(
     # mwpf package panic on duplicate edges, thus we need to handle them here
     hyperedges = deduplicate_hyperedges(hyperedges)
 
-    # fix the input by connecting an edge to all isolated vertices
+    # fix the input by connecting an edge to all isolated vertices; will be supported in the next version
     for idx in range(num_detectors):
         if not is_detector_connected[idx]:
             hyperedges.append(([idx], 0, 0))
@@ -299,9 +290,11 @@ def detector_error_model_to_mwpf_solver_and_fault_masks(
     if decoder_cls is None:
         # default to the solver with highest accuracy
         decoder_cls = mwpf.SolverSerialJointSingleHair
+    elif isinstance(decoder_cls, str):
+        decoder_cls = getattr(mwpf, decoder_cls)
     return (
         (
-            decoder_cls(initializer)
+            decoder_cls(initializer, config={"cluster_node_limit": cluster_node_limit})
             if num_detectors > 0 and len(rescaled_edges) > 0
             else None
         ),

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_decoding/_decoding_test.py

@@ -10,6 +10,7 @@ import pytest
 import sinter
 import stim
 
+from sinter import CompiledDecoder
 from sinter._collection import post_selection_mask_from_4th_coord
 from sinter._decoding._decoding_all_built_in_decoders import BUILT_IN_DECODERS
 from sinter._decoding._decoding import sample_decode
@@ -391,3 +392,89 @@ def test_full_scale(decoder: str):
     assert result.discards == 0
     assert result.shots == 1000
     assert result.errors == 0
+
+
+def test_infer_decode_via_files_from_decode_from_compile_decoder_for_dem():
+    class IncompleteDecoder(sinter.Decoder):
+        pass
+
+    class WrongDecoder(sinter.Decoder, sinter.CompiledDecoder):
+        def compile_decoder_for_dem(
+                self,
+                *,
+                dem: stim.DetectorErrorModel,
+        ) -> CompiledDecoder:
+            return self
+        def decode_shots_bit_packed(
+                self,
+                *,
+                bit_packed_detection_event_data: np.ndarray,
+        ) -> np.ndarray:
+            return np.zeros(shape=5, dtype=np.bool_)
+
+    class TrivialCompiledDecoder(sinter.CompiledDecoder):
+        def __init__(self, num_obs: int):
+            self.num_obs = -(-num_obs // 8)
+
+        def decode_shots_bit_packed(
+                self,
+                *,
+                bit_packed_detection_event_data: np.ndarray,
+        ) -> np.ndarray:
+            return np.zeros(dtype=np.uint8, shape=(bit_packed_detection_event_data.shape[0], self.num_obs))
+
+    class TrivialDecoder(sinter.Decoder):
+        def compile_decoder_for_dem(
+            self,
+            *,
+            dem: stim.DetectorErrorModel,
+        ) -> CompiledDecoder:
+                return TrivialCompiledDecoder(num_obs=dem.num_observables)
+
+    circuit = stim.Circuit.generated("repetition_code:memory", distance=3, rounds=3)
+    dem = circuit.detector_error_model()
+
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+
+        circuit.compile_detector_sampler().sample_write(
+            shots=10,
+            filepath=d / 'dets.b8',
+            format='b8',
+        )
+
+        dem.to_file(d / 'dem.dem')
+
+        with pytest.raises(NotImplementedError, match='compile_decoder_for_dem'):
+            IncompleteDecoder().decode_via_files(
+                num_shots=10,
+                num_dets=dem.num_detectors,
+                num_obs=dem.num_observables,
+                dem_path=d / 'dem.dem',
+                dets_b8_in_path=d / 'dets.b8',
+                obs_predictions_b8_out_path=d / 'obs.b8',
+                tmp_dir=d,
+            )
+
+        with pytest.raises(ValueError, match='shape='):
+            WrongDecoder().decode_via_files(
+                num_shots=10,
+                num_dets=dem.num_detectors,
+                num_obs=dem.num_observables,
+                dem_path=d / 'dem.dem',
+                dets_b8_in_path=d / 'dets.b8',
+                obs_predictions_b8_out_path=d / 'obs.b8',
+                tmp_dir=d,
+            )
+
+        TrivialDecoder().decode_via_files(
+            num_shots=10,
+            num_dets=dem.num_detectors,
+            num_obs=dem.num_observables,
+            dem_path=d / 'dem.dem',
+            dets_b8_in_path=d / 'dets.b8',
+            obs_predictions_b8_out_path=d / 'obs.b8',
+            tmp_dir=d,
+        )
+        obs = np.fromfile(d / 'obs.b8', dtype=np.uint8, count=10)
+        np.testing.assert_array_equal(obs, [0] * 10)

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_decoding/_stim_then_decode_sampler.py

@@ -140,7 +140,7 @@ def _compile_decoder_with_disk_fallback(
 ) -> CompiledDecoder:
     try:
         return decoder.compile_decoder_for_dem(dem=task.detector_error_model)
-    except (NotImplementedError, ValueError):
+    except NotImplementedError:
         pass
     if tmp_dir is None:
         raise ValueError(f"Decoder {task.decoder=} didn't implement `compile_decoder_for_dem`, but no temporary directory was provided for falling back to `decode_via_files`.")

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter/_probability_util.py

@@ -51,7 +51,7 @@ def log_binomial(*, p: Union[float, np.ndarray], n: int, hits: int) -> np.ndarra
     Examples:
         >>> import sinter
         >>> sinter.log_binomial(p=0.5, n=100, hits=50)
-        array(-2.5308785, dtype=float32)
+        array(-2.5308762, dtype=float32)
         >>> sinter.log_binomial(p=0.2, n=1_000_000, hits=1_000)
         array(-216626.97, dtype=float32)
         >>> sinter.log_binomial(p=0.1, n=1_000_000, hits=1_000)
@@ -321,7 +321,7 @@ def fit_line_slope(*,
 
     low_slope = binary_intercept(start_x=fit.slope, step=-1, target_y=base_cost + max_extra_squared_error, func=cost_for_slope, atol=1e-5)
     high_slope = binary_intercept(start_x=fit.slope, step=1, target_y=base_cost + max_extra_squared_error, func=cost_for_slope, atol=1e-5)
-    return Fit(low=low_slope, best=fit.slope, high=high_slope)
+    return Fit(low=float(low_slope), best=float(fit.slope), high=float(high_slope))
 
 
 def fit_binomial(

{sinter-1.14.dev1727164676 → sinter-1.15.0/src/sinter.egg-info}/PKG-INFO

@@ -1,16 +1,24 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sinter
-Version: 1.14.dev1727164676
+Version: 1.15.0
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com
 License: Apache 2
 Requires-Python: >=3.7.0
 Description-Content-Type: text/markdown
-Requires-Dist: matplotlib~=3.5
-Requires-Dist: numpy~=1.22
+Requires-Dist: matplotlib
+Requires-Dist: numpy
 Requires-Dist: stim
-Requires-Dist: scipy~=1.9
+Requires-Dist: scipy
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # sinter: fast QEC sampling
 

{sinter-1.14.dev1727164676 → sinter-1.15.0}/src/sinter.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/sinter/_collection/_collection_worker_test.py
 src/sinter/_collection/_mux_sampler.py
 src/sinter/_collection/_printer.py
 src/sinter/_collection/_sampler_ramp_throttled.py
+src/sinter/_collection/_sampler_ramp_throttled_test.py
 src/sinter/_command/__init__.py
 src/sinter/_command/_main.py
 src/sinter/_command/_main_collect.py

sinter-1.15.0/src/sinter.egg-info/requires.txt

@@ -0,0 +1,4 @@
+matplotlib
+numpy
+stim
+scipy

sinter-1.14.dev1727164676/requirements.txt

@@ -1,4 +0,0 @@
-matplotlib ~= 3.5
-numpy ~= 1.22
-stim
-scipy ~= 1.9

sinter-1.14.dev1727164676/src/sinter.egg-info/requires.txt

@@ -1,4 +0,0 @@
-matplotlib~=3.5
-numpy~=1.22
-stim
-scipy~=1.9