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

{quapp_merlin-0.0.1.dev2/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.dev2
+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.dev2 → 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.dev2"
+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.dev2 → quapp_merlin-0.0.1.dev3}/quapp_merlin/model/device/merlin_remote_device.py

@@ -92,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}')

{quapp_merlin-0.0.1.dev2 → 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.dev2
+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.dev2 → quapp_merlin-0.0.1.dev3}/quapp_merlin.egg-info/SOURCES.txt

@@ -35,5 +35,6 @@ 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_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')