sinter 1.15.dev1742871434__tar.gz → 1.16.dev1768553279__tar.gz

{sinter-1.15.dev1742871434/src/sinter.egg-info → sinter-1.16.dev1768553279}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinter
-Version: 1.15.dev1742871434
+Version: 1.16.dev1768553279
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/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.15.dev1742871434'
+__version__ = '1.16.dev1768553279'
 
 setup(
     name='sinter',

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/src/sinter/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.15.dev1742871434'
+__version__ = '1.16.dev1768553279'
 
 from sinter._collection import (
     collect,

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/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.15.dev1742871434 → sinter-1.16.dev1768553279}/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.15.dev1742871434 → sinter-1.16.dev1768553279}/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.16.dev1768553279/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.15.dev1742871434 → sinter-1.16.dev1768553279}/src/sinter/_data/_anon_task_stats.py

@@ -1,6 +1,7 @@
 import collections
 import dataclasses
 from typing import Counter, Union, TYPE_CHECKING
+import numpy as np
 
 if TYPE_CHECKING:
     from sinter._data._task_stats import TaskStats
@@ -34,16 +35,16 @@ class AnonTaskStats:
     custom_counts: Counter[str] = dataclasses.field(default_factory=collections.Counter)
 
     def __post_init__(self):
-        assert isinstance(self.errors, int)
-        assert isinstance(self.shots, int)
-        assert isinstance(self.discards, int)
-        assert isinstance(self.seconds, (int, float))
+        assert isinstance(self.errors, (int, np.integer))
+        assert isinstance(self.shots, (int, np.integer))
+        assert isinstance(self.discards, (int, np.integer))
+        assert isinstance(self.seconds, (int, float, np.integer, np.floating))
         assert isinstance(self.custom_counts, collections.Counter)
         assert self.errors >= 0
         assert self.discards >= 0
         assert self.seconds >= 0
         assert self.shots >= self.errors + self.discards
-        assert all(isinstance(k, str) and isinstance(v, int) for k, v in self.custom_counts.items())
+        assert all(isinstance(k, str) and isinstance(v, (int, np.integer)) for k, v in self.custom_counts.items())
 
     def __repr__(self) -> str:
         terms = []

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/src/sinter/_data/_csv_out.py

@@ -36,6 +36,9 @@ def csv_line(*,
                                    separators=(',', ':'),
                                    sort_keys=True)
         if custom_counts:
+            # Ensure all custom_counts values are integers before dumping to JSON
+            for k in custom_counts:
+                custom_counts[k] = int(custom_counts[k])
             custom_counts = escape_csv(
                 json.dumps(custom_counts,
                            separators=(',', ':'),

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/src/sinter/_data/_task_stats.py

@@ -4,7 +4,7 @@ from typing import Counter, List, Any
 from typing import Optional
 from typing import Union
 from typing import overload
-
+import numpy as np
 from sinter._data._anon_task_stats import AnonTaskStats
 from sinter._data._csv_out import csv_line
 
@@ -71,10 +71,10 @@ class TaskStats:
     custom_counts: Counter[str] = dataclasses.field(default_factory=collections.Counter)
 
     def __post_init__(self):
-        assert isinstance(self.errors, int)
-        assert isinstance(self.shots, int)
-        assert isinstance(self.discards, int)
-        assert isinstance(self.seconds, (int, float))
+        assert isinstance(self.errors, (int, np.integer))
+        assert isinstance(self.shots, (int, np.integer))
+        assert isinstance(self.discards, (int, np.integer))
+        assert isinstance(self.seconds, (int, float, np.integer, np.floating))
         assert isinstance(self.custom_counts, collections.Counter)
         assert isinstance(self.decoder, str)
         assert isinstance(self.strong_id, str)
@@ -83,7 +83,7 @@ class TaskStats:
         assert self.discards >= 0
         assert self.seconds >= 0
         assert self.shots >= self.errors + self.discards
-        assert all(isinstance(k, str) and isinstance(v, int) for k, v in self.custom_counts.items())
+        assert all(isinstance(k, str) and isinstance(v, (int, np.integer)) for k, v in self.custom_counts.items())
 
     def with_edits(
         self,
@@ -190,13 +190,13 @@ class TaskStats:
             >>> print(sinter.CSV_HEADER)
                  shots,    errors,  discards, seconds,decoder,strong_id,json_metadata,custom_counts
             >>> print(stat.to_csv_line())
-                    22,         3,         0,       5,pymatching,test,"{""a"":[1,2,3]}",
+                    22,         3,         0,    5.00,pymatching,test,"{""a"":[1,2,3]}",
         """
         return csv_line(
-            shots=self.shots,
-            errors=self.errors,
-            seconds=self.seconds,
-            discards=self.discards,
+            shots=int(self.shots),
+            errors=int(self.errors),
+            seconds=float(self.seconds),
+            discards=int(self.discards),
             strong_id=self.strong_id,
             decoder=self.decoder,
             json_metadata=self.json_metadata,

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/src/sinter/_data/_task_stats_test.py

@@ -29,7 +29,7 @@ def test_to_csv_line():
         discards=4,
         seconds=5,
     )
-    assert v.to_csv_line() == str(v) == '        22,         3,         4,       5,pymatching,test,"{""a"":[1,2,3]}",'
+    assert v.to_csv_line() == str(v) == '        22,         3,         4,    5.00,pymatching,test,"{""a"":[1,2,3]}",'
 
 
 def test_to_anon_stats():

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/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.15.dev1742871434 → sinter-1.16.dev1768553279}/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.15.dev1742871434 → sinter-1.16.dev1768553279}/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.15.dev1742871434 → sinter-1.16.dev1768553279}/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.15.dev1742871434 → sinter-1.16.dev1768553279/src/sinter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinter
-Version: 1.15.dev1742871434
+Version: 1.16.dev1768553279
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com

{sinter-1.15.dev1742871434 → sinter-1.16.dev1768553279}/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