מדריך מהיר ל-Estimator

ה-primitive של Estimator מחשב את ערכי הציפייה עבור observable אחד או יותר ביחס למצבים שהוכנו על ידי מעגלים קוונטיים. המעגלים יכולים להיות פרמטריים, כל עוד ערכי הפרמטרים מסופקים גם כן כקלט ל-primitive.

ל-primitive זה יש מספר טכניקות הפחתת שגיאות ודיכוי שגיאות מובנות, כולל dynamical decoupling, Pauli-twirling, gate-folding ZNE, PEA ו-PEC. הוא גם תומך באפשרות resilience_level שמאפשרת לך להגדיר בקלות את הפשרה בין עלות לדיוק. השלבים בנושא זה מסבירים כיצד להגדיר את Estimator, לחקור את האפשרויות שאפשר להגדיר בו, ולהפעיל אותו בתוכנית.

גרסאות חבילות

הקוד בדף זה פותח תוך שימוש בדרישות הבאות. אנחנו ממליצים להשתמש בגרסאות אלה או חדשות יותר.

qiskit[all]~=2.4.0
qiskit-ibm-runtime~=0.46.1

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-runtime
```json

{/*Verified the v2 examples 2/29/24 - updated 10/29/24*/}

## שלבים לשימוש ב-primitive של Estimator \{#steps-to-use-the-estimator-primitive}

### 1. אתחול החשבון \{#1-initialize-the-account}

מכיוון ש-Qiskit Runtime הוא שירות מנוהל, קודם צריך לאתחל את החשבון שלך. לאחר מכן אפשר לבחור את ה-QPU שרוצים להשתמש בו לחישוב ערך הציפייה.

עקוב אחר השלבים ב[הגדרת חשבון IBM Cloud שלך](cloud-setup) אם עוד לא הגדרת חשבון.

:::note[שערים שברים]

כדי להשתמש ב-[שערים שברים](/guides/fractional-gates) הנתמכים החדשים, הגדר `use_fractional_gates=True` בעת בקשת backend ממופע `QiskitRuntimeService`. לדוגמה:
```python
service = QiskitRuntimeService()
fractional_gate_backend = service.least_busy(use_fractional_gates=True)

זוהי תכונה ניסיונית שעשויה להשתנות בעתיד.

:::

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)

print(backend.name)

ibm_fez

2. יצירת Circuit ו-observable

צריך לפחות Circuit אחד ו-observable אחד כקלטים ל-primitive של Estimator.

from qiskit.circuit.library import qaoa_ansatz
from qiskit.quantum_info import SparsePauliOp

entanglement = [tuple(edge) for edge in backend.coupling_map.get_edges()]
observable = SparsePauliOp.from_sparse_list(
    [("ZZ", [i, j], 0.5) for i, j in entanglement],
    num_qubits=backend.num_qubits,
)
circuit = qaoa_ansatz(observable, reps=2)
# The circuit is parametrized, so we will define the parameter values for execution
param_values = [0.1, 0.2, 0.3, 0.4]

ה-Circuit וה-observable צריכים להיות מוּמרים כך שישתמשו רק בהוראות הנתמכות על ידי ה-QPU (המכונות מעגלי instruction set architecture (ISA)). השתמש ב-Transpiler לשם כך.

from qiskit.transpiler import generate_preset_pass_manager

pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pm.run(circuit)
isa_observable = observable.apply_layout(isa_circuit.layout)
print(f">>> Circuit ops (ISA): {isa_circuit.count_ops()}")

>>> Circuit ops (ISA): OrderedDict([('rz', 4472), ('sx', 1884), ('cz', 1120)])

3. אתחול Qiskit Runtime Estimator

כשמאתחלים את Estimator, משתמשים בפרמטר mode כדי לציין את המצב שרוצים שהוא יפעל בו. הערכים האפשריים הם אובייקטי batch, session או backend למצב הרצת batch, session ו-job בהתאמה. למידע נוסף, ראו מבוא למצבי הרצה של Qiskit Runtime. שים לב שמשתמשי Open Plan לא יכולים להגיש עבודות session.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. הפעלת Estimator וקבלת תוצאות

לאחר מכן, הפעל את מתודת run() כדי לחשב ערכי ציפייה עבור מעגלים ו-observables הקלטים. ה-Circuit, ה-observable וסדרות ערכי הפרמטרים האופציונליות מוזנות כ-tuples מסוג primitive unified bloc (PUB).

job = estimator.run([(isa_circuit, isa_observable, param_values)])
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")

>>> Job ID: d82869ntjchs73bnokog

>>> Job Status: QUEUED

result = job.result()
print(f">>> {result}")
print(f"  > Expectation value: {result[0].data.evs}")
print(f"  > Metadata: {result[0].metadata}")

>>> PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(), dtype=float64>), stds=np.ndarray(<shape=(), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(), dtype=float64>)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})
  > Expectation value: 30.60337496305257
  > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

השלבים הבאים

המלצות

• למד כיצד לבדוק מקומית לפני הרצה על מחשבים קוונטיים.
• עיין בדוגמאות המפורטות.
• תרגל עם primitives באמצעות עבודה על שיעור פונקציית עלות בלימוד IBM Quantum.
• למד כיצד לבצע transpile מקומית בחלק Transpile.
• נסה את מדריך השוואת הגדרות Transpiler.
• למד כיצד להשתמש באפשרויות ה-primitive.
• עיין ב-API עבור אפשרויות Estimator.
• קרא מעבר ל-V2 primitives.