Merge dev into master 0.30

demonstrations/ensemble_multi_qpu.py

@@ -29,6 +29,7 @@
 
 from collections import Counter
 
+import dask
 import matplotlib.pyplot as plt
 import numpy as np
 import pennylane as qml
@@ -229,14 +230,14 @@ def circuit1(params, x=None):
 
 
 ##############################################################################
-# We finally combine the two devices into a :class:`~.pennylane.QNodeCollection` that uses the
+# We finally combine the two devices into a :class:`~.pennylane.QNode` list that uses the
 # PyTorch interface:
 
 
-qnodes = qml.QNodeCollection(
-    [qml.QNode(circuit0, dev0, interface="torch"),
-     qml.QNode(circuit1, dev1, interface="torch")]
-)
+qnodes = [
+    qml.QNode(circuit0, dev0, interface="torch"),
+    qml.QNode(circuit1, dev1, interface="torch"),
+]
 
 ##############################################################################
 # Postprocessing into a prediction
@@ -245,19 +246,23 @@ def circuit1(params, x=None):
 # The ``predict_point`` function below allows us to find the ensemble prediction, as well as keeping
 # track of the individual predictions from each QPU.
 #
-# We include a ``parallel`` keyword argument for evaluating the :class:`~.pennylane.QNodeCollection`
+# We include a ``parallel`` keyword argument for evaluating the :class:`~.pennylane.QNode` list
 # in a parallel asynchronous manner. This feature requires the ``dask`` library, which can be
 # installed using ``pip install "dask[delayed]"``. When ``parallel=True``, we are able to make
 # predictions faster because we do not need to wait for one QPU to output before running on the
 # other.
 
-
 def decision(softmax):
     return int(torch.argmax(softmax))
 
 
 def predict_point(params, x_point=None, parallel=True):
-    results = qnodes(params, x=x_point, parallel=parallel)
+    if parallel:
+        results = tuple(dask.delayed(q)(params, x=x_point) for q in qnodes)
+        results = torch.tensor(dask.compute(*results, scheduler="threads"))
+    else:
+        results = tuple(q(params, x=x_point) for q in qnodes)
+        results = torch.tensor(results)
     softmax = torch.nn.functional.softmax(results, dim=1)
     choice = torch.where(softmax == torch.max(softmax))[0][0]
     chosen_softmax = softmax[choice]
@@ -364,7 +369,7 @@ def accuracy(predictions, actuals):
 #
 #    Training accuracy (ensemble): 0.824
 #    Training accuracy (QPU0):  0.648
-#    Training accuracy (QPU1):  0.28
+#    Training accuracy (QPU1):  0.296
 
 ##############################################################################
 

demonstrations/tutorial_gbs.py → demonstrations/gbs.py

@@ -19,6 +19,9 @@
 
 *Authors: Josh Izaac and Nathan Killoran — Posted: 04 December 2020. Last updated: 04 December 2020.*
 
+.. warning::
+    This demo is only compatible with PennyLane version ``0.29`` or below.
+
 On the journey to large-scale fault-tolerant quantum computers, one of the first major
 milestones is to demonstrate a quantum device carrying out tasks that are beyond the reach of
 any classical algorithm. The launch of Xanadu's Borealis device marked an important milestone
@@ -147,7 +150,22 @@
 U = unitary_group.rvs(4)
 print(U)
 
-######################################################################
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       [[ 0.23648826-0.48221431j  0.06829648+0.04447898j  0.51150074-0.09529866j
+#         0.55205719-0.35974699j]
+#        [-0.11148167+0.69780321j -0.24943828+0.08410701j  0.46705929-0.43192981j
+#          0.16220654-0.01817602j]
+#       [-0.22351926-0.25918352j  0.24364996-0.05375623j -0.09259829-0.53810588j
+#          0.27267708+0.66941977j]
+#         [ 0.11519953-0.28596729j -0.90164923-0.22099186j -0.09627758-0.13105595j
+#         -0.0200152 +0.12766128j]]
+#
 # We can now use this to construct the circuit, choosing a compatible
 # device. For the simulation, we can use the Strawberry Fields
 # Gaussian backend. This backend is perfectly suited for simulation of GBS,
@@ -197,6 +215,15 @@ def gbs_circuit():
 probs = gbs_circuit().reshape([cutoff] * n_wires)
 print(probs.shape)
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       (10, 10, 10, 10)
+#
 ######################################################################
 # For example, element ``[1,2,0,1]`` represents the probability of
 # detecting 1 photon on wire
@@ -214,6 +241,19 @@ def gbs_circuit():
 for i in measure_states:
     print(f"|{''.join(str(j) for j in i)}>: {probs[i]}")
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       |0000>: 0.17637844761413496
+#       |1100>: 0.03473293649420282
+#       |0101>: 0.011870900427255589
+#       |1111>: 0.005957399165336106
+#       |2000>: 0.02957384308320549
+#
 ######################################################################
 # The GBS Distribution
 # --------------------
@@ -292,6 +332,16 @@ def gbs_circuit():
 
 print(A[:, [0, 1]][[0, 1]])
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       [[ 0.19343159-0.54582922j  0.43418269-0.09169615j]
+#        [ 0.43418269-0.09169615j -0.27554025-0.46222197j]]
+#
 ######################################################################
 # i.e., we consider only the rows and columns where a photon was detected, which gives us
 # the submatrix corresponding to indices :math:`0` and :math:`1`.
@@ -310,20 +360,50 @@ def gbs_circuit():
 print(1 / np.cosh(1) ** 4)
 print(probs[0, 0, 0, 0])
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       0.1763784476141347
+#       0.17637844761413496
+#
 ######################################################################
 # **Measuring** :math:`|1,1,0,0\rangle` **at the output**
 
 A = (np.dot(U, U.T) * np.tanh(1))[:, [0, 1]][[0, 1]]
 print(np.abs(haf(A)) ** 2 / np.cosh(1) ** 4)
 print(probs[1, 1, 0, 0])
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       0.03473293649420271
+#       0.03473293649420282
+#
 ######################################################################
 # **Measuring** :math:`|0,1,0,1\rangle` **at the output**
 
 A = (np.dot(U, U.T) * np.tanh(1))[:, [1, 3]][[1, 3]]
 print(np.abs(haf(A)) ** 2 / np.cosh(1) ** 4)
 print(probs[0, 1, 0, 1])
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       0.011870900427255558
+#       0.011870900427255589
+#
 ######################################################################
 # **Measuring** :math:`|1,1,1,1\rangle` **at the output**
 #
@@ -333,6 +413,16 @@ def gbs_circuit():
 print(np.abs(haf(A)) ** 2 / np.cosh(1) ** 4)
 print(probs[1, 1, 1, 1])
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       0.005957399165336081
+#       0.005957399165336106
+#
 ######################################################################
 # **Measuring** :math:`|2,0,0,0\rangle` **at the output**
 #
@@ -343,7 +433,16 @@ def gbs_circuit():
 print(np.abs(haf(A)) ** 2 / (2 * np.cosh(1) ** 4))
 print(probs[2, 0, 0, 0])
 
-######################################################################
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       0.029573843083205383
+#       0.02957384308320549
+#
 # The PennyLane simulation results agree (with almost negligible numerical error) to the
 # expected result from the Gaussian boson sampling equation!
 #

demonstrations/tutorial_plugins_hybrid.metadata.json → demonstrations/plugins_hybrid.metadata.json

@@ -19,7 +19,7 @@
     ],
     "seoDescription": "This tutorial introduces the notion of hybrid computation by combining several PennyLane device backends to train an algorithm containing both photonic and qubit devices.",
     "doi": "",
-    "canonicalURL": "https://pennylane.ai/qml/demos/tutorial_plugins_hybrid.html",
+    "canonicalURL": "https://pennylane.ai/qml/demos/plugins_hybrid.html",
     "references": [],
     "basedOnPapers": [],
     "referencedByPapers": [],

demonstrations/tutorial_plugins_hybrid.py → demonstrations/plugins_hybrid.py

@@ -24,6 +24,9 @@
 Be sure to read through the introductory :ref:`qubit rotation <qubit_rotation>` and
 :ref:`Gaussian transformation <gaussian_transformation>` tutorials before attempting this tutorial.
 
+.. warning::
+    This demo is only compatible with PennyLane version ``0.29`` or below.
+
 .. note::
 
     To follow along with this tutorial on your own computer, you will require the
@@ -195,6 +198,16 @@ def cost(params):
 init_params = np.array([0.01, 0.01], requires_grad=True)
 print(cost(init_params))
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       -9.999666671111081e-05
+#
+
 ##############################################################################
 # Here, we choose the values of :math:`\theta` and :math:`\phi` to be very close to zero;
 # this results in :math:`B(\theta,\phi)\approx I`, and the output of the quantum
@@ -212,6 +225,16 @@ def cost(params):
 dphoton_redirection = qml.grad(photon_redirection, argnum=0)
 print(dphoton_redirection([0.0, 0.0]))
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#       [array(0.), array(0.)]
+#
+
 ##############################################################################
 # Now, let's use the :class:`~.pennylane.GradientDescentOptimizer`, and update the circuit
 # parameters over 100 optimization steps.
@@ -233,6 +256,36 @@ def cost(params):
 
 print("Optimized rotation angles: {}".format(params))
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#        Cost after step     5: -0.0349558
+#        Cost after step    10: -0.9969017
+#        Cost after step    15: -1.0000000
+#        Cost after step    20: -1.0000000
+#        Cost after step    25: -1.0000000
+#        Cost after step    30: -1.0000000
+#        Cost after step    35: -1.0000000
+#        Cost after step    40: -1.0000000
+#        Cost after step    45: -1.0000000
+#        Cost after step    50: -1.0000000
+#        Cost after step    55: -1.0000000
+#        Cost after step    60: -1.0000000
+#        Cost after step    65: -1.0000000
+#        Cost after step    70: -1.0000000
+#        Cost after step    75: -1.0000000
+#        Cost after step    80: -1.0000000
+#        Cost after step    85: -1.0000000
+#        Cost after step    90: -1.0000000
+#        Cost after step    95: -1.0000000
+#        Cost after step   100: -1.0000000
+#        Optimized rotation angles: [1.57079633 0.01      ]
+#
+#
 
 ##############################################################################
 # Comparing this to the :ref:`exact calculation <photon_redirection_calc>` above,
@@ -342,6 +395,37 @@ def cost(params, phi1=0.5, phi2=0.1):
 
 print("Optimized rotation angles: {}".format(params))
 
+
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#        Cost after step     5:  0.2154539
+#        Cost after step    10:  0.0000982
+#        Cost after step    15:  0.0000011
+#        Cost after step    20:  0.0000000
+#        Cost after step    25:  0.0000000
+#        Cost after step    30:  0.0000000
+#        Cost after step    35:  0.0000000
+#        Cost after step    40:  0.0000000
+#        Cost after step    45:  0.0000000
+#        Cost after step    50:  0.0000000
+#        Cost after step    55:  0.0000000
+#        Cost after step    60:  0.0000000
+#        Cost after step    65:  0.0000000
+#        Cost after step    70:  0.0000000
+#        Cost after step    75:  0.0000000 
+#        Cost after step    80:  0.0000000
+#        Cost after step    85:  0.0000000
+#        Cost after step    90:  0.0000000
+#        Cost after step    95:  0.0000000
+#        Cost after step   100:  0.0000000
+#        Optimized rotation angles: [1.20671364 0.01      ]
+#
+#
 ##############################################################################
 # Substituting this into the photon redirection QNode shows that it now produces
 # the same output as the qubit rotation QNode:
@@ -350,6 +434,16 @@ def cost(params, phi1=0.5, phi2=0.1):
 print(photon_redirection(result))
 print(qubit_rotation(0.5, 0.1))
 
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  Out:
+#
+#  .. code-block:: none
+#
+#        0.8731983021146449
+#        0.8731983044562817
+#
 ##############################################################################
 # This is just a simple example of the kind of hybrid computation that can be carried
 # out in PennyLane. Quantum nodes (bound to different devices) and classical