Penganggaran tenaga keadaan asas rantaian Heisenberg dengan VQE
Anggaran penggunaan: Dua minit pada pemproses Eagle r3 (NOTA: Ini adalah anggaran sahaja. Masa jalan sebenar anda mungkin berbeza.)
Latar Belakang​
Tutorial ini menunjukkan cara membina, deploy, dan menjalankan corak Qiskit untuk mensimulasikan rantaian Heisenberg dan menganggar tenaga keadaan asasnya. Untuk maklumat lanjut tentang corak Qiskit dan cara Qiskit Serverless boleh digunakan untuk men-deploy-nya ke awan bagi pelaksanaan terurus, lawati halaman dokumentasi kami mengenai IBM Quantum® Platform.
Keperluan​
Sebelum memulakan tutorial ini, pastikan anda telah memasang perkara berikut:
- Qiskit SDK v1.2 atau lebih baharu, dengan sokongan visualisasi
- Qiskit Runtime v0.28 atau lebih baharu (
pip install qiskit-ibm-runtime) - Qiskit Serverless (pip install qiskit_serverless)
- IBM Catalog (pip install qiskit-ibm-catalog)
Persediaan​
# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit qiskit-ibm-catalog qiskit-ibm-runtime scipy
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from typing import Sequence
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives.base import BaseEstimatorV2
from qiskit.circuit.library import XGate
from qiskit.circuit.library import efficient_su2
from qiskit.transpiler import PassManager
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler.passes.scheduling import (
ALAPScheduleAnalysis,
PadDynamicalDecoupling,
)
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import Session, Estimator
from qiskit_ibm_catalog import QiskitServerless, QiskitFunction
def visualize_results(results):
plt.plot(results["cost_history"], lw=2)
plt.xlabel("Iteration")
plt.ylabel("Energy")
plt.show()
def build_callback(
ansatz: QuantumCircuit,
hamiltonian: SparsePauliOp,
estimator: BaseEstimatorV2,
callback_dict: dict,
):
def callback(current_vector):
# Keep track of the number of iterations
callback_dict["iters"] += 1
# Set the prev_vector to the latest one
callback_dict["prev_vector"] = current_vector
# Compute the value of the cost function at the current vector
current_cost = (
estimator.run([(ansatz, hamiltonian, [current_vector])])
.result()[0]
.data.evs[0]
)
callback_dict["cost_history"].append(current_cost)
# Print to screen on single line
print(
"Iters. done: {} [Current cost: {}]".format(
callback_dict["iters"], current_cost
),
end="\r",
flush=True,
)
return callback
Langkah 1: Petakan input klasik kepada masalah kuantum​
- Input: Bilangan spin
- Output: Ansatz dan Hamiltonian yang memodelkan rantaian Heisenberg
Bina ansatz dan Hamiltonian yang memodelkan rantaian Heisenberg 10-spin. Pertama, kita import beberapa pakej umum dan cipta beberapa fungsi pembantu.
num_spins = 10
ansatz = efficient_su2(num_qubits=num_spins, reps=3)
# Remember to insert your token in the QiskitRuntimeService constructor
service = QiskitRuntimeService()
backend = service.least_busy(
operational=True, min_num_qubits=num_spins, simulator=False
)
coupling = backend.target.build_coupling_map()
reduced_coupling = coupling.reduce(list(range(num_spins)))
edge_list = reduced_coupling.graph.edge_list()
ham_list = []
for edge in edge_list:
ham_list.append(("ZZ", edge, 0.5))
ham_list.append(("YY", edge, 0.5))
ham_list.append(("XX", edge, 0.5))
for qubit in reduced_coupling.physical_qubits:
ham_list.append(("Z", [qubit], np.random.random() * 2 - 1))
hamiltonian = SparsePauliOp.from_sparse_list(ham_list, num_qubits=num_spins)
ansatz.draw("mpl", style="iqp")
Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum​
- Input: Circuit abstrak, boleh diperhatikan
- Output: Circuit sasaran dan boleh diperhatikan, dioptimumkan untuk QPU yang dipilih
Gunakan fungsi generate_preset_pass_manager daripada Qiskit untuk menjana rutin pengoptimuman secara automatik bagi Circuit kita berkenaan dengan QPU yang dipilih. Kita pilih optimization_level=3, yang memberikan tahap pengoptimuman tertinggi bagi pengurus laluan pratetap. Kita juga menyertakan laluan penjadualan ALAPScheduleAnalysis dan PadDynamicalDecoupling untuk mengurangkan ralat dekoherensi.
target = backend.target
pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
pm.scheduling = PassManager(
[
ALAPScheduleAnalysis(durations=target.durations()),
PadDynamicalDecoupling(
durations=target.durations(),
dd_sequence=[XGate(), XGate()],
pulse_alignment=target.pulse_alignment,
),
]
)
ansatz_ibm = pm.run(ansatz)
observable_ibm = hamiltonian.apply_layout(ansatz_ibm.layout)
ansatz_ibm.draw("mpl", scale=0.6, style="iqp", fold=-1, idle_wires=False)
Langkah 3: Laksanakan menggunakan primitif Qiskit​
- Input: Circuit sasaran dan boleh diperhatikan
- Output: Keputusan pengoptimuman
Minimumkan tenaga keadaan asas sistem yang dianggarkan dengan mengoptimumkan parameter Circuit. Gunakan primitif Estimator daripada Qiskit Runtime untuk menilai fungsi kos semasa pengoptimuman.
Untuk demo ini, kita akan jalankan pada QPU menggunakan primitif qiskit-ibm-runtime. Untuk menjalankan dengan primitif berasaskan statevector qiskit, gantikan blok kod yang menggunakan primitif Qiskit IBM Runtime dengan blok yang dikomentari.
# SciPy minimizer routine
def cost_func(
params: Sequence,
ansatz: QuantumCircuit,
hamiltonian: SparsePauliOp,
estimator: BaseEstimatorV2,
) -> float:
"""Ground state energy evaluation."""
return (
estimator.run([(ansatz, hamiltonian, [params])])
.result()[0]
.data.evs[0]
)
num_params = ansatz_ibm.num_parameters
params = 2 * np.pi * np.random.random(num_params)
callback_dict = {
"prev_vector": None,
"iters": 0,
"cost_history": [],
}
# Evaluate the problem on a QPU by using Qiskit IBM Runtime
with Session(backend=backend) as session:
estimator = Estimator()
callback = build_callback(
ansatz_ibm, observable_ibm, estimator, callback_dict
)
res = minimize(
cost_func,
x0=params,
args=(ansatz_ibm, observable_ibm, estimator),
callback=callback,
method="cobyla",
options={"maxiter": 100},
)
visualize_results(callback_dict)
Langkah 4: Proses pasca dan kembalikan keputusan dalam format klasik yang dikehendaki​
- Input: Anggaran tenaga keadaan asas semasa pengoptimuman
- Output: Tenaga keadaan asas yang dianggarkan
print(f'Estimated ground state energy: {res["fun"]}')
Deploy corak Qiskit ke awan​
Untuk melakukan ini, pindahkan kod sumber di atas ke dalam fail, ./source/heisenberg.py, balut kod dalam skrip yang mengambil input dan mengembalikan penyelesaian akhir, dan akhirnya muat naiknya ke kluster jauh menggunakan kelas QiskitFunction daripada qiskit-ibm-catalog. Untuk panduan tentang menentukan kebergantungan luaran, menghantar argumen input, dan lain-lain, semak panduan Qiskit Serverless.
Input kepada Corak ialah bilangan spin dalam rantaian. Outputnya ialah anggaran tenaga keadaan asas sistem.
# Authenticate to the remote cluster and submit the pattern for remote execution
serverless = QiskitServerless()
heisenberg_function = QiskitFunction(
title="ibm_heisenberg",
entrypoint="heisenberg.py",
working_dir="./source/",
)
serverless.upload(heisenberg_function)
Jalankan corak Qiskit sebagai perkhidmatan terurus​
Setelah kita memuat naik corak ke awan, kita boleh menjalankannya dengan mudah menggunakan klien QiskitServerless.
# Run the pattern on the remote cluster
ibm_heisenberg = serverless.load("ibm_heisenberg")
job = serverless.run(ibm_heisenberg)
solution = job.result()
print(solution)
print(job.logs())
Tinjauan tutorial​
Sila ambil tinjauan ringkas ini untuk memberikan maklum balas tentang tutorial ini. Pandangan anda akan membantu kami menambah baik kandungan dan pengalaman pengguna kami.
Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.