Estimasi energi ground state rantai Heisenberg dengan VQE

Perkiraan penggunaan: Dua menit pada prosesor Eagle r3 (CATATAN: Ini hanya perkiraan. Waktu eksekusi aktualmu bisa berbeda.)

Latar Belakang

Tutorial ini menunjukkan cara membangun, men-deploy, dan menjalankan Qiskit pattern untuk mensimulasikan rantai Heisenberg dan mengestimasi energi ground state-nya. Untuk informasi lebih lanjut tentang Qiskit patterns dan bagaimana Qiskit Serverless dapat digunakan untuk men-deploy-nya ke cloud untuk eksekusi terkelola, kunjungi halaman dokumentasi kami tentang IBM Quantum® Platform.

Persyaratan

Sebelum memulai tutorial ini, pastikan kamu sudah menginstal hal-hal berikut:

• Qiskit SDK v1.2 atau lebih baru, dengan dukungan visualisasi
• Qiskit Runtime v0.28 atau lebih baru (pip install qiskit-ibm-runtime)
• Qiskit Serverless (pip install qiskit_serverless)
• IBM Catalog (pip install qiskit-ibm-catalog)

Setup

# 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: Memetakan input klasik ke masalah kuantum

• Input: Jumlah spin
• Output: Ansatz dan Hamiltonian yang memodelkan rantai Heisenberg

Buat ansatz dan Hamiltonian yang memodelkan rantai Heisenberg 10-spin. Pertama, kita impor beberapa paket umum dan buat 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: Mengoptimalkan masalah untuk eksekusi hardware kuantum

• Input: Circuit abstrak, observable
• Output: Target Circuit dan observable, dioptimalkan untuk QPU yang dipilih

Gunakan fungsi generate_preset_pass_manager dari Qiskit untuk secara otomatis menghasilkan rutinitas optimasi untuk Circuit kita terhadap QPU yang dipilih. Kita pilih optimization_level=3, yang memberikan tingkat optimasi tertinggi dari preset pass manager. Kita juga menyertakan scheduling pass ALAPScheduleAnalysis dan PadDynamicalDecoupling untuk menekan kesalahan 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: Eksekusi menggunakan primitif Qiskit

• Input: Target Circuit dan observable
• Output: Hasil optimasi

Minimalkan estimasi energi ground state sistem dengan mengoptimalkan parameter Circuit. Gunakan primitif Estimator dari Qiskit Runtime untuk mengevaluasi fungsi cost selama optimasi.

Untuk demo ini, kita akan menjalankan pada QPU menggunakan primitif qiskit-ibm-runtime. Untuk menjalankan dengan primitif berbasis statevector qiskit, ganti blok kode 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: Post-process dan kembalikan hasil dalam format klasik yang diinginkan

• Input: Estimasi energi ground state selama optimasi
• Output: Estimasi energi ground state

print(f'Estimated ground state energy: {res["fun"]}')

Deploy pola Qiskit ke cloud

Untuk melakukan ini, pindahkan kode sumber di atas ke sebuah file, ./source/heisenberg.py, bungkus kode dalam sebuah skrip yang mengambil input dan mengembalikan solusi akhir, lalu unggah ke cluster remote menggunakan kelas QiskitFunction dari qiskit-ibm-catalog. Untuk panduan tentang cara menentukan dependensi eksternal, melewatkan argumen input, dan lainnya, lihat panduan Qiskit Serverless.

Input ke Pattern adalah jumlah spin dalam rantai. Output-nya adalah estimasi energi ground state 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 pola Qiskit sebagai layanan terkelola

Setelah kita mengunggah pola ke cloud, kita bisa dengan mudah menjalankannya 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())

Survei tutorial

Tolong isi survei singkat ini untuk memberikan masukan tentang tutorial ini. Wawasanmu akan membantu kami meningkatkan konten dan pengalaman pengguna kami.

Tautan ke survei

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.