Input dan output primitif

Versi pakej

Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan penggunaan versi ini atau yang lebih baharu.

qiskit[all]~=2.4.0

Halaman ini memberikan gambaran keseluruhan tentang input dan output primitif Qiskit. Dengan primitif ini anda boleh menggunakan struktur data yang dikenali sebagai Primitive Unified Bloc (PUB) untuk mentakrifkan beban kerja yang divektorkan dengan cekap. PUB ini merupakan unit kerja asas bagi pelaksanaan beban kerja. Ia digunakan sebagai input kepada kaedah run() untuk primitif Sampler dan Estimator, yang melaksanakan beban kerja yang ditakrifkan sebagai satu tugas. Kemudian, selepas tugas selesai, hasilnya dikembalikan dalam format yang bergantung pada PUB yang digunakan dan sebarang pilihan yang ditetapkan.

Gambaran keseluruhan PUB

Apabila menggunakan kaedah run() sesebuah primitif, argumen utama yang diperlukan ialah satu list yang mengandungi satu atau lebih tupel — satu bagi setiap litar yang dilaksanakan oleh primitif tersebut. Setiap tupel ini dianggap sebagai PUB, dan elemen yang diperlukan bagi setiap tupel dalam senarai bergantung pada primitif yang digunakan. Data yang diberikan kepada tupel ini juga boleh disusun dalam pelbagai bentuk untuk memberikan fleksibiliti dalam beban kerja melalui penyiaran — peraturannya diterangkan dalam bahagian berikut.

Estimator PUB

Untuk primitif Estimator, format PUB mestilah mengandungi paling banyak empat nilai:

• Satu QuantumCircuit tunggal, yang mungkin mengandungi satu atau lebih objek Parameter
• Senarai satu atau lebih boleh cerap, yang menentukan nilai jangkaan untuk dianggarkan, disusun dalam suatu tatasusunan (contohnya, satu boleh cerap tunggal diwakili sebagai tatasusunan 0-d, senarai boleh cerap sebagai tatasusunan 1-d, dan seterusnya). Data boleh berada dalam mana-mana satu format ObservablesArrayLike seperti Pauli, SparsePauliOp, PauliList, atau str.
  nota

  Jika anda mempunyai dua boleh cerap yang bertukar-tukar (commuting) dalam PUB yang berbeza tetapi dengan litar yang sama, ia tidak akan dianggarkan menggunakan pengukuran yang sama. Setiap PUB mewakili asas pengukuran yang berbeza, justeru pengukuran berasingan diperlukan untuk setiap PUB. Untuk memastikan boleh cerap yang bertukar-tukar dianggarkan menggunakan pengukuran yang sama, ia mesti dikumpulkan dalam PUB yang sama.

• Koleksi nilai parameter untuk mengikat litar. Ini boleh ditetapkan sebagai satu objek seperti tatasusunan di mana indeks terakhir adalah atas objek Parameter litar, atau diabaikan (atau setara, ditetapkan kepada None) jika litar tidak mempunyai objek Parameter.
• (Pilihan) ketepatan sasaran untuk nilai jangkaan yang hendak dianggarkan

Sampler PUB

Untuk primitif Sampler, format tupel PUB mengandungi paling banyak tiga nilai:

• Satu QuantumCircuit tunggal, yang mungkin mengandungi satu atau lebih objek Parameter Nota: Litar ini juga mesti mengandungi arahan pengukuran untuk setiap qubit yang hendak dipersamplkan.
• Koleksi nilai parameter untuk mengikat litar terhadap $\theta_k$ (hanya diperlukan jika ada objek Parameter yang mesti diikat semasa masa jalan)
• (Pilihan) bilangan tembakan untuk mengukur litar

---

Kod berikut menunjukkan contoh set input yang divektorkan kepada primitif Estimator.

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

from qiskit.circuit import (
    Parameter,
    QuantumCircuit,
    ClassicalRegister,
    QuantumRegister,
)
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives.containers import BitArray
from qiskit.primitives import StatevectorEstimator

import numpy as np

# Define a circuit with two parameters.
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.ry(Parameter("a"), 0)
circuit.rz(Parameter("b"), 0)
circuit.cx(0, 1)
circuit.h(0)

# Transpile the circuit without providing a backend
pm = generate_preset_pass_manager(optimization_level=1)
transpiled_circuit = pm.run(circuit)
layout = transpiled_circuit.layout

# Now define a sweep over parameter values, the last axis of dimension 2 is
# for the two parameters "a" and "b"
params = np.vstack(
    [
        np.linspace(-np.pi, np.pi, 10),
        np.linspace(-4 * np.pi, 4 * np.pi, 10),
    ]
).T

# Define three observables. The inner length-1 lists cause this array of
# observables to have shape (3, 1), rather than shape (3,) if they were
# omitted.
observables = [
    [SparsePauliOp(["XX", "IY"], [0.5, 0.5])],
    [SparsePauliOp("XX")],
    [SparsePauliOp("IY")],
]
# Apply the same layout as the transpiled circuit.
observables = [
    [observable.apply_layout(layout) for observable in observable_set]
    for observable_set in observables
]

# Estimate the expectation value for all 300 combinations of observables
# and parameter values, where the pub result will have shape (3, 100).
#
# This shape is due to our array of parameter bindings having shape
# (100, 2), combined with our array of observables having shape (3, 1).
estimator = StatevectorEstimator()
estimator_pub = (transpiled_circuit, observables, params)

# Run the transpiled circuit
# using the set of parameters and observables.

job = estimator.run([estimator_pub])
result = job.result()

Peraturan penyiaran

PUB menggabungkan elemen daripada pelbagai tatasusunan (boleh cerap dan nilai parameter) dengan mengikuti peraturan penyiaran yang sama seperti NumPy. Bahagian ini meringkaskan peraturan tersebut secara ringkas. Untuk penjelasan terperinci, lihat dokumentasi peraturan penyiaran NumPy.

Peraturan:

• Tatasusunan input tidak perlu mempunyai bilangan dimensi yang sama.
  • Tatasusunan yang terhasil akan mempunyai bilangan dimensi yang sama dengan tatasusunan input yang mempunyai dimensi terbesar.
  • Saiz setiap dimensi ialah saiz terbesar bagi dimensi yang sepadan.
  • Dimensi yang tiada dianggap mempunyai saiz satu.
• Perbandingan bentuk bermula dari dimensi paling kanan dan diteruskan ke kiri.
• Dua dimensi serasi jika saiznya sama atau jika salah satunya ialah 1.

Contoh pasangan tatasusunan yang boleh disiarkan:

A1     (1d array):      1
A2     (2d array):  3 x 5
Result (2d array):  3 x 5

A1     (3d array):  11 x 2 x 7
A2     (3d array):  11 x 1 x 7
Result (3d array):  11 x 2 x 7

Contoh pasangan tatasusunan yang tidak boleh disiarkan:

A1     (1d array):  5
A2     (1d array):  3

A1     (2d array):      2 x 1
# The following would work if the middle dimension were 2,
# instead of 5.
A2     (3d array):  6 x 5 x 4

Estimator mengembalikan satu anggaran nilai jangkaan bagi setiap elemen bentuk yang disiarkan.

Berikut adalah beberapa contoh corak biasa yang dinyatakan dari segi penyiaran tatasusunan. Representasi visual yang menyertainya ditunjukkan dalam rajah yang berikut:

Set nilai parameter diwakili oleh tatasusunan n x m, dan tatasusunan boleh cerap diwakili oleh satu atau lebih tatasusunan lajur tunggal. Bagi setiap contoh dalam kod sebelumnya, set nilai parameter digabungkan dengan tatasusunan boleh cerap mereka untuk menghasilkan anggaran nilai jangkaan.

• Contoh 1: (siarkan satu boleh cerap) mempunyai set nilai parameter yang merupakan tatasusunan 5x1 dan tatasusunan boleh cerap 1x1. Item tunggal dalam tatasusunan boleh cerap digabungkan dengan setiap item dalam set nilai parameter untuk menghasilkan tatasusunan 5x1 tunggal di mana setiap item adalah gabungan item asal dalam set nilai parameter dengan item dalam tatasusunan boleh cerap.

• Contoh 2: (zip) mempunyai set nilai parameter 5x1 dan tatasusunan boleh cerap 5x1. Output ialah tatasusunan 5x1 di mana setiap item adalah gabungan item ke-n dalam set nilai parameter dengan item ke-n dalam tatasusunan boleh cerap.

• Contoh 3: (luar/hasil) mempunyai set nilai parameter 1x6 dan tatasusunan boleh cerap 4x1. Gabungan mereka menghasilkan tatasusunan 4x6 yang dicipta dengan menggabungkan setiap item dalam set nilai parameter dengan setiap item dalam tatasusunan boleh cerap, justeru setiap nilai parameter menjadi satu lajur penuh dalam output.

• Contoh 4: (Generalisasi nd piawai) mempunyai tatasusunan set nilai parameter 3x6 dan dua tatasusunan boleh cerap 3x1. Ini digabungkan untuk menghasilkan dua tatasusunan output 3x6 dengan cara yang serupa dengan contoh sebelumnya.

# Broadcast single observable
parameter_values = np.random.uniform(size=(5,))  # shape (5,)
observables = SparsePauliOp("ZZZ")  # shape ()
# >> pub result has shape (5,)

# Zip
parameter_values = np.random.uniform(size=(5,))  # shape (5,)
observables = [
    SparsePauliOp(pauli) for pauli in ["III", "XXX", "YYY", "ZZZ", "XYZ"]
]  # shape (5,)
# >> pub result has shape (5,)

# Outer/Product
parameter_values = np.random.uniform(size=(1, 6))  # shape (1, 6)
observables = [
    [SparsePauliOp(pauli)] for pauli in ["III", "XXX", "YYY", "ZZZ"]
]  # shape (4, 1)
# >> pub result has shape (4, 6)

# Standard nd generalization
parameter_values = np.random.uniform(size=(3, 6))  # shape (3, 6)
observables = [
    [
        [SparsePauliOp(["XII"])],
        [SparsePauliOp(["IXI"])],
        [SparsePauliOp(["IIX"])],
    ],
    [
        [SparsePauliOp(["ZII"])],
        [SparsePauliOp(["IZI"])],
        [SparsePauliOp(["IIZ"])],
    ],
]  # shape (2, 3, 1)
# >> pub result has shape (2, 3, 6)

Estimator mengembalikan satu anggaran nilai jangkaan bagi setiap elemen bentuk yang disiarkan.

SparsePauliOp

Setiap SparsePauliOp dikira sebagai satu elemen dalam konteks ini, tanpa mengira bilangan Pauli yang terkandung dalam SparsePauliOp. Oleh itu, bagi tujuan peraturan penyiaran ini, semua elemen berikut mempunyai bentuk yang sama:

a = SparsePauliOp("Z") # shape ()
b = SparsePauliOp("IIIIZXYIZ") # shape ()
c = SparsePauliOp.from_list(["XX", "XY", "IZ"]) # shape ()

Senarai pengoperasi berikut, walaupun setara dari segi maklumat yang terkandung, mempunyai bentuk yang berbeza:

list1 = SparsePauliOp.from_list(["XX", "XY", "IZ"])
# list1 has shape ()
list2 = [SparsePauliOp("XX"), SparsePauliOp("XY"), SparsePauliOp("IZ")]
# list2 has shape (3, )

Gambaran keseluruhan output primitif

Setelah satu atau lebih PUB dihantar ke QPU untuk dilaksanakan dan tugas berjaya diselesaikan, data dikembalikan sebagai objek kontena PrimitiveResult. PrimitiveResult mengandungi senarai boleh ulang bagi objek PubResult yang mengandungi hasil pelaksanaan bagi setiap PUB. Contohnya, tugas yang diserahkan dengan 20 PUB akan mengembalikan objek PrimitiveResult yang mengandungi senarai 20 PubResult, satu sepadan dengan setiap PUB.

Setiap objek PubResult ini mempunyai atribut data dan atribut metadata yang opsyenal. Atribut data ialah DataBin yang disesuaikan dan mengandungi anggaran nilai jangkaan dalam kes Estimator, atau sampel output litar dalam kes Sampler.

Atribut data juga mungkin mengandungi maklumat khusus pelaksanaan yang lain seperti sisihan piawai. Atribut metadata boleh mengandungi maklumat khusus pelaksanaan tambahan tentang pelaksanaan PUB yang berkaitan.

Berikut ialah garis besar visual struktur data PrimitiveResult:

Output Estimator

└── PrimitiveResult
    ├── PubResult[0]
    │   ├── metadata
    │   └── data  ## In the form of a DataBin object,
    |       |     ## which includes data such as the following:
    │       ├── evs
    │       │   └── List of estimated expectation values in the shape
    |       |         specified by the first pub
    │       └── stds
    │           └── List of calculated standard deviations in the
    |                 same shape as above
    ├── PubResult[1]
    |   ├── metadata
    |   └── data  ## In the form of a DataBin object,
    |       |     ## which includes data such as the following:
    |       ├── evs
    |       │   └── List of estimated expectation values in the shape
    |       |        specified by the second pub
    |       └── stds
    |           └── List of calculated standard deviations in the
    |                same shape as above
    ├── ...
    ├── ...
    └── ...

nota

Contoh di atas ialah contoh data yang mungkin dikembalikan. Data sebenar yang dikembalikan bergantung pada pelaksanaan.

Output Sampler

└── PrimitiveResult
    ├── PubResult[0]
    │   ├── metadata
    │   └── data  ## In the form of a DataBin object
    │       ├── NAME_OF_CLASSICAL_REGISTER
    │       │   └── BitArray of count data for first PUB (default is 'meas')
    |       |
    │       └── NAME_OF_ANOTHER_CLASSICAL_REGISTER
    │           └── BitArray of count data (exists only if more than one
    |                 ClassicalRegister was specified in the circuit)
    ├── PubResult[1]
    |   ├── metadata
    |   └── data  ## In the form of a DataBin object
    |       └── NAME_OF_CLASSICAL_REGISTER
    |           └── BitArray of count data for second PUB
    ├── ...
    ├── ...
    └── ...

Output Estimator

Seperti yang dinyatakan sebelum ini, data yang dikembalikan dalam PubResult untuk primitif Estimator bergantung pada pelaksanaan. Contohnya, ia mungkin mengandungi satu tatasusunan nilai jangkaan (PubResult.data.evs) dan sisihan piawai yang berkaitan (PubResult.data.stds).

Petikan kod di bawah menerangkan format PrimitiveResult (dan PubResult yang berkaitan) bagi tugas yang dibuat di atas.

print(
    f"The result of the submitted job had {len(result)} PUB and "
    f"has a value:\n {result}\n"
)
print(
    f"The associated PubResult of this job has the following data bins:"
    f"\n {result[0].data}\n"
)
print(f"And this DataBin has attributes: {result[0].data.keys()}")
print(
    "Recall that this shape is due to our array of parameter binding sets "
    "having shape (100, 2) -- where 2 is the number of parameters in the circuit -- "
    "combined with our array of observables having shape (3, 1)."
)

print(
    f"The expectation values measured from this PUB are: \n{result[0].data.evs}"
)

The result of the submitted job had 1 PUB and has a value:
 PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(3, 10), dtype=float64>), stds=np.ndarray(<shape=(3, 10), dtype=float64>), shape=(3, 10)), metadata={'target_precision': 0.0, 'circuit_metadata': {}})], metadata={'version': 2})

The associated PubResult of this job has the following data bins:
 DataBin(evs=np.ndarray(<shape=(3, 10), dtype=float64>), stds=np.ndarray(<shape=(3, 10), dtype=float64>), shape=(3, 10))

And this DataBin has attributes: dict_keys(['evs', 'stds'])
Recall that this shape is due to our array of parameter binding sets having shape (100, 2) -- where 2 is the
         number of parameters in the circuit -- combined with our array of observables having shape (3, 1). 

The expectation values measured from this PUB are: 
[[ 3.06161700e-16  4.52395120e-01  4.36594428e-01  2.16506351e-01
   6.33718361e-01 -6.33718361e-01 -2.16506351e-01 -4.36594428e-01
  -4.52395120e-01 -3.06161700e-16]
 [ 1.22464680e-16  6.42787610e-01  9.84807753e-01  8.66025404e-01
   3.42020143e-01 -3.42020143e-01 -8.66025404e-01 -9.84807753e-01
  -6.42787610e-01 -1.22464680e-16]
 [ 4.89858720e-16  2.62002630e-01 -1.11618897e-01 -4.33012702e-01
   9.25416578e-01 -9.25416578e-01  4.33012702e-01  1.11618897e-01
  -2.62002630e-01 -4.89858720e-16]]

Output Sampler

Apabila tugas Sampler berjaya diselesaikan, objek PrimitiveResult yang dikembalikan mengandungi senarai SamplerPubResult, satu bagi setiap PUB. Tong data objek SamplerPubResult ini adalah objek seperti kamus yang mengandungi satu BitArray bagi setiap ClassicalRegister dalam litar.

Kelas BitArray adalah kontena untuk data tembakan yang tersusun. Lebih terperinci, ia menyimpan rentetan bit yang disamplkan sebagai bait dalam tatasusunan dua dimensi. Paksi paling kiri tatasusunan ini berjalan melalui tembakan yang tersusun, manakala paksi paling kanan berjalan melalui bait.

Sebagai contoh pertama, mari kita lihat litar sepuluh qubit berikut:

from qiskit.primitives import StatevectorSampler

# generate a ten-qubit GHZ circuit
circuit = QuantumCircuit(10)
circuit.h(0)
circuit.cx(range(0, 9), range(1, 10))

# append measurements with the `measure_all` method
circuit.measure_all()

# transpile the circuit
transpiled_circuit = pm.run(circuit)

sampler = StatevectorSampler()

# run the Sampler job and retrieve the results

job = sampler.run([transpiled_circuit])
result = job.result()

# the data bin contains one BitArray
data = result[0].data
print(f"Databin: {data}\n")

# to access the BitArray, use the key "meas", which is the default name of
# the classical register when this is added by the `measure_all` method
array = data.meas
print(f"BitArray: {array}\n")
print(f"The shape of register `meas` is {data.meas.array.shape}.\n")
print(f"The bytes in register `alpha`, shot by shot:\n{data.meas.array}\n")

Databin: DataBin(meas=BitArray(<shape=(), num_shots=1024, num_bits=10>))

BitArray: BitArray(<shape=(), num_shots=1024, num_bits=10>)

The shape of register `meas` is (1024, 2).

The bytes in register `alpha`, shot by shot:
[[  0   0]
 [  3 255]
 [  0   0]
 ...
 [  3 255]
 [  3 255]
 [  3 255]]

Kadang kala lebih mudah untuk menukar daripada format bait dalam BitArray kepada rentetan bit. Kaedah get_count mengembalikan kamus yang memetakan rentetan bit kepada bilangan kali ia muncul.

# optionally convert the native BitArray format to a dictionary format
counts = data.meas.get_counts()
print(f"Counts: {counts}")

Counts: {'0000000000': 492, '1111111111': 532}

Apabila litar mengandungi lebih daripada satu daftar klasikal, hasilnya disimpan dalam objek BitArray yang berbeza. Contoh berikut mengubah suai petikan sebelumnya dengan membahagikan daftar klasikal kepada dua daftar yang berbeza:

# generate a ten-qubit GHZ circuit with two classical registers
circuit = QuantumCircuit(
    qreg := QuantumRegister(10),
    alpha := ClassicalRegister(1, "alpha"),
    beta := ClassicalRegister(9, "beta"),
)
circuit.h(0)
circuit.cx(range(0, 9), range(1, 10))

# append measurements with the `measure_all` method
circuit.measure([0], alpha)
circuit.measure(range(1, 10), beta)

# transpile the circuit
transpiled_circuit = pm.run(circuit)

# run the Sampler job and retrieve the results

job = sampler.run([transpiled_circuit])
result = job.result()

# the data bin contains two BitArrays, one per register, and can be accessed
# as attributes using the registers' names
data = result[0].data
print(f"BitArray for register 'alpha': {data.alpha}")
print(f"BitArray for register 'beta': {data.beta}")

BitArray for register 'alpha': BitArray(<shape=(), num_shots=1024, num_bits=1>)
BitArray for register 'beta': BitArray(<shape=(), num_shots=1024, num_bits=9>)

print(f"The shape of register `alpha` is {data.alpha.array.shape}.")
print(f"The bytes in register `alpha`, shot by shot:\n{data.alpha.array}\n")

print(f"The shape of register `beta` is {data.beta.array.shape}.")
print(f"The bytes in register `beta`, shot by shot:\n{data.beta.array}\n")

# post-select the bitstrings of `beta` based on having sampled "1" in `alpha`
mask = data.alpha.array == "0b1"
ps_beta = data.beta[mask[:, 0]]
print(f"The shape of `beta` after post-selection is {ps_beta.array.shape}.")
print(f"The bytes in `beta` after post-selection:\n{ps_beta.array}")

# get a slice of `beta` to retrieve the first three bits
beta_sl_bits = data.beta.slice_bits([0, 1, 2])
print(
    f"The shape of `beta` after bit-wise slicing is {beta_sl_bits.array.shape}."
)
print(f"The bytes in `beta` after bit-wise slicing:\n{beta_sl_bits.array}\n")

# get a slice of `beta` to retrieve the bytes of the first five shots
beta_sl_shots = data.beta.slice_shots([0, 1, 2, 3, 4])
print(
    f"The shape of `beta` after shot-wise slicing is {beta_sl_shots.array.shape}."
)
print(
    f"The bytes in `beta` after shot-wise slicing:\n{beta_sl_shots.array}\n"
)

# calculate the expectation value of diagonal operators on `beta`
ops = [SparsePauliOp("ZZZZZZZZZ"), SparsePauliOp("IIIIIIIIZ")]
exp_vals = data.beta.expectation_values(ops)
for o, e in zip(ops, exp_vals):
    print(f"Exp. val. for observable `{o}` is: {e}")

# concatenate the bitstrings in `alpha` and `beta` to "merge" the results
# of the two registers
merged_results = BitArray.concatenate_bits([data.alpha, data.beta])
print(f"\nThe shape of the merged results is {merged_results.array.shape}.")
print(f"The bytes of the merged results:\n{merged_results.array}\n")

Memanfaatkan objek BitArray untuk pemprosesan pasca yang berprestasi

Memandangkan tatasusunan umumnya menawarkan prestasi yang lebih baik berbanding kamus, adalah disyorkan untuk melakukan sebarang pemprosesan pasca terus pada objek BitArray dan bukannya pada kamus kiraan. Kelas BitArray menawarkan pelbagai kaedah untuk melakukan beberapa operasi pemprosesan pasca yang biasa:

The shape of register `alpha` is (1024, 1).
The bytes in register `alpha`, shot by shot:
[[1]
 [1]
 [1]
 ...
 [0]
 [0]
 [1]]

The shape of register `beta` is (1024, 2).
The bytes in register `beta`, shot by shot:
[[  1 255]
 [  1 255]
 [  1 255]
 ...
 [  0   0]
 [  0   0]
 [  1 255]]

The shape of `beta` after post-selection is (0, 2).
The bytes in `beta` after post-selection:
[]
The shape of `beta` after bit-wise slicing is (1024, 1).
The bytes in `beta` after bit-wise slicing:
[[7]
 [7]
 [7]
 ...
 [0]
 [0]
 [7]]

The shape of `beta` after shot-wise slicing is (5, 2).
The bytes in `beta` after shot-wise slicing:
[[  1 255]
 [  1 255]
 [  1 255]
 [  1 255]
 [  1 255]]

Exp. val. for observable `SparsePauliOp(['ZZZZZZZZZ'],
              coeffs=[1.+0.j])` is: -0.017578125
Exp. val. for observable `SparsePauliOp(['IIIIIIIIZ'],
              coeffs=[1.+0.j])` is: -0.017578125

The shape of the merged results is (1024, 2).
The bytes of the merged results:
[[  3 255]
 [  3 255]
 [  3 255]
 ...
 [  0   0]
 [  0   0]
 [  3 255]]

Metadata hasil

Selain hasil pelaksanaan, objek PrimitiveResult dan PubResult mengandungi atribut metadata yang opsyenal tentang tugas yang diserahkan. Metadata yang dikembalikan (jika ada) adalah khusus pelaksanaan.

# Print out the results metadata
print("The metadata of the PrimitiveResult is:")
for key, val in result.metadata.items():
    print(f"'{key}' : {val},")

print("\nThe metadata of the PubResult result is:")
for key, val in result[0].metadata.items():
    print(f"'{key}' : {val},")

The metadata of the PrimitiveResult is:
'version' : 2,

The metadata of the PubResult result is:
'shots' : 1024,
'circuit_metadata' : {},

Langkah seterusnya

Cadangan

• Semak API primitif Qiskit.
• Semak API primitif Qiskit Aer.
• Ketahui lebih lanjut tentang primitif Qiskit Runtime.
• Semak API Qiskit Runtime Estimator.
• Semak API Qiskit Runtime Sampler.