Fix QAOA example

docs/examples/02_qaoa.ipynb

@@ -174,12 +174,12 @@
     }
    ],
    "source": [
-    "USE_RUNTIME_SERVICE = False\n",
-    "\n",
-    "service = None\n",
-    "backend = \"ibmq_qasm_simulator\"\n",
-    "if USE_RUNTIME_SERVICE:\n",
-    "    service = QiskitRuntimeService(verify=False)\n",
+    "backend = None\n",
+    "service = QiskitRuntimeService(\n",
+    "    channel='ibm_quantum',\n",
+    "    instance='ibm-q/open/main',\n",
+    "    token='<insert your token>'\n",
+    ")\n",
     "\n",
     "input_arguments = {\n",
     "    \"initial_point\": None,\n",
@@ -333,7 +333,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.10.14"
   }
  },
  "nbformat": 4,

docs/examples/source_files/qaoa/qaoa.py

@@ -1,38 +1,42 @@
-import logging
-from typing import Optional
-
+# General imports
 import numpy as np
-from scipy.optimize import minimize
 
+# Pre-defined ansatz circuit, operator class and visualization tools
 from qiskit import QuantumCircuit
-from qiskit.primitives import BaseEstimator, Estimator as QiskitEstimator
+from qiskit.circuit.library import QAOAAnsatz
 from qiskit.quantum_info import SparsePauliOp
 
-from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, Session, Options
+from qiskit.primitives import BaseEstimator
+from qiskit_ibm_runtime import QiskitRuntimeService, Session
+from qiskit_ibm_runtime import EstimatorV2 as Estimator
+from qiskit_ibm_runtime import SamplerV2 as Sampler
+
+# SciPy minimizer routine
+from scipy.optimize import minimize
+from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 
 from qiskit_serverless import (
-    distribute_task,
     get_arguments,
     get,
     save_result,
 )
 
-
 def cost_func(params, ansatz, hamiltonian, estimator):
     """Return estimate of energy from estimator
 
     Parameters:
         params (ndarray): Array of ansatz parameters
         ansatz (QuantumCircuit): Parameterized ansatz circuit
         hamiltonian (SparsePauliOp): Operator representation of Hamiltonian
-        estimator (Estimator): Estimator primitive instance
+        estimator (EstimatorV2): Estimator primitive instance
 
     Returns:
         float: Energy estimate
     """
-    cost = (
-        estimator.run(ansatz, hamiltonian, parameter_values=params).result().values[0]
-    )
+    pub = (ansatz, [hamiltonian], [params])
+    result = estimator.run(pubs=[pub]).result()
+    cost = result[0].data.evs[0]
+
     return cost
 
 
@@ -49,31 +53,47 @@ def run_qaoa(
 
 
 if __name__ == "__main__":
+
     arguments = get_arguments()
 
     service = arguments.get("service")
-
-    operator = arguments.get("operator")
+    hamiltonian = arguments.get("operator")
     ansatz = arguments.get("ansatz")
     initial_point = arguments.get("initial_point")
     method = arguments.get("method", "COBYLA")
+    backend = arguments.get("backend")
+
+    if not backend:
+        backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
+    session = Session(backend=backend)
+    target = backend.target
+
+    pm = generate_preset_pass_manager(target=target, optimization_level=3)
+    ansatz_isa = pm.run(ansatz)
+    operator = hamiltonian.apply_layout(ansatz_isa.layout)
+
+    # Configure estimator
+    estimator = Estimator(session=session)
+    estimator.options.default_shots = 10_000
+    estimator.options.dynamical_decoupling.enable = True
+
+    # Configure sampler
+    sampler = Sampler(session=session)
+    sampler.options.default_shots = 10_000
+    sampler.options.dynamical_decoupling.enable = True
 
-    if initial_point is None:
-        initial_point = 2 * np.pi * np.random.rand(ansatz.num_parameters)
+    initial_point = 2 * np.pi * np.random.rand(ansatz_isa.num_parameters)
 
-    if service is not None:
-        # if we have service we need to open a session and create sampler
-        service = arguments.get("service")
-        backend = arguments.get("backend", "ibmq_qasm_simulator")
-        session = Session(service=service, backend=backend)
-        options = Options()
-        options.optimization_level = 3
+    res = run_qaoa(ansatz_isa, estimator, operator, initial_point, method)
 
-        estimator = Estimator(session=session, options=options)
-    else:
-        # if we do not have a service let's use standart local sampler
-        estimator = QiskitEstimator()
+    # Assign solution parameters to ansatz
+    qc = ansatz.assign_parameters(res.x)
+    # Add measurements to our circuit
+    qc.measure_all()
+    qc_isa = pm.run(qc)
 
-    result = run_qaoa(ansatz, estimator, operator, initial_point, method)
+    result = sampler.run([qc_isa]).result()
+    samp_dist = result[0].data.meas.get_counts()
+    session.close()
 
-    save_result({"optimal_point": result.x.tolist(), "optimal_value": result.fun})
+    save_result({"optimal_point": res.x.tolist(), "optimal_value": res.fun, "probabilitie":samp_dist})