Implementation of pennylane optimizers

openqaoa/optimizers/optimization_methods_pennylane.py

@@ -0,0 +1,141 @@
+
+
+from importlib.metadata import requires
+from operator import ne
+import pennylane as pl
+import inspect
+from scipy.optimize import OptimizeResult
+import numpy as np
+
+import matplotlib.pyplot as plt
+
+def pennylane_optimizer(fun, x0, args=(), maxfev=None, method='vgd', qfim=None,
+                        maxiter=100, tol=10**(-6), jac=None, callback=None,                         
+                        nums_frequency=None, spectra=None, shifts=None, **options):
+
+    '''    
+    Minimize a function `fun` using some pennylane method.
+    To check available methods look at the available_methods_dict variable.
+    Read https://docs.pennylane.ai/en/stable/introduction/interfaces.html#optimizers
+
+    PARAMETERS
+    ----------
+    fun : callable
+        Function to minimize
+    x0 : ndarray
+        Initial guess.
+    args : sequence, optional
+        Arguments to pass to `func`.
+    maxfev : int, optional
+        Maximum number of function evaluations.
+    method : string, optional
+        Optimizer method to compute the steps.
+    qfim : callable, optional (required for natural_grad_descent)
+        Callable Fubini-Study metric tensor
+    maxiter : int, optional
+        Maximum number of iterations.
+    tol : float
+        Tolerance before the optimizer terminates; if `tol` is larger than the difference between two steps, terminate optimization.
+    jac : callable, optinal (required for all methods but rotosolve and spsa)
+        Callable gradient function.
+    callback : callable, optional
+        Called after each iteration, as ``callback(xk)``, where ``xk`` is the
+        current parameter vector.
+    options : dict, optional
+        Dictionary where keys are the arguments for the optimizers object, and
+        the values are the values to pass to these arguments.
+        To know all the possible argumets read
+        https://docs.pennylane.ai/en/stable/introduction/interfaces.html#optimizers.
+
+
+    (read https://docs.pennylane.ai/en/stable/code/api/pennylane.RotosolveOptimizer.html#pennylane.RotosolveOptimizer.step)
+    nums_frequency : dict[dict], required for rotosolve
+        The number of frequencies in the fun per parameter.
+    spectra : dict[dict], required for rotosolve
+        Frequency spectra in the objective_fn per parameter.
+    shifts : dict[dict], required for rotosolve
+        Shift angles for the reconstruction per parameter.
+
+
+    RETURNS
+    -------
+    OptimizeResult : OptimizeResult
+        Scipy OptimizeResult object.
+    '''
+
+    def cost(params, **k): # define a function to convert the params list from pennylane to numpy
+        return fun(np.array(params), *k)
+
+    available_methods_dict = {  # optimizers implemented
+                                'adagrad': pl.AdagradOptimizer, 
+                                'adam': pl.AdamOptimizer, 
+                                'vgd': pl.GradientDescentOptimizer, 
+                                'momentum':  pl.MomentumOptimizer,
+                                'nesterov_momentum': pl.NesterovMomentumOptimizer,
+                                'natural_grad_descent': pl.QNGOptimizer,
+                                'rmsprop': pl.RMSPropOptimizer,
+                                'rotosolve': pl.RotosolveOptimizer, 
+                                'spsa': pl.SPSAOptimizer,
+                             }
+
+    optimizer = available_methods_dict[method] # define the optimizer
+
+    #get optimizer arguments
+    arguments = inspect.signature(optimizer).parameters.keys()
+    options_keys = list(options.keys())
+
+    #check which values of the options dict can be passed to the optimizer (pop the others)
+    for key in options_keys:
+        if key not in arguments: options.pop(key) 
+        if 'maxiter' in arguments: options['maxiter'] = maxiter
+
+    optimizer = optimizer(**options) #pass the arguments
+
+    bestx = pl.numpy.array(x0, requires_grad=True)
+    besty = cost(x0, *args)
+    funcalls = 1  # tracks no. of function evals.
+    niter = 0
+    improved = True
+    stop = False  
+
+    testx = np.copy(bestx)
+    testy = np.real(besty)
+    while improved and not stop and niter < maxiter:
+        improved = False
+        niter += 1
+
+        # compute step
+        if qfim:    #natural_grad_descent
+            testx, testy = optimizer.step_and_cost(cost, bestx, *args, grad_fn=jac, metric_tensor_fn=qfim) 
+        elif jac:   #adagrad, adam, vgd, momentum, nesterov_momentum, rmsprop
+            testx, testy = optimizer.step_and_cost(cost, bestx, *args, grad_fn=jac)
+        elif method=='rotosolve': 
+            testx, testy = optimizer.step_and_cost(
+                                                    cost, bestx, *args,
+                                                    nums_frequency={'params': {(i,):1 for i in range(bestx.size)}} if not nums_frequency else nums_frequency,
+                                                    spectra=spectra,
+                                                    shifts=shifts,
+                                                    full_output=False,
+                                                  )
+        else:       #spsa  
+            testx, testy = optimizer.step_and_cost(cost, bestx, *args)
+
+        # check if stable
+        if np.abs(besty-testy) < tol and niter > 2:
+            improved = False
+
+        else:
+            besty = testy
+            bestx = testx
+            improved = True
+
+        if callback is not None:
+            callback(bestx)
+        if maxfev is not None and funcalls >= maxfev:
+            stop = True
+            break
+
+    return OptimizeResult(fun=besty, x=np.array(bestx), nit=niter,
+                          nfev=funcalls, success=(niter > 1))
+
+

openqaoa/optimizers/training_vqa.py

@@ -26,6 +26,7 @@
 from ..basebackend import VQABaseBackend
 from ..qaoa_parameters.baseparams import QAOAVariationalBaseParams
 from . import optimization_methods as om
+from . import optimization_methods_pennylane as ompl
 
 from .logger_vqa import Logger
 from .result import Result
@@ -469,10 +470,16 @@ class CustomScipyGradientOptimizer(OptimizeVQA):
         * optimizer_options
 
             * Dictionary of optimiser-specific arguments, defaults to ``None``
+            * Used also for the pennylande optimizers (and step function) arguments
 
     """
     CUSTOM_GRADIENT_OPTIMIZERS = ['vgd', 'newton',
-                                  'rmsprop', 'natural_grad_descent', 'spsa']
+                                  'rmsprop', 'natural_grad_descent', 'spsa', 
+                                  'pennylane',
+                                  'pennylane adagrad', 'pennylane adam', 'pennylane vgd', 
+                                  'pennylane momentum', 'pennylane nesterov_momentum',
+                                  'pennylane natural_grad_descent', 'pennylane rmsprop', 
+                                  'pennylane rotosolve', 'pennylane spsa']
 
     def __init__(self,
                  vqa_object: Type[VQABaseBackend],
@@ -562,6 +569,7 @@ def optimize(self):
         : 
             The optimized return object from the ``scipy.optimize`` package the result is assigned to the attribute ``opt_result``
         '''
+
         if self.method == 'vgd':
             method = om.grad_descent
         elif self.method == 'newton':
@@ -575,6 +583,16 @@ def optimize(self):
         elif self.method == 'spsa':
             print("Warning : SPSA is an experimental feature.")
             method = om.SPSA
+        elif self.method.lower().split()[0] == 'pennylane': # check if we are using a pennylane optimizer
+            method = ompl.pennylane_optimizer
+
+            if len(self.method.split()) > 1: # check if we are not using the default (vgd)
+                self.options['method'] = self.method.lower().split()[1] 
+
+                if self.options['method'] == 'natural_grad_descent': 
+                    self.options['qfim'] = qfim(self.vqa_object, self.variational_params, self.log)
+                elif self.options['method'] in ['spsa', 'rotosolve']:    
+                    self.jac = None 
 
         try:
             if self.hess == None:

setup.py

@@ -17,7 +17,8 @@
     "matplotlib>=3.4.3, <3.5.0",
     "qiskit>=0.36.1",
     "pyquil>=3.1.0",
-    "docplex>=2.23.1"
+    "docplex>=2.23.1",
+    "pennylane>=0.26.0"
 ]
 
 requirements_docs = [

tests/test_optimizers_pennylane.py

@@ -0,0 +1,50 @@
+import warnings
+import unittest
+
+import networkx as nx
+from openqaoa.workflows.optimizer import QAOA
+from openqaoa.devices import create_device
+from openqaoa.problems.problem import MaximumCut
+from openqaoa.optimizers.training_vqa import CustomScipyGradientOptimizer
+
+
+#create a problem
+nodes = 4
+edge_probability = 0.6
+g = nx.generators.fast_gnp_random_graph(n=nodes,p=edge_probability)
+maxcut_prob = MaximumCut(g)
+maxcut_qubo = maxcut_prob.get_qubo_problem()
+
+
+class TestPennylaneOptimizers(unittest.TestCase):
+
+    def _run_method(self, method):
+        " function tu run the test for any method "
+        q = QAOA()
+        device = create_device(location='local', name='qiskit.statevector_simulator')
+        q.set_device(device)
+
+
+        q.set_circuit_properties(p=2, param_type='standard', init_type='rand', mixer_hamiltonian='x')
+        q.set_backend_properties(prepend_state=None, append_state=None)
+        q.set_classical_optimizer(method=method, maxiter=4, optimizer_options = {'blocking':False, 'resamplings': 0},
+                                optimization_progress=True, cost_progress=True, parameter_log=True, jac='finite_difference')
+
+        q.compile(maxcut_qubo) 
+        q.optimize()
+
+    def test_pennylane_optimizers(self):
+        " function to run the tests for pennylane optimizers "
+        list_optimizers = CustomScipyGradientOptimizer.CUSTOM_GRADIENT_OPTIMIZERS
+
+        for opt in list_optimizers:
+            if opt.split()[0] == "pennylane":
+                self._run_method(opt)
+
+
+
+
+if __name__ == "__main__":
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', category=PendingDeprecationWarning)
+        unittest.main()