end-to-end test and scenario settings

QNetOptimizer/network_ansatz.py

@@ -1,5 +1,6 @@
 from functools import wraps
 import pennylane as qml
+from pennylane import numpy as np
 
 
 class PrepareNode:
@@ -84,3 +85,31 @@ def collect_wires(network_nodes):
             )
 
         return all_wires
+
+    def zero_scenario_settings(self):
+        prepare_settings = []
+        for node in self.prepare_nodes:
+            settings_dims = (node.num_in, node.num_settings)
+            prepare_settings.append(np.zeros(settings_dims))
+
+        measure_settings = []
+        for node in self.measure_nodes:
+            settings_dims = (node.num_in, node.num_settings)
+            measure_settings.append(np.zeros(settings_dims))
+
+        return [prepare_settings, measure_settings]
+
+    def rand_scenario_settings(self):
+        prepare_settings = []
+        for node in self.prepare_nodes:
+            settings_dims = (node.num_in, node.num_settings)
+            node_settings = 2 * np.pi * np.random.random(settings_dims) - np.pi
+            prepare_settings.append(node_settings)
+
+        measure_settings = []
+        for node in self.measure_nodes:
+            settings_dims = (node.num_in, node.num_settings)
+            node_settings = 2 * np.pi * np.random.random(settings_dims) - np.pi
+            measure_settings.append(node_settings)
+
+        return [prepare_settings, measure_settings]

test/chsh_gradient_descent_test.py

@@ -0,0 +1,57 @@
+import pytest
+import pennylane as qml
+from pennylane import numpy as np
+
+from context import QNetOptimizer as QNopt
+
+
+class TestCHSHGradientDescent:
+    def bell_state_RY(self, settings, wires=[0, 1]):
+        print("bell_state_RY settings : ", settings)
+        qml.Hadamard(wires=wires[0])
+        qml.CNOT(wires=wires)
+
+        qml.RY(settings[0], wires=wires[0])
+        qml.RY(settings[1], wires=wires[1])
+
+    def local_RY(self, settings, wires=[0]):
+        print("local_RY settings : ", settings)
+
+        qml.RY(settings[0], wires=wires[0])
+
+    def test_chsh_gradient_descent(self):
+        prepare_nodes = [
+            QNopt.PrepareNode(1, [0, 1], self.bell_state_RY, 2),
+        ]
+        measure_nodes = [
+            QNopt.MeasureNode(2, 2, [0], self.local_RY, 1),
+            QNopt.MeasureNode(2, 2, [1], self.local_RY, 1),
+        ]
+
+        chsh_ansatz = QNopt.NetworkAnsatz(prepare_nodes, measure_nodes)
+
+        @qml.qnode(chsh_ansatz.dev)
+        def chsh_circuit(prepare_settings, measure_settings):
+            chsh_ansatz.fn(prepare_settings, measure_settings)
+
+            return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+        def chsh_cost(scenario_settings):
+            score = 0
+            for x in [0, 1]:
+                for y in [0, 1]:
+                    prep_settings = scenario_settings[0][0]
+                    A_meas_settings = scenario_settings[1][0][x]
+                    B_meas_settings = scenario_settings[1][1][y]
+
+                    run = chsh_circuit(prep_settings, [A_meas_settings, B_meas_settings])
+                    scalar = (-1) ** (x * y)
+
+                    score += scalar * run
+            return -(score)
+
+        np.random.seed(666)
+        init_settings = chsh_ansatz.rand_scenario_settings()
+        opt_dict = QNopt.gradient_descent(chsh_cost, init_settings, verbose=False)
+
+        assert np.isclose(opt_dict["opt_score"], 2 * np.sqrt(2), atol=1e-5)

test/network_ansatz_test.py

@@ -139,3 +139,55 @@ def ansatz_circuit(settings, wires):
             match="One or more wires are not unique. Each node must contain unique wires.",
         ):
             QNopt.NetworkAnsatz.collect_wires([node2, node3])
+
+    def test_scenario_settings(self):
+        def ansatz_circuit(settings, wires):
+            return None
+
+        prep_nodes = [
+            QNopt.PrepareNode(3, [0], ansatz_circuit, 2),
+            QNopt.PrepareNode(2, [1], ansatz_circuit, 4),
+        ]
+        meas_nodes = [
+            QNopt.MeasureNode(2, 2, [0], ansatz_circuit, 1),
+            QNopt.MeasureNode(1, 2, [1], ansatz_circuit, 3),
+        ]
+
+        network_ansatz = QNopt.NetworkAnsatz(prep_nodes, meas_nodes)
+
+        zero_settings = network_ansatz.zero_scenario_settings()
+
+        match_settings = [
+            [[[0, 0], [0, 0], [0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]]],
+            [[[0], [0]], [[0, 0, 0]]],
+        ]
+
+        assert len(zero_settings[0]) == 2
+        assert np.array_equal(zero_settings[0][0], match_settings[0][0])
+        assert np.array_equal(zero_settings[0][1], match_settings[0][1])
+
+        assert len(zero_settings[1]) == 2
+        assert np.array_equal(zero_settings[1][0], match_settings[1][0])
+        assert np.array_equal(zero_settings[1][1], match_settings[1][1])
+
+        np.random.seed(123)
+        rand_settings = network_ansatz.rand_scenario_settings()
+
+        match_settings = [
+            [
+                [[1.2344523, -1.34372619], [-1.71624293, 0.3224202], [1.37896421, -0.48313636]],
+                [
+                    [3.02073055, 1.1613195, -0.1198084, -0.67784562],
+                    [-0.98534158, 1.43916176, -0.38596197, -2.76662537],
+                ],
+            ],
+            [[[-0.64060684], [1.49536924]], [[-1.99496329, -2.03919676, 0.19824313]]],
+        ]
+
+        assert len(rand_settings[0]) == 2
+        assert np.allclose(rand_settings[0][0], match_settings[0][0])
+        assert np.allclose(rand_settings[0][1], match_settings[0][1])
+
+        assert len(rand_settings[1]) == 2
+        assert np.allclose(rand_settings[1][0], match_settings[1][0])
+        assert np.allclose(rand_settings[1][1], match_settings[1][1])