Rotosolve can be used in case of QNNs?

Hi, I’m one of PennyLane lovers!

I studied a nice algorithm of Rotosolve in a PennyLane demo.
I think that it is very powerful optimization scheme for VQE, QAOA etc.

Quantum circuit structure learning — PennyLane

Is it possible to apply the Rotosolve to QNN?
How?

Unlike VQE and QAOA, in QNN, the cost function depends on the input classical data.
We have to minimize |H - Y| instead of H.

Hey @Kuma-quant,

That is an excellent question, since the use of this optimiser is a bit more specific than the usual classical ones.

As you may have seen, according to the docstring the objective function can be any function as long as we know that it is a Fourier series in the trainable arguments up to degrees indicated in the `num_freqs` kwarg. This is exactly the property of quantum expectations that rotosolve uses.

Of course, if you have data-dependent QML cost functions, it is very hard to specify the “frequency” structure of the cost, so I’d say that you cannot use Rotosolve easily for such tasks.

But let me also ask a colleague for the details, maybe we can use methods from general parameter shift rules…will get back to you!

Hey @Kuma-quant ,

A great question indeed! We have not explored an exact classification of objective functions beyond expectation values that are accessible for Rotosolve yet.
Maria is right with her answer, and as long as you know the correct frequencies of your objective function, you should be good to go!
However, as so often, there are details!

For classical post-processing of circuit outputs there are multiple ways of reconstructing: Reconstruct the circuits and combine them classically via the post-processing that already is classsical, or reconstruct the full objective function right away. It is not obvious which approach is better!

Let me give an example:
Consider the QNode and objective function

``````dev = qml.device("default.qubit", wires=1)

@qml.qnode(dev)
def circuit(weight, inp):
qml.RX(weight*inp, wires=0)
return qml.expval(qml.Projector([0], wires=dev.wires))

def objective_fun(weight, inputs=None, targets=None):
cost = 0.
for inp, targ in inputs, targets:
cost += (circuit(weight, inp) - targ) ** 2
return cost
``````

Then we see that `circuit` will produce a finite Fourier series with a single (non-zero) frequency, namely `freqs=[weight]`. (Call the number of frequencies R, so that we get R=1 here).
This means that we can reconstruct this Fourier series with 2R+1=3 evaluations of `circuit` per input `inp` , leading to (2R+1)n = 3n evaluations for n inputs.
Once we have reconstructed these Fourier series, we can combine them into the classical objective function by plugging the reconstructions into `objective_fun`.
This does not require additional quantum computer calls.

If we would want to call Rotosolve on the `objective_fun` directly, we would need to reconstruct a Fourier series with frequencies `freqs=[weight, 2*weight]`, i.e. a series with R'=2. This costs 2R'+1=5 evaluations and thus is much cheaper - it does not even depend on . Yay!
But careful: If we instead would have multiple frequencies in the `circuit`, i.e. R>1, and they would not be equidistant (i.e. the second frequency is not just the doubled first frequency and so on), we would get (2R+1)n evaluations in the first approach and up to 2R^2+1 evaluations for the second approach (Let me know if you want details on this - admittedly rough - estimate; The general parameter shift rules demo could be a good place to start reading if I may shamelessly advertise it as its author). So now we need to know R an n and compare the number of evaluations to decide which approach we want to go for.

If you want to modify the cost function to use `** 4` instead of `** 2`, the estimate for the second approach is completely different, so the classical processing really matters as well.

I hope this helps to stress that there is no generic answer to “Should I use Rotosolve on the objective function or on the circuits?”.
Implementation-wise, you might be happy to hear that a reconstruction functionality is on its way into PennyLane. It might be helpful in implementing your ideas