MindQuantum自定义损失函数和目标标签训练部分量子线路

MindQuantum 自定义损失函数和目标标签训练部分量子线路

MindQuantum 的默认优化方式是将目标哈密顿量期望值最小化，但这种方法有时不能满足我们的需求。下面通过一个简单的例子，展示如何通过自定义损失函数，来使网络能够按照我们的希望进行优化。

案例是将两个 RX 门作用在初始化为 $|0⟩$ 的比特 0 上，其中一个的值是指定的，另一个是变分的，目标哈密顿量为 Z0，如果采用 MindQuantum 的默认优化方式，即，使得目标哈密顿量的期望值最小，则最终的量子态将为 $|1⟩$。我们将通过自定义损失函数的方式，让线路的最终量子态为 $|0⟩$，以与默认方式的结果相区别。（如果仅仅要制备 $|0⟩$， 在默认优化方式下，可通过仅仅将目标哈密顿量变为 -Z0 就可以做到，但换成其他任务就不一定这么简单了）

下面展示了默认优化方式的结果，可见最终量子态确为 $|1⟩$。

from mindquantum import *
import numpy as np
import mindspore as ms
from mindspore import nn
from mindspore.nn import Adam, TrainOneStepCell, LossBase
ms.context.set_context(mode=ms.context.PYNATIVE_MODE, device_target="CPU")

enc = Circuit().rx('a', 0)
ham = Hamiltonian(QubitOperator('Z0'))
sim = Simulator('projectq', 1)
# sim.set_qs(np.array([0,1]))

grad_ops = sim.get_expectation_with_grad(ham, enc,
                                         ansatz_params_name=enc.params_name)
QuantumNet = MQAnsatzOnlyLayer(grad_ops)
opti = Adam(QuantumNet.trainable_params(), learning_rate=0.5)     # 需要优化的是Quantumnet中可训练的参数，学习率设为0.5
net = TrainOneStepCell(QuantumNet, opti)

for i in range(200):
    res = net()
    if i % 20 == 0:
        print(i, ': ', res)

print('\nRX 门的参数为：', QuantumNet.weight.asnumpy()[0])

0 :  [0.99986804]
20 :  [-0.8914195]
40 :  [-0.9845511]
60 :  [-0.996968]
80 :  [-0.99999636]
100 :  [-0.9999503]
120 :  [-0.99999547]
140 :  [-0.99999976]
160 :  [-1.]
180 :  [-1.]

RX 门的参数为： 3.1415355

下面采用自定义损失函数的方式，制备 $|0⟩$ 态。因量子态 $|0⟩$ 的期望值为 1，所以我们将目标标签设置为 Tensor([1])。而非变分部分的值，我们指定为 $\pi /2$。读者可参考如何在 MindSpore 下 自定义损失函数 和 WithLossCell 的方法。

from mindquantum import *
import numpy as np
import mindspore as ms
from mindspore import nn, ops, Tensor
from mindspore.nn import Adam, TrainOneStepCell, LossBase
ms.context.set_context(mode=ms.context.PYNATIVE_MODE, device_target="CPU")

encoder = Circuit().rx('theta_0', 0)
encoder.no_grad()

ansatz = Circuit().rx('theta_1', 0)
circ = encoder + ansatz

ham = Hamiltonian(QubitOperator('Z0'))
sim = Simulator('projectq', 1)
grad_ops = sim.get_expectation_with_grad(ham, circ,
                                         encoder_params_name=encoder.params_name,
                                         ansatz_params_name=ansatz.params_name)
QuantumNet = MQLayer(grad_ops)

class MyLoss(LossBase):
    def __init__(self, reduction='mean'):
        super(MyLoss, self).__init__(reduction)
        self.abs = ops.Abs()

    def construct(self, logits, label):
        out =self.abs(logits - label)
        return self.get_loss(out)

class MyWithLossCell(nn.Cell):
   def __init__(self, backbone, loss_fn):
       super(MyWithLossCell, self).__init__(auto_prefix=False)
       self._backbone = backbone
       self._loss_fn = loss_fn

   def construct(self, x, label):
       out = self._backbone(x)
       return self._loss_fn(out, label)

   @property
   def backbone_network(self):
       return self._backbone

loss = MyLoss()
net_with_criterion = MyWithLossCell(QuantumNet, loss)
opti = Adam(QuantumNet.trainable_params(), learning_rate=0.5)     # 需要优化的是Quantumnet中可训练的参数，学习率设为0.5
net = TrainOneStepCell(net_with_criterion, opti)

for i in range(200):
    res = net(Tensor([[np.pi/2]]), Tensor([1.]))
    if i % 20 == 0:
        print(i, ': ', res)

print('\nRX 门的参数为：', QuantumNet.weight.asnumpy()[0])

[WARNING] DEBUG(8884,7f4762a54740,python):2022-07-06-07:19:22.313.909 [mindspore/ccsrc/debug/debugger/debugger.cc:95] Debugger] Not enabling debugger. Debugger does not support CPU.
0 :  0.9735574
20 :  0.002192676
40 :  0.0044816732
60 :  0.00027894974
80 :  0.00012224913
100 :  1.603365e-05
120 :  8.940697e-07
140 :  0.0
160 :  0.0
180 :  0.0

RX 门的参数为： -1.5706801