|
1 | 1 | module QAOA |
2 | 2 |
|
3 | | -using Random |
4 | | -using PythonCall: pyconvert |
| 3 | +using LinearAlgebra |
| 4 | +using PythonCall: pyconvert, pylist, pydict, pyint, pytuple, pybool, @pyexec |
5 | 5 | using ..QiskitOpt: |
6 | 6 | qiskit, |
7 | | - qiskit_optimization_algorithms, |
8 | | - qiskit_optimization_runtime, |
9 | | - quadratic_program |
10 | | -import QUBODrivers: |
11 | | - MOI, |
12 | | - QUBODrivers, |
13 | | - QUBOTools, |
14 | | - Sample, |
15 | | - SampleSet, |
16 | | - @setup, |
17 | | - sample |
18 | | - |
19 | | -@setup Optimizer begin |
20 | | - name = "IBM Qiskit QAOA" |
21 | | - sense = :min |
22 | | - domain = :bool |
23 | | - version = v"0.4.0" |
| 7 | + qiskit_ibm_runtime, |
| 8 | + qiskit_algorithms, |
| 9 | + qiskit_aer, |
| 10 | + quadratic_program, |
| 11 | + scipy, |
| 12 | + numpy |
| 13 | + |
| 14 | +using QUBO |
| 15 | +MOI = QUBODrivers.MOI |
| 16 | +Sample = QUBODrivers.Sample |
| 17 | +SampleSet = QUBODrivers.SampleSet |
| 18 | + |
| 19 | +QUBODrivers.@setup Optimizer begin |
| 20 | + name = "QAOA @ IBMQ" |
24 | 21 | attributes = begin |
25 | | - NumberOfReads["num_reads"]::Integer = 1_000 |
26 | | - RandomSeed["seed"]::Union{Integer,Nothing} = nothing |
27 | | - IBMBackend["ibm_backend"]::String = "ibmq_qasm_simulator" |
| 22 | + MaximumIterations["max_iter"]::Integer = 15 |
| 23 | + NumberOfReads["num_reads"]::Integer = 100 |
| 24 | + NumberOfLayers["num_layers"]::Integer = 1 |
| 25 | + InitialParameters["initial_parameters"]::Union{Vector{Float64}, Nothing} = nothing |
| 26 | + IBMFakeBackend["ibm_fake_backend"] = qiskit_ibm_runtime.fake_provider.FakeAlgiers |
| 27 | + IBMBackend["ibm_backend"]::Union{String, Nothing} = nothing |
| 28 | + IsLocal["is_local"]::Bool = false |
| 29 | + Entanglement["entanglement"]::String = "linear" |
| 30 | + Channel["channel"]::String = "ibm_quantum" |
| 31 | + Instance["instance"]::String = "ibm-q/open/main" |
28 | 32 | end |
29 | 33 | end |
30 | 34 |
|
31 | | -function sample(sampler::Optimizer{T}) where {T} |
| 35 | +function QUBODrivers.sample(sampler::Optimizer{T}) where {T} |
32 | 36 | # -*- Retrieve Attributes - *- |
33 | | - seed = MOI.get(sampler, QAOA.RandomSeed()) |
34 | | - num_reads = MOI.get(sampler, QAOA.NumberOfReads()) |
| 37 | + n, L, Q, α, β = QUBOTools.qubo(sampler, :dense) |
35 | 38 | ibm_backend = MOI.get(sampler, QAOA.IBMBackend()) |
36 | 39 |
|
37 | | - # -*- Retrieve Model -*- # |
38 | | - qp, α, β = quadratic_program(sampler) |
39 | | - |
40 | | - # -*- Instantiate Random Generator -*- # |
41 | | - rng = Random.Xoshiro(seed) |
42 | | - |
43 | 40 | # Results vector |
44 | | - samples = Vector{Sample{T,Int}}(undef, num_reads) |
| 41 | + samples = QUBOTools.Sample{T,Int}[] |
45 | 42 |
|
46 | | - # Timing Information |
| 43 | + # Extra Information |
47 | 44 | metadata = Dict{String,Any}( |
48 | 45 | "origin" => "IBMQ QAOA @ $(ibm_backend)", |
49 | | - "time" => Dict{String,Any}(), |
| 46 | + "time" => Dict{String,Any}(), |
| 47 | + "evals" => Vector{Float64}(), |
50 | 48 | ) |
51 | 49 |
|
52 | | - # Connect to IBMQ and get backend |
53 | | - connect(sampler) do client |
54 | | - qaoa = qiskit_optimization_algorithms.MinimumEigenOptimizer(client) |
55 | | - results = qaoa.solve(qp) |
56 | | - |
57 | | - Ψ = Vector{Int}[] |
58 | | - ρ = Float64[] |
59 | | - Λ = T[] |
| 50 | + retrieve(sampler) do result, sample_results |
| 51 | + if MOI.get(sampler, MOI.ObjectiveSense()) == MOI.MAX_SENSE |
| 52 | + α = -α |
| 53 | + end |
60 | 54 |
|
61 | | - for sample in results.samples |
| 55 | + for key in sample_results.keys() |
| 56 | + state = reverse(parse.(Int,split(pyconvert.(String, key),""))) |
| 57 | + sample = QUBOTools.Sample{T,Int}( |
62 | 58 | # state: |
63 | | - push!(Ψ, pyconvert.(Int, sample.x)) |
| 59 | + state, |
| 60 | + # energy: |
| 61 | + α * (state'* (Q+Diagonal(L)) * state + β), |
64 | 62 | # reads: |
65 | | - push!(ρ, pyconvert(Float64, sample.probability)) |
66 | | - # value: |
67 | | - push!(Λ, α * (pyconvert(T, sample.fval) + β)) |
| 63 | + pyconvert(Int, sample_results[key]) |
| 64 | + ) |
| 65 | + push!(samples, sample) |
68 | 66 | end |
69 | 67 |
|
70 | | - P = cumsum(ρ) |
71 | | - |
72 | | - for i = 1:num_reads |
73 | | - p = rand(rng) |
74 | | - j = first(searchsorted(P, p)) |
75 | | - |
76 | | - samples[i] = Sample{T}(Ψ[j], Λ[j]) |
77 | | - end |
78 | | - |
79 | | - metadata["time"]["effective"] = pyconvert( |
80 | | - Float64, |
81 | | - results.min_eigen_solver_result.optimizer_time, |
82 | | - ) |
83 | | - |
84 | 68 | return nothing |
85 | 69 | end |
86 | 70 |
|
87 | 71 | return SampleSet{T}(samples, metadata) |
88 | 72 | end |
89 | 73 |
|
90 | | -function connect( |
| 74 | +function retrieve( |
91 | 75 | callback::Function, |
92 | | - sampler::Optimizer, |
93 | | -) |
| 76 | + sampler::Optimizer{T}, |
| 77 | +) where {T} |
94 | 78 | # -*- Retrieve Attributes -*- # |
95 | | - ibm_backend = MOI.get(sampler, QAOA.IBMBackend()) |
| 79 | + max_iter = MOI.get(sampler, QAOA.MaximumIterations()) |
| 80 | + num_reads = MOI.get(sampler, QAOA.NumberOfReads()) |
| 81 | + num_layers = MOI.get(sampler, QAOA.NumberOfLayers()) |
| 82 | + ibm_backend = MOI.get(sampler, QAOA.IBMBackend()) |
| 83 | + ibm_fake_backend = MOI.get(sampler, QAOA.IBMFakeBackend()) |
| 84 | + channel = MOI.get(sampler, QAOA.Channel()) |
| 85 | + instance = MOI.get(sampler, QAOA.Instance()) |
| 86 | + initial_parameters = MOI.get(sampler, QAOA.InitialParameters()) |
| 87 | + is_local = MOI.get(sampler, QAOA.IsLocal()) |
| 88 | + |
| 89 | + @pyexec """ |
| 90 | + def cost_function(params, ansatz, hamiltonian, estimator): |
| 91 | + pub = (ansatz, [hamiltonian], [params]) |
| 92 | + result = estimator.run(pubs=[pub]).result() |
| 93 | + energy = result[0].data.evs[0] |
| 94 | + return energy |
| 95 | + """ => cost_function |
| 96 | + |
| 97 | + service = qiskit_ibm_runtime.QiskitRuntimeService( |
| 98 | + channel = channel, |
| 99 | + instance = instance, |
| 100 | + ) |
| 101 | + |
| 102 | + backend = if !isnothing(ibm_backend) |
| 103 | + _backend = service.get_backend(ibm_backend) |
| 104 | + if is_local && ibm_backend != "ibmq_qasm_simulator" |
| 105 | + qiskit_aer.AerSimulator.from_backend(_backend) |
| 106 | + else |
| 107 | + _backend |
| 108 | + end |
| 109 | + else |
| 110 | + _backend = ibm_fake_backend() |
| 111 | + is_local = true |
| 112 | + ibm_backend = _backend.backend_name |
| 113 | + _backend |
| 114 | + end |
96 | 115 |
|
97 | | - # -*- Load Credentials -*- # |
98 | | - qiskit.IBMQ.load_account() |
| 116 | + if is_local && ibm_backend != "ibmq_qasm_simulator" |
| 117 | + backend = qiskit_aer.AerSimulator.from_backend(backend) |
| 118 | + end |
99 | 119 |
|
100 | | - # -*- Connect to provider -*- # |
101 | | - provider = qiskit.IBMQ.get_provider() |
102 | | - backend = provider.get_backend(ibm_backend) |
| 120 | + ising_qp = quadratic_program(sampler) |
| 121 | + ising_hamiltonian = ising_qp[0] |
| 122 | + ansatz = qiskit.circuit.library.QAOAAnsatz( |
| 123 | + ising_hamiltonian, |
| 124 | + reps = num_layers |
| 125 | + ) |
| 126 | + |
| 127 | + # pass manager for the quantum circuit (optimize the circuit for the target device) |
| 128 | + pass_manager = qiskit.transpiler.preset_passmanagers.generate_preset_pass_manager( |
| 129 | + target = backend.target, |
| 130 | + optimization_level = 3 |
| 131 | + ) |
| 132 | + |
| 133 | + |
| 134 | + # Ansatz and Hamiltonian to ISA (Instruction Set Architecture) |
| 135 | + ansatz_isa = pass_manager.run(ansatz) |
| 136 | + ising_hamiltonian = ising_hamiltonian.apply_layout(layout = ansatz_isa.layout) |
| 137 | + |
| 138 | + |
| 139 | + if isnothing(initial_parameters) |
| 140 | + initial_parameters = numpy.empty([ansatz_isa.num_parameters]) |
| 141 | + for i in 1:pyconvert(Int, ansatz_isa.num_parameters) |
| 142 | + initial_parameters[i-1] = numpy.random.rand() |
| 143 | + end |
| 144 | + end |
| 145 | + |
| 146 | + estimator = if is_local || ibm_backend == "ibmq_qasm_simulator" |
| 147 | + qiskit_ibm_runtime.EstimatorV2(backend = backend) |
| 148 | + else |
| 149 | + session = qiskit_ibm_runtime.Session(service=service, backend=backend) |
| 150 | + qiskit_ibm_runtime.EstimatorV2(session=session) |
| 151 | + end |
| 152 | + if !is_local |
| 153 | + estimator.options.default_shots = num_reads |
| 154 | + end |
103 | 155 |
|
104 | | - # -*- Setup QAOA Client -*- # |
105 | | - client = qiskit_optimization_runtime.QAOAClient( |
106 | | - provider = provider, |
107 | | - backend = backend, |
| 156 | + println("Running QAOA on $(ibm_backend)...") |
| 157 | + scipy_options = pydict() |
| 158 | + scipy_options["maxiter"] = max_iter |
| 159 | + result = scipy.optimize.minimize( |
| 160 | + cost_function, |
| 161 | + initial_parameters, |
| 162 | + args = (ansatz_isa, ising_hamiltonian, estimator), |
| 163 | + method = "cobyla", |
| 164 | + options = scipy_options |
108 | 165 | ) |
109 | 166 |
|
110 | | - callback(client) |
| 167 | + qc = ansatz.assign_parameters(result.x) |
| 168 | + qc.measure_all() |
| 169 | + optimized_qc = pass_manager.run(qc) |
| 170 | + |
| 171 | + qiskit_sampler = qiskit.primitives.StatevectorSampler(default_shots = pyint(num_reads)) |
| 172 | + sampling_result = qiskit_sampler.run(pylist([optimized_qc])).result()[0] |
| 173 | + samples = sampling_result.data.meas.get_counts() |
| 174 | + |
| 175 | + callback(result, samples) |
111 | 176 |
|
112 | 177 | return nothing |
113 | 178 | end |
|
0 commit comments