quapp-merlin 0.0.1.dev1__tar.gz → 0.0.1.dev3__tar.gz

{quapp_merlin-0.0.1.dev1/quapp_merlin.egg-info → quapp_merlin-0.0.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-merlin
-Version: 0.0.1.dev1
+Version: 0.0.1.dev3
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-merlin"
-version = "0.0.1.dev1"
+version = "0.0.1.dev3"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev3}/quapp_merlin/model/device/merlin_device.py

@@ -110,6 +110,40 @@ class MerlinDevice(CustomDevice, ABC):
 
     # ------------------------------------------------------------- helpers
 
+    # A MeasurementStrategy keeps its kind in `.type`, a MeasurementKind enum
+    # (PROBABILITIES / MODE_EXPECTATIONS / AMPLITUDES / PARTIAL). It has no
+    # `.name` of its own -- the first version of this read
+    # type(strategy).__name__ instead, which is always 'MeasurementStrategy',
+    # so nothing ever matched 'probs' and no job ever produced a histogram.
+    MEASUREMENT_KINDS = {'PROBABILITIES'     : 'probs',
+                         'MODE_EXPECTATIONS' : 'mode_expectations',
+                         'AMPLITUDES'        : 'amplitudes',
+                         'PARTIAL'           : 'partial'}
+
+    def _measurement_name(self, model) -> str | None:
+        """Which measurement the quantum layer uses, as a short string.
+
+        Only used to decide whether a histogram makes sense, so anything
+        unrecognised degrades to None rather than raising.
+        """
+        modules = model.modules() if hasattr(model, 'modules') else [model]
+
+        for module in modules:
+            strategy = getattr(module, 'measurement_strategy', None)
+            if strategy is None:
+                continue
+
+            kind = getattr(strategy, 'type', None)
+            name = (getattr(kind, 'name', None) or getattr(kind, 'value', None)
+                    or kind)
+            if name is None:
+                return None
+
+            name = str(name).upper()
+            return self.MEASUREMENT_KINDS.get(name, name.lower())
+
+        return None
+
     def _histogram_from(self, output, shots, batch_size, measurement) -> dict | None:
         """Bin a single-row probability output into a state -> count histogram.
 

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev3}/quapp_merlin/model/device/merlin_local_device.py

@@ -174,22 +174,3 @@ class MerlinLocalDevice(MerlinDevice):
 
         return output, {'epochs': epochs, 'loss': tensors.plain(history),
                         'final_loss': history[-1] if history else None}
-
-    @staticmethod
-    def _measurement_name(model) -> str | None:
-        """Which MeasurementStrategy the quantum layer uses, as a short string.
-
-        Only used to decide whether a histogram makes sense, so an unknown shape
-        degrades to None instead of raising.
-        """
-        for module in (model.modules() if hasattr(model, 'modules') else [model]):
-            strategy = getattr(module, 'measurement_strategy', None)
-            if strategy is None:
-                continue
-            name = getattr(strategy, 'name', None) or type(strategy).__name__
-            name = str(name).lower()
-            for known in ('probs', 'probabilit', 'expectation', 'amplitude'):
-                if known in name:
-                    return 'probs' if known.startswith('prob') else known
-            return name
-        return None

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev3}/quapp_merlin/model/device/merlin_remote_device.py

@@ -29,8 +29,7 @@ from quapp_common.model.provider.provider import Provider
 
 from .merlin_device import MerlinDevice
 from ...util import tensors
-from ...util.single_machine import (DEFAULT_MAX_BATCH, batch_size_of,
-                                    quantum_leaves, reject_foreign_backend,
+from ...util.single_machine import (DEFAULT_MAX_BATCH, reject_foreign_backend,
                                     require_batch_fits, require_single_leaf)
 
 # How long we are willing to hold the invocation open waiting for the cloud.
@@ -93,9 +92,16 @@ class MerlinRemoteDevice(MerlinDevice):
                 f'Submitting to {self.device_specification} | batch={batch_size} '
                 f'| shots={shots} | timeout={TIMEOUT_SECONDS}s')
 
+        # forward_async refuses a module still in training mode -- "no gradient
+        # can flow through the QPU runs" (merlin_processor.py:1109, it reads
+        # module.training). A torch Module is training=True from the moment it
+        # is built, so a handler that never calls .eval() is rejected every
+        # single time. The local device already switched to eval before running
+        # inference; this one did not.
+        model = spec.model.eval()
+
         started = time.perf_counter()
-        future = processor.forward_async(spec.model, spec.inputs,
-                                         nsample=shots)
+        future = processor.forward_async(model, spec.inputs, nsample=shots)
 
         job_ids = list(getattr(future, 'job_ids', None) or [])
         self.logger.info(f'Remote job submitted: job_ids={job_ids}')
@@ -148,17 +154,3 @@ class MerlinRemoteDevice(MerlinDevice):
             return ','.join(str(job_id) for job_id in job_ids)
 
         return str(job_ids[0])
-
-    @staticmethod
-    def _measurement_name(model) -> str | None:
-        leaves = quantum_leaves(model)
-        for _, leaf in leaves:
-            strategy = getattr(leaf, 'measurement_strategy', None)
-            if strategy is None:
-                continue
-            name = str(getattr(strategy, 'name', None)
-                       or type(strategy).__name__).lower()
-            if name.startswith('prob') or 'probabilit' in name:
-                return 'probs'
-            return name
-        return None

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev3/quapp_merlin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-merlin
-Version: 0.0.1.dev1
+Version: 0.0.1.dev3
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev3}/quapp_merlin.egg-info/SOURCES.txt

@@ -34,5 +34,7 @@ tests/test_error_logging.py
 tests/test_error_rules.py
 tests/test_job_spec.py
 tests/test_lazy_sdk_imports.py
+tests/test_measurement_kind.py
+tests/test_remote_eval_mode.py
 tests/test_single_machine.py
 tests/test_tensors.py

quapp_merlin-0.0.1.dev3/tests/test_measurement_kind.py

@@ -0,0 +1,114 @@
+#  Quapp Platform Project
+#  test_measurement_kind.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+"""Reading the measurement kind off a MerLin strategy.
+
+This decides whether a job gets a histogram, and the first version got it
+wrong in a way nothing would have noticed: MeasurementStrategy has no `.name`,
+so `type(strategy).__name__` was read instead -- always the string
+'MeasurementStrategy' -- nothing ever matched 'probs', and `_histogram_from`
+returned None for every job ever run.
+
+The stand-ins mirror merlinquantum 0.4.1 exactly: `MeasurementStrategy.type` is
+a `MeasurementKind` enum whose members are PROBABILITIES, MODE_EXPECTATIONS,
+AMPLITUDES and PARTIAL (merlin/measurement/strategies.py:244).
+"""
+
+import enum
+
+import pytest
+
+from quapp_merlin.model.device.merlin_device import MerlinDevice
+
+
+class MeasurementKind(enum.Enum):
+    PROBABILITIES = 'PROBABILITIES'
+    MODE_EXPECTATIONS = 'MODE_EXPECTATIONS'
+    AMPLITUDES = 'AMPLITUDES'
+    PARTIAL = 'PARTIAL'
+
+
+class MeasurementStrategy:
+    """No `.name` -- exactly like the real one. The kind lives in `.type`."""
+
+    def __init__(self, kind):
+        self.type = kind
+
+
+class Module:
+    def __init__(self, children=None, **attributes):
+        self._children = children or {}
+        self.__dict__.update(attributes)
+
+    def modules(self):
+        yield self
+        for child in self._children.values():
+            yield from child.modules()
+
+
+def read(model):
+    """_measurement_name does not touch instance state, so call it unbound."""
+    return MerlinDevice._measurement_name(MerlinDevice, model)
+
+
+@pytest.mark.parametrize('kind, expected', [
+    (MeasurementKind.PROBABILITIES, 'probs'),
+    (MeasurementKind.MODE_EXPECTATIONS, 'mode_expectations'),
+    (MeasurementKind.AMPLITUDES, 'amplitudes'),
+    (MeasurementKind.PARTIAL, 'partial'),
+])
+def test_every_kind_is_recognised(kind, expected):
+    model = Module(measurement_strategy=MeasurementStrategy(kind))
+
+    assert read(model) == expected
+
+
+def test_probabilities_is_what_enables_a_histogram():
+    """The whole point: 'probs' is the only value _histogram_from accepts."""
+    model = Module(measurement_strategy=MeasurementStrategy(
+            MeasurementKind.PROBABILITIES))
+
+    assert read(model) == 'probs'
+
+
+def test_the_strategy_is_found_on_a_nested_layer():
+    """simple() returns a SimpleSequential wrapper; the strategy sits on the
+    QuantumLayer inside it."""
+    layer = Module(measurement_strategy=MeasurementStrategy(
+            MeasurementKind.PROBABILITIES))
+    model = Module(children={'quantum_layer': layer})
+
+    assert read(model) == 'probs'
+
+
+def test_class_name_is_never_used_as_the_kind():
+    """The regression: reading type(strategy).__name__ gave
+    'measurementstrategy', which matches no kind and silently killed the
+    histogram."""
+    model = Module(measurement_strategy=MeasurementStrategy(
+            MeasurementKind.PROBABILITIES))
+
+    assert read(model) != 'measurementstrategy'
+
+
+def test_no_strategy_at_all():
+    assert read(Module()) is None
+
+
+def test_unknown_kind_degrades_instead_of_raising():
+    class Odd(enum.Enum):
+        SOMETHING_NEW = 'SOMETHING_NEW'
+
+    model = Module(measurement_strategy=MeasurementStrategy(Odd.SOMETHING_NEW))
+
+    assert read(model) == 'something_new'
+
+
+def test_a_bare_module_without_modules_still_works():
+    """A handler may return the layer itself rather than a wrapper."""
+
+    class Bare:
+        measurement_strategy = MeasurementStrategy(MeasurementKind.AMPLITUDES)
+
+    assert read(Bare()) == 'amplitudes'

quapp_merlin-0.0.1.dev3/tests/test_remote_eval_mode.py

@@ -0,0 +1,106 @@
+#  Quapp Platform Project
+#  test_remote_eval_mode.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+"""A model sent to the cloud has to be in eval mode.
+
+MerlinProcessor refuses anything else::
+
+    if module.training:
+        raise RuntimeError(
+            "Backend quantum execution requires `.eval()` mode because no
+             gradient can flow through the QPU runs...")
+
+-- merlinquantum 0.4.1, merlin/core/merlin_processor.py:1109.
+
+A torch Module is ``training=True`` from the moment it is constructed, so a
+handler that never calls ``.eval()`` -- which is every handler, because nothing
+in the contract tells them to -- was rejected on every single remote job. The
+local device already switched to eval before inference; the remote one did not.
+
+Checked by reading the source rather than by running a model: importing merlin
+would drag torch into the test suite, and the rule being enforced is "the call
+is there, before the submit", which the AST answers exactly.
+"""
+
+import ast
+import pathlib
+
+import pytest
+
+REMOTE_DEVICE = (pathlib.Path(__file__).resolve().parent.parent
+                 / 'quapp_merlin' / 'model' / 'device'
+                 / 'merlin_remote_device.py')
+LOCAL_DEVICE = (pathlib.Path(__file__).resolve().parent.parent
+                / 'quapp_merlin' / 'model' / 'device'
+                / 'merlin_local_device.py')
+
+
+def create_job(path):
+    tree = ast.parse(path.read_text(encoding='utf-8'), filename=str(path))
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == '_create_job':
+            return node
+    raise AssertionError(f'_create_job() not found in {path.name}')
+
+
+def call_lines(node, attribute) -> list:
+    """Line numbers of every ``x.<attribute>(...)`` call inside a function."""
+    return sorted(inner.lineno for inner in ast.walk(node)
+                  if isinstance(inner, ast.Call)
+                  and getattr(inner.func, 'attr', None) == attribute)
+
+
+def test_remote_switches_the_model_to_eval():
+    assert call_lines(create_job(REMOTE_DEVICE), 'eval'), (
+        'merlin_remote_device._create_job never calls .eval(); MerlinProcessor '
+        'rejects a module in training mode and every remote job fails')
+
+
+def test_eval_happens_before_the_submit():
+    """Calling it after forward_async would be too late to matter."""
+    node = create_job(REMOTE_DEVICE)
+
+    eval_at = call_lines(node, 'eval')
+    submit_at = call_lines(node, 'forward_async')
+
+    assert submit_at, 'no forward_async call in _create_job'
+    assert min(eval_at) < min(submit_at), (
+        f'.eval() is at line {min(eval_at)} but forward_async is at '
+        f'{min(submit_at)} -- the model is still in training mode when it is '
+        f'submitted')
+
+
+def test_the_model_that_is_submitted_is_the_one_that_was_evalled():
+    """`spec.model.eval()` returns the module, so the submit has to use that
+    return value -- passing spec.model again would work only by side effect and
+    would break the moment eval() stops returning self."""
+    node = create_job(REMOTE_DEVICE)
+
+    submitted = None
+    for inner in ast.walk(node):
+        if isinstance(inner, ast.Call) and \
+                getattr(inner.func, 'attr', None) == 'forward_async':
+            submitted = inner.args[0] if inner.args else None
+
+    assert isinstance(submitted, ast.Name), (
+        'forward_async should be handed the local name bound from '
+        'spec.model.eval(), not an attribute read straight off the spec')
+
+
+def test_local_device_also_evals_before_inference():
+    """Same rule on the simulator path, where it was already right -- a
+    regression there would be just as invisible."""
+    assert call_lines(create_job(LOCAL_DEVICE), 'eval')
+
+
+@pytest.mark.parametrize('path', [REMOTE_DEVICE, LOCAL_DEVICE],
+                         ids=lambda p: p.name)
+def test_no_train_mode_on_the_inference_path(path):
+    """`.train()` belongs to the training loop only. On a device that submits to
+    a QPU it would put the module straight back into the state MerLin refuses."""
+    node = create_job(path)
+
+    assert not call_lines(node, 'train'), (
+        f'{path.name}: _create_job calls .train(); the training loop is the '
+        f'only place that may do that')