Support Hamiltonian observables on default.qubit #1551

mariaschuld · 2021-08-18T10:50:24Z

Context:

Circuits with expval(Hamiltonian) currently get split up into other circuits unless the device supports Hamiltonian observables and implements something smarter. This PR adds Hamiltonian support for default qubit. Note that nothing will change for the user, but circuits with expval(H) should run and differentiate a lot faster for default.qubit with diff_method=best (-> backpropagating through sparse simulation), and a little faster when using diff_method="parameter-shift" (-> using the new gradient rule)!

Note: Initially we added a new differentiable SparseMatrix class, but this turned out to be much harder than anticipated. So now we are using essentially the same recipe as the SparseHamiltonian class, but with a bit more care to not break differentiability: scipy.sparse is used for all sparse support, and the elements of the sparse matrix (which are floats) are multiplied to differentiable tensors, and hence do not disturb the differentiation pipeline.

Description of the Change:

Add a Hamiltonian gradient rule for parameter shift differentiation, and call that gradient rule if we differentiate wrt Hamiltonian coefficients
Add a sparse_matrix method to the Tensor class, which returns a sparse matrix representation of a Tensor.
Compute expectations of Hamiltonian observables in default.qubit using the sparse representation.
Add tests.

The VQE tests are quite distributed: test_vqe and test_hamiltonian already contain tests for differentiating Hamiltonian and other params, device/test_measurements now has a sanity check that Hamiltonian observables are supported, and test_qubit_device checks whether the Hamiltonian is split or not.

Benefits:

Avoiding tape splitting should be a lot faster on the forward pass. Previously with our own SparseMatrix implementation I got a 15x speedup, which now reduced to a 4x speedup for optimising VQE using a Hamiltonian with 15 terms. I believe that this slowdown stems from the fact that it is faster to do \sum_ij psi[i] H_sparse[ij] psi[j] than \sum_k c_k * \sum_ij psi[i] PauliWord_sparse[ij] psi[j], since we do not have to repeatedly index into the state. But we don't get around this without a differentiable representation of H_sparse!

Possible Drawbacks:

There may be some places to still optimise the pipeline, and in future we could revert to the plan of having a differentiable sparse class!

The only feature I can think of that is not supported is when Tensors are made up of operations acting on non-consecutive wires like Hermitian(..., wires=[0,2]) @ PauliX(1). This case is implicitly nowhere supported in PennyLane (i.e. the Tensor class is not foolproof against it, and the SparseHamiltonian class fails such constructions). It is non-trivial to compute a matrix from tensor products of constituent matrices, and suspect the only way to do it is to shuffle wires around and afterwards reshuffle the matrix.

…t_hamiltonian

github-actions · 2021-08-18T10:50:44Z

Hello. You may have forgotten to update the changelog!
Please edit .github/CHANGELOG.md with:

A one-to-two sentence description of the change. You may include a small working example for new features.
A link back to this PR.
Your name (or GitHub username) in the contributors section.

mariaschuld · 2021-08-18T10:52:07Z

pennylane/devices/default_qubit.py

@@ -468,8 +470,6 @@ def expval(self, observable, shot_range=None, bin_size=None):
            if self.shots is not None:
                raise DeviceError("SparseHamiltonian must be used with shots=None")

-        if observable.name == "SparseHamiltonian" and self.shots is None:
-


Cosmetic change - this line was obsolete.

mariaschuld · 2021-08-18T10:52:51Z

pennylane/measure.py

@@ -232,7 +232,7 @@ def circuit(x):
    """
    if not isinstance(op, (Observable, qml.Hamiltonian)):
        raise qml.QuantumFunctionError(
-            "{} is not an observable or Hamiltonian: cannot be used with expval".format(op.name)
+            "{} is not an observable: cannot be used with expval".format(op.name)


Cosmetic: overlooked this when Hamiltonians became observables

mariaschuld · 2021-08-18T10:53:48Z

pennylane/qnode.py

        hamiltonian_in_obs = "Hamiltonian" in [obs.name for obs in self.qtape.observables]
-        if hamiltonian_in_obs and not supports_hamiltonian:
+        if hamiltonian_in_obs and (does_not_support_hamiltonian or finite_shots):


Until the device can preprocess tapes before entering the blackbox we always split if finite shots are asked for - else we have a situation that the device gets expval(H) and shots=1000, and it can only raise an error because splitting the tape would not be tracked by autodiff.

mariaschuld · 2021-08-18T10:54:20Z

pennylane/qnode.py

            try:
                tapes, fn = qml.transforms.hamiltonian_expand(self.qtape, group=False)
            except ValueError as e:
                raise ValueError(
-                    "Only a single expectation of a Hamiltonian observable can be returned"
+                    "Only a (single) expectation of a Hamiltonian observable can be returned "


Error message sounds strange if one has a single variance measurement.

pennylane/devices/default_qubit.py

…t_hamiltonian

codecov · 2021-08-25T15:23:02Z

Codecov Report

Merging #1551 (b0c6bb2) into master (5d8b0c3) will increase coverage by 0.00%.
The diff coverage is 100.00%.

@@           Coverage Diff           @@
##           master    #1551   +/-   ##
=======================================
  Coverage   99.17%   99.17%           
=======================================
  Files         192      193    +1     
  Lines       13844    13889   +45     
=======================================
+ Hits        13730    13775   +45     
  Misses        114      114

Impacted Files	Coverage Δ
pennylane/measure.py	`98.95% <ø> (ø)`
pennylane/qnode.py	`98.85% <ø> (ø)`
pennylane/_qubit_device.py	`98.69% <100.00%> (+<0.01%)`	⬆️
pennylane/devices/default_qubit.py	`100.00% <100.00%> (ø)`
pennylane/gradients/__init__.py	`100.00% <100.00%> (ø)`
pennylane/gradients/hamiltonian_grad.py	`100.00% <100.00%> (ø)`
pennylane/operation.py	`98.79% <100.00%> (+0.02%)`	⬆️
pennylane/tape/jacobian_tape.py	`98.19% <100.00%> (+0.03%)`	⬆️
pennylane/tape/reversible.py	`100.00% <100.00%> (ø)`
pennylane/tape/tape.py	`98.90% <100.00%> (ø)`
... and 1 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 5d8b0c3...b0c6bb2. Read the comment docs.

…e into support_hamiltonian

…t_hamiltonian

josh146

@mariaschuld I am happy to approve this subject to minor changes in the tests, to avoid them being skipped!

I think it is a amazing improvement, and the code changes to allow it to work are all very clean 💯

pennylane/devices/default_qubit.py

pennylane/devices/tests/test_measurements.py

josh146 · 2021-08-26T06:52:08Z

pennylane/tape/tape.py

@@ -163,7 +163,7 @@ def expand_tape(tape, depth=1, stop_at=None, expand_measurements=False):
    if tape._obs_sharing_wires:
        try:
            rotations, diag_obs = qml.grouping.diagonalize_qwc_pauli_words(tape._obs_sharing_wires)
-        except ValueError as e:
+        except (TypeError, ValueError) as e:


however I imagine this is something we should be able to support on default.qubit? Simply reuse the same state for the different inner products?

I think this is doable once the device is in charge of decomps.

tests/devices/test_default_qubit.py

tests/gradients/test_hamiltonian_gradient.py

josh146 · 2021-08-26T06:55:31Z

tests/ops/test_hamiltonian.py

@@ -20,6 +20,13 @@
 import pennylane as qml
 from pennylane import numpy as pnp


unfortunately I think the original design was intentional, to allow contributors to run the tests locally without requiring all of JAX/TF/Torch be installed!

tests/test_vqe.py

mariaschuld · 2021-08-26T09:12:12Z

tests/ops/test_hamiltonian.py

@@ -1207,12 +1207,12 @@ def circuit():
        assert pars == [0.1, 3.0]


-@pytest.mark.parametrize("simplify", [True, False])
-@pytest.mark.parametrize("group", [None, "qwc"])


I moved these fixtures to the individual tests, since now there are tests that don't rely on the fixtures in this class

mariaschuld · 2021-08-26T09:13:06Z

tests/ops/test_hamiltonian.py

@@ -1286,7 +1322,37 @@ def combine(coeffs, param):
        assert np.allclose(grad[0], grad_expected[0])
        assert np.allclose(grad[1], grad_expected[1])

-    def test_vqe_differentiation_jax(self, simplify, group):
+    def test_nontrainable_coeffs_autograd(self):


Previously we found an error for this test case, so I am adding them all here!

soranjh · 2021-08-26T14:00:47Z

pennylane/devices/default_qubit.py

+            # note: it is important that we use the Hamiltonian's data and not the coeffs attribute
+            for op, coeff in zip(observable.ops, observable.data):
+                # extract a scipy.sparse.coo_matrix representation of this Pauli word
+                coo = qml.operation.Tensor(op).sparse_matrix(wires=self.wires)


Maybe have a better name instead of coo?

soranjh · 2021-08-26T14:25:34Z

tests/devices/test_default_qubit.py

@@ -2357,3 +2353,96 @@ def _matrix(cls, *params):
            assert np.allclose(res_state, test_state)
            assert np.allclose(res_mat, op.matrix)
            assert np.allclose(res_wires, wires)
+
+
+class TestHamiltonianSupport:


Is there any test to check if the expectation value of a sample Hamiltonian, such as the one for H2, is computed correctly? (probably covered by other tests but wanted to double check)

soranjh · 2021-08-26T15:53:05Z

pennylane/devices/default_qubit.py

+                for idx_row, idx_col, entry in zip(coo.row, coo.col, coo.data):
+                    # while "entry" is not differentiable, it will be parsed during multiplication
+                    product = self._conj(self.state)[idx_row] * entry * self.state[idx_col]


I guess this loop replaces an operation like coo_matrix.dot to avoid breaking differentiability? Is there a way to make it more efficient, if it is not efficient already?

@mariaschuld here is a way of removing the loop that appears to pass all tests:

for op, coeff in zip(observable.ops, observable.data): # extract a scipy.sparse.coo_matrix representation of this Pauli word coo = qml.operation.Tensor(op).sparse_matrix(wires=self.wires) # todo: remove this hack that avoids errors when attempting to multiply # a nontrainable qml.tensor to a trainable Arraybox if isinstance(coeff, qml.numpy.tensor) and not coeff.requires_grad: coeff = qml.math.toarray(coeff) product = ( qml.math.gather(self._conj(self.state), coo.row) * coo.data * qml.math.gather(self.state, coo.col) ) c = qml.math.cast(qml.math.convert_like(coeff, product), "complex128") res = res + qml.math.sum(c * product)

A small benchmark:

Original VQE: 1.0342366695404053 (1x) New VQE this PR: 0.28333497047424316 (3.65x) New VQE, above comment: 0.09953856468200684 (10.39x)

soranjh

Looks good to me Maria, just left few questions. Will be good to double check if the new addition works for getting the correct expectation value in a VQE qchem problem, if not covered by other tests.

mariaschuld · 2021-08-26T16:05:32Z

Looks good to me Maria, just left few questions. Will be good to double check if the new addition works for getting the correct expectation value in a VQE qchem problem, if not covered by other tests.

Thanks for the approval! I wonder if someone could just run a few old qchem scripts once this is merged, so we can pressure test it before the next release? I hope that one should only have to change a few lines!

soranjh · 2021-08-26T16:10:27Z

Looks good to me Maria, just left few questions. Will be good to double check if the new addition works for getting the correct expectation value in a VQE qchem problem, if not covered by other tests.

Thanks for the approval! I wonder if someone could just run a few old qchem scripts once this is merged, so we can pressure test it before the next release? I hope that one should only have to change a few lines!

I will do some tests for few small molecules.

ixfoduap

Took a quick look, without a chance to go deep into the tests. The changes are great! 🤩

I won't request this as as a change, but I worry that the method to compute expectation values can be optimized further with just a bit of extra effort.

To the best of my understanding, this PR is implementing a method that computes expectation values by converting PauliWords into sparse representations and computing expvals for each term. My bet is that if we instead add these matrices together weighted by their coefficients, and compute a single expval for the entire matrix, the simulation will be faster.

But maybe this breaks differentiabilty with respect to the coefficients?

ixfoduap · 2021-08-26T15:15:20Z

.github/CHANGELOG.md

@@ -250,9 +250,18 @@

 <h3>Improvements</h3>

+* Hamiltonians are now natively supported on the `default.qubit` device if `shots=None`. 
+  This makes VQE workflows a lot faster in some cases.


Optional:

A simple code snippet would be nice to illustrate what we mean by native support

I don't think there is any user-facing change here though, apart from speedup! No UI changes to enable this, etc.

The UI does not change, so I am struggling to find a good example!

ixfoduap · 2021-08-26T15:40:51Z

pennylane/devices/default_qubit.py

+        if observable.name == "Hamiltonian":
+            assert self.shots is None, "Hamiltonian must be used with shots=None"
+
+            # compute  <psi| H |psi> via sum_i coeff_i * <psi| PauliWord |psi> using a sparse


Why do we decompose the Hamiltonian into Pauli terms and compute sparse representations of them, instead of calculating a sparse representation of the entire matrix? This current implementation seems suboptimal in that regard

Note that this can be done using https://pennylane.readthedocs.io/en/stable/code/api/pennylane.utils.sparse_hamiltonian.html

Differentiability is hard! We tired that before!

ixfoduap · 2021-08-26T15:54:05Z

pennylane/gradients/hamiltonian_grad.py

+import pennylane as qml
+
+
+def hamiltonian_grad(tape, idx, params=None):


So cool! 🤩

ixfoduap · 2021-08-26T15:59:37Z

pennylane/operation.py

+        for o in self.obs:
+            if len(o.wires) > 1:
+                # todo: deal with multi-qubit operations that do not act on consecutive qubits
+                raise ValueError(


You can decompose any observable into the Pauli basis, so restricting to PauliWords doesn't lose generality, it may just be inconvenient in niche cases.

Really, a list of coeffs and PauliWords is a sparse representation, where instead of using the canonical basis with of matrices with zeros everywhere except for a one in entry (i, j), we use the Pauli basis

mariaschuld added 9 commits August 17, 2021 17:50

add some checks

3c17980

backup

a40a886

Merge branch 'master' of github.com:PennyLaneAI/pennylane into suppor…

d406739

…t_hamiltonian

backup

0a3a66d

backup

d795a44

make function wire label independent

4e49f97

black

40c24fb

add check test

0c87a1a

first draft

c810617

mariaschuld changed the title ~~Support hamiltonian on default.qubit~~ [WIP] Support hamiltonian on default.qubit Aug 18, 2021

mariaschuld changed the title ~~[WIP] Support hamiltonian on default.qubit~~ [WIP] Support Hamiltonian observables on default.qubit Aug 18, 2021

mariaschuld commented Aug 18, 2021

View reviewed changes

mariaschuld added 4 commits August 18, 2021 12:55

fix some formal issues

e68b3fe

Merge branch 'master' into support_hamiltonian

256c910

numpy gradient hack is working

64ce853

prototype for sparse product

59ee66d

mariaschuld commented Aug 19, 2021

View reviewed changes

pennylane/devices/default_qubit.py Show resolved Hide resolved

mariaschuld added 9 commits August 23, 2021 10:16

resolve conflicts

2609b5a

move class to math module

977bea0

fix SequenceArrayBox issue

8140333

Merge branch 'master' of github.com:PennyLaneAI/pennylane into suppor…

d4c3b6c

…t_hamiltonian

backup

2a9dbf8

port files from other branch

da65edf

tests for SparseMatrix class

83ccd07

add hamiltonian method tests

46de01a

polish

0b59f1f

mariaschuld requested a review from ixfoduap August 25, 2021 14:51

mariaschuld added 2 commits August 25, 2021 17:00

some fixing

86c0286

add flaky to device test

1c8ad5d

Base automatically changed from tiny_improvements to master August 25, 2021 15:22

mariaschuld added 6 commits August 25, 2021 17:27

Merge branch 'master' into support_hamiltonian

c65c818

add pylint

e82abaf

Merge branch 'support_hamiltonian' of github.com:PennyLaneAI/pennylan…

025d2e3

…e into support_hamiltonian

backup

4ea59b5

Merge branch 'master' of github.com:PennyLaneAI/pennylane into suppor…

145d24f

…t_hamiltonian

rebase qnode file where the diff was strange

d6cff96

josh146 approved these changes Aug 26, 2021

View reviewed changes

mariaschuld added 5 commits August 26, 2021 09:48

fix autograd bug and add tests

eea79a8

add more tests

58ff487

black

e315478

add exceptions for adjoint and reverse diff

73ebc90

split tests per interface

b0c6bb2

mariaschuld commented Aug 26, 2021

View reviewed changes

soranjh reviewed Aug 26, 2021

View reviewed changes

soranjh approved these changes Aug 26, 2021

View reviewed changes

ixfoduap reviewed Aug 26, 2021

View reviewed changes

mariaschuld merged commit 8e57efa into master Aug 26, 2021

mariaschuld deleted the support_hamiltonian branch August 26, 2021 19:03

This was referenced Aug 27, 2021

Vectorize and remove for loop in sparse expvals #1596

Merged

Add support for the new VQE workflows to the differentiable batch execution pipeline #1608

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Support Hamiltonian observables on default.qubit #1551

Support Hamiltonian observables on default.qubit #1551

mariaschuld commented Aug 18, 2021 •

edited

Loading

github-actions bot commented Aug 18, 2021

mariaschuld Aug 18, 2021

mariaschuld Aug 18, 2021

mariaschuld Aug 18, 2021 •

edited

Loading

mariaschuld Aug 18, 2021

codecov bot commented Aug 25, 2021 •

edited

Loading

josh146 left a comment

josh146 Aug 26, 2021

josh146 Aug 26, 2021

mariaschuld Aug 26, 2021

mariaschuld Aug 26, 2021

soranjh Aug 26, 2021

soranjh Aug 26, 2021

soranjh Aug 26, 2021

josh146 Aug 26, 2021

josh146 Aug 26, 2021 •

edited

Loading

soranjh left a comment

mariaschuld commented Aug 26, 2021

soranjh commented Aug 26, 2021

ixfoduap left a comment •

edited

Loading

ixfoduap Aug 26, 2021

josh146 Aug 26, 2021

mariaschuld Aug 26, 2021

ixfoduap Aug 26, 2021

mariaschuld Aug 26, 2021

ixfoduap Aug 26, 2021

ixfoduap Aug 26, 2021

		@@ -20,6 +20,13 @@
		import pennylane as qml
		from pennylane import numpy as pnp

		import pennylane as qml


		def hamiltonian_grad(tape, idx, params=None):

Support Hamiltonian observables on default.qubit #1551

Support Hamiltonian observables on default.qubit #1551

Conversation

mariaschuld commented Aug 18, 2021 • edited Loading

github-actions bot commented Aug 18, 2021

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mariaschuld Aug 18, 2021 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

codecov bot commented Aug 25, 2021 • edited Loading

Codecov Report

josh146 left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

josh146 Aug 26, 2021 • edited Loading

Choose a reason for hiding this comment

soranjh left a comment

Choose a reason for hiding this comment

mariaschuld commented Aug 26, 2021

soranjh commented Aug 26, 2021

ixfoduap left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mariaschuld commented Aug 18, 2021 •

edited

Loading

mariaschuld Aug 18, 2021 •

edited

Loading

codecov bot commented Aug 25, 2021 •

edited

Loading

josh146 Aug 26, 2021 •

edited

Loading

ixfoduap left a comment •

edited

Loading