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])。读者可参考如何在 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")

enc = Circuit().rx('a', 0)
ham = Hamiltonian(QubitOperator('Z0'))
sim = Simulator('projectq', 1)
grad_ops = sim.get_expectation_with_grad(ham, enc,
                                         ansatz_params_name=enc.params_name)
QuantumNet = MQAnsatzOnlyLayer(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, label):
       out = self._backbone()
       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([1.]))
    if i % 20 == 0:
        print(i, ': ', res)

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

0 :  2.026558e-06
20 :  0.0073863864
40 :  0.00020515919
60 :  3.927946e-05
80 :  9.059906e-06
100 :  1.013279e-06
120 :  2.9802322e-07
140 :  0.0
160 :  0.0
180 :  0.0

RX 门的参数为： -1.7155076e-05