1
class CustomFunction(torch.autograd.Function):
2
    # CustomFunction继承自torch.autograd.Function
3
    @staticmethod
4
    def forward(ctx, x, exponent=2):
5
        ctx.saved_info = {'x': x, 'exponent': exponent}
6
        return x ** exponent
7

8
    @staticmethod
9
    def backward(ctx, dy):
10
        x = ctx.saved_info['x']
11
        exponent = ctx.saved_info['exponent']
12
        print(f"Calculating the gradient with x={x}, dy={dy}, exponent={exponent}")
13
        return dy * exponent * x ** (exponent-1), None

1
@qml.qnode(dev, interface='torch', diff_method='parameter-shift')
2
def circuit(x):
3
    qml.RX(x, wires=0)
4
    return qml.probs(wires=0)

1
deferred_qnode = qml.defer_measurements(my_qnode)
2
pars = np.array([0.643, 0.246])
3
deferred_qnode(*pars)
4

5
print(qml.draw(my_qnode)(*pars)) # 原始mid-circuit测量
6
print(qml.draw(deferred_qnode)(*pars)) # deffered measurement

1
dev = qml.device("default.qubit", wires=3, shots=10)
2

3
def circ():
4
    qml.Hadamard(0)
5
    m_0 = qml.measure(0, postselect=1)
6
    return qml.sample(qml.PauliZ(0))
7

8
# 通过参数配置QNode
9
fill_shots = qml.QNode(circ, dev, mcm_method="one-shot", postselect_mode="fill-shots")
10
hw_like = qml.QNode(circ, dev, mcm_method="one-shot", postselect_mode="hw-like")

1
import pennylane as qml
2
from pennylane.templates import BasicEntanglerLayers
3
from pennylane import numpy as np
4

5
n_wires = 3
6
dev = qml.device('default.qubit', wires=n_wires)
7

8
@qml.qnode(dev)
9
def circuit(weights1,weights2):
10
    BasicEntanglerLayers(weights=weights1, wires=range(n_wires))
11
    BasicEntanglerLayers(weights=weights2, wires=range(n_wires))
12
    return qml.expval(qml.PauliZ(0))
13

14
# 读取编码层的形状
15
shape = BasicEntanglerLayers.shape(n_layers=2, n_wires=n_wires)
16

17
# 初始化BasicEntanglerLayers的参数
18
np.random.seed(42)  # to make the result reproducible
19
weights1 = np.random.random(size=shape)
20
weights2 = np.random.random(size=shape)
21

22
# 输入对应模块的参数
23
# 如果有多个模板可以添加参数
24
circuit(weights1, weights2)

1
dev = qml.device('default.qubit', wires=4)
2

3
@qml.qnode(dev, diff_method='parameter-shift')
4
def circuit(x, y):
5
    qml.RX(x[0], wires=0)
6
    qml.Toffoli(wires=(0, 1, 2))
7
    qml.CRY(x[1], wires=(0, 1))
8
    qml.Rot(x[2], x[3], y, wires=0)
9
    return qml.expval(qml.Z(0)), qml.expval(qml.X(1))

1
dev = qml.device('default.qubit')
2

3
@qml.qnode(dev)
4
def circuit(x, z):
5
    qml.QFT(wires=(0,1,2,3))
6
    qml.IsingXX(1.234, wires=(0,2))
7
    qml.Toffoli(wires=(0,1,2))
8
    mcm = qml.measure(1)
9
    mcm_out = qml.measure(2)
10
    qml.CSWAP(wires=(0,2,3))
11
    qml.RX(x, wires=0)
12
    qml.cond(mcm, qml.RY)(np.pi / 4, wires=3)
13
    qml.CRZ(z, wires=(3,0))
14
    return qml.expval(qml.Z(0)), qml.probs(op=mcm_out)
15

16
fig, ax = qml.draw_mpl(circuit)(1.2345,1.2345)
17
fig.show()

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

3
@qml.qnode(dev, interface=None)
4
def circuit():
5
    qml.Snapshot(measurement=qml.expval(qml.Z(0)))
6
    qml.Hadamard(wires=0)
7
    qml.Snapshot("very_important_state")
8
    qml.CNOT(wires=[0, 1])
9
    qml.Snapshot()
10
    return qml.expval(qml.X(0))

1
qml.snapshots(circuit)()

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

3
@qml.simplify
4
@qml.qnode(dev)
5
def circuit(x):
6
    (
7
        qml.RX(x[0], wires=0)
8
        @ qml.RY(x[1], wires=1)
9
        @ qml.RZ(x[2], wires=2)
10
        @ qml.RX(-1, wires=0)
11
        @ qml.RY(-2, wires=1)
12
        @ qml.RZ(2, wires=2)
13
    )
14
    return qml.probs([0, 1, 2])

1
from pennylane.transforms import decompose
2
from functools import partial
3

4
dev = qml.device('default.qubit')
5
allowed_gates = {qml.Toffoli, qml.RX, qml.RZ}
6

7
@partial(decompose, gate_set=allowed_gates)
8
@qml.qnode(dev)
9
def circuit():
10
    qml.Hadamard(wires=[0])
11
    qml.Toffoli(wires=[0,1,2])
12
    return qml.expval(qml.Z(0))

1
# 默认电路
2
def circuit(weights):
3
    qml.BasicEntanglerLayers(weights, wires=[0, 1, 2])
4
    return qml.expval(qml.Z(0))
5

6
# CNOT的转化规则函数
7
def custom_cnot(wires, **_):
8
    return [
9
        qml.Hadamard(wires=wires[1]),
10
        qml.CZ(wires=[wires[0], wires[1]]),
11
        qml.Hadamard(wires=wires[1])
12
    ]
13

14
# 可以将一系列规则函数，构成一个列表
15
custom_decomps = {qml.CNOT: custom_cnot}
16

17
# 使用自定义的分解方法分解逻辑门。
18
decomp_dev = qml.device("default.qubit", wires=3, custom_decomps=custom_decomps)
19
decomp_qnode = qml.QNode(circuit, decomp_dev)

1
from jax import numpy as jnp
2

3
dev = qml.device("lightning.qubit", wires=2, shots=1000)
4

5
@qml.qjit
6
@qml.qnode(dev)
7
def circuit(params): # 一个量子电路
8
    qml.Hadamard(0)
9
    qml.RX(jnp.sin(params[0]) ** 2, wires=1)
10
    qml.CRY(params[0], wires=[0, 1])
11
    qml.RX(jnp.sqrt(params[1]), wires=1)
12
    return qml.expval(qml.Z(1))

1
@qml.qjit
2
def hybrid_function(params, x):
3
    grad = qml.grad(circuit)(params) # 量子电路
4
    return jnp.abs(grad - x) ** 2 # 经典数据处理

1
@qml.qjit(autograph=True) # 设置参数
2
@qml.qnode(dev)
3
def circuit(x: int):
4
    # 使用python的控制流
5
    if x < 5:
6
        qml.Hadamard(wires=0)
7
    else:
8
        qml.T(wires=0)
9

10
    return qml.expval(qml.Z(0))