用量子神经网络实现GAN

假设已有的目标量子态是一个纯态，且生成器接受的输入为|0> 制备已有的目标量子态的线路        

制备已有的目标量子态的线路

生成器的线路为

判别器的线路为

通过对判别器输出的量子态进行测量，我们可以得到将目标态判断为目标态的概率 PT和将生成态判断为目标态的概率 PG（通过对判别器连接目标态和生成器这两个不同的输入得到

安装量桨

!pip install paddle_quantum

导入相关的包

import numpy as npimport paddlefrom paddle_quantum.circuit import UAnsatzfrom paddle_quantum.utils import partial_trace, dagger, state_fidelityfrom tqdm import tqdm

模型组网

class QGAN(paddle.nn.Layer):
    def __init__(self):
        super(QGAN, self).__init__()        
        # 用以制备目标量子态的角度
        target_omega_0 = 0.9 * np.pi
        target_omega_1 = 0.2 * np.pi
        self.target_omega = paddle.to_tensor(
            np.array([target_omega_0, target_omega_1], np.float64))        
        # 生成器和判别器电路的参数
        self.gen_theta = self.create_parameter([9], 
        dtype="float64", default_initializer=paddle.nn.initializer.Uniform(
                            low=0.0, high=np.pi))
        self.disc_phi = self.create_parameter([9], 
        dtype="float64", default_initializer=paddle.nn.initializer.Uniform(
                            low=0.0, high=np.pi))        
        # 制备目标量子态
        cir = UAnsatz(3)
        cir.ry(self.target_omega[0], 0)
        cir.rz(self.target_omega[1], 0)
        self.target_state = cir.run_state_vector()    def generator(self, theta):
        """
        生成器的量子线路
        """
        cir = UAnsatz(3)
        cir.u3(*theta[:3], 0)
        cir.u3(*theta[3:6], 1)
        cir.cnot([0, 1])
        cir.u3(*theta[6:], 0)        return cir    def discriminator(self, phi):
        """
        判别器的量子线路
        """
        cir = UAnsatz(3)
        cir.u3(*phi[:3], 0)
        cir.u3(*phi[3:6], 2)
        cir.cnot([0, 2])
        cir.u3(*phi[6:], 0)        return cir    def disc_target_as_target(self):
        """
        判别器将目标态判断为目标态的概率
        """
        # 判别器电路
        cir = self.discriminator(self.disc_phi)
        cir.run_state_vector(self.target_state)        
        # 判别器对目标态的判断结果
        target_disc_output = cir.expecval([[1.0, 'z2']])
        prob_as_target = (target_disc_output + 1) / 2

        return prob_as_target    def disc_gen_as_target(self):
        """
        判别器将生成态判断为目标态的概率
        """
        # 得到生成器生成的量子态
        gen_state = self.generator(
                    self.gen_theta).run_state_vector()        # 判别器电路
        cir = self.discriminator(self.disc_phi)
        cir.run_state_vector(gen_state)        # 判别器对生成态的判断结果
        gen_disc_output = cir.expecval([[1.0, 'z2']])
        prob_as_target = (gen_disc_output + 1) / 2
        
        return prob_as_target    def forward(self, model_name):
        if model_name == 'gen':            # 计算生成器的损失函数，loss值的区间为[-1, 0]，
            # 0表示生成效果极差，为-1表示生成效果极好
            loss =  -1 * self.disc_gen_as_target()        else:            # 计算判别器的损失函数，loss值的区间为[-1, 1]，
            # 为-1表示完美区分，为0表示无法区分，为1表示区分颠倒
            loss = self.disc_gen_as_target() - self.disc_target_as_target()        return loss    def get_target_state(self):
        """
        得到目标态的密度矩阵表示
        """
        state = self.target_state
        state = paddle.reshape(state, [1] + state.shape)
        density_matrix = paddle.matmul(dagger(state), state)
        state = partial_trace(density_matrix, 2, 4, 2)        return state.numpy()    def get_generated_state(self):
        """
        得到生成态的密度矩阵表示
        """
        state = self.generator(self.gen_theta).run_state_vector()
        state = paddle.reshape(state, [1] + state.shape)
        density_matrix = paddle.matmul(dagger(state), state)
        state = partial_trace(density_matrix, 2, 4, 2)        return state.numpy()

训练模型

# 学习率LR = 0.03# 总的迭代次数ITR = 30# 每次迭代时，判别器的迭代次数ITR1 = 20# 每次迭代时，生成器的迭代次数ITR2 = 50# 用来记录loss值的变化loss_history = list()
paddle.seed(18)
gan_demo = QGAN()
optimizer = paddle.optimizer.SGD(learning_rate=LR, parameters=gan_demo.parameters())
pbar = tqdm(desc="Training: ", total=ITR * (ITR1 + ITR2), ncols=100, ascii=True)for itr0 in range(ITR):    # 记录判别器loss值的变化
    loss_disc_history = list()    # 训练判别器
    for itr1 in range(ITR1):
        pbar.update(1)
        loss_disc = gan_demo('disc')
        loss_disc.backward()
        optimizer.minimize(loss_disc, parameters=[gan_demo.disc_phi],
                           no_grad_set=[gan_demo.gen_theta])
        gan_demo.clear_gradients()
        loss_disc_history.append(loss_disc.numpy()[0])    # 记录生成器loss值的变化
    loss_gen_history = list()    # 训练生成器
    for itr2 in range(ITR2):
        pbar.update(1)
        loss_gen = gan_demo('gen')
        loss_gen.backward()
        optimizer.minimize(loss_gen, parameters=[gan_demo.gen_theta],
                           no_grad_set=[gan_demo.disc_phi])
        optimizer.clear_grad()
        loss_gen_history.append(loss_gen.numpy()[0])

    loss_history.append((loss_disc_history, loss_gen_history))
pbar.close()# 得到目标量子态target_state = gan_demo.get_target_state()# 得到生成器最终生成的量子态gen_state = gan_demo.get_generated_state()print("the density matrix of the target state:")print(target_state, "\n")print("the density matrix of the generated state:")print(gen_state, "\n")# 计算两个量子态之间的距离，# 这里的距离定义为 tr[(target_state-gen_state)^2]distance = np.trace(np.matmul(target_state-gen_state, 
                              target_state-gen_state)).real# 计算两个量子态的保真度fidelity = state_fidelity(target_state, gen_state)print("the distance between these two quantum states is", distance, "\n")print("the fidelity between these two quantum states is", fidelity)