move QSVD to examples folder

Author: GiggleLiu

examples/PortZygote/gate_learning.jl

@@ -1,6 +1,7 @@
 using YaoExtensions, Yao
 using Test, Random
 using Optim: LBFGS, optimize
+using Optim
 
 # port the `Matrix` function to Yao's AD.
 include("zygote_patch.jl")
@@ -28,4 +29,4 @@ end
 using Random
 Random.seed!(2)
 u = rand_unitary(4)
-c = learn_u4(u)
+c = learn_u4(u; niter=150)

src/QSVD.jl renamed to examples/QSVD/QSVD.jl

@@ -1,6 +1,7 @@
-# Quantum SVD
-# Reference: https://arxiv.org/abs/1905.01353
-export QuantumSVD, circuit_qsvd, train_qsvd!, readout_qsvd
+using QuAlgorithmZoo, Yao,YaoExtensions
+using BitBasis: log2i
+using Test
+using Random, LinearAlgebra
 
 """
 Quantum singular value decomposition algorithm.
@@ -14,12 +15,12 @@ Quantum singular value decomposition algorithm.
 """
 function train_qsvd!(reg, circuit_a::AbstractBlock{Na}, circuit_b::AbstractBlock{Nb}, optimizer; Nc::Int=min(Na, Nb), maxiter::Int=100) where {Na, Nb}
     nbit = Na+Nb
-    c = circuit_qsvd(circuit_a, circuit_b, Nc) |> autodiff(:QC)   # construct a differentiable circuit for training
+    c = circuit_qsvd(circuit_a, circuit_b, Nc)
 
     obs = -mapreduce(i->put(nbit, i=>Z), +, (1:Na..., Na+Nc+1:Na+Nb...))
     params = parameters(c)
     for i = 1:maxiter
-        grad = opdiff.(() -> copy(reg) |> c, collect_blocks(Diff, c), Ref(obs))
+        grad = expect'(obs, reg => c).second
         QuAlgorithmZoo.update!(params, grad, optimizer)
         println("Iter $i, Loss = $(Na+expect(obs, copy(reg) |> c))")
         dispatch!(c, params)
@@ -54,8 +55,8 @@ kwargs includes
     * `optimizer`, default is `Adam(lr=0.1)`.
 """
 function QuantumSVD(M::AbstractMatrix; Nc::Int=log2i(min(size(M)...)),
-        circuit_a=variational_circuit(log2i(size(M, 1)), 5, pair_ring(log2i(size(M, 1)))),
-        circuit_b=variational_circuit(log2i(size(M, 2)), 5, pair_ring(log2i(size(M, 2)))),
+        circuit_a=variational_circuit(log2i(size(M, 1))),
+        circuit_b=variational_circuit(log2i(size(M, 2))),
         maxiter=200, optimizer=Adam(lr=0.1))
 
     dispatch!(circuit_a, :random)
@@ -64,3 +65,21 @@ function QuantumSVD(M::AbstractMatrix; Nc::Int=log2i(min(size(M)...)),
     train_qsvd!(reg, circuit_a, circuit_b, optimizer, Nc=Nc, maxiter=maxiter)
     readout_qsvd(reg, circuit_a, circuit_b, Nc)
 end
+
+@testset "QSVD" begin
+    Random.seed!(2)
+    # define a matrix of size (2^Na, 2^Nb)
+    Na = 2
+    Nb = 2
+
+    # the exact result
+    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)
+
+    @test isapprox(U*Diagonal(S)*V', M, atol=1e-2)
+    @test isapprox(abs.(S), S_exact, atol=1e-2)
+    @test isapprox(U'*U_exact .|> abs2, I, atol=1e-2)
+    @test isapprox(V'*V_exact .|> abs2, I, atol=1e-2)
+end

examples/QSVD/README.md

@@ -0,0 +1,2 @@
+# Quantum SVD
+## Reference: https://arxiv.org/abs/1905.01353

examples/StructureOpt/StructureOpt.jl

@@ -0,0 +1,46 @@
+using Yao, YaoExtensions
+using YaoBlocks.Optimise: replace_block
+using YaoBlocks.ConstGate
+using YaoBlocks
+using Test
+using LinearAlgebra
+
+"""
+    TODO:
+    * optimize to optimal value,
+    * if this optimal value's loss is close to `θ = 0.0`, kill it.
+"""
+performance(params, gradient) = abs.(params .* gradient)
+
+nbit = 5
+c = variational_circuit(nbit, 50)
+
+dispatch!(c, :random)
+h = heisenberg(nbit)
+cc = replace_block(x->x isa RotationGate ? Bag(x) : x, c)
+
+function train(h, c; kill_rate=0.1, kill_step=10, niter=100)
+    bags = blockfilter(b->b isa Bag && isenabled(b), c)
+    for i=1:niter
+        regδ, paramsδ = expect'(h, zero_state(nbit) => c)
+        dispatch!(-, c, 0.01 .* paramsδ)
+        loss = expect(h, zero_state(nbit)=>c) |> real
+
+        Nk = round(Int, kill_rate*length(paramsδ))
+
+        if i%kill_step == 0 && kill_rate != 0
+            ps = performance(parameters(c), paramsδ)
+            cut = sort(ps)[Nk]
+            disable_block!.(bags[ps .<= cut])
+            bags = bags[ps .> cut]
+        end
+        @show i,nparameters(c), loss
+    end
+end
+
+
+train(h, cc; kill_rate=0.01, niter=200)
+
+cr = variational_circuit(nbit, 5)
+dispatch!(cr, :random)
+train(h, cr; kill_rate=0.0, niter=200)

src/QuAlgorithmZoo.jl

@@ -8,7 +8,6 @@ include("Adam.jl")
 include("PhaseEstimation.jl")
 include("hamiltonian_solvers.jl")
 include("HadamardTest.jl")
-include("QSVD.jl")
 include("number_theory.jl")
 
 @deprecate random_diff_circuit variational_circuit