hybrid computing with batch

[WeiyinchiangFu]

Hi,

I am trying to perform the calculation of something similar in pennylane on qudaquantum.
First, I tried to reproduce the result in hybrid_qnns.ipynb while monitoring the memory usage.
Then, I increase the batch size, the quantum_circuit.run now needs to deal with the batched input. However, in QuantumCircuit.run, cudaq.observe will return a list of results. expectation_z()s are obtained by accessing the results iteratively.

for i,obs in enumerate(cudaq.observe(self.kernel, spin.z(0), thetas)):
            obss[i] = obs.expectation_z()

This is time-consuming when batch size is increased. Any way to avoid this?

Thanks.

[zohimchandani]

Hi @WeiyinchiangFu,

For batched inputs, a typical workflow is this:

import cudaq 
from cudaq import spin 
import numpy as np 

qubit_count = 1 
hamiltonian = spin.z(0)
num_of_samples = 4 
num_of_params = 2
theta_vals = np.random.rand(num_of_samples, num_of_params)

kernel, thetas = cudaq.make_kernel(list)

qubits = kernel.qalloc(qubit_count)

kernel.ry(thetas[0], qubits[0])
kernel.rx(thetas[1], qubits[0])

results = cudaq.observe(kernel, hamiltonian, theta_vals)

for i in range(len(results)): 
    print(results[i].expectation())

Here we are batching over the num_of_samples. The final for loop is required and can't be avoided.

The observe call is where the execution of the quantum circuit happens. To speed this up, you could use cudaq.observe_async which allows you to parallelize along the leading dimension of theta_vals but requires the mqpu target and hence multiple GPUs. See the last section in this example here. This will kick off multiple observe calls simultaneously and move on to other parts of the code whilst the execution takes place.

If you have a single GPU resource, you would have to parallelize the execution via observe manually.

Let us know if that helps, thanks.

[WeiyinchiangFu]

Hi,
Thanks for your suggestion.

If we considier to perform the measurement on multiple qubits,

cudaq.observe(self.kernel, [spin.z(0),spin.z(1),spin.z(2)], thetas)

Here thetas consists of batched learnable angle(i.e. batch_size=2) and measure on qubit[0], qubit[1] and qubit[2] at the same time.
This will return ObserveResults with the length of batch_size instead of batch_size x # of measured qubits . The measurement outcomes become the aggregation of three qubits.

However, I can write this in an alternative way to obtain the results I want, something like

for i in range(len(thetas)):
    results_one_batch = cudaq.observe(self.kernel, [spin.z(0),spin.z(1),spin.z(2)], thetas[i,:])
    m_qubit_0, m_qubit_1, m_qubit_2 = obs[0].expectation(), obs[1].expectation(), obs[2].expectation()

But, is this what we expect to deal with the batch measurement on multiple qubits?

[zohimchandani]

See below code snippet for how to handle multiple measurements on batched inputs:

qubit_count = 2 
hamiltonian = [spin.z(0), spin.z(1)]
num_of_samples = 3 
num_of_params = 2
theta_vals = np.random.rand(num_of_samples, num_of_params)

kernel, thetas = cudaq.make_kernel(list)

qubits = kernel.qalloc(qubit_count)

kernel.ry(thetas[0], qubits[0])
kernel.rx(thetas[1], qubits[1])

results = cudaq.observe(kernel, hamiltonian, theta_vals)

for s in range(num_of_samples): 
    
    for h in range(len(hamiltonian)): 
        
        print(results[s][h].expectation())

This code snippet calls observe once to calculate the results and then postprocesses to retrieve them. Here results is a nested list with length = number of samples and the inner list contains measurement results on different qubits.

In your second code snippet, you call observe inside a for loop. I would think that is not efficient as observe is compute intensive.

Hope that helps.

Thanks.

[WeiyinchiangFu]

Thanks. The issue is sorted after upgrading to version 0.6.0.

[WeiyinchiangFu]

Hi,

I performed some tests in further.

results = cudaq.observe(kernel, [spin.z(0),spin.z(1)], tt)
print([[results[i][j].expectation() for j in range(2)] for i in range(3)])

results = cudaq.observe(kernel, [spin.z(0),spin.z(1),spin.z(2)], tt)
print([[results[i][j].expectation() for j in range(3)] for i in range(3)])

results = cudaq.observe(kernel, [spin.z(0),spin.z(1),spin.z(2),spin.z(3)], tt)
print([[results[i][j].expectation() for j in range(4)] for i in range(3)])

and got results like this

[[0.6855994438337802, 0.7041660568320367], [0.8472767965308776, 0.8325644453893801], [0.6702531445901059, 0.8185794131406965]]
[[0.6855994438337802, 0.0, 0.8528160375535663], [0.8472767965308776, 0.0, 0.8298034314670986], [0.6702531445901059, 0.0, 0.8355104996865066]]
[[0.6855994438337802, 0.0, 0.0, 0.8621619506848219], [0.8472767965308776, 0.0, 0.0, 0.8354331482864836], [0.6702531445901059, 0.0, 0.0, 0.8548394196243407]]

However, when I rewrite the code in an inefficient way,

hamiltonian = [spin.z(0),spin.z(1),spin.z(2),spin.z(3)]
for i in range(3):
    results = []
    for jdx, j in enumerate(hamiltonian):
        tmp = cudaq.observe(kernel, j , tt[i]).expectation()
        results.append(tmp)
    print(results)

I got

[0.6855994438337802, 0.7041660568320367, 0.8528160375535663, 0.8621619506848219]
[0.8472767965308776, 0.8325644453893801, 0.8298034314670986, 0.8354331482864836]
[0.6702531445901059, 0.8185794131406965, 0.8355104996865066, 0.8548394196243407]

Did I do something wrong?

[zohimchandani]

Theoretically, if you use the same kernel, hamiltonian and variational parameters, you should get the same output for the state vector target. Can I ask what target you are using?

There may be slight differences due to numerical rounding errors.

[WeiyinchiangFu]

Here is the definition of the circuit.

layer = 2
n_qubits = 4
        
kernel, theta = cudaq.make_kernel(list)
qubits = kernel.qalloc(n_qubits)
r_ang = torch.arcsin(torch.rand(2)*2 -1)
w = theta 
        
for i in range(n_qubits):
    kernel.ry(r_ang[0],qubits[i])
    kernel.rz(r_ang[1],qubits[i])

for l in range(layer):
    for i in range(n_qubits):
        kernel.ry(parameter=w[i],target=qubits[i])
    for i in range(n_qubits-1):
        kernel.cx(control=qubits[i], target=qubits[i+1])
        kernel.rz(parameter=w[i+n_qubits], target=qubits[i+1])
        kernel.cx(control=qubits[i], target=qubits[i+1])

and

tt = torch.rand(3,7, device=device)

These are the tests I have done.

results = cudaq.observe(kernel, [spin.z(0),spin.z(1)], tt)
print([[results[i][j].expectation() for j in range(2)] for i in range(3)])

results = cudaq.observe(kernel, [spin.z(0),spin.z(1),spin.z(2)], tt)
print([[results[i][j].expectation() for j in range(3)] for i in range(3)])

results = cudaq.observe(kernel, [spin.z(0),spin.z(1),spin.z(2),spin.z(3)], tt)
print([[results[i][j].expectation() for j in range(4)] for i in range(3)])

and obtained

[[0.13211762811988592, 0.731730923987925], [-0.2547830753028393, -0.07659455109387636], [0.9243434910495125, 0.9458624367434822]]
[[0.13211762811988592, 0.0, 0.4107034904882312], [-0.2547830753028393, 0.0, 0.8014257559552789], [0.9243434910495125, 0.0, 0.6890320228594646]]
[[0.13211762811988592, 0.0, 0.0, -0.4300142051652074], [-0.2547830753028393, 0.0, 0.0, -0.11434407066553831], [0.9243434910495125, 0.0, 0.0, -0.2529510685162677]]

hamiltonian = [spin.z(0),spin.z(1),spin.z(2),spin.z(3)]
for i in range(3):
    results = []
    for jdx, j in enumerate(hamiltonian):
        tmp = cudaq.observe(kernel, j , tt[i]).expectation()
        results.append(tmp)
    print(results)

obtained

[0.13211762811988592, 0.731730923987925, 0.4107034904882312, -0.4300142051652074]
[-0.2547830753028393, -0.07659455109387636, 0.8014257559552789, -0.11434407066553831]
[0.9243434910495125, 0.9458624367434822, 0.6890320228594646, -0.2529510685162677]

hamiltonian = [spin.z(0),spin.z(1),spin.z(2),spin.z(3)]

results = []
for jdx, j in enumerate(hamiltonian):
    tmp = cudaq.observe(kernel, j , tt)
    results.append([tmp[i].expectation() for i in range(3)])

for i in range(3):
    print([results[j][i] for j in range(len(hamiltonian))])

obtained

[0.13211762811988592, 0.731730923987925, 0.4107034904882312, -0.4300142051652074]
[-0.2547830753028393, -0.07659455109387636, 0.8014257559552789, -0.11434407066553831]
[0.9243434910495125, 0.9458624367434822, 0.6890320228594646, -0.2529510685162677]

My question is how we simultaneously deal with the multi-qubit measurement and the batched input. When I fed the input data and performed the measurement on more than two qubits, weird things happened.

[zohimchandani]

Hi @WeiyinchiangFu, apologies for the delay in replying. I am taking a look at this for you and will get back to you soon.

Thanks

[zohimchandani]

Hi @WeiyinchiangFu, this has been fixed with this PR. Please pull the latest container once it's merged into main and test.

Apologies for the delay in getting back to you.