Menyatukan semuanya dengan Qiskit Runtime

Ringkasan

Victoria Lipinska memberikan ulasan akhir tentang apa yang telah kita pelajari setakat ini.

Rujukan

Artikel-artikel berikut dirujuk dalam video di atas.

• Quantum Chemistry in the Age of Quantum Computing, Cao, et al.
• Quantum computational chemistry, McArdle, et al.

VQE dengan corak Qiskit

Kita mempunyai semua komponen yang diperlukan untuk pengiraan VQE:

• Hamiltonian
• Ansatz
• Pengoptimum klasik

Sekarang kita hanya perlu menyatukannya dalam rangka kerja corak Qiskit.

Langkah 1: Petakan input klasik kepada masalah kuantum

Seperti yang dinyatakan sebelum ini, kita akan menganggap di sini bahawa Hamiltonian berformat sesuai yang diminati telah dijana. Jika kamu mempunyai soalan tentang perkara itu, lihat pelajaran tentang Hamiltonian untuk panduan. Blok kod di bawah menetapkan komponen yang dijelaskan dalam pelajaran sebelumnya. Di sini kita telah memilih untuk memodelkan H2 kerana Hamiltoniannya cukup padat untuk ditulis.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer qiskit-ibm-runtime scipy

# General imports
import numpy as np
from qiskit.quantum_info import SparsePauliOp

# Hamiltonian obtained from a previous lesson

H = SparsePauliOp(
    [
        "IIII",
        "IIIZ",
        "IZII",
        "IIZI",
        "ZIII",
        "IZIZ",
        "IIZZ",
        "ZIIZ",
        "IZZI",
        "ZZII",
        "ZIZI",
        "YYYY",
        "XXYY",
        "YYXX",
        "XXXX",
    ],
    coeffs=[
        -0.09820182 + 0.0j,
        -0.1740751 + 0.0j,
        -0.1740751 + 0.0j,
        0.2242933 + 0.0j,
        0.2242933 + 0.0j,
        0.16891402 + 0.0j,
        0.1210099 + 0.0j,
        0.16631441 + 0.0j,
        0.16631441 + 0.0j,
        0.1210099 + 0.0j,
        0.17504456 + 0.0j,
        0.04530451 + 0.0j,
        0.04530451 + 0.0j,
        0.04530451 + 0.0j,
        0.04530451 + 0.0j,
    ],
)

nuclear_repulsion = 0.7199689944489797

Kita pilih litar efficient_su2, dan pengoptimum COBYLA, untuk bermula.

# Pre-defined ansatz circuit
from qiskit.circuit.library import efficient_su2

# SciPy minimizer routine
from scipy.optimize import minimize

# Plotting functions

# Random initial state and efficient_su2 ansatz
ansatz = efficient_su2(H.num_qubits, su2_gates=["rx"], entanglement="linear", reps=1)
x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)
print(ansatz.decompose().depth())
ansatz.decompose().draw("mpl")

5

Sekarang kita bina fungsi kos. Ini jelas berkaitan dengan Hamiltonian, tetapi berbeza kerana Hamiltonian adalah operator, dan kita mahukan fungsi yang mengembalikan nilai jangkaan operator tersebut, menggunakan Estimator. Sudah tentu, ia mencapai ini dengan menggunakan ansatz dan parameter variasi, jadi semuanya muncul sebagai argumen. Di bawah, kita takrifkan versi yang sedikit berbeza untuk digunakan pada perkakasan sebenar atau simulator.

def cost_func(params, ansatz, H, estimator):
    pub = (ansatz, [H], [params])
    result = estimator.run(pubs=[pub]).result()
    energy = result[0].data.evs[0]
    return energy

# def cost_func_sim(params, ansatz, H, estimator):
#    energy = estimator.run(ansatz, H, parameter_values=params).result().values[0]
#    return energy

Langkah 2: Optimumkan masalah untuk pelaksanaan kuantum.

Kita mahu kod kita berjalan seefisien mungkin pada perkakasan yang digunakan. Jadi kita mesti memilih Backend untuk memulakan langkah pengoptimuman. Kod di bawah memilih Backend yang paling kurang sibuk yang tersedia untuk kamu.

# To run on hardware, select the backend with the fewest number of jobs in the queue
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel="ibm_quantum_platform")
backend = service.least_busy(operational=True, simulator=False)
backend.name

Mengoptimumkan litar untuk dijalankan pada Backend sebenar adalah topik yang kaya dan kritikal. Tetapi ia tidak khusus untuk VQE. Buat masa ini, kita hanya akan mengingatkan kamu tentang dua istilah penting:

• optimization_level: Ini menerangkan sejauh mana litar disesuaikan dengan susunan Backend yang dipilih. Tahap pengoptimuman terendah hanya melakukan kerja minimum yang diperlukan untuk menjalankan litar pada peranti; ia memetakan Qubit litar ke Qubit peranti dan menambah Gate swap untuk membolehkan semua operasi dua-Qubit. Tahap pengoptimuman tertinggi jauh lebih bijak dan menggunakan banyak helah untuk mengurangkan jumlah bilangan Gate. Oleh kerana Gate berbilang Qubit mempunyai kadar ralat yang tinggi dan Qubit menjadi dekoherens dari masa ke masa, litar yang lebih pendek sepatutnya memberikan hasil yang lebih baik.
• Dynamical Decoupling: Kita boleh menerapkan urutan Gate kepada Qubit yang melahu. Ini membatalkan beberapa interaksi yang tidak diingini dengan persekitaran. Rujuk dokumentasi yang dipautkan untuk maklumat lanjut tentang mengoptimumkan litar. Kod di bawah menjana pengurus lulus menggunakan pengurus lulus praset daripada qiskit.transpiler.

from qiskit.transpiler import PassManager
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler.passes import (
    ALAPScheduleAnalysis,
    PadDynamicalDecoupling,
    ConstrainedReschedule,
)
from qiskit.circuit.library import XGate

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
pm.scheduling = PassManager(
    [
        ALAPScheduleAnalysis(target=target),
        ConstrainedReschedule(
            acquire_alignment=target.acquire_alignment,
            pulse_alignment=target.pulse_alignment,
            target=target,
        ),
        PadDynamicalDecoupling(
            target=target,
            dd_sequence=[XGate(), XGate()],
            pulse_alignment=target.pulse_alignment,
        ),
    ]
)

# Use the pass manager and draw the resulting circuit
ansatz_isa = pm.run(ansatz)
ansatz_isa.draw(output="mpl", idle_wires=False, style="iqp")

Kita juga mesti menerapkan ciri susun atur peranti kepada Hamiltonian.

hamiltonian_isa = H.apply_layout(ansatz_isa.layout)
hamiltonian_isa

SparsePauliOp(['IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYYYII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYXXII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXYYII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXXXII'],
              coeffs=[-0.09820182+0.j, -0.1740751 +0.j, -0.1740751 +0.j,  0.2242933 +0.j,
  0.2242933 +0.j,  0.16891402+0.j,  0.1210099 +0.j,  0.16631441+0.j,
  0.16631441+0.j,  0.1210099 +0.j,  0.17504456+0.j,  0.04530451+0.j,
  0.04530451+0.j,  0.04530451+0.j,  0.04530451+0.j])

Langkah 3: Laksanakan menggunakan Qiskit Primitives.

Sebelum melaksanakan pada perkakasan yang dipilih, adalah idea yang baik untuk menggunakan simulator bagi penyahpepijatan ringkas, dan kadang-kadang untuk menganggar ralat. Atas sebab itu, kita secara ringkas menunjukkan cara menjalankan VQE pada simulator. Tetapi adalah penting untuk diingat bahawa tiada komputer klasik, simulator, atau GPU yang boleh mensimulasikan dengan tepat fungsi penuh komputer kuantum 127-Qubit yang berpembelitan tinggi. Dalam era utiliti kuantum semasa, simulator akan mempunyai kegunaan yang terhad.

Ingat bahawa untuk setiap pilihan parameter dalam litar variasi, nilai jangkaan mesti dikira (kerana itulah nilai yang perlu diminimumkan). Seperti yang mungkin kamu duga, cara paling efisien untuk melakukannya ialah menggunakan primitif Qiskit, Estimator. Kita akan mulakan dengan menggunakan simulator setempat, yang memerlukan kita menggunakan versi setempat Estimator yang dipanggil BackendEstimator.

Dengan mengekalkan Backend sebenar yang kita gunakan untuk pengoptimuman, kita boleh mengimport model tingkah laku hingar peranti tersebut untuk digunakan dengan simulator setempat pilihan kita. Di sini, kita akan menggunakan aer_simulator_statevector.

# We will start by using a local simulator
from qiskit_aer import AerSimulator

# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)
from qiskit.primitives import BackendEstimatorV2

# generate a simulator that mimics the real quantum system
backend_sim = AerSimulator.from_backend(backend)
estimator = BackendEstimatorV2(backend=backend_sim)

Akhirnya tiba masa untuk melaksanakan VQE, meminimumkan fungsi kos menggunakan Hamiltonian, ansatz, pengoptimum klasik, dan BackendEstimator kita, berdasarkan Backend sebenar yang dipilih untuk kegunaan seterusnya. Perhatikan bahawa di sini kita telah memilih nombor yang agak kecil untuk bilangan iterasi maksimum. Ini kerana kita hanya menggunakan simulator untuk penyahpepijatan. Langkah pengoptimuman VQE sering memerlukan ratusan iterasi untuk menumpu.

res = minimize(
    cost_func,
    x0,
    args=(ansatz_isa, hamiltonian_isa, estimator),
    method="cobyla",
    options={"maxiter": 10, "disp": True},
)

print(getattr(res, "fun") - nuclear_repulsion)
print(res)

Return from COBYLA because the objective function has been evaluated MAXFUN times.
Number of function values = 10   Least value of F = -0.11556938907226563
The corresponding X is:
[4.11796514 4.52126324 0.69570423 4.12781503 6.55507846 1.80713073
 0.9645473  6.23812214]

-0.8355383835212453
 message: Return from COBYLA because the objective function has been evaluated MAXFUN times.
 success: False
  status: 3
     fun: -0.11556938907226563
       x: [ 4.118e+00  4.521e+00  6.957e-01  4.128e+00  6.555e+00
            1.807e+00  9.645e-01  6.238e+00]
    nfev: 10
   maxcv: 0.0

Kod ini berjalan dengan betul, walaupun ia tidak menumpu, yang memang kita jangkakan. Kita akan meneruskan menjalankan pengiraan pada perkakasan sebenar, dan kemudian membincangkan output. Untuk Backend sebenar, kita akan menggunakan Qiskit Runtime Estimator. Kita akan mahu melaksanakan ini di dalam sesi Qiskit Runtime dan kita umumnya akan mahu menyatakan pilihan untuk sesi tersebut.

from qiskit_ibm_runtime import QiskitRuntimeService, Session
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit_ibm_runtime.options import EstimatorOptions

Antara lain, menggunakan sesi bermakna kerja kita hanya akan menunggu dalam giliran sekali sahaja, untuk bermula. Iterasi seterusnya pengoptimum klasik tidak akan bergilir. Dalam sesi, kita boleh menetapkan tahap daya tahan dan pengoptimuman. Alat-alat ini cukup penting sehingga kita menyertakan ulasan ringkas tentang setiap satu dan kepentingannya dalam VQE, dengan pautan untuk mengetahui lebih lanjut:

• Sesi Runtime: VQE secara dasarnya adalah berulang, dengan pengoptimum klasik memilih parameter variasi baharu, dan dengan itu Gate baharu digunakan, dalam setiap percubaan berikutnya. Tanpa menggunakan sesi, ini boleh mengakibatkan masa giliran tambahan antara setiap litar percubaan. Merangkumi pengiraan VQE di dalam sesi menghasilkan hanya satu giliran awal sebelum kerja bermula, tetapi tiada masa giliran tambahan antara langkah variasi. Strategi ini telah digunakan dalam contoh pelajaran sebelumnya, tetapi mungkin memainkan peranan yang lebih penting apabila mengubah geometri. Untuk maklumat lanjut tentang sesi, semak dokumentasi mod pelaksanaan.
• Pengoptimuman terbina dalam Estimator: Dalam Estimator terdapat pilihan terbina dalam untuk mengoptimumkan pengiraan. Dalam banyak konteks (termasuk Estimator), tetapan terhad kepada 0 dan 1, dengan 0 menunjukkan tiada pengoptimuman, dan 1 (lalai) menunjukkan beberapa pengoptimuman litar kepada perkakasan yang dipilih. Beberapa konteks lain membolehkan tetapan 0, 1, 2, atau 3. Untuk maklumat lanjut tentang kaedah khusus yang digunakan dalam tetapan yang berbeza, lihat dokumentasi. Di sini, kita sebenarnya akan menetapkan pengoptimuman kepada 0, dan menggunakan 'skip_transpilation = true', kerana kita telah mentranspil litar menggunakan pengurus lulus di atas, dalam bahagian pengoptimuman.
• Daya tahan terbina dalam Estimator: Seperti pengoptimuman, Estimator mempunyai tetapan terbina dalam untuk daya tahan terhadap ralat, bersamaan dengan pendekatan yang berbeza terhadap pengurangan ralat. Untuk mengetahui tentang tetapan tahap daya tahan, rujuk dokumentasi.

Perlu diperhatikan bahawa pengurangan ralat memainkan peranan bernuansa dalam penumpuan pengiraan VQE. Pengoptimum klasik mencari ruang parameter untuk parameter yang meminimumkan tenaga. Apabila kamu jauh dari parameter optimum, kecerunan yang curam mungkin kelihatan kepada pengoptimum klasik walaupun dalam kehadiran ralat. Tetapi apabila pengiraan menumpu dan kamu mendekati nilai optimum, kecerunan menjadi lebih kecil, dan lebih mudah dihapuskan oleh ralat. Berapa banyak pengurangan ralat yang kamu mahu gunakan? Pada titik mana dalam penumpuan? Ini adalah pilihan yang mesti kamu buat untuk kes penggunaan kamu yang tertentu.

Untuk larian perkakasan pertama ini, kita telah menetapkan daya tahan kepada 0 untuk memudahkan larian yang agak pantas. Untuk sebarang aplikasi serius, kamu akan mahu menggunakan pengurangan ralat. Perhatikan bahawa dalam sel di bawah terdapat dua set pilihan: (1) pilihan untuk sesi Runtime, yang kita namakan "session_options", dan (2) pilihan untuk pengoptimum klasik, yang dipanggil "options" di sini.

estimator_options = EstimatorOptions(resilience_level=0, default_shots=2000)
with Session(backend=backend) as session:
    estimator = Estimator(mode=session, options=estimator_options)

    res = minimize(
        cost_func,
        x0,
        args=(ansatz_isa, hamiltonian_isa, estimator),
        method="cobyla",
        options={"maxiter": 10, "disp": True},
    )

Return from COBYLA because the objective function has been evaluated MAXFUN times.
Number of function values = 10   Least value of F = -0.11691688904
The corresponding X is:
[5.11796514 5.52126324 0.69570423 5.12781503 6.55507846 1.80713073
 1.9645473  6.23812214]

Kamu boleh melihat kemajuan kerja kamu pada IBM Quantum® Platform di bawah Workloads.

print(getattr(res, "fun") - nuclear_repulsion)
print(res)

-0.8368858834889796
 message: Return from COBYLA because the objective function has been evaluated MAXFUN times.
 success: False
  status: 3
     fun: -0.11691688904
       x: [ 5.118e+00  5.521e+00  6.957e-01  5.128e+00  6.555e+00
            1.807e+00  1.965e+00  6.238e+00]
    nfev: 10
   maxcv: 0.0

Langkah 4: Proses pasca, kembalikan hasil dalam format klasik.

Mari kita ambil masa untuk memastikan kita memahami output ini. Output "fun" ialah nilai minimum yang kita peroleh untuk fungsi kos (tidak semestinya nilai terakhir yang dikira). Ini adalah tenaga keseluruhan, termasuk tolakan nuklear positif, itulah sebabnya kita juga mentakrifkan electron_energy.

Dalam kes di atas, kita mempunyai mesej bahawa bilangan maksimum penilaian fungsi telah dilampaui, dan bahawa bilangan penilaian fungsi (nfev) ialah 10. Ini hanya bermakna kriteria lain untuk penumpuan pengoptimuman tidak dipenuhi; dalam erti kata lain, tiada sebab untuk menganggap kita telah menemui tenaga keadaan dasar. Ini juga adalah maksud success yang bernilai "False".

Akhirnya, kita mempunyai x. Ini ialah vektor parameter variasi. Ini adalah parameter yang digunakan dalam pengiraan yang menghasilkan fungsi kos minimum (nilai jangkaan tenaga). Lapan nilai ini bersamaan dengan lapan sudut putaran dalam Gate ansatz yang menerima sudut putaran berubah.

Tahniah! Kamu telah menjalankan pengiraan VQE pada QPU IBM Quantum!

Dalam pelajaran seterusnya, kita akan melihat cara menyesuaikan aliran kerja ini untuk merangkumi pemboleh ubah dalam Hamiltonian kamu. Dalam konteks masalah kimia kuantum, ini mungkin bermakna mengubah geometri untuk menentukan bentuk molekul atau tapak pengikatan.

import qiskit
import qiskit_ibm_runtime

print(qiskit.version.get_version_info())
print(qiskit_ibm_runtime.version.get_version_info())

2.1.0
0.40.1