fix for Yao-0.6.0

Author: GiggleLiu

examples/Grover/Grover.jl

@@ -63,7 +63,7 @@ function single_try(oracle, gen::AbstractBlock{N}, nstep::Int; nbatch::Int) wher
         return r
     end
     reg |> checker
-    res = measure_remove!(reg, (N+1))
+    res = measure!(RemoveMeasured(), reg, (N+1))
     return res, reg
 end
 
@@ -76,7 +76,7 @@ checker = control(num_bit+1,ctrl, num_bit+1=>X)
 
 # The register is batched, with batch dimension `nshot`.
 # [`focus!`](@ref Yao.focus!) views the first 1-N qubts as system.
-# For a batched register, [`measure_remove!`](@ref Yao.measure_remove!)
+# For a batched register, [`measure!`](@ref Yao.measure!)
 # returns a vector of bitstring as output.
 
 # #### Run

examples/HHL/HHLlib.jl

@@ -56,7 +56,7 @@ function hhlcircuit(UG, n_reg::Int, C_value::Real)
     n_all = 1 + n_reg + n_b
     pe = PEBlock(UG, n_reg, n_b)
     cr = HHLCRot{n_reg+1}([2:n_reg+1...], 1, C_value)
-    chain(n_all, concentrate(n_all, pe, [2:n_all...,]), concentrate(n_all, cr, [1:(n_reg+1)...,]), concentrate(n_all, pe', [2:n_all...,]))
+    chain(n_all, subroutine(n_all, pe, [2:n_all...,]), subroutine(n_all, cr, [1:(n_reg+1)...,]), subroutine(n_all, pe', [2:n_all...,]))
 end
 
 """

examples/QCBM/Kernels.jl

@@ -1,28 +1,54 @@
 # # Quantum Circuit Born Machine
-
 using Yao, YaoExtensions
-import QuAlgorithmZoo
-include("qcbmlib.jl")
+import Yao: probs
+using QuAlgorithmZoo: Adam, update!
+
+struct QCBM{BT<:AbstractBlock, MT<:MMD}
+    circuit::BT
+    mmd::MT
+end
+
+"""generated output probability distribution"""
+function probs(qcbm::QCBM)
+    zero_state(qcbm.circuit |> nqubits) |> qcbm.circuit |> probs
+end
+
+function loss(qcbm::QCBM)
+    expect(qcbm.mmd, probs(qcbm) |> as_weights)
+end
+
+function getgrad(qcbm::QCBM)
+    expect'(qcbm.mmd, zero_state(nqubits(qcbm.circuit))=>qcbm.circuit).second
+end
 
 # ## DATA: Target Probability Distribution
 # The gaussian probability disctribution in phase space of 2^6
 nbit = 6
 N = 1<<nbit
+
+function gaussian_pdf(x, μ::Real, σ::Real)
+    pl = @. 1 / sqrt(2pi * σ^2) * exp(-(x - μ)^2 / (2 * σ^2))
+    pl / sum(pl)
+end
 pg = gaussian_pdf(1:N, N/2-0.5, N/4);
 
 # ## MODEL: Quantum Circuit and Loss
 # Using a random differentiable circuit of depth 6 for training, the kernel function is universal RBF kernel
 depth = 6
-kernel = rbf_kernel(0:N-1, 0.25)
-c = variational_circuit(nbit, depth, pair_ring(nbit)) |> autodiff(:QC);
+kernel = rbf_kernel(0.25)
+c = variational_circuit(nbit, depth, pair_ring(nbit))
 dispatch!(c, :random)
-qcbm = QCBM(c, kernel, pg);
+qcbm = QCBM(c, MMD(kernel, pg))
 
 # ## TRAINING: Adam Optimizer
 # We probide the QCBMGo! iterative interface for training
 niter = 100
 optim = Adam(lr=0.1)
-for info in QCBMGo!(qcbm, optim, niter)
-    curr_loss = loss(qcbm, info["probs"])
-    println("Step = ", info["step"], ", Loss = ", curr_loss)
+
+params = parameters(qcbm.circuit)
+for i=1:niter
+    # initialize the parameters
+    update!(params, getgrad(qcbm), optim)
+    dispatch!(qcbm.circuit, params)
+    println("Step = $i, Loss = $(loss(qcbm))")
 end

examples/QCBM/QCBM.jl

@@ -31,12 +31,12 @@ end
 function circuit_qsvd(circuit_a::AbstractBlock{Na}, circuit_b::AbstractBlock{Nb}, Nc::Int) where {Na, Nb}
     nbit = Na+Nb
     cnots = chain(control(nbit, i+Na, i=>X) for i=1:Nc)
-    c = chain(concentrate(nbit, circuit_a, 1:Na), concentrate(nbit, circuit_b, Na+1:nbit), cnots)
+    c = chain(subroutine(nbit, circuit_a, 1:Na), subroutine(nbit, circuit_b, Na+1:nbit), cnots)
 end
 
 """read QSVD results"""
 function readout_qsvd(reg::AbstractRegister, circuit_a::AbstractBlock{Na}, circuit_b::AbstractBlock{Nb}, Nc::Int) where {Na, Nb}
-    reg = copy(reg) |> concentrate(Na+Nb, circuit_a, 1:Na) |> concentrate(Na+Nb, circuit_b, Na+1:Na+Nb)
+    reg = copy(reg) |> subroutine(Na+Nb, circuit_a, 1:Na) |> subroutine(Na+Nb, circuit_b, Na+1:Na+Nb)
     _S = [select(reg, b|b<<Na).state[] for b in basis(Nc)]
     S = abs.(_S)
     order = sortperm(S, rev=true)
@@ -45,7 +45,7 @@ function readout_qsvd(reg::AbstractRegister, circuit_a::AbstractBlock{Na}, circu
 end
 
 """
-    QuantumSVD(M; kwargs...)
+    quantumSVD(M; kwargs...)
 Quantum SVD.
     * `M`, the matrix to decompose, size should be (2^Na × 2^Nb), the sum of squared spectrum must be 1.
 kwargs includes
@@ -54,7 +54,7 @@ kwargs includes
     * `maxiter`, maximum number of iterations,
     * `optimizer`, default is `Adam(lr=0.1)`.
 """
-function QuantumSVD(M::AbstractMatrix; Nc::Int=log2i(min(size(M)...)),
+function quantumSVD(M::AbstractMatrix; Nc::Int=log2i(min(size(M)...)),
         circuit_a=variational_circuit(log2i(size(M, 1))),
         circuit_b=variational_circuit(log2i(size(M, 2))),
         maxiter=200, optimizer=Adam(lr=0.1))
@@ -76,7 +76,7 @@ end
     M = reshape(rand_state(Na+Nb).state, 1<<Na, 1<<Nb)
     U_exact, S_exact, V_exact = svd(M)
 
-    U, S, V = QuantumSVD(M; maxiter=400)
+    U, S, V = quantumSVD(M; maxiter=400)
 
     @test isapprox(U*Diagonal(S)*V', M, atol=1e-2)
     @test isapprox(abs.(S), S_exact, atol=1e-2)

examples/QCBM/qcbmlib.jl

@@ -1,33 +1,78 @@
-# # Quantum GAN
-using Yao, YaoExtensions
-using Yao.ConstGate: P0
-import QuAlgorithmZoo
-using Test, Random
+using Yao
+using YaoExtensions: variational_circuit, Sequence, faithful_grad, numdiff
+using QuAlgorithmZoo: Adam, update!
+import Yao: tracedist
 
-include("QuGANlib.jl")
+"""
+Quantum GAN.
 
-# ## DATA: Target Wave Function
-# here we learn a 3 qubit state
-nbit = 3
-target_state = rand_state(nbit)
+Reference:
+    Benedetti, M., Grant, E., Wossnig, L., & Severini, S. (2018). Adversarial quantum circuit learning for pure state approximation, 1–14.
+"""
+struct QuGAN{N}
+    target::ArrayReg
+    generator::AbstractBlock{N}
+    discriminator::AbstractBlock
+    reg0::ArrayReg
+    witness_op::AbstractBlock
+    circuit::AbstractBlock
+
+    function QuGAN(target::ArrayReg, gen::AbstractBlock, dis::AbstractBlock)
+        N = nqubits(target)
+        c = Sequence([gen, addbits!(1), dis])
+        witness_op = put(N+1, (N+1)=>ConstGate.P0)
+        new{N}(target, gen, dis, zero_state(N), witness_op, c)
+    end
+end
+
+# INTERFACES
+circuit(qg::QuGAN) = qg.circuit
+loss(qg::QuGAN) = p0t(qg) - p0g(qg)
+
+function gradient(qg::QuGAN)
+    grad_gen = faithful_grad(qg.witness_op, qg.reg0 => qg.circuit)
+    grad_tar = faithful_grad(qg.witness_op, qg.target => qg.circuit[2:end])
+    ngen = nparameters(qg.generator)
+    [-grad_gen[1:ngen]; grad_tar - grad_gen[ngen+1:end]]
+end
+
+"""probability to get evidense qubit 0 on generation set."""
+p0g(qg::QuGAN) = expect(qg.witness_op, qg.reg0 => qg.circuit) |> real
+"""probability to get evidense qubit 0 on target set."""
+p0t(qg::QuGAN) = expect(qg.witness_op, qg.target => qg.circuit[2:end]) |> real
+"""generated wave function"""
+outputψ(qg::QuGAN) = copy(qg.reg0) |> qg.generator
 
-# ## MODEL: Quantum Circuit and Loss
-# using a 4-layer random differential circuit for both generator and discriminator
-# we build the qcgan setup.
+"""tracedistance between target and generated wave function"""
+tracedist(qg::QuGAN) = tracedist(qg.target, outputψ(qg))[]
+
+using Test, Random
+Random.seed!(2)
+
+nbit = 3
 depth_gen = 4
-generator = dispatch!(variational_circuit(nbit, depth_gen, pair_ring(nbit)), :random) |> autodiff(:QC);
-
-#------------------------------
-depth_disc = 4
-discriminator = dispatch!(variational_circuit(nbit+1, depth_disc, pair_ring(nbit+1)), :random) |> autodiff(:QC)
-qg = QuGAN(target_state, generator, discriminator);
-
-# ## TRAINING: Gradient Descent
-# using a proper learning parameters, we perform 1000 steps of training
-g_learning_rate=0.2
-d_learning_rate=0.5
-niter=1000
-for info in QuGANGo!(qg, g_learning_rate, d_learning_rate, niter)
-    i = info["step"]
-    (i*20)%niter==0 && println("Step = $i, Trace Distance = $(tracedist(qg)), loss = $(qg |> loss)")
+depth_dis = 4
+
+# define a QuGAN
+target = rand_state(nbit)
+generator = dispatch!(variational_circuit(nbit, depth_gen), :random)
+discriminator = dispatch!(variational_circuit(nbit+1, depth_dis), :random)
+qg = QuGAN(target, generator, discriminator)
+
+# check the gradient
+grad = gradient(qg)
+numgrad = numdiff(c->loss(qg), qg.circuit)
+@test isapprox(grad, numgrad, atol=1e-4)
+
+# learning rates for the generator and discriminator
+g_lr = 0.2
+d_lr = 0.5
+for i=1:300
+    ng = nparameters(qg.generator)
+    grad = gradient(qg)
+    dispatch!(-, qg.generator, grad[1:ng]*g_lr)
+    dispatch!(-, qg.discriminator, -grad[ng+1:end]*d_lr)
+    println("Step $i, trace distance = $(tracedist(qg))")
 end
+
+@test qg |> loss < 0.1