From c3c60084e02e35f3c6634c53cc534f79410cf147 Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Wed, 18 Sep 2024 11:17:39 -0400 Subject: [PATCH 01/13] Remove qml.broadcast --- demonstrations/tutorial_backprop.py | 13 +++++++++-- demonstrations/tutorial_kernels_module.py | 4 +++- .../tutorial_learning_from_experiments.py | 22 +++++++++---------- .../tutorial_local_cost_functions.py | 9 +++++--- demonstrations/tutorial_vqt.py | 15 ++++++++----- 5 files changed, 39 insertions(+), 24 deletions(-) diff --git a/demonstrations/tutorial_backprop.py b/demonstrations/tutorial_backprop.py index becc9b8280..96fa467a4d 100644 --- a/demonstrations/tutorial_backprop.py +++ b/demonstrations/tutorial_backprop.py @@ -69,19 +69,28 @@ # create a device to execute the circuit on dev = qml.device("default.qubit", wires=3) + +def CNOT_ring(wires): + """Apply CNOTs in a ring pattern""" + n_wires = len(wires) + + for w in wires: + qml.CNOT([w % n_wires, (w + 1) % n_wires]) + + @qml.qnode(dev, diff_method="parameter-shift") def circuit(params): qml.RX(params[0], wires=0) qml.RY(params[1], wires=1) qml.RZ(params[2], wires=2) - qml.broadcast(qml.CNOT, wires=[0, 1, 2], pattern="ring") + CNOT_ring(wires=[0, 1, 2]) qml.RX(params[3], wires=0) qml.RY(params[4], wires=1) qml.RZ(params[5], wires=2) - qml.broadcast(qml.CNOT, wires=[0, 1, 2], pattern="ring") + CNOT_ring(wires=[0, 1, 2]) return qml.expval(qml.PauliY(0) @ qml.PauliZ(2)) diff --git a/demonstrations/tutorial_kernels_module.py b/demonstrations/tutorial_kernels_module.py index 5e68b196cb..22153db7bc 100644 --- a/demonstrations/tutorial_kernels_module.py +++ b/demonstrations/tutorial_kernels_module.py @@ -250,7 +250,9 @@ def layer(x, params, wires, i0=0, inc=1): i += inc qml.RY(params[0, j], wires=[wire]) - qml.broadcast(unitary=qml.CRZ, pattern="ring", wires=wires, parameters=params[1]) + n_wires = len(wires) + for p, w in zip(params[1], wires): + qml.CRZ(p, wires=[w % n_wires, (w + 1) % n_wires]) ############################################################################## diff --git a/demonstrations/tutorial_learning_from_experiments.py b/demonstrations/tutorial_learning_from_experiments.py index bca1dda7bd..f3906af28b 100644 --- a/demonstrations/tutorial_learning_from_experiments.py +++ b/demonstrations/tutorial_learning_from_experiments.py @@ -346,6 +346,12 @@ def process_data(raw_data): dev = qml.device("lightning.qubit", wires=qubits * 2, shots=n_shots) +def CNOT_sequence(control_wires, target_wires): + """Apply CNOTs in sequence using the provided control and target wires""" + for c_wire, t_wire in zip(control_wires, target_wires): + qml.CNOT([c_wire, t_wire]) + + @qml.qnode(dev) def enhanced_circuit(ts=False): "implement the enhanced circuit, using a random unitary" @@ -361,14 +367,10 @@ def enhanced_circuit(ts=False): for q in range(qubits): qml.Hadamard(wires=q) - qml.broadcast( - qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2) - ) + CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits)) RandomLayers(weights, wires=range(0, qubits), rotations=ops, seed=seed) RandomLayers(weights, wires=range(qubits, 2 * qubits), rotations=ops, seed=seed) - qml.broadcast( - qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2) - ) + CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits)) for q in range(qubits): qml.Hadamard(wires=q) @@ -479,15 +481,11 @@ def enhanced_circuit(ts=False): for q in range(qubits): qml.Hadamard(wires=q) - qml.broadcast( - qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2) - ) + CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits)) RandomLayers(weights, wires=range(0, qubits), rotations=ops, seed=seed) RandomLayers(weights, wires=range(qubits, 2 * qubits), rotations=ops, seed=seed) noise_layer(np.pi / 4) # added noise layer - qml.broadcast( - qml.CNOT, pattern=[[qubits + q, q] for q in range(qubits)], wires=range(qubits * 2) - ) + CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits)) for q in range(qubits): qml.Hadamard(wires=qubits + q) diff --git a/demonstrations/tutorial_local_cost_functions.py b/demonstrations/tutorial_local_cost_functions.py index d3d1756b9b..c07a18f8c1 100644 --- a/demonstrations/tutorial_local_cost_functions.py +++ b/demonstrations/tutorial_local_cost_functions.py @@ -241,14 +241,16 @@ def global_cost_simple(rotations): for i in range(wires): qml.RX(rotations[0][i], wires=i) qml.RY(rotations[1][i], wires=i) - qml.broadcast(qml.CNOT, wires=range(wires), pattern="chain") + for i in range(wires - 1): + qml.CNOT([i, i + 1]) return qml.probs(wires=range(wires)) def local_cost_simple(rotations): for i in range(wires): qml.RX(rotations[0][i], wires=i) qml.RY(rotations[1][i], wires=i) - qml.broadcast(qml.CNOT, wires=range(wires), pattern="chain") + for i in range(wires - 1): + qml.CNOT([i, i + 1]) return qml.probs(wires=[0]) global_circuit = qml.QNode(global_cost_simple, dev, interface="autograd") @@ -371,7 +373,8 @@ def tunable_cost_simple(rotations): for i in range(wires): qml.RX(rotations[0][i], wires=i) qml.RY(rotations[1][i], wires=i) - qml.broadcast(qml.CNOT, wires=range(wires), pattern="chain") + for i in range(wires - 1): + qml.CNOT([i, i + 1]) return qml.probs(range(locality)) def cost_tunable(rotations): diff --git a/demonstrations/tutorial_vqt.py b/demonstrations/tutorial_vqt.py index 29a536da03..cd53bb8c91 100644 --- a/demonstrations/tutorial_vqt.py +++ b/demonstrations/tutorial_vqt.py @@ -250,6 +250,14 @@ def single_rotation(phi_params, qubits): # +def CRX_ring(parameters, wires): + """Apply a controlled RX on all wires in a ring pattern""" + n_wires = len(wires) + + for param, w in zip(parameters, wires): + qml.CRX(param, wires=[w % n_wires, (w + 1) % n_wires]) + + depth = 4 dev = qml.device("lightning.qubit", wires=nr_qubits) @@ -262,12 +270,7 @@ def quantum_circuit(rotation_params, coupling_params, sample=None, return_state= # Prepares the variational ansatz for the circuit for i in range(0, depth): single_rotation(rotation_params[i], range(nr_qubits)) - qml.broadcast( - unitary=qml.CRX, - pattern="ring", - wires=range(nr_qubits), - parameters=coupling_params[i], - ) + CRX_ring(coupling_params[i], list(range(nr_qubits))) if return_state: return qml.state() From bb22782e0234ca393533dba6d7c9f5e0ebc87244 Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Wed, 18 Sep 2024 11:17:57 -0400 Subject: [PATCH 02/13] Remove QubitStateVector and BasisStatePreparation --- demonstrations/tutorial_mcm_introduction.py | 2 +- demonstrations/tutorial_rl_pulse.py | 4 ++-- demonstrations/tutorial_sc_qubits.py | 6 +++--- demonstrations/tutorial_tn_circuits.py | 8 ++++---- demonstrations/tutorial_trapped_ions.py | 4 ++-- demonstrations/tutorial_vqt.py | 2 +- 6 files changed, 13 insertions(+), 13 deletions(-) diff --git a/demonstrations/tutorial_mcm_introduction.py b/demonstrations/tutorial_mcm_introduction.py index 79f3bcaa27..8acbfc83e0 100644 --- a/demonstrations/tutorial_mcm_introduction.py +++ b/demonstrations/tutorial_mcm_introduction.py @@ -360,7 +360,7 @@ def bell_pair_with_reset(reset): magic_state = np.array([1, np.exp(1j * np.pi / 4)]) / np.sqrt(2) def t_gadget(wire, aux_wire): - qml.QubitStateVector(magic_state, aux_wire) + qml.StatePrep(magic_state, aux_wire) qml.CNOT([wire, aux_wire]) mcm = qml.measure(aux_wire, reset=True) # Resetting disentangles aux qubit qml.cond(mcm, qml.S)(wire) # Apply qml.S(wire) if mcm was 1 diff --git a/demonstrations/tutorial_rl_pulse.py b/demonstrations/tutorial_rl_pulse.py index 7658e3273f..15e0a119f3 100644 --- a/demonstrations/tutorial_rl_pulse.py +++ b/demonstrations/tutorial_rl_pulse.py @@ -224,7 +224,7 @@ @partial(jax.vmap, in_axes=(0, None, 0, None)) @qml.qnode(device=device, interface="jax") def evolve_states(state, H, params, t): - qml.QubitStateVector(state, wires=wires) + qml.StatePrep(state, wires=wires) qml.evolve(H)(params, t, atol=1e-5) return qml.state() @@ -929,7 +929,7 @@ def get_drive(timespan, freq, wire): @qml.qnode(device=device, interface="jax") def evolve_states(state, params, t): params_sq, params_cr = params - qml.QubitStateVector(state, wires=wires) + qml.StatePrep(state, wires=wires) # Single qubit pulses qml.evolve(H_int + H_sq_ini)(params_sq, t, atol=1e-5) diff --git a/demonstrations/tutorial_sc_qubits.py b/demonstrations/tutorial_sc_qubits.py index 3cbde8ea11..075bcf154f 100644 --- a/demonstrations/tutorial_sc_qubits.py +++ b/demonstrations/tutorial_sc_qubits.py @@ -619,7 +619,7 @@ def Sc_Y_rot(state, phi): # Implement Hamiltonian evolution for time t and some initial computational basis state @qml.qnode(dev3, interface="autograd") def Sc_ISWAP(basis_state, time): - qml.templates.BasisStatePreparation(basis_state, wires=range(2)) + qml.BasisState(basis_state, wires=range(2)) ApproxTimeEvolution(Two_qubit_H, time, 1) return qml.state() @@ -627,7 +627,7 @@ def Sc_ISWAP(basis_state, time): # Implement ISWAP exactly @qml.qnode(dev3, interface="autograd") def iswap(basis_state): - qml.templates.BasisStatePreparation(basis_state, wires=range(2)) + qml.BasisState(basis_state, wires=range(2)) qml.ISWAP(wires=[0, 1]) return qml.state() @@ -735,7 +735,7 @@ def cnot_with_iswap(): @qml.qnode(dev3, interface="autograd") def H_evolve(state, phi, time): # Prepare initial state - qml.templates.BasisStatePreparation(state, wires=range(2)) + qml.BasisState(state, wires=range(2)) # Define Hamiltonian coeffs = [np.cos(phi), np.sin(phi)] ops = [qml.PauliZ(0) @ qml.PauliX(1), qml.PauliZ(0) @ qml.PauliY(1)] diff --git a/demonstrations/tutorial_tn_circuits.py b/demonstrations/tutorial_tn_circuits.py index 45dce62b3e..035b32a01e 100644 --- a/demonstrations/tutorial_tn_circuits.py +++ b/demonstrations/tutorial_tn_circuits.py @@ -317,11 +317,11 @@ def block(weights, wires): ############################################################################## # As for the tensor-network architecture, we use the tree tensor-network quantum circuit. -# We use :class:`~pennylane.BasisStatePreparation` to encode the input images. -# The following code implements the :class:`~pennylane.BasisStatePreparation` encoding, +# We use :class:`~pennylane.BasisState` to encode the input images. +# The following code implements the :class:`~pennylane.BasisState` encoding, # followed by a :class:`~pennylane.TTN` circuit using the above ``block``. Finally, we compute the expectation # value of a :class:`~pennylane.PauliZ` measurement as the output. -# The circuit diagram below shows the full circuit. The :class:`~pennylane.BasisStatePreparation` +# The circuit diagram below shows the full circuit. The :class:`~pennylane.BasisState` # encoding appears in the initial :class:`~pennylane.PauliX` gates. dev = qml.device("default.qubit", wires=4) @@ -329,7 +329,7 @@ def block(weights, wires): @qml.qnode(dev) def circuit(image, template_weights): - qml.BasisStatePreparation(image, wires=range(4)) + qml.BasisState(image, wires=range(4)) qml.TTN( wires=range(4), n_block_wires=2, diff --git a/demonstrations/tutorial_trapped_ions.py b/demonstrations/tutorial_trapped_ions.py index 1d13bf0fdf..e7acb35e9d 100644 --- a/demonstrations/tutorial_trapped_ions.py +++ b/demonstrations/tutorial_trapped_ions.py @@ -815,7 +815,7 @@ def Molmer_Sorensen(t): def ion_cnot(basis_state): #Prepare the two-qubit basis states from the input - qml.templates.BasisStatePreparation(basis_state, wires=range(2)) + qml.BasisState(basis_state, wires=range(2)) #Implements the circuit shown above qml.RY(np.pi/2, wires=0) @@ -830,7 +830,7 @@ def ion_cnot(basis_state): @qml.qnode(dev2, interface="autograd") def cnot_gate(basis_state): - qml.templates.BasisStatePreparation(basis_state, wires=range(2)) + qml.BasisState(basis_state, wires=range(2)) qml.CNOT(wires=[0,1]) diff --git a/demonstrations/tutorial_vqt.py b/demonstrations/tutorial_vqt.py index cd53bb8c91..278cb2e783 100644 --- a/demonstrations/tutorial_vqt.py +++ b/demonstrations/tutorial_vqt.py @@ -265,7 +265,7 @@ def CRX_ring(parameters, wires): def quantum_circuit(rotation_params, coupling_params, sample=None, return_state=False): # Prepares the initial basis state corresponding to the sample - qml.BasisStatePreparation(sample, wires=range(nr_qubits)) + qml.BasisState(sample, wires=range(nr_qubits)) # Prepares the variational ansatz for the circuit for i in range(0, depth): From e3fc7bb548fa9218023ec3452e821dfd62bc674b Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 19 Sep 2024 10:57:26 -0400 Subject: [PATCH 03/13] Update metadata files --- demonstrations/tutorial_backprop.metadata.json | 2 +- demonstrations/tutorial_classical_kernels.metadata.json | 2 +- demonstrations/tutorial_learning_from_experiments.metadata.json | 2 +- demonstrations/tutorial_local_cost_functions.metadata.json | 2 +- demonstrations/tutorial_mcm_introduction.metadata.json | 2 +- demonstrations/tutorial_rl_pulse.metadata.json | 2 +- demonstrations/tutorial_sc_qubits.metadata.json | 2 +- demonstrations/tutorial_tn_circuits.metadata.json | 2 +- demonstrations/tutorial_trapped_ions.metadata.json | 2 +- demonstrations/tutorial_vqt.metadata.json | 2 +- 10 files changed, 10 insertions(+), 10 deletions(-) diff --git a/demonstrations/tutorial_backprop.metadata.json b/demonstrations/tutorial_backprop.metadata.json index b472049cb5..fa7b27bdda 100644 --- a/demonstrations/tutorial_backprop.metadata.json +++ b/demonstrations/tutorial_backprop.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2020-08-11T00:00:00+00:00", - "dateOfLastModification": "2024-08-06T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Getting Started" ], diff --git a/demonstrations/tutorial_classical_kernels.metadata.json b/demonstrations/tutorial_classical_kernels.metadata.json index 2b8ca1bb58..eae832b6cf 100644 --- a/demonstrations/tutorial_classical_kernels.metadata.json +++ b/demonstrations/tutorial_classical_kernels.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2022-03-01T00:00:00+00:00", - "dateOfLastModification": "2024-09-04T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Quantum Machine Learning" ], diff --git a/demonstrations/tutorial_learning_from_experiments.metadata.json b/demonstrations/tutorial_learning_from_experiments.metadata.json index 0c4563082e..3df2006331 100644 --- a/demonstrations/tutorial_learning_from_experiments.metadata.json +++ b/demonstrations/tutorial_learning_from_experiments.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2022-04-18T00:00:00+00:00", - "dateOfLastModification": "2024-08-06T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Quantum Machine Learning" ], diff --git a/demonstrations/tutorial_local_cost_functions.metadata.json b/demonstrations/tutorial_local_cost_functions.metadata.json index 91b2ec37d6..1f1e2ffcc7 100644 --- a/demonstrations/tutorial_local_cost_functions.metadata.json +++ b/demonstrations/tutorial_local_cost_functions.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2020-09-09T00:00:00+00:00", - "dateOfLastModification": "2024-08-05T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Optimization" ], diff --git a/demonstrations/tutorial_mcm_introduction.metadata.json b/demonstrations/tutorial_mcm_introduction.metadata.json index 586633d57e..6aacafa406 100644 --- a/demonstrations/tutorial_mcm_introduction.metadata.json +++ b/demonstrations/tutorial_mcm_introduction.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2024-05-10T00:00:00+00:00", - "dateOfLastModification": "2024-08-05T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Getting Started", "Quantum Computing" diff --git a/demonstrations/tutorial_rl_pulse.metadata.json b/demonstrations/tutorial_rl_pulse.metadata.json index 0e59a897ba..1dd4af105f 100644 --- a/demonstrations/tutorial_rl_pulse.metadata.json +++ b/demonstrations/tutorial_rl_pulse.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2024-04-09T00:00:00+00:00", - "dateOfLastModification": "2024-09-04T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Getting Started", "Optimization", diff --git a/demonstrations/tutorial_sc_qubits.metadata.json b/demonstrations/tutorial_sc_qubits.metadata.json index 96bd72975d..29137dd18d 100644 --- a/demonstrations/tutorial_sc_qubits.metadata.json +++ b/demonstrations/tutorial_sc_qubits.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2022-03-22T00:00:00+00:00", - "dateOfLastModification": "2024-08-06T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Quantum Hardware", "Quantum Computing" diff --git a/demonstrations/tutorial_tn_circuits.metadata.json b/demonstrations/tutorial_tn_circuits.metadata.json index f0dde1deb3..5d33fa07cf 100644 --- a/demonstrations/tutorial_tn_circuits.metadata.json +++ b/demonstrations/tutorial_tn_circuits.metadata.json @@ -15,7 +15,7 @@ } ], "dateOfPublication": "2022-03-29T00:00:00+00:00", - "dateOfLastModification": "2024-08-12T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Quantum Machine Learning" ], diff --git a/demonstrations/tutorial_trapped_ions.metadata.json b/demonstrations/tutorial_trapped_ions.metadata.json index 977922539a..40e477bcc7 100644 --- a/demonstrations/tutorial_trapped_ions.metadata.json +++ b/demonstrations/tutorial_trapped_ions.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2021-11-10T00:00:00+00:00", - "dateOfLastModification": "2024-08-06T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Quantum Hardware", "Quantum Computing" diff --git a/demonstrations/tutorial_vqt.metadata.json b/demonstrations/tutorial_vqt.metadata.json index 7f5b69076d..567a2b9dc7 100644 --- a/demonstrations/tutorial_vqt.metadata.json +++ b/demonstrations/tutorial_vqt.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2020-07-07T00:00:00+00:00", - "dateOfLastModification": "2024-08-05T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Optimization" ], From 1567bd2716e4eff16b4b512fb74b615bf1fad02c Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 19 Sep 2024 13:21:51 -0400 Subject: [PATCH 04/13] Fix tn_circuits demo --- demonstrations/tutorial_tn_circuits.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/demonstrations/tutorial_tn_circuits.py b/demonstrations/tutorial_tn_circuits.py index 035b32a01e..bc6c3f5628 100644 --- a/demonstrations/tutorial_tn_circuits.py +++ b/demonstrations/tutorial_tn_circuits.py @@ -116,8 +116,9 @@ of tensors in the network. """ +import numpy as np import pennylane as qml -from pennylane import numpy as np +from pennylane import numpy as pnp def block(weights, wires): @@ -233,7 +234,7 @@ def circuit(template_weights): shapes = qml.SimplifiedTwoDesign.shape(n_layers=1, n_wires=4) weights = [np.random.random(size=shape) for shape in shapes] -template_weights = qml._np.array([weights] * 3, dtype="object") +template_weights = np.array([weights] * 3, dtype="object") fig, ax = qml.draw_mpl(circuit, level="device")(template_weights) ############################################################################## @@ -368,7 +369,7 @@ def costfunc(params): # train the circuit over 100 iterations. This optimizer will attempt to minimize # the cost function. -params = np.random.random(size=[3, 2], requires_grad=True) +params = pnp.random.random(size=[3, 2], requires_grad=True) optimizer = qml.GradientDescentOptimizer(stepsize=0.1) for k in range(100): From 8477d02e5b55dc32b1d84452f9b5e675f0406eae Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 19 Sep 2024 14:01:06 -0400 Subject: [PATCH 05/13] Replace np with pnp and vice versa in various places --- demonstrations/tutorial_backprop.py | 22 ++++---- demonstrations/tutorial_kernels_module.py | 50 +++++++++---------- .../tutorial_learning_from_experiments.py | 4 +- .../tutorial_local_cost_functions.py | 30 +++++------ demonstrations/tutorial_sc_qubits.py | 18 +++---- demonstrations/tutorial_trapped_ions.py | 18 +++---- demonstrations/tutorial_vqt.py | 1 - 7 files changed, 71 insertions(+), 72 deletions(-) diff --git a/demonstrations/tutorial_backprop.py b/demonstrations/tutorial_backprop.py index 96fa467a4d..4b01da23ed 100644 --- a/demonstrations/tutorial_backprop.py +++ b/demonstrations/tutorial_backprop.py @@ -55,7 +55,7 @@ Let's have a go implementing the parameter-shift rule manually in PennyLane. """ import pennylane as qml -from jax import numpy as np +from jax import numpy as jnp from matplotlib import pyplot as plt import jax @@ -118,10 +118,10 @@ def circuit(params): def parameter_shift_term(qnode, params, i): shifted = params.copy() - shifted = shifted.at[i].add(np.pi/2) + shifted = shifted.at[i].add(jnp.pi/2) forward = qnode(shifted) # forward evaluation - shifted = shifted.at[i].add(-np.pi) + shifted = shifted.at[i].add(-jnp.pi) backward = qnode(shifted) # backward evaluation return 0.5 * (forward - backward) @@ -134,7 +134,7 @@ def parameter_shift_term(qnode, params, i): # to loop over the index ``i``: def parameter_shift(qnode, params): - gradients = np.zeros([len(params)]) + gradients = jnp.zeros([len(params)]) for i in range(len(params)): gradients = gradients.at[i].set(parameter_shift_term(qnode, params, i)) @@ -156,7 +156,7 @@ def parameter_shift(qnode, params): # Alternatively, we can directly compute quantum gradients of QNodes using # PennyLane's built in :mod:`qml.gradients ` module: -print(np.stack(qml.gradients.param_shift(circuit)(params))) +print(jnp.stack(qml.gradients.param_shift(circuit)(params))) ############################################################################## # If you count the number of quantum evaluations, you will notice that we had to evaluate the circuit @@ -381,10 +381,10 @@ def circuit(params): t = timeit.repeat("grad_qnode_backprop(params)", globals=globals(), number=num, repeat=reps) gradient_backprop.append([num_params, min(t) / num]) -gradient_shift = np.array(gradient_shift).T -gradient_backprop = np.array(gradient_backprop).T -forward_shift = np.array(forward_shift).T -forward_backprop = np.array(forward_backprop).T +gradient_shift = jnp.array(gradient_shift).T +gradient_backprop = jnp.array(gradient_backprop).T +forward_shift = jnp.array(forward_shift).T +forward_backprop = jnp.array(forward_backprop).T ############################################################################## # We now import matplotlib, and plot the results. @@ -428,8 +428,8 @@ def circuit(params): # perform a least squares regression to determine the linear best fit/gradient # for the normalized time vs. number of parameters x = gradient_shift[0] -m_shift, c_shift = np.polyfit(*gradient_shift, deg=1) -m_back, c_back = np.polyfit(*gradient_backprop, deg=1) +m_shift, c_shift = jnp.polyfit(*gradient_shift, deg=1) +m_back, c_back = jnp.polyfit(*gradient_backprop, deg=1) ax.plot(x, m_shift * x + c_shift, '--', label=f"{m_shift:.2f}p{c_shift:+.2f}") ax.plot(x, m_back * x + c_back, '--', label=f"{m_back:.2f}p{c_back:+.2f}") diff --git a/demonstrations/tutorial_kernels_module.py b/demonstrations/tutorial_kernels_module.py index 22153db7bc..545a597f2b 100644 --- a/demonstrations/tutorial_kernels_module.py +++ b/demonstrations/tutorial_kernels_module.py @@ -129,10 +129,10 @@ # training variational embedding kernels and the available functionalities # to do both in PennyLane. We of course need to start with some imports: -from pennylane import numpy as np +from pennylane import numpy as pnp import matplotlib as mpl -np.random.seed(1359) +pnp.random.seed(1359) ############################################################################## # And we proceed right away to create a dataset to work with, the @@ -144,12 +144,12 @@ def _make_circular_data(num_sectors): """Generate datapoints arranged in an even circle.""" - center_indices = np.array(range(0, num_sectors)) - sector_angle = 2 * np.pi / num_sectors + center_indices = pnp.array(range(0, num_sectors)) + sector_angle = 2 * pnp.pi / num_sectors angles = (center_indices + 0.5) * sector_angle - x = 0.7 * np.cos(angles) - y = 0.7 * np.sin(angles) - labels = 2 * np.remainder(np.floor_divide(angles, sector_angle), 2) - 1 + x = 0.7 * pnp.cos(angles) + y = 0.7 * pnp.sin(angles) + labels = 2 * pnp.remainder(pnp.floor_divide(angles, sector_angle), 2) - 1 return x, y, labels @@ -159,13 +159,13 @@ def make_double_cake_data(num_sectors): x2, y2, labels2 = _make_circular_data(num_sectors) # x and y coordinates of the datapoints - x = np.hstack([x1, 0.5 * x2]) - y = np.hstack([y1, 0.5 * y2]) + x = pnp.hstack([x1, 0.5 * x2]) + y = pnp.hstack([y1, 0.5 * y2]) # Canonical form of dataset - X = np.vstack([x, y]).T + X = pnp.vstack([x, y]).T - labels = np.hstack([labels1, -1 * labels2]) + labels = pnp.hstack([labels1, -1 * labels2]) # Canonical form of labels Y = labels.astype(int) @@ -276,7 +276,7 @@ def ansatz(x, params, wires): def random_params(num_wires, num_layers): """Generate random variational parameters in the shape for the ansatz.""" - return np.random.uniform(0, 2 * np.pi, (num_layers, 2, num_wires), requires_grad=True) + return pnp.random.uniform(0, 2 * pnp.pi, (num_layers, 2, num_wires), requires_grad=True) ############################################################################## @@ -349,7 +349,7 @@ def kernel(x1, x2, params): init_kernel = lambda x1, x2: kernel(x1, x2, init_params) K_init = qml.kernels.square_kernel_matrix(X, init_kernel, assume_normalized_kernel=True) -with np.printoptions(precision=3, suppress=True): +with pnp.printoptions(precision=3, suppress=True): print(K_init) ############################################################################## @@ -385,7 +385,7 @@ def kernel(x1, x2, params): def accuracy(classifier, X, Y_target): - return 1 - np.count_nonzero(classifier.predict(X) - Y_target) / len(Y_target) + return 1 - pnp.count_nonzero(classifier.predict(X) - Y_target) / len(Y_target) accuracy_init = accuracy(svm, X, Y) @@ -399,11 +399,11 @@ def accuracy(classifier, X, Y_target): def plot_decision_boundaries(classifier, ax, N_gridpoints=14): - _xx, _yy = np.meshgrid(np.linspace(-1, 1, N_gridpoints), np.linspace(-1, 1, N_gridpoints)) + _xx, _yy = pnp.meshgrid(pnp.linspace(-1, 1, N_gridpoints), pnp.linspace(-1, 1, N_gridpoints)) - _zz = np.zeros_like(_xx) - for idx in np.ndindex(*_xx.shape): - _zz[idx] = classifier.predict(np.array([_xx[idx], _yy[idx]])[np.newaxis, :]) + _zz = pnp.zeros_like(_xx) + for idx in pnp.ndindex(*_xx.shape): + _zz[idx] = classifier.predict(pnp.array([_xx[idx], _yy[idx]])[pnp.newaxis, :]) plot_data = {"_xx": _xx, "_yy": _yy, "_zz": _zz} ax.contourf( @@ -534,15 +534,15 @@ def target_alignment( ) if rescale_class_labels: - nplus = np.count_nonzero(np.array(Y) == 1) + nplus = pnp.count_nonzero(pnp.array(Y) == 1) nminus = len(Y) - nplus - _Y = np.array([y / nplus if y == 1 else y / nminus for y in Y]) + _Y = pnp.array([y / nplus if y == 1 else y / nminus for y in Y]) else: - _Y = np.array(Y) + _Y = pnp.array(Y) - T = np.outer(_Y, _Y) - inner_product = np.sum(K * T) - norm = np.sqrt(np.sum(K * K) * np.sum(T * T)) + T = pnp.outer(_Y, _Y) + inner_product = pnp.sum(K * T) + norm = pnp.sqrt(pnp.sum(K * K) * pnp.sum(T * T)) inner_product = inner_product / norm return inner_product @@ -553,7 +553,7 @@ def target_alignment( for i in range(500): # Choose subset of datapoints to compute the KTA on. - subset = np.random.choice(list(range(len(X))), 4) + subset = pnp.random.choice(list(range(len(X))), 4) # Define the cost function for optimization cost = lambda _params: -target_alignment( X[subset], diff --git a/demonstrations/tutorial_learning_from_experiments.py b/demonstrations/tutorial_learning_from_experiments.py index f3906af28b..4af0b17b9f 100644 --- a/demonstrations/tutorial_learning_from_experiments.py +++ b/demonstrations/tutorial_learning_from_experiments.py @@ -163,7 +163,7 @@ import pennylane as qml from pennylane.templates.layers import RandomLayers -from pennylane import numpy as np +import numpy as np np.random.seed(234087) @@ -485,7 +485,7 @@ def enhanced_circuit(ts=False): RandomLayers(weights, wires=range(0, qubits), rotations=ops, seed=seed) RandomLayers(weights, wires=range(qubits, 2 * qubits), rotations=ops, seed=seed) noise_layer(np.pi / 4) # added noise layer - CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits)) + CNOT_sequence(control_wires=range(qubits, 2 * qubits), target_wires=range(qubits)) for q in range(qubits): qml.Hadamard(wires=qubits + q) diff --git a/demonstrations/tutorial_local_cost_functions.py b/demonstrations/tutorial_local_cost_functions.py index c07a18f8c1..eee8bf2b90 100644 --- a/demonstrations/tutorial_local_cost_functions.py +++ b/demonstrations/tutorial_local_cost_functions.py @@ -63,7 +63,7 @@ import matplotlib.pyplot as plt from matplotlib.ticker import LinearLocator, FormatStrFormatter -np.random.seed(42) +pnp.random.seed(42) ###################################################################### # Visualizing the problem @@ -128,7 +128,7 @@ def local_cost_simple(rotations): local_circuit = qml.QNode(local_cost_simple, dev, interface="autograd") def cost_local(rotations): - return 1 - np.sum([i for (i, _) in local_circuit(rotations)]) / wires + return 1 - pnp.sum([i for (i, _) in local_circuit(rotations)]) / wires def cost_global(rotations): return 1 - global_circuit(rotations)[0] @@ -140,8 +140,8 @@ def cost_global(rotations): # parameters for each rotation. # -RX = np.random.uniform(low=-np.pi, high=np.pi) -RY = np.random.uniform(low=-np.pi, high=np.pi) +RX = pnp.random.uniform(low=-pnp.pi, high=pnp.pi) +RY = pnp.random.uniform(low=-pnp.pi, high=pnp.pi) rotations = [[RX for i in range(wires)], [RY for i in range(wires)]] @@ -179,9 +179,9 @@ def generate_surface(cost_function): Z = [] Z_assembler = [] - X = np.arange(-np.pi, np.pi, 0.25) - Y = np.arange(-np.pi, np.pi, 0.25) - X, Y = np.meshgrid(X, Y) + X = pnp.arange(-pnp.pi, pnp.pi, 0.25) + Y = pnp.arange(-pnp.pi, pnp.pi, 0.25) + X, Y = pnp.meshgrid(X, Y) for x in X[0, :]: for y in Y[:, 0]: @@ -190,13 +190,13 @@ def generate_surface(cost_function): Z.append(Z_assembler) Z_assembler = [] - Z = np.asarray(Z) + Z = pnp.asarray(Z) return Z def plot_surface(surface): - X = np.arange(-np.pi, np.pi, 0.25) - Y = np.arange(-np.pi, np.pi, 0.25) - X, Y = np.meshgrid(X, Y) + X = pnp.arange(-pnp.pi, pnp.pi, 0.25) + Y = pnp.arange(-pnp.pi, pnp.pi, 0.25) + X, Y = pnp.meshgrid(X, Y) fig = plt.figure() ax = fig.add_subplot(111, projection="3d") surf = ax.plot_surface(X, Y, surface, cmap="viridis", linewidth=0, antialiased=False) @@ -286,7 +286,7 @@ def cost_global(rotations): # landscape is :math:`(\pi,0)` as it is in the middle of the plateau, so let's use that. -rotations = np.array([[3.] * len(range(wires)), [0.] * len(range(wires))], requires_grad=True) +rotations = pnp.array([[3.] * len(range(wires)), [0.] * len(range(wires))], requires_grad=True) opt = qml.GradientDescentOptimizer(stepsize=0.2) steps = 100 params_global = rotations @@ -308,7 +308,7 @@ def cost_global(rotations): # function and see how it performs. # -rotations = np.array([[3. for i in range(wires)], [0. for i in range(wires)]], requires_grad=True) +rotations = pnp.array([[3. for i in range(wires)], [0. for i in range(wires)]], requires_grad=True) opt = qml.GradientDescentOptimizer(stepsize=0.2) steps = 100 params_local = rotations @@ -449,7 +449,7 @@ def cost_tunable(rotations): print("--- New run! ---") has_been_trained = False - params_global = np.random.uniform(-np.pi, np.pi, (2, wires), requires_grad=True) + params_global = pnp.random.uniform(-pnp.pi, pnp.pi, (2, wires), requires_grad=True) for i in range(steps): # update the circuit parameters @@ -483,7 +483,7 @@ def cost_tunable(rotations): print("--- New run! ---") has_been_trained = False - params_tunable = np.random.uniform(-np.pi, np.pi, (2, wires), requires_grad=True) + params_tunable = pnp.random.uniform(-pnp.pi, pnp.pi, (2, wires), requires_grad=True) for i in range(steps): # update the circuit parameters params_tunable = opt.step(cost_tunable, params_tunable) diff --git a/demonstrations/tutorial_sc_qubits.py b/demonstrations/tutorial_sc_qubits.py index 075bcf154f..8fccde1640 100644 --- a/demonstrations/tutorial_sc_qubits.py +++ b/demonstrations/tutorial_sc_qubits.py @@ -404,7 +404,7 @@ # angle :math:`\phi` actually means a rotation by :math:`\omega_r+\phi`. In PennyLane, the operations read: import pennylane as qml -from pennylane import numpy as np +import numpy as np import matplotlib.pyplot as plt # Call the default.gaussian device with 50 shots @@ -416,14 +416,14 @@ # Implement displacement and rotation and measure both X and P observables -@qml.qnode(dev, interface="autograd") +@qml.qnode(dev) def measure_P_shots(time, state): qml.Displacement(epsilon * time, 0, wires=0) qml.Rotation((-1) ** state * chi * time, wires=0) return qml.sample(qml.QuadP(0)) -@qml.qnode(dev, interface="autograd") +@qml.qnode(dev) def measure_X_shots(time, state): qml.Displacement(epsilon * time, 0, wires=0) qml.Rotation((-1) ** state * chi * time, wires=0) @@ -499,7 +499,7 @@ def measure_X_shots(time, state): dev2 = qml.device("lightning.qubit", wires=1) # Implement Hamiltonian evolution given phase phi and time t, from a given initial state -@qml.qnode(dev2, interface="autograd") +@qml.qnode(dev2) def H_evolve(state, phi, time): if state == 1: @@ -513,7 +513,7 @@ def H_evolve(state, phi, time): # Implement X rotation exactly -@qml.qnode(dev2, interface="autograd") +@qml.qnode(dev2) def Sc_X_rot(state, phi): if state == 1: @@ -524,7 +524,7 @@ def Sc_X_rot(state, phi): # Implement Y rotation exactly -@qml.qnode(dev2, interface="autograd") +@qml.qnode(dev2) def Sc_Y_rot(state, phi): if state == 1: @@ -617,7 +617,7 @@ def Sc_Y_rot(state, phi): Two_qubit_H = qml.Hamiltonian(coeffs, ops) # Implement Hamiltonian evolution for time t and some initial computational basis state -@qml.qnode(dev3, interface="autograd") +@qml.qnode(dev3) def Sc_ISWAP(basis_state, time): qml.BasisState(basis_state, wires=range(2)) ApproxTimeEvolution(Two_qubit_H, time, 1) @@ -625,7 +625,7 @@ def Sc_ISWAP(basis_state, time): # Implement ISWAP exactly -@qml.qnode(dev3, interface="autograd") +@qml.qnode(dev3) def iswap(basis_state): qml.BasisState(basis_state, wires=range(2)) qml.ISWAP(wires=[0, 1]) @@ -732,7 +732,7 @@ def cnot_with_iswap(): # the evolution under this Hamiltonian for a time :math:`t=\tfrac{\pi}{4\Omega}` with :math:`R_x` and :math:`R_y` rotations # and a ``qml.Hadamard`` gate: # -@qml.qnode(dev3, interface="autograd") +@qml.qnode(dev3) def H_evolve(state, phi, time): # Prepare initial state qml.BasisState(state, wires=range(2)) diff --git a/demonstrations/tutorial_trapped_ions.py b/demonstrations/tutorial_trapped_ions.py index e7acb35e9d..87fe4c5846 100644 --- a/demonstrations/tutorial_trapped_ions.py +++ b/demonstrations/tutorial_trapped_ions.py @@ -401,7 +401,7 @@ # duration :math:`t` of the pulse, with :math:`\Omega` set to 100 kHz. import pennylane as qml -from pennylane import numpy as np +import numpy as np from scipy.linalg import expm Omega = 100 @@ -422,7 +422,7 @@ def evolution(phi, t): dev = qml.device("default.qubit", wires=1) -@qml.qnode(dev, interface="autograd") +@qml.qnode(dev) def ion_hadamard(state): if state == 1: @@ -440,7 +440,7 @@ def ion_hadamard(state): return qml.state() #For comparison, we use the Hadamard built into PennyLane -@qml.qnode(dev, interface="autograd") +@qml.qnode(dev) def hadamard(state): if state == 1: @@ -459,7 +459,7 @@ def hadamard(state): # A similar exercise can be done for the :math:`T` gate: -@qml.qnode(dev, interface="autograd") +@qml.qnode(dev) def ion_Tgate(state): if state == 1: @@ -472,7 +472,7 @@ def ion_Tgate(state): return qml.state() -@qml.qnode(dev, interface="autograd") +@qml.qnode(dev) def tgate(state): if state == 1: @@ -504,7 +504,7 @@ def tgate(state): import matplotlib.pyplot as plt -@qml.qnode(dev, interface="autograd") +@qml.qnode(dev) def evolution_prob(t): qml.QubitUnitary(evolution(0, t / Omega), wires=0) @@ -513,7 +513,7 @@ def evolution_prob(t): t = np.linspace(0, 4 * np.pi, 101) -s = [evolution_prob(i)[1].numpy() for i in t] +s = [evolution_prob(i)[1] for i in t] fig1, ax1 = plt.subplots(figsize=(9, 6)) @@ -811,7 +811,7 @@ def Molmer_Sorensen(t): dev2 = qml.device("default.qubit",wires=2) -@qml.qnode(dev2, interface="autograd") +@qml.qnode(dev2) def ion_cnot(basis_state): #Prepare the two-qubit basis states from the input @@ -827,7 +827,7 @@ def ion_cnot(basis_state): return qml.state() #Compare with built-in CNOT -@qml.qnode(dev2, interface="autograd") +@qml.qnode(dev2) def cnot_gate(basis_state): qml.BasisState(basis_state, wires=range(2)) diff --git a/demonstrations/tutorial_vqt.py b/demonstrations/tutorial_vqt.py index 278cb2e783..2e2c53b939 100644 --- a/demonstrations/tutorial_vqt.py +++ b/demonstrations/tutorial_vqt.py @@ -110,7 +110,6 @@ import pennylane as qml from matplotlib import pyplot as plt import numpy as np -from numpy import array import scipy from scipy.optimize import minimize import networkx as nx From ecf7c0795b3b054c0c0352261edfe1086b730e20 Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 19 Sep 2024 15:04:24 -0400 Subject: [PATCH 06/13] Temporarily suppress top level legacy device warning --- conf.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/conf.py b/conf.py index c8a9239f6e..b48fe2bb47 100644 --- a/conf.py +++ b/conf.py @@ -110,6 +110,9 @@ # Raise PennyLane deprecation warnings as errors warnings.filterwarnings("error", category=PennyLaneDeprecationWarning) +warnings.filterwarnings( + "ignore", message="will no longer be accessible top level", category=PennyLaneDeprecationWarning +) # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] From 80f67609b8ee9b9503c2fe469e6302061a2896ba Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 19 Sep 2024 15:28:52 -0400 Subject: [PATCH 07/13] Temp warning suppression --- conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/conf.py b/conf.py index b48fe2bb47..ae1916b50e 100644 --- a/conf.py +++ b/conf.py @@ -111,7 +111,7 @@ # Raise PennyLane deprecation warnings as errors warnings.filterwarnings("error", category=PennyLaneDeprecationWarning) warnings.filterwarnings( - "ignore", message="will no longer be accessible top level", category=PennyLaneDeprecationWarning + "ignore", message="QubitDevice will no longer be accessible", category=PennyLaneDeprecationWarning ) # Add any paths that contain templates here, relative to this directory. From 8ad9bb3c6472dabfa84dd754b75684a4f130f164 Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 19 Sep 2024 16:00:35 -0400 Subject: [PATCH 08/13] Suppress even more dep warnings --- conf.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/conf.py b/conf.py index ae1916b50e..da1d1caa8e 100644 --- a/conf.py +++ b/conf.py @@ -110,9 +110,15 @@ # Raise PennyLane deprecation warnings as errors warnings.filterwarnings("error", category=PennyLaneDeprecationWarning) +warnings.filterwarnings( + "ignore", message="Device will no longer be accessible", category=PennyLaneDeprecationWarning +) warnings.filterwarnings( "ignore", message="QubitDevice will no longer be accessible", category=PennyLaneDeprecationWarning ) +warnings.filterwarnings( + "ignore", message="QutritDevice will no longer be accessible", category=PennyLaneDeprecationWarning +) # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] From 5a9b23ae5e170f2bf0a7bfbb2c5fcefbf4293a64 Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Fri, 20 Sep 2024 11:02:52 -0400 Subject: [PATCH 09/13] Address code review, change order of install in makefile --- Makefile | 2 +- conf.py | 9 --------- demonstrations/tutorial_classical_kernels.metadata.json | 2 +- demonstrations/tutorial_kernels_module.metadata.json | 2 +- demonstrations/tutorial_local_cost_functions.py | 2 +- 5 files changed, 4 insertions(+), 13 deletions(-) diff --git a/Makefile b/Makefile index 76860ac0ac..ff5c334968 100644 --- a/Makefile +++ b/Makefile @@ -76,8 +76,8 @@ environment: $$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane-cirq.git#egg=pennylane-cirq;\ $$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane-qiskit.git#egg=pennylane-qiskit;\ $$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane-qulacs.git#egg=pennylane-qulacs;\ - $$PYTHON_VENV_PATH/bin/python -m pip install --extra-index-url https://test.pypi.org/simple/ PennyLane-Lightning --pre --upgrade;\ $$PYTHON_VENV_PATH/bin/python -m pip install --extra-index-url https://test.pypi.org/simple/ PennyLane-Catalyst --pre --upgrade;\ + $$PYTHON_VENV_PATH/bin/python -m pip install --extra-index-url https://test.pypi.org/simple/ PennyLane-Lightning --pre --upgrade;\ $$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane.git#egg=pennylane;\ fi;\ fi diff --git a/conf.py b/conf.py index da1d1caa8e..c8a9239f6e 100644 --- a/conf.py +++ b/conf.py @@ -110,15 +110,6 @@ # Raise PennyLane deprecation warnings as errors warnings.filterwarnings("error", category=PennyLaneDeprecationWarning) -warnings.filterwarnings( - "ignore", message="Device will no longer be accessible", category=PennyLaneDeprecationWarning -) -warnings.filterwarnings( - "ignore", message="QubitDevice will no longer be accessible", category=PennyLaneDeprecationWarning -) -warnings.filterwarnings( - "ignore", message="QutritDevice will no longer be accessible", category=PennyLaneDeprecationWarning -) # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] diff --git a/demonstrations/tutorial_classical_kernels.metadata.json b/demonstrations/tutorial_classical_kernels.metadata.json index eae832b6cf..2b8ca1bb58 100644 --- a/demonstrations/tutorial_classical_kernels.metadata.json +++ b/demonstrations/tutorial_classical_kernels.metadata.json @@ -6,7 +6,7 @@ } ], "dateOfPublication": "2022-03-01T00:00:00+00:00", - "dateOfLastModification": "2024-09-19T00:00:00+00:00", + "dateOfLastModification": "2024-09-04T00:00:00+00:00", "categories": [ "Quantum Machine Learning" ], diff --git a/demonstrations/tutorial_kernels_module.metadata.json b/demonstrations/tutorial_kernels_module.metadata.json index 71eb88b6e3..383283de05 100644 --- a/demonstrations/tutorial_kernels_module.metadata.json +++ b/demonstrations/tutorial_kernels_module.metadata.json @@ -21,7 +21,7 @@ } ], "dateOfPublication": "2021-06-24T00:00:00+00:00", - "dateOfLastModification": "2024-08-05T00:00:00+00:00", + "dateOfLastModification": "2024-09-19T00:00:00+00:00", "categories": [ "Quantum Machine Learning" ], diff --git a/demonstrations/tutorial_local_cost_functions.py b/demonstrations/tutorial_local_cost_functions.py index eee8bf2b90..a46a63b370 100644 --- a/demonstrations/tutorial_local_cost_functions.py +++ b/demonstrations/tutorial_local_cost_functions.py @@ -59,7 +59,7 @@ """ import pennylane as qml -from pennylane import numpy as np +from pennylane import numpy as pnp import matplotlib.pyplot as plt from matplotlib.ticker import LinearLocator, FormatStrFormatter From 821f7a52edd7922f371a8d8d75cc2842837ecf58 Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Mon, 30 Sep 2024 15:24:45 -0400 Subject: [PATCH 10/13] Remove pnp --- conf.py | 3 ++ demonstrations/tutorial_kernels_module.py | 50 +++++++++---------- .../tutorial_local_cost_functions.py | 32 ++++++------ demonstrations/tutorial_tn_circuits.py | 10 ++-- 4 files changed, 49 insertions(+), 46 deletions(-) diff --git a/conf.py b/conf.py index c8a9239f6e..4e105066e1 100644 --- a/conf.py +++ b/conf.py @@ -110,6 +110,9 @@ # Raise PennyLane deprecation warnings as errors warnings.filterwarnings("error", category=PennyLaneDeprecationWarning) +warnings.filterwarnings( + "ignore", message="Device will no longer be accessible", category=PennyLaneDeprecationWarning +) # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] diff --git a/demonstrations/tutorial_kernels_module.py b/demonstrations/tutorial_kernels_module.py index 545a597f2b..22153db7bc 100644 --- a/demonstrations/tutorial_kernels_module.py +++ b/demonstrations/tutorial_kernels_module.py @@ -129,10 +129,10 @@ # training variational embedding kernels and the available functionalities # to do both in PennyLane. We of course need to start with some imports: -from pennylane import numpy as pnp +from pennylane import numpy as np import matplotlib as mpl -pnp.random.seed(1359) +np.random.seed(1359) ############################################################################## # And we proceed right away to create a dataset to work with, the @@ -144,12 +144,12 @@ def _make_circular_data(num_sectors): """Generate datapoints arranged in an even circle.""" - center_indices = pnp.array(range(0, num_sectors)) - sector_angle = 2 * pnp.pi / num_sectors + center_indices = np.array(range(0, num_sectors)) + sector_angle = 2 * np.pi / num_sectors angles = (center_indices + 0.5) * sector_angle - x = 0.7 * pnp.cos(angles) - y = 0.7 * pnp.sin(angles) - labels = 2 * pnp.remainder(pnp.floor_divide(angles, sector_angle), 2) - 1 + x = 0.7 * np.cos(angles) + y = 0.7 * np.sin(angles) + labels = 2 * np.remainder(np.floor_divide(angles, sector_angle), 2) - 1 return x, y, labels @@ -159,13 +159,13 @@ def make_double_cake_data(num_sectors): x2, y2, labels2 = _make_circular_data(num_sectors) # x and y coordinates of the datapoints - x = pnp.hstack([x1, 0.5 * x2]) - y = pnp.hstack([y1, 0.5 * y2]) + x = np.hstack([x1, 0.5 * x2]) + y = np.hstack([y1, 0.5 * y2]) # Canonical form of dataset - X = pnp.vstack([x, y]).T + X = np.vstack([x, y]).T - labels = pnp.hstack([labels1, -1 * labels2]) + labels = np.hstack([labels1, -1 * labels2]) # Canonical form of labels Y = labels.astype(int) @@ -276,7 +276,7 @@ def ansatz(x, params, wires): def random_params(num_wires, num_layers): """Generate random variational parameters in the shape for the ansatz.""" - return pnp.random.uniform(0, 2 * pnp.pi, (num_layers, 2, num_wires), requires_grad=True) + return np.random.uniform(0, 2 * np.pi, (num_layers, 2, num_wires), requires_grad=True) ############################################################################## @@ -349,7 +349,7 @@ def kernel(x1, x2, params): init_kernel = lambda x1, x2: kernel(x1, x2, init_params) K_init = qml.kernels.square_kernel_matrix(X, init_kernel, assume_normalized_kernel=True) -with pnp.printoptions(precision=3, suppress=True): +with np.printoptions(precision=3, suppress=True): print(K_init) ############################################################################## @@ -385,7 +385,7 @@ def kernel(x1, x2, params): def accuracy(classifier, X, Y_target): - return 1 - pnp.count_nonzero(classifier.predict(X) - Y_target) / len(Y_target) + return 1 - np.count_nonzero(classifier.predict(X) - Y_target) / len(Y_target) accuracy_init = accuracy(svm, X, Y) @@ -399,11 +399,11 @@ def accuracy(classifier, X, Y_target): def plot_decision_boundaries(classifier, ax, N_gridpoints=14): - _xx, _yy = pnp.meshgrid(pnp.linspace(-1, 1, N_gridpoints), pnp.linspace(-1, 1, N_gridpoints)) + _xx, _yy = np.meshgrid(np.linspace(-1, 1, N_gridpoints), np.linspace(-1, 1, N_gridpoints)) - _zz = pnp.zeros_like(_xx) - for idx in pnp.ndindex(*_xx.shape): - _zz[idx] = classifier.predict(pnp.array([_xx[idx], _yy[idx]])[pnp.newaxis, :]) + _zz = np.zeros_like(_xx) + for idx in np.ndindex(*_xx.shape): + _zz[idx] = classifier.predict(np.array([_xx[idx], _yy[idx]])[np.newaxis, :]) plot_data = {"_xx": _xx, "_yy": _yy, "_zz": _zz} ax.contourf( @@ -534,15 +534,15 @@ def target_alignment( ) if rescale_class_labels: - nplus = pnp.count_nonzero(pnp.array(Y) == 1) + nplus = np.count_nonzero(np.array(Y) == 1) nminus = len(Y) - nplus - _Y = pnp.array([y / nplus if y == 1 else y / nminus for y in Y]) + _Y = np.array([y / nplus if y == 1 else y / nminus for y in Y]) else: - _Y = pnp.array(Y) + _Y = np.array(Y) - T = pnp.outer(_Y, _Y) - inner_product = pnp.sum(K * T) - norm = pnp.sqrt(pnp.sum(K * K) * pnp.sum(T * T)) + T = np.outer(_Y, _Y) + inner_product = np.sum(K * T) + norm = np.sqrt(np.sum(K * K) * np.sum(T * T)) inner_product = inner_product / norm return inner_product @@ -553,7 +553,7 @@ def target_alignment( for i in range(500): # Choose subset of datapoints to compute the KTA on. - subset = pnp.random.choice(list(range(len(X))), 4) + subset = np.random.choice(list(range(len(X))), 4) # Define the cost function for optimization cost = lambda _params: -target_alignment( X[subset], diff --git a/demonstrations/tutorial_local_cost_functions.py b/demonstrations/tutorial_local_cost_functions.py index a46a63b370..c07a18f8c1 100644 --- a/demonstrations/tutorial_local_cost_functions.py +++ b/demonstrations/tutorial_local_cost_functions.py @@ -59,11 +59,11 @@ """ import pennylane as qml -from pennylane import numpy as pnp +from pennylane import numpy as np import matplotlib.pyplot as plt from matplotlib.ticker import LinearLocator, FormatStrFormatter -pnp.random.seed(42) +np.random.seed(42) ###################################################################### # Visualizing the problem @@ -128,7 +128,7 @@ def local_cost_simple(rotations): local_circuit = qml.QNode(local_cost_simple, dev, interface="autograd") def cost_local(rotations): - return 1 - pnp.sum([i for (i, _) in local_circuit(rotations)]) / wires + return 1 - np.sum([i for (i, _) in local_circuit(rotations)]) / wires def cost_global(rotations): return 1 - global_circuit(rotations)[0] @@ -140,8 +140,8 @@ def cost_global(rotations): # parameters for each rotation. # -RX = pnp.random.uniform(low=-pnp.pi, high=pnp.pi) -RY = pnp.random.uniform(low=-pnp.pi, high=pnp.pi) +RX = np.random.uniform(low=-np.pi, high=np.pi) +RY = np.random.uniform(low=-np.pi, high=np.pi) rotations = [[RX for i in range(wires)], [RY for i in range(wires)]] @@ -179,9 +179,9 @@ def generate_surface(cost_function): Z = [] Z_assembler = [] - X = pnp.arange(-pnp.pi, pnp.pi, 0.25) - Y = pnp.arange(-pnp.pi, pnp.pi, 0.25) - X, Y = pnp.meshgrid(X, Y) + X = np.arange(-np.pi, np.pi, 0.25) + Y = np.arange(-np.pi, np.pi, 0.25) + X, Y = np.meshgrid(X, Y) for x in X[0, :]: for y in Y[:, 0]: @@ -190,13 +190,13 @@ def generate_surface(cost_function): Z.append(Z_assembler) Z_assembler = [] - Z = pnp.asarray(Z) + Z = np.asarray(Z) return Z def plot_surface(surface): - X = pnp.arange(-pnp.pi, pnp.pi, 0.25) - Y = pnp.arange(-pnp.pi, pnp.pi, 0.25) - X, Y = pnp.meshgrid(X, Y) + X = np.arange(-np.pi, np.pi, 0.25) + Y = np.arange(-np.pi, np.pi, 0.25) + X, Y = np.meshgrid(X, Y) fig = plt.figure() ax = fig.add_subplot(111, projection="3d") surf = ax.plot_surface(X, Y, surface, cmap="viridis", linewidth=0, antialiased=False) @@ -286,7 +286,7 @@ def cost_global(rotations): # landscape is :math:`(\pi,0)` as it is in the middle of the plateau, so let's use that. -rotations = pnp.array([[3.] * len(range(wires)), [0.] * len(range(wires))], requires_grad=True) +rotations = np.array([[3.] * len(range(wires)), [0.] * len(range(wires))], requires_grad=True) opt = qml.GradientDescentOptimizer(stepsize=0.2) steps = 100 params_global = rotations @@ -308,7 +308,7 @@ def cost_global(rotations): # function and see how it performs. # -rotations = pnp.array([[3. for i in range(wires)], [0. for i in range(wires)]], requires_grad=True) +rotations = np.array([[3. for i in range(wires)], [0. for i in range(wires)]], requires_grad=True) opt = qml.GradientDescentOptimizer(stepsize=0.2) steps = 100 params_local = rotations @@ -449,7 +449,7 @@ def cost_tunable(rotations): print("--- New run! ---") has_been_trained = False - params_global = pnp.random.uniform(-pnp.pi, pnp.pi, (2, wires), requires_grad=True) + params_global = np.random.uniform(-np.pi, np.pi, (2, wires), requires_grad=True) for i in range(steps): # update the circuit parameters @@ -483,7 +483,7 @@ def cost_tunable(rotations): print("--- New run! ---") has_been_trained = False - params_tunable = pnp.random.uniform(-pnp.pi, pnp.pi, (2, wires), requires_grad=True) + params_tunable = np.random.uniform(-np.pi, np.pi, (2, wires), requires_grad=True) for i in range(steps): # update the circuit parameters params_tunable = opt.step(cost_tunable, params_tunable) diff --git a/demonstrations/tutorial_tn_circuits.py b/demonstrations/tutorial_tn_circuits.py index bc6c3f5628..7d80052e6e 100644 --- a/demonstrations/tutorial_tn_circuits.py +++ b/demonstrations/tutorial_tn_circuits.py @@ -116,9 +116,9 @@ of tensors in the network. """ -import numpy as np +import numpy as onp import pennylane as qml -from pennylane import numpy as pnp +from pennylane import numpy as np def block(weights, wires): @@ -233,8 +233,8 @@ def circuit(template_weights): shapes = qml.SimplifiedTwoDesign.shape(n_layers=1, n_wires=4) -weights = [np.random.random(size=shape) for shape in shapes] -template_weights = np.array([weights] * 3, dtype="object") +weights = [onp.random.random(size=shape) for shape in shapes] +template_weights = onp.array([weights] * 3, dtype="object") fig, ax = qml.draw_mpl(circuit, level="device")(template_weights) ############################################################################## @@ -369,7 +369,7 @@ def costfunc(params): # train the circuit over 100 iterations. This optimizer will attempt to minimize # the cost function. -params = pnp.random.random(size=[3, 2], requires_grad=True) +params = np.random.random(size=[3, 2], requires_grad=True) optimizer = qml.GradientDescentOptimizer(stepsize=0.1) for k in range(100): From 19b005a5c17150e0c79adaee65d5f2c119ee5a2f Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 3 Oct 2024 10:56:56 -0400 Subject: [PATCH 11/13] Suppress another warning coming from external plugin --- conf.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/conf.py b/conf.py index 4e105066e1..814eaaa3bb 100644 --- a/conf.py +++ b/conf.py @@ -113,6 +113,9 @@ warnings.filterwarnings( "ignore", message="Device will no longer be accessible", category=PennyLaneDeprecationWarning ) +warnings.filterwarnings( + "ignore", message="QubitDevice will no longer be accessible", category=PennyLaneDeprecationWarning +) # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] From 532bd65b90c5087b86b5605106635629e61844de Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 3 Oct 2024 15:48:23 -0400 Subject: [PATCH 12/13] Suppressing warning in demo --- conf.py | 6 ------ demonstrations/tutorial_bluequbit.py | 4 ++++ 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/conf.py b/conf.py index 814eaaa3bb..c8a9239f6e 100644 --- a/conf.py +++ b/conf.py @@ -110,12 +110,6 @@ # Raise PennyLane deprecation warnings as errors warnings.filterwarnings("error", category=PennyLaneDeprecationWarning) -warnings.filterwarnings( - "ignore", message="Device will no longer be accessible", category=PennyLaneDeprecationWarning -) -warnings.filterwarnings( - "ignore", message="QubitDevice will no longer be accessible", category=PennyLaneDeprecationWarning -) # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] diff --git a/demonstrations/tutorial_bluequbit.py b/demonstrations/tutorial_bluequbit.py index 95f74963e4..574356d8ac 100644 --- a/demonstrations/tutorial_bluequbit.py +++ b/demonstrations/tutorial_bluequbit.py @@ -41,6 +41,10 @@ import matplotlib.pyplot as plt import numpy as np +# This filter will suppress deprecation warnings for viewability +import warnings +warnings.filterwarnings("ignore", "QubitDevice", qml.PennyLaneDeprecationWarning) + def bell_pair(): qml.Hadamard(0) From d7a8ae7b48ee47ddfface8ad706ec30917a07b62 Mon Sep 17 00:00:00 2001 From: Mudit Pandey Date: Thu, 3 Oct 2024 16:21:35 -0400 Subject: [PATCH 13/13] Add back warning to conf.py --- conf.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/conf.py b/conf.py index c8a9239f6e..4e105066e1 100644 --- a/conf.py +++ b/conf.py @@ -110,6 +110,9 @@ # Raise PennyLane deprecation warnings as errors warnings.filterwarnings("error", category=PennyLaneDeprecationWarning) +warnings.filterwarnings( + "ignore", message="Device will no longer be accessible", category=PennyLaneDeprecationWarning +) # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"]