Small fix (#25)

* removed constrained import, print
* sequential mode for landscape sampling. good for running large jobs, to avoid memory overload

Author: fgfuchs

examples/plotroutines.py

@@ -5,10 +5,10 @@
 import numpy as np
 
 from qaoa import QAOA
-from qaoa.mixers.constrained_mixer import Constrained
 
 from qaoa.util import Statistic
 
+
 def __plot_landscape(A, extent, fig):
     if not fig:
         fig = pl.figure(figsize=(6, 6), dpi=80, facecolor="w", edgecolor="k")
@@ -75,9 +75,7 @@ def plot_ApproximationRatio(
     ax.xaxis.set_major_locator(MaxNLocator(integer=True))
 
 
-def plot_successprob(
-    qaoa_instance, maxdepth, label, style="", fig=None, shots=10**4
-):
+def plot_successprob(qaoa_instance, maxdepth, label, style="", fig=None, shots=10**4):
     successp = []
     for p in range(1, qaoa_instance.current_depth + 1):
         ar, sp = __apprrat_successprob(qaoa_instance, p, shots=shots)
@@ -125,7 +123,7 @@ def __apprrat_successprob(qaoa_instance, depth, shots=10**4):
 
 
 def plot_angles(qaoa_instance, depth, label, style="", fig=None):
-    angles=qaoa_instance.optimization_results[depth].get_best_angles()
+    angles = qaoa_instance.optimization_results[depth].get_best_angles()
 
     if not fig:
         ax = pl.figure().gca()
@@ -135,13 +133,13 @@ def plot_angles(qaoa_instance, depth, label, style="", fig=None):
     pl.plot(
         np.arange(1, depth + 1),
         angles[::2],
-        "--"+style,
+        "--" + style,
         label=r"$\gamma$ " + label,
     )
     pl.plot(
         np.arange(1, depth + 1),
         angles[1::2],
-        "-"+style,
+        "-" + style,
         label=r"$\beta$ " + label,
     )
     pl.xlim(1 - 0.25, depth + 0.25)

qaoa/qaoa.py

@@ -100,6 +100,7 @@ def __init__(
         flip=False,
         post=False,
         number_trottersteps_mixer=1,
+        sequential=False,
     ) -> None:
         """
         A QAO-Ansatz consist of these parts:
@@ -146,6 +147,8 @@ def __init__(
         self.memory = self.memorysize > 0
         self.interpolate = interpolate
 
+        self.sequential = sequential
+
         self.usebarrier = False
         self.isQNSPSA = False
 
@@ -276,8 +279,7 @@ def createParameterizedCircuit(self, depth):
         self.parametrized_circuit_depth = depth
 
     def sample_cost_landscape(
-        self,
-        angles={"gamma": [0, 2 * np.pi, 20], "beta": [0, 2 * np.pi, 20]},
+        self, angles={"gamma": [0, 2 * np.pi, 20], "beta": [0, 2 * np.pi, 20]}
     ):
         self.landscape_p1_angles = angles
         logger = LOG.bind(func=self.sample_cost_landscape.__name__)
@@ -291,32 +293,88 @@ def sample_cost_landscape(
         self.beta_grid = np.linspace(tmp[0], tmp[1], tmp[2])
 
         if self.backend.configuration().local:
-            print(depth, self.current_depth)
-            self.createParameterizedCircuit(depth)
-            gamma = [None] * angles["beta"][2] * angles["gamma"][2]
-            beta = [None] * angles["beta"][2] * angles["gamma"][2]
-
-            counter = 0
-            for b in range(angles["beta"][2]):
-                for g in range(angles["gamma"][2]):
-                    gamma[counter] = self.gamma_grid[g]
-                    beta[counter] = self.beta_grid[b]
-                    counter += 1
-
-            parameters = {self.gamma_params[0]: gamma, self.beta_params[0]: beta}
-
-            logger.info("Executing sample_cost_landscape")
-            logger.info(f"parameters: {len(parameters)}")
-            job = self.backend.run(
-                self.parameterized_circuit,
-                shots=self.shots,
-                parameter_binds=[parameters],
-                optimization_level=0,
-                memory=self.memory,
-            )
-            logger.info("Done execute")
-            self.measurementStatistics(job)
-            logger.info("Done measurement")
+            if self.sequential:
+                expectations = []
+                variances = []
+                maxcosts = []
+                mincosts = []
+
+                self.createParameterizedCircuit(depth)
+                logger.info("Executing sample_cost_landscape")
+                for b in range(angles["beta"][2]):
+                    for g in range(angles["gamma"][2]):
+                        gamma = self.gamma_grid[g]
+                        beta = self.beta_grid[b]
+                        params = self.getParametersToBind(
+                            [gamma, beta], self.parametrized_circuit_depth, asList=True
+                        )
+
+                        job = self.backend.run(
+                            self.parameterized_circuit,
+                            noise_model=self.noisemodel,
+                            shots=self.shots,
+                            parameter_binds=[params],
+                            optimization_level=0,
+                            memory=self.memory,
+                        )
+
+                        jres = job.result()
+                        counts_list = jres.get_counts()
+
+                        self.stat.reset()
+                        for string in counts_list:
+                            # qiskit binary strings use little endian encoding, but our cost function expects big endian encoding. Therefore, we reverse the order
+                            cost = self.problem.cost(string[::-1])
+                            self.stat.add_sample(
+                                cost, counts_list[string], string[::-1]
+                            )
+
+                        expectations.append(self.stat.get_CVaR())
+                        variances.append(self.stat.get_Variance())
+                        maxcosts.append(self.stat.get_max())
+                        mincosts.append(self.stat.get_min())
+
+                angles = self.landscape_p1_angles
+                self.Exp_sampled_p1 = -np.array(expectations).reshape(
+                    angles["beta"][2], angles["gamma"][2]
+                )
+                self.Var_sampled_p1 = np.array(variances).reshape(
+                    angles["beta"][2], angles["gamma"][2]
+                )
+                self.MaxCost_sampled_p1 = -np.array(maxcosts).reshape(
+                    angles["beta"][2], angles["gamma"][2]
+                )
+                self.MinCost_sampled_p1 = -np.array(mincosts).reshape(
+                    angles["beta"][2], angles["gamma"][2]
+                )
+                logger.info("Done measurement")
+            else:
+                self.createParameterizedCircuit(depth)
+                gamma = [None] * angles["beta"][2] * angles["gamma"][2]
+                beta = [None] * angles["beta"][2] * angles["gamma"][2]
+
+                counter = 0
+                for b in range(angles["beta"][2]):
+                    for g in range(angles["gamma"][2]):
+                        gamma[counter] = self.gamma_grid[g]
+                        beta[counter] = self.beta_grid[b]
+                        counter += 1
+
+                parameters = {self.gamma_params[0]: gamma, self.beta_params[0]: beta}
+
+                logger.info("Executing sample_cost_landscape")
+                logger.info(f"parameters: {len(parameters)}")
+                job = self.backend.run(
+                    self.parameterized_circuit,
+                    noise_model=self.noisemodel,
+                    shots=self.shots,
+                    parameter_binds=[parameters],
+                    optimization_level=0,
+                    memory=self.memory,
+                )
+                logger.info("Done execute")
+                self.measurementStatistics(job)
+                logger.info("Done measurement")
 
         else:
             raise NotImplementedError