From 85ef4997f1716010d6643f1bd7e1faacca779093 Mon Sep 17 00:00:00 2001 From: Qunsheng Huang Date: Wed, 27 Oct 2021 16:52:00 +0200 Subject: [PATCH 1/3] Updating gradient calculation to use in-place memory manipulation --- src/Qaintellect.jl | 3 +++ src/flux_integration.jl | 25 +++++++++++++++++++++ test/test_gradients.jl | 49 +++++++++++++++++++++++++++++++++++++++-- 3 files changed, 75 insertions(+), 2 deletions(-) diff --git a/src/Qaintellect.jl b/src/Qaintellect.jl index 69d23c4..f970081 100644 --- a/src/Qaintellect.jl +++ b/src/Qaintellect.jl @@ -71,4 +71,7 @@ export export apply +# apply_density +export + apply! end diff --git a/src/flux_integration.jl b/src/flux_integration.jl index 2fa5806..607538e 100644 --- a/src/flux_integration.jl +++ b/src/flux_integration.jl @@ -75,6 +75,20 @@ Zygote.@adjoint apply(ρ::DensityMatrix, moments::Vector{Moment}) = begin end end +# custom adjoint for applying moments to a density matrix +Zygote.@adjoint apply!(ρ::DensityMatrix, moments::Vector{Moment}) = begin + apply!(ρ, moments) + ρ, function(Δ) + if !(Δ isa DensityMatrix) + Δ = DensityMatrix(Δ[1], ρ.N) + end + dmoments, ρbar = Qaintessent.backward_density(moments, ρ, Δ) + collect_gradients(__context__, moments, dmoments) + return (ρbar, dmoments) + end +end + + # custom adjoint for applying a circuit to a density matrix Zygote.@adjoint apply(ρ::DensityMatrix, c::Circuit{N}) where {N} = begin @@ -87,6 +101,17 @@ Zygote.@adjoint apply(ρ::DensityMatrix, c::Circuit{N}) where {N} = begin end end +# custom adjoint for applying a circuit to a density matrix +Zygote.@adjoint apply!(ρ::DensityMatrix, c::Circuit{N}) where {N} = begin + @assert(ρ.N == N) + apply!(ρ, c), function(Δ) + # TODO: don't recompute apply(c, ρ) here + dc, ρbar = Qaintessent.gradients!(c, ρ, Δ) + collect_gradients(__context__, c, dc) + return (ρbar, dc) + end +end + # custom adjoint for DensityMatrix constructor; setting gradient with respect to integer `N` to zero. Zygote.@adjoint DensityMatrix(v::AbstractVector{<:Real}, N::Integer) = DensityMatrix(v, N), ρbar -> (ρbar.v, 0) diff --git a/test/test_gradients.jl b/test/test_gradients.jl index edb1322..4414956 100644 --- a/test/test_gradients.jl +++ b/test/test_gradients.jl @@ -99,11 +99,11 @@ end ρ = density_from_statevector(ψ) grads = Flux.gradient(() -> dot(Δ.v, apply(ρ, c.moments).v), Flux.Params([rz.θ, ps.ϕ, ry.θ, rg.nθ])) - # arguments used implicitly via references f(args...) = dot(Δ.v, apply(ρ, c.moments).v) @test all(isapprox.(ngradient(f, rz.θ, ps.ϕ, ry.θ, rg.nθ), - (grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ]), rtol=1e-5, atol=1e-5)) + (grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ]), rtol=1e-5, atol=1e-5)) + end @@ -118,6 +118,7 @@ end f(args...) = dot(Δ, apply(ρ, c)) @test all(isapprox.(ngradient(f, rz.θ, ps.ϕ, ry.θ, rg.nθ), (grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ]), rtol=1e-5, atol=1e-5)) + end @testset "circuit with measurement gradients for parametric density matrices" begin @@ -131,6 +132,50 @@ end @test all(isapprox.(ngradient(f, θopt, rz.θ, ps.ϕ, ry.θ, rg.nθ), (grads[θopt], grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ]), rtol=1e-5, atol=1e-5)) + end + @testset "moments chain gradients for density matrices" begin + # fictitious gradients of cost function with respect to output density matrix + Δ = DensityMatrix(0.1*randn(Float64, 256), 4) + + ρ = density_from_statevector(ψ) + + grads = Flux.gradient(() -> dot(Δ.v, apply!(deepcopy(ρ), c.moments).v), Flux.Params([rz.θ, ps.ϕ, ry.θ, rg.nθ])) + # arguments used implicitly via references + f(args...) = dot(Δ.v, apply(ρ, c.moments).v) + @test all(isapprox.(ngradient(f, rz.θ, ps.ϕ, ry.θ, rg.nθ), + (grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ]), rtol=1e-5, atol=1e-5)) + end + + @testset "circuit with measurement gradients for density matrices" begin + # fictitious gradients of cost function with respect to circuit output + Δ = [0.3, -1.2] + ρ = density_from_statevector(ψ) + + grads = Flux.gradient(() -> dot(Δ, apply!(deepcopy(ρ), c)), Flux.Params([rz.θ, ps.ϕ, ry.θ, rg.nθ])) + + # arguments used implicitly via references + f(args...) = dot(Δ, apply(ρ, c)) + println() + println(ngradient(f, rz.θ, ps.ϕ, ry.θ, rg.nθ)) + println((grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ])) + @test all(isapprox.(ngradient(f, rz.θ, ps.ϕ, ry.θ, rg.nθ), + (grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ]), rtol=1e-5, atol=1e-5)) + + end + + @testset "circuit with measurement gradients for parametric density matrices" begin + Δ = [0.3, -1.2] + latent_density(θlist) = DensityMatrix(kron([[1-cos(θ), 0, 0, cos(θ)] for θ in θlist]...), length(θlist)) + θopt = π/2 * (1 .+ 0.5*randn(N)) + + grads = Flux.gradient(() -> dot(Δ, apply!(latent_density(θopt), c)), Flux.Params([θopt, rz.θ, ps.ϕ, ry.θ, rg.nθ])) + + f(args...) = dot(Δ, apply(latent_density(θopt), c)) + + @test all(isapprox.(ngradient(f, θopt, rz.θ, ps.ϕ, ry.θ, rg.nθ), + (grads[θopt], grads[rz.θ], grads[ps.ϕ], grads[ry.θ], grads[rg.nθ]), rtol=1e-5, atol=1e-5)) + + end end \ No newline at end of file From cbec45bfffb7d047697f4b60977127f6b1b8675a Mon Sep 17 00:00:00 2001 From: Qunsheng Huang Date: Tue, 15 Feb 2022 19:53:55 +0100 Subject: [PATCH 2/3] Updated ipynb notebooks --- examples/qaoa_example.ipynb | 975 +----------------- examples/training_example1.ipynb | 43 +- examples/training_example2.ipynb | 136 +-- examples/vqt_example.ipynb | 1648 +++++++++++++++--------------- 4 files changed, 906 insertions(+), 1896 deletions(-) diff --git a/examples/qaoa_example.ipynb b/examples/qaoa_example.ipynb index c242b96..1ab7502 100644 --- a/examples/qaoa_example.ipynb +++ b/examples/qaoa_example.ipynb @@ -34,18 +34,7 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Info: Precompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]\n", - "└ @ Base loading.jl:1278\n", - "┌ Info: Precompiling LaTeXStrings [b964fa9f-0449-5b57-a5c2-d3ea65f4040f]\n", - "└ @ Base loading.jl:1278\n" - ] - } - ], + "outputs": [], "source": [ "# visualization\n", "using Plots\n", @@ -71,7 +60,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -81,7 +69,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -163,7 +150,7 @@ "outputs": [], "source": [ "# define uniform superposition state s\n", - "s_uni = fill(1/√(2^n) + 0.0im, 2^n);" + "s_uni = convert(Vector{ComplexQ}, fill(1/√(2^n) + 0.0im, 2^n));" ] }, { @@ -245,7 +232,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "diag(Cmat) = Complex{Float64}[0.0 + 0.0im, 1.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 4.0 + 0.0im, 5.0 - 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 5.0 - 0.0im, 4.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im]\n" + "diag(Cmat) = ComplexF64[0.0 + 0.0im, 1.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 4.0 + 0.0im, 5.0 - 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 5.0 - 0.0im, 4.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 3.0 + 0.0im, 2.0 + 0.0im, 2.0 + 0.0im, 3.0 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im]\n" ] } ], @@ -299,8 +286,8 @@ { "data": { "text/plain": [ - "1-element Array{Float64,1}:\n", - " 2.499208652309536" + "1-element Vector{Float32}:\n", + " 2.4999192" ] }, "execution_count": 8, @@ -329,9 +316,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "apply(s_uni, circ1) = [2.5001403700650973]\n", - "apply(s_uni, circ1) = [3.9999999999999973]\n", - "apply(s_uni, circ1) = [4.0]\n" + "(apply(s_uni, circ1))[1] = 2.5000854f0\n", + "(apply(s_uni, circ1))[1] = 3.9999993f0\n", + "(apply(s_uni, circ1))[1] = 3.9999988f0\n" ] } ], @@ -350,7 +337,7 @@ "opt = Descent(0.5)\n", "\n", "# define evaluation function\n", - "evalcb() = @show(apply(s_uni, circ1))\n", + "evalcb() = @show(apply(s_uni, circ1)[1])\n", "\n", "# perform minimization with the negated target function to achieve maximization\n", "Flux.train!(() -> -apply(s_uni, circ1)[1], paras, data, opt, cb=Flux.throttle(evalcb, 0.5))" @@ -380,467 +367,18 @@ "outputs": [ { "data": { - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] + "image/png": "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" }, - "execution_count": 11, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "tags = [join(reverse(digits(i, pad=n, base=2))) for i in 0:2^n-1]\n", - "bar(tags, abs2.(ψ1), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)" + "bar(tags, abs2.(ψ1), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)\n", + "savefig(\"./bar.png\")\n", + "display(\"image/png\", read(\"bar.png\"))\n", + "rm(\"./bar.png\")" ] }, { @@ -852,11 +390,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "apply(s_uni, circ2) = [2.5002312727553515]\n", - "apply(s_uni, circ2) = [4.999920933578631]\n", - "apply(s_uni, circ2) = [4.9999384211975295]\n", - "apply(s_uni, circ2) = [4.999949989885429]\n", - "apply(s_uni, circ2) = [4.9999587023966185]\n" + "apply(s_uni, circ2) = Float32[2.502068]\n", + "apply(s_uni, circ2) = Float32[4.9996953]\n", + "apply(s_uni, circ2) = Float32[4.999895]\n", + "apply(s_uni, circ2) = Float32[4.999957]\n", + "apply(s_uni, circ2) = Float32[4.9999776]\n", + "apply(s_uni, circ2) = Float32[4.999991]\n" ] } ], @@ -898,472 +437,18 @@ "outputs": [ { "data": { - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] + "image/png": "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" }, - "execution_count": 14, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "tags = [join(reverse(digits(i, pad=n, base=2))) for i in 0:2^n-1]\n", - "bar(tags, abs2.(ψ2), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)" + "bar(tags, abs2.(ψ2), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)\n", + "savefig(\"./bar.png\")\n", + "display(\"image/png\", read(\"bar.png\"))\n", + "rm(\"./bar.png\")" ] }, { @@ -1376,15 +461,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.5.4", + "display_name": "Julia 1.7.0", "language": "julia", - "name": "julia-1.5" + "name": "julia-1.7" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.4" + "version": "1.7.0" } }, "nbformat": 4, diff --git a/examples/training_example1.ipynb b/examples/training_example1.ipynb index 20774b7..b6a2900 100644 --- a/examples/training_example1.ipynb +++ b/examples/training_example1.ipynb @@ -17,6 +17,7 @@ "metadata": {}, "outputs": [], "source": [ + "using Qaintessent\n", "using Qaintellect\n", "using LinearAlgebra\n", "using Flux\n", @@ -57,14 +58,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "rx = RxGate([0.2852979630949063])\n", - "ry = RyGate([5.897114323717471])\n" + "rx = RxGate(Float32[0.2345506])\n", + "ry = RyGate(Float32[4.734649])\n" ] }, { "data": { "text/plain": [ - "RyGate([5.897114323717471])" + "RyGate(Float32[4.734649])" ] }, "execution_count": 2, @@ -132,15 +133,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "ψ = Complex{Float64}[1.0 + 0.0im, 0.0 + 0.0im]\n" + "ψ = ComplexF32[1.0f0 + 0.0f0im, 0.0f0 + 0.0f0im]\n" ] }, { "data": { "text/plain": [ - "2-element Array{Complex{Float64},1}:\n", - " 1.0 + 0.0im\n", - " 0.0 + 0.0im" + "2-element Vector{ComplexF32}:\n", + " 1.0f0 + 0.0f0im\n", + " 0.0f0 + 0.0f0im" ] }, "execution_count": 4, @@ -149,7 +150,7 @@ } ], "source": [ - "ψ = ComplexF64[1, 0]\n", + "ψ = ComplexQ[1, 0]\n", "e = -1\n", "@show(ψ)" ] @@ -170,9 +171,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "paras = Params([[0.2852979630949063], [5.897114323717471], \n", - " [1, 1] = 1.0+0.0im\n", - " [2, 2] = -1.0+0.0im])\n" + "paras = Params([Float32[0.2345506], Float32[4.734649], sparse([1, 2], [1, 2], ComplexF32[1.0f0 + 0.0f0im, -1.0f0 + 0.0f0im], 2, 2)])\n" ] }, { @@ -188,7 +187,7 @@ ], "source": [ "# create loss function: note that circuit `c` is applied to `x`\n", - "loss(x, y) = Flux.mse(c(x), y)\n", + "loss(x, y) = Flux.mse(apply(x, c), y)\n", "\n", "# gather parameters from Circuit\n", "paras = Flux.params(c)\n", @@ -212,8 +211,8 @@ { "data": { "text/plain": [ - "1-element Array{Float64,1}:\n", - " 1.3650695278938842" + "1-element Vector{Float32}:\n", + " 1.9868569" ] }, "execution_count": 6, @@ -243,7 +242,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "loss(ψ, e) = 2.094566636677492\n" + "loss(ψ, e) = 0.4340008f0\n" ] } ], @@ -259,9 +258,7 @@ { "data": { "text/plain": [ - "Params([[-0.06611831314621944], [3.1552160317265447], \n", - " [1, 1] = 1.0+0.0im\n", - " [2, 2] = -1.0+0.0im])" + "Params([Float32[0.00041586455], Float32[3.1005328], sparse([1, 2], [1, 2], ComplexF32[1.0f0 + 0.0f0im, -1.0f0 + 0.0f0im], 2, 2)])" ] }, "execution_count": 8, @@ -289,8 +286,8 @@ { "data": { "text/plain": [ - "1-element Array{Float64,1}:\n", - " -0.9977223864977636" + "1-element Vector{Float32}:\n", + " -0.9991572" ] }, "execution_count": 9, @@ -305,15 +302,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.5.4", + "display_name": "Julia 1.7.0", "language": "julia", - "name": "julia-1.5" + "name": "julia-1.7" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.4" + "version": "1.7.0" } }, "nbformat": 4, diff --git a/examples/training_example2.ipynb b/examples/training_example2.ipynb index 8029969..294a0db 100644 --- a/examples/training_example2.ipynb +++ b/examples/training_example2.ipynb @@ -13,71 +13,9 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[?25l\u001b[2K" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m git-repo `https://github.com/Qaintum/Qaintessent.jl`\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[?25h" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[?25l\u001b[2K" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[?25h" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Warning: Some registries failed to update:\n", - "│ — /home/ga53vuw/.julia/registries/General — failed to fetch from repo\n", - "└ @ Pkg.Types /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/Pkg/src/Types.jl:1194\n", - "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", - "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `/import/home/ga53vuw/Documents/PhD/projects/QAI/Qaintellect.jl/Project.toml`\n", - "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `/import/home/ga53vuw/Documents/PhD/projects/QAI/Qaintellect.jl/Manifest.toml`\n" - ] - } - ], + "outputs": [], "source": [ - "using Pkg; Pkg.add(url=\"https://github.com/Qaintum/Qaintessent.jl\");\n", + "using Qaintessent\n", "using Qaintellect\n", "using LinearAlgebra\n", "using Flux\n", @@ -100,7 +38,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "rg = RotationGate([-0.3770941769323742, -0.18191239085016125, -0.4684997756909257])\n" + "rg = RotationGate(Float32[-0.53703034, 0.05597703, -0.3213241])\n" ] }, { @@ -127,7 +65,7 @@ "N = 4\n", "\n", "ry = RyGate(√2)\n", - "n = randn(Float64, 3)\n", + "n = randn(FloatQ, 3)\n", "n /= norm(n)\n", "rg = RotationGate(0.2π, n)\n", "@show(rg)\n", @@ -153,49 +91,7 @@ { "data": { "text/plain": [ - "Params([[4.71238898038469], [0.3], [-0.3770941769323742, -0.18191239085016125, -0.4684997756909257], \n", - " [1 , 1] = 1.0+0.0im\n", - " [2 , 2] = 1.0+0.0im\n", - " [3 , 3] = 1.0+0.0im\n", - " [4 , 4] = 1.0+0.0im\n", - " [5 , 5] = 1.0+0.0im\n", - " [6 , 6] = 1.0+0.0im\n", - " [7 , 7] = 1.0+0.0im\n", - " [8 , 8] = 1.0+0.0im\n", - " [9 , 9] = 1.0+0.0im\n", - " [10, 10] = 1.0+0.0im\n", - " [11, 11] = 1.0+0.0im\n", - " [12, 12] = 1.0+0.0im\n", - " [13, 13] = 1.0+0.0im\n", - " [14, 14] = 1.0+0.0im\n", - " [15, 15] = 1.0+0.0im\n", - " [16, 16] = 1.0+0.0im, \n", - " [1 , 1] = 0.412232+0.0im\n", - " [2 , 1] = 1.12021-0.256048im\n", - " [3 , 1] = 0.302475+0.717748im\n", - " [4 , 1] = -2.45391-0.991839im\n", - " [5 , 1] = -0.84334+0.657044im\n", - " [6 , 1] = -0.843339+0.632229im\n", - " [7 , 1] = -1.27159+1.11835im\n", - " [8 , 1] = -0.360019-0.698453im\n", - " [9 , 1] = -1.21463-0.462286im\n", - " [10, 1] = 0.246136+0.40925im\n", - " [11, 1] = 0.614472+0.0312881im\n", - " [12, 1] = -0.301658+0.415073im\n", - " ⋮\n", - " [4 , 16] = -0.282751-1.06899im\n", - " [5 , 16] = -1.55817+1.4844im\n", - " [6 , 16] = 0.24081-0.161829im\n", - " [7 , 16] = -0.475453-0.114766im\n", - " [8 , 16] = 0.233323+0.248452im\n", - " [9 , 16] = -0.303145+0.68772im\n", - " [10, 16] = -1.31163-0.0208782im\n", - " [11, 16] = -0.145369-0.0330198im\n", - " [12, 16] = -1.20301-0.620426im\n", - " [13, 16] = 0.446624+1.19501im\n", - " [14, 16] = -1.15907+0.118706im\n", - " [15, 16] = 1.05218-0.523801im\n", - " [16, 16] = 1.56749+0.0im])" + "Params([Float32[4.712389], Float32[0.3], Float32[-0.53703034, 0.05597703, -0.3213241], sparse([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], ComplexF32[1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im, 1.0f0 + 0.0f0im], 16, 16), sparse([1, 2, 3, 4, 5, 6, 7, 8, 9, 10 … 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1 … 16, 16, 16, 16, 16, 16, 16, 16, 16, 16], ComplexF32[-1.4366738f0 + 0.0f0im, 0.03560376f0 - 0.6054848f0im, -0.527578f0 - 0.27173388f0im, -1.3991385f0 - 1.1131895f0im, -1.1278617f0 - 0.37390763f0im, 0.75828916f0 - 0.37697834f0im, -0.17399871f0 + 0.68030006f0im, -0.9440648f0 - 0.098141216f0im, 0.24595958f0 + 0.6661913f0im, -0.4319537f0 - 0.27240527f0im … 1.8054765f0 + 0.6945263f0im, 0.7939487f0 - 0.21607582f0im, 0.027468143f0 + 0.08795561f0im, 0.9270779f0 + 0.29685333f0im, -0.1285605f0 - 0.32457453f0im, 0.6224388f0 + 0.89071685f0im, 0.1555624f0 - 0.021069005f0im, -0.5535621f0 + 0.8260739f0im, -0.20685427f0 - 1.1576917f0im, -0.72568375f0 + 0.0f0im], 16, 16)])" ] }, "execution_count": 3, @@ -228,16 +124,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "Initial model evaluation: -0.6411689764188402, target: 0.65\n", - "loss(ψ, e) = 3.2547793683377075\n", - "loss(ψ, e) = 7.703719777548943e-30\n", - "Final model evaluation: 0.6500000000000004, target: 0.65\n" + "Initial model evaluation: -0.5137484192848205, target: 0.65\n", + "loss(ψ, e) = 4.427609752931719\n", + "loss(ψ, e) = 1.1252841773625583e-5\n", + "loss(ψ, e) = 1.1828014123388259e-11\n", + "loss(ψ, e) = 2.1850610211407502e-12\n", + "Final model evaluation: 0.6499985218048095, target: 0.65\n" ] } ], "source": [ "# input quantum state\n", - "ψ = randn(ComplexF64, 2^N)\n", + "ψ = randn(ComplexQ, 2^N)\n", "ψ /= norm(ψ)\n", "\n", "# desired output\n", @@ -268,8 +166,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "ry = RyGate([1.4142135623730951])\n", - "rg = RotationGate([2.2792445765601532, 14.620422188462491, 4.557172204234055])\n" + "ry = RyGate(Float32[1.4142135])\n", + "rg = RotationGate(Float32[2.4036388, -1.0326958, -0.18446656])\n" ] } ], @@ -284,15 +182,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.5.3", + "display_name": "Julia 1.7.0", "language": "julia", - "name": "julia-1.5" + "name": "julia-1.7" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.3" + "version": "1.7.0" } }, "nbformat": 4, diff --git a/examples/vqt_example.ipynb b/examples/vqt_example.ipynb index 6ee7902..712e114 100644 --- a/examples/vqt_example.ipynb +++ b/examples/vqt_example.ipynb @@ -105,7 +105,7 @@ { "data": { "text/plain": [ - "6×6 BitArray{2}:\n", + "6×6 BitMatrix:\n", " 0 1 1 0 0 0\n", " 1 0 0 1 0 0\n", " 1 0 0 1 1 0\n", @@ -131,7 +131,7 @@ { "data": { "text/plain": [ - "1×6 Array{Int64,2}:\n", + "1×6 Matrix{Int64}:\n", " 2 2 3 3 2 2" ] }, @@ -228,7 +228,7 @@ { "data": { "text/plain": [ - "6×6 BitArray{2}:\n", + "6×6 BitMatrix:\n", " 0 1 0 0 0 0\n", " 1 0 0 0 0 0\n", " 0 0 0 1 0 0\n", @@ -254,7 +254,7 @@ { "data": { "text/plain": [ - "6×6 BitArray{2}:\n", + "6×6 BitMatrix:\n", " 0 0 1 0 0 0\n", " 0 0 0 1 0 0\n", " 1 0 0 0 1 0\n", @@ -430,162 +430,162 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -596,7 +596,7 @@ ], "source": [ "# show eigenvalues\n", - "scatter(eigvals(Matrix(H)), xlabel=L\"i\", ylabel=L\"\\lambda_i\", legend=false)" + "fig = scatter(eigvals(Matrix(H)), xlabel=L\"i\", ylabel=L\"\\lambda_i\", legend=false)" ] }, { @@ -630,7 +630,7 @@ { "data": { "text/plain": [ - "-5.974568533204814" + "-5.974568533204815" ] }, "execution_count": 18, @@ -676,7 +676,7 @@ { "data": { "text/plain": [ - "Array{Float64,2}" + "Matrix{Float64} (alias for Array{Float64, 2})" ] }, "execution_count": 20, @@ -697,7 +697,7 @@ { "data": { "text/plain": [ - "-5.551115123125783e-16" + "-3.3306690738754696e-16" ] }, "execution_count": 21, @@ -721,104 +721,104 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", "\n", + "\" transform=\"translate(514, 186)\"/>\n", "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", + "\n", "\n", "\n", - "\n", "\n" ] @@ -1333,7 +1333,7 @@ { "data": { "text/plain": [ - "DensityMatrix([1.0, 0.0, 0.0, 0.38268343236508984, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5000000000000001, 0.0, 0.0, 0.19134171618254497], 2)" + "DensityMatrix(Float32[1.0, 0.0, 0.0, 0.38268343, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.19134171], 2, Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])" ] }, "execution_count": 28, @@ -1417,90 +1417,90 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", "\n" ] @@ -1567,13 +1567,13 @@ { "data": { "text/plain": [ - "6-element Array{Float64,1}:\n", - " 1.868359801242441\n", - " 1.060389067387116\n", - " 0.6242057421026134\n", - " 1.4731764371932827\n", - " 0.8061934487488968\n", - " 0.9868069670558753" + "6-element Vector{Float64}:\n", + " 2.0318529706098656\n", + " 2.717020097618788\n", + " 0.9989301137413403\n", + " 1.827423480478452\n", + " 1.0620257822930346\n", + " 1.703306429578291" ] }, "execution_count": 34, @@ -1594,7 +1594,7 @@ { "data": { "text/plain": [ - "-3.454346355247991" + "-3.4045424285034054" ] }, "execution_count": 35, @@ -1615,7 +1615,7 @@ { "data": { "text/plain": [ - "-8.881784197001252e-16" + "-7.304052225265423e-7" ] }, "execution_count": 36, @@ -1659,7 +1659,7 @@ { "data": { "text/plain": [ - "0.19579532341343417" + "0.1580962285190922" ] }, "execution_count": 38, @@ -1687,7 +1687,7 @@ { "data": { "text/plain": [ - "Params([[-0.032689516897612896, 0.11723480881283915, -0.045725107158529676], [-0.001520505936978918, -0.2860597192812869, -0.14517933263127242], [-0.044905983990877814, 0.13584324485124732, 0.16067012148353474], [0.35345577510743387, 0.1522511129504494, -0.02784330896229452], [0.14938863218235993, -0.10540393806198983, -0.2095642486984505], [0.22021717064502935, -0.036630740017564944, 0.39804581190311705], [-0.10968491520044701], [0.025272938605999738], [-0.23647154235046933], [-0.008800429124181719], [0.13451804982256704], [-0.030642555602742146], [0.014644393047936886], [-0.057949370924255984], [0.1788031093792638], [0.22130813368007962, 0.10181161281624457, 0.349895172414667], [0.05207820405618892, 0.25992990214146633, -0.4411003513588946], [0.17938794853556728, -0.1422455891426142, 0.23752073528613366], [0.1827189357647708, 0.06580117281617619, -0.11518921080548353], [0.1934973944083283, -0.2508076153066435, 0.08224480669615179], [-0.2418979625048874, 0.05148535176720055, -0.13629890988859208], [0.20154963994502484], [-0.26568141081417873], [-0.08761099891259813], [0.1280957061798972], [0.007924579668396676], [-0.25767063818741], [0.06986301428225668, 0.06457884259329327, 0.13931701987728934], [-0.2927576981293754, 0.012127849247136904, 0.04039834409483199], [-0.08067003549566268, 0.05980143027399572, 0.02477438869423316], [-0.21836335540308946, 0.1432329812663253, -0.3286515748333684], [-0.18452433196289325, -0.023517956108989713, -0.02018594625843944], [0.009447246002819414, 0.19800582475438747, 0.20776194351880986], [0.2551887919088065], [0.3901054474244471], [-0.19189338169996753], [-0.16768827766526712], [-0.0017896557300903968], [-0.02683692482320626], [-0.0874508115842101], [0.08844939815918329], [-0.034626460405281355], [1.868359801242441, 1.060389067387116, 0.6242057421026134, 1.4731764371932827, 0.8061934487488968, 0.9868069670558753]])" + "Params([Float32[0.040983554, 0.40255836, 0.052698717], Float32[-0.18232352, -0.090331964, -0.23458481], Float32[-0.05776069, 0.26747993, -0.082058355], Float32[0.20918545, 0.021930521, -0.037663504], Float32[0.07177894, 0.4778533, 0.031728465], Float32[-0.05435562, 0.09969929, 0.12545373], Float32[0.06536225], Float32[0.06538801], Float32[-0.0025789517], Float32[0.07517289], Float32[-0.20450656], Float32[0.15270717], Float32[0.24226269], Float32[0.12700617], Float32[0.1032697], Float32[0.15523788, 0.25014, 0.023242695], Float32[-0.23708455, 0.37828633, 0.06864064], Float32[-0.29249632, -0.1975691, 0.27519658], Float32[0.20765826, 0.12546287, 0.07934507], Float32[0.025782868, -0.016668057, -0.0030892137], Float32[0.019070923, -0.2959702, -0.122801594], Float32[-0.19996083], Float32[0.16453618], Float32[-0.1413626], Float32[0.10085954], Float32[-0.38797143], Float32[-0.42302066], Float32[-0.1435571, -0.06259261, -0.09940565], Float32[0.05932232, 0.14004058, 0.14094594], Float32[-0.12282301, 0.18269998, 0.13822873], Float32[-0.16693018, -0.091183335, -0.024416452], Float32[0.12726356, -0.10762896, -0.11706082], Float32[0.02451601, -0.095727436, -0.07154836], Float32[0.25357822], Float32[0.16726197], Float32[-0.027558237], Float32[0.011515793], Float32[-0.25561082], Float32[-0.07055576], Float32[0.15574162], Float32[0.013619483], Float32[0.26867974], [2.0318529706098656, 2.717020097618788, 0.9989301137413403, 1.827423480478452, 1.0620257822930346, 1.703306429578291]])" ] }, "execution_count": 39, @@ -1714,16 +1714,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "ftarget(θopt): -3.678300721472213, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.13803943670772087\n", - "ftarget(θopt): -4.590431716959359, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.10639718308146373\n", - "ftarget(θopt): -5.01858281019304, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.11718644924475256\n", - "ftarget(θopt): -5.002687717346051, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.12493455726080116\n", - "ftarget(θopt): -5.045669006549844, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.11988221945792962\n", - "ftarget(θopt): -5.05297127716456, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.12645067129811421\n", - "ftarget(θopt): -5.075158770691137, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.1180673811268966\n", - "ftarget(θopt): -5.070433666546223, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.12884618725714092\n", - "ftarget(θopt): -5.074394808644552, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.11874443255684518\n", - "ftarget(θopt): -5.07865488439036, reference: -5.974568533204814; trdistance(θopt, σtherm): 0.11567474448335813\n" + "ftarget(θopt): -3.8078123277395046, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.09304344968001448\n", + "ftarget(θopt): -5.062739362531575, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.09923470591479783\n", + "ftarget(θopt): -5.0783605590405445, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.10650343740452659\n", + "ftarget(θopt): -5.079034989199891, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.10340607401604444\n", + "ftarget(θopt): -5.0661708497557285, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.09890088655326984\n", + "ftarget(θopt): -5.089324888199436, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.09929270270215339\n", + "ftarget(θopt): -5.100506874880439, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.09389422891624996\n", + "ftarget(θopt): -5.088653536256394, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.10653916776205019\n", + "ftarget(θopt): -5.101507146557374, reference: -5.974568533204815; trdistance(θopt, σtherm): 0.105862362889609\n" ] } ], @@ -1749,7 +1748,7 @@ { "data": { "text/plain": [ - "0.11786512992119075" + "0.09954551276510074" ] }, "execution_count": 41, @@ -1770,7 +1769,7 @@ { "data": { "text/plain": [ - "DensityMatrix([1.0, -0.2240240285540103, 0.13888467753134587, 0.23882728585700327, -0.21782546676437542, 0.11825863409919554, -0.04779808642791852, -0.10646227927716767, 0.16857608236370117, -0.07439850585505864 … -0.0005690406193910706, -0.001113420300054632, 0.0010362060028279987, -0.00017741695043474697, 0.0018412725810255813, 0.0003510349081122797, 0.0016678481598943477, -0.0007221969664301109, 0.0003841977188883014, 0.002044061874363257], 6)" + "DensityMatrix(Float32[1.0, -0.2574142, -0.22260246, -0.046752844, -0.27132773, 0.3369535, 0.09101708, -0.030676048, -0.11435073, -0.001410556 … 0.0002822072, -0.00055167964, -0.0011726355, 0.00021294449, 0.0010414027, -0.00018670928, -0.00046235285, 0.00030048873, 0.00029659903, 0.00033298373], 6, Float32[2.2f-44, 0.0, 1.7f-44, 0.0, 2.0f-44, 0.0, 2.1f-44, 0.0, 1.1f-44, 0.0 … -1.0842022f-19, 1.0699999, 0.0, 0.0, -1.0842022f-19, 1.0699999, 0.0, 0.0, -1.0842022f-19, 1.0699999])" ] }, "execution_count": 42, @@ -1794,560 +1793,598 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", "\n", + "eUYwAAAAAMozggEAAABQnhEMAAAAgPKMYAAAAACU91819YlKEtjUBwAAAABJRU5ErkJggg==\n", + "\" transform=\"translate(519, 195)\"/>\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", "\n", - "\n", "\n" ] @@ -2418,26 +2455,19 @@ "# visualize optimized density matrix\n", "heatmap(log.(max.(real(matrix(ρopt)), 1e-4)), title=L\"\\rho_{\\mathrm{opt}}\", yflip=true, aspect_ratio=:equal)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Julia 1.5.4", + "display_name": "Julia 1.7.0", "language": "julia", - "name": "julia-1.5" + "name": "julia-1.7" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.4" + "version": "1.7.0" } }, "nbformat": 4, From 0310fc26e36d6b95dab8b13665fef27e477503f7 Mon Sep 17 00:00:00 2001 From: Qunsheng Huang Date: Wed, 16 Feb 2022 09:47:41 +0100 Subject: [PATCH 3/3] Added pictures back to ipynb --- examples/qaoa_example.ipynb | 1022 ++++++++++++++++++++++++++++++++++- 1 file changed, 999 insertions(+), 23 deletions(-) diff --git a/examples/qaoa_example.ipynb b/examples/qaoa_example.ipynb index 1ab7502..4a5f47e 100644 --- a/examples/qaoa_example.ipynb +++ b/examples/qaoa_example.ipynb @@ -60,6 +60,11 @@ ] }, { + "attachments": { + "068aa9dd-70e5-4795-9d06-958de47c874b.png": { + "image/png": "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" + } + }, "cell_type": "markdown", "metadata": {}, "source": [ @@ -69,6 +74,11 @@ ] }, { + "attachments": { + "b9a93210-395f-4bad-9d8b-541b45f624c9.png": { + "image/png": "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" + } + }, "cell_type": "markdown", "metadata": {}, "source": [ @@ -287,7 +297,7 @@ "data": { "text/plain": [ "1-element Vector{Float32}:\n", - " 2.4999192" + " 2.499939" ] }, "execution_count": 8, @@ -316,9 +326,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "(apply(s_uni, circ1))[1] = 2.5000854f0\n", - "(apply(s_uni, circ1))[1] = 3.9999993f0\n", - "(apply(s_uni, circ1))[1] = 3.9999988f0\n" + "apply(s_uni, circ1) = Float32[2.50052]\n", + "apply(s_uni, circ1) = Float32[3.999999]\n", + "apply(s_uni, circ1) = Float32[3.9999993]\n" ] } ], @@ -337,7 +347,7 @@ "opt = Descent(0.5)\n", "\n", "# define evaluation function\n", - "evalcb() = @show(apply(s_uni, circ1)[1])\n", + "evalcb() = @show(apply(s_uni, circ1))\n", "\n", "# perform minimization with the negated target function to achieve maximization\n", "Flux.train!(() -> -apply(s_uni, circ1)[1], paras, data, opt, cb=Flux.throttle(evalcb, 0.5))" @@ -367,18 +377,499 @@ "outputs": [ { "data": { - "image/png": "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" + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] }, + "execution_count": 11, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ "tags = [join(reverse(digits(i, pad=n, base=2))) for i in 0:2^n-1]\n", - "bar(tags, abs2.(ψ1), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)\n", - "savefig(\"./bar.png\")\n", - "display(\"image/png\", read(\"bar.png\"))\n", - "rm(\"./bar.png\")" + "bar(tags, abs2.(ψ1), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)" ] }, { @@ -390,12 +881,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "apply(s_uni, circ2) = Float32[2.502068]\n", - "apply(s_uni, circ2) = Float32[4.9996953]\n", - "apply(s_uni, circ2) = Float32[4.999895]\n", - "apply(s_uni, circ2) = Float32[4.999957]\n", - "apply(s_uni, circ2) = Float32[4.9999776]\n", - "apply(s_uni, circ2) = Float32[4.999991]\n" + "apply(s_uni, circ2) = Float32[2.501162]\n", + "apply(s_uni, circ2) = Float32[4.9998145]\n", + "apply(s_uni, circ2) = Float32[4.999973]\n", + "apply(s_uni, circ2) = Float32[4.999996]\n", + "apply(s_uni, circ2) = Float32[4.9999986]\n" ] } ], @@ -437,18 +927,504 @@ "outputs": [ { "data": { - "image/png": "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" + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] }, + "execution_count": 14, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ "tags = [join(reverse(digits(i, pad=n, base=2))) for i in 0:2^n-1]\n", - "bar(tags, abs2.(ψ2), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)\n", - "savefig(\"./bar.png\")\n", - "display(\"image/png\", read(\"bar.png\"))\n", - "rm(\"./bar.png\")" + "bar(tags, abs2.(ψ2), xticks=:all, xrotation=45, ylabel=L\"|\\psi|^2\", legend=false)" ] }, {