שינויי תכונות ב-Qiskit 1.0

מדריך זה מתאר נתיבי מעבר עבור שינויי התכונות החשובים ביותר ב-Qiskit 1.0, מאורגנים לפי מודול. השתמש בתוכן העניינים בצד ימין כדי לנווט למודול שאתה מעוניין בו.

כלי המעבר של Qiskit 1.0

כדי להקל על תהליך המעבר, אתה יכול להשתמש בכלי flake8-qiskit-migration לזיהוי נתיבי ייבוא שהוסרו בקוד שלך והצעת חלופות.

הרצה עם pipx
הרצה עם venv

אם יש לך pipx מותקן, פשוט הרץ את הפקודה הבאה.

pipx run flake8-qiskit-migration <path-to-source-directory>

פעולה זו תתקין את החבילה בסביבה וירטואלית זמנית ותריץ אותה על הקוד שלך.

אם אינך רוצה להשתמש ב-pipx, תוכל ליצור ידנית סביבה חדשה עבור הכלי. גישה זו גם מאפשרת לך להשתמש ב- nbqa כדי לבדוק דוגמאות קוד במחברות Jupyter. מחק את הסביבה כשתסיים.

# Make new environment and install
python -m venv .flake8-qiskit-migration-venv
source .flake8-qiskit-migration-venv/bin/activate
pip install flake8-qiskit-migration

# Run plugin on Python code
flake8 --select QKT100 <path-to-source-directory>  # e.g. `src/`

# (Optional) run plugin on notebooks
pip install nbqa
nbqa flake8 ./**/*.ipynb --select QKT100

# Deactivate and delete environment
deactivate
rm -r .flake8-qiskit-migration-venv

מגבלות

כלי זה מזהה רק נתיבי ייבוא שהוסרו. הוא אינו מזהה שימוש בשיטות שהוסרו (כגון QuantumCircuit.qasm) או ארגומנטים. הוא גם אינו יכול לעקוב אחר השמות כגון qk = qiskit, אם כי הוא יכול לטפל בכינויים כגון import qiskit as qk.

למידע נוסף, ראה את מאגר הפרויקט.

מופעים ופונקציות גלובליים

Aer

האובייקט qiskit.Aer אינו זמין ב-Qiskit 1.0. במקום זאת, השתמש באותו אובייקט ממרחב השמות qiskit_aer, שהוא תחליף שקוף. כדי להתקין את qiskit_aer, הרץ:

pip install qiskit-aer

BasicAer

האובייקט qiskit.BasicAer אינו זמין ב-Qiskit 1.0. ראה את קטע המעבר של basicaer לאפשרויות מעבר.

execute

הפונקציה qiskit.execute אינה זמינה ב-Qiskit 1.0. פונקציה זו שימשה כעטיפה ברמה גבוהה סביב פונקציות transpile ו- run ב-Qiskit. במקום qiskit.execute, השתמש בפונקציה transpile ולאחר מכן ב- backend.run().

# Legacy path
from qiskit import execute

job = execute(circuit, backend)

# New path
from qiskit import transpile

new_circuit = transpile(circuit, backend)
job = backend.run(new_circuit)

לחלופין, ה-primitive Sampler שקולה מבחינה סמנטית לפונקציה qiskit.execute שהוסרה. המחלקה BackendSampler היא עטיפה גנרית לBackends שאינן תומכות ב-primitives:

from qiskit.primitives import BackendSampler

sampler = BackendSampler(backend)
job = sampler.run(circuit)

qiskit.circuit

QuantumCircuit.qasm

שיטת QuantumCircuit.qasm הוסרה. במקום זאת, השתמש ב- qasm2.dump או ב- qasm2.dumps.

לפלט מעוצב עם Pygments, עיין בחבילה העצמאית openqasm-pygments, מאחר ש-qasm2.dump ו-qasm2.dumps אינן מספקות פלט מצויר עם Pygments.

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)

# Old
qasm_str = qc.qasm()

# Alternative
from qiskit.qasm2 import dumps

qasm_str = dumps(qc)

# Alternative: Write to file
from qiskit.qasm2 import dump

with open("my_file.qasm", "w") as f:
    dump(qc, f)

שערי QuantumCircuit

שיטות Gate הבאות הוסרו לטובת שיטות מבוססות יותר המוסיפות את אותם שערים:

הוסר	חלופה
`QuantumCircuit.cnot`	`QuantumCircuit.cx`
`QuantumCircuit.toffoli`	`QuantumCircuit.ccx`
`QuantumCircuit.fredkin`	`QuantumCircuit.cswap`
`QuantumCircuit.mct`	`QuantumCircuit.mcx`
`QuantumCircuit.i`	`QuantumCircuit.id`
`QuantumCircuit.squ`	`QuantumCircuit.unitary`

שיטות Circuit הבאות הוסרו. במקום זאת, ניתן להחיל שערים אלה על Circuit עם QuantumCircuit.append.

הוסר	חלופה (append)
`QuantumCircuit.diagonal`	`DiagonalGate`
`QuantumCircuit.hamiltonian`	`HamiltonianGate`
`QuantumCircuit.isometry`	`Isometry`
`QuantumCircuit.iso`	`Isometry`
`QuantumCircuit.uc`	`UCGate`
`QuantumCircuit.ucrx`	`UCRXGate`
`QuantumCircuit.ucry`	`UCRYGate`
`QuantumCircuit.ucrz`	`UCRZGate`

לדוגמה, עבור DiagonalGate:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import DiagonalGate  # new location in the circuit library

circuit = QuantumCircuit(2)
circuit.h([0, 1])  # some initial state

gate = DiagonalGate([1, -1, -1, 1])
qubits = [0, 1]  # qubit indices on which to apply the gate
circuit.append(gate, qubits)  # apply the gate

שיטות QuantumCircuit הבאות הוסרו גם הן:

הוסר	חלופה
`QuantumCircuit.bind_parameters`	`QuantumCircuit.assign_parameters`
`QuantumCircuit.snapshot`	הוראות שמירה של `qiskit-aer`

qiskit.converters

הפונקציה qiskit.converters.ast_to_dag הוסרה מ-Qiskit. היא המירה את עץ התחביר המופשט שנוצר על ידי מנתח ה-OpenQASM 2 הישן ל- DAGCircuit. מאחר שמנתח ה-OpenQASM 2 הישן הוסר (ראה qiskit.qasm), פונקציה זו אינה משרתת עוד מטרה. במקום זאת, נתח את קבצי OpenQASM 2 שלך ל- QuantumCircuit באמצעות שיטות הקונסטרקטור QuantumCircuit.from_qasm_file או QuantumCircuit.from_qasm_str (או את המודול qiskit.qasm2), ולאחר מכן המר את ה-QuantumCircuit ל- DAGCircuit עם circuit_to_dag.

# Previous
from qiskit.converters import ast_to_dag
from qiskit.qasm import Qasm

dag = ast_to_dag(Qasm(filename="myfile.qasm").parse())

# Current alternative
import qiskit.qasm2
from qiskit.converters import circuit_to_dag

dag = circuit_to_dag(qiskit.qasm2.load("myfile.qasm"))

qiskit.extensions

המודול qiskit.extensions אינו זמין עוד. רוב האובייקטים שלו שולבו בספריית Circuit (qiskit.circuit.library). למעבר ל- המיקום החדש, פשוט החלף את qiskit.extensions ב-qiskit.circuit.library בנתיב ייבוא האובייקט. זהו תחליף שקוף.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

המחלקות שהועברו ל-qiskit.circuit.library הן:

DiagonalGate
HamiltonianGate
Initialize
Isometry
qiskit.circuit.library.generalized_gates.mcg_up_diag.MCGupDiag
UCGate
UCPauliRotGate
UCRXGate
UCRYGate
UCRZGate
UnitaryGate

המחלקות הבאות הוסרו מבסיס הקוד, מכיוון שפונקציותיהן היו כפולות או קשורות למודול extensions:

הוסר	חלופה
`SingleQubitUnitary`	`qiskit.circuit.library.UnitaryGate`
`Snapshot`	השתמש ב-הוראות שמירה של `qiskit-aer`
`ExtensionError`	מחלקת שגיאה רלוונטית

qiskit.primitives

השינוי הבולט ביותר במודול qiskit.primitives הוא הכנסת ממשק primitives V2 החדש. חלק זה מראה כיצד להעביר את זרימת העבודה שלך מ-primitives V1 ל-primitives V2, כמו גם השינויים הקטנים שחלו בקלטים המתקבלים על ידי ממשק V1.

הערה

החל מגרסה 1.0, נתייחס לממשק primitives שקדם ל-1.0 כ-"primitives V1".

מעבר מ-V1 ל-V2

ההבחנה הפורמלית בין ממשקי primitives V1 ו-V2 היא מחלקות הבסיס שמהן יורשות מימושי primitives. למעבר למחלקות הבסיס החדשות, תוכל לשמור על נתיב הייבוא המקורי מ-qiskit.primitives:

מעבר מ-	החלף ב-
`BaseEstimator`	`BaseEstimatorV2`
`BaseSampler`	`BaseSamplerV2`

שמות מימושי הליבה של qiskit עבור primitives V2 (אלה הניתנים לייבוא מ-qiskit.primitives), שונו כדי להבהיר את מטרתם כמימושים שניתן להריץ באופן מקומי עם Backend סימולטור statevector. השמות החדשים אינם כוללים את הסיומת -V2.

מעבר מ-	החלף ב-
`qiskit.primitives.Estimator`	`qiskit.primitives.StatevectorEstimator`
`qiskit.primitives.Sampler`	`qiskit.primitives.StatevectorSampler`

ישנם כמה הבדלים רעיוניים לחשוב עליהם בעת המעבר מ-V1 ל-V2. הבדלים אלה מוכתבים על ידי מחלקת הבסיס, אך מוצגים בדוגמאות הבאות באמצעות מימושי statevector שנמצאים ב-qiskit.primitives:

הערה

לדוגמאות הבאות, הנח את הייבואים ואתחולי ה-primitive הבאים:

from qiskit.primitives import (
    Sampler,
    StatevectorSampler,
    Estimator,
    StatevectorEstimator,
)

estimator_v1 = Estimator()
sampler_v1 = Sampler()
estimator_v2 = StatevectorEstimator()
sampler_v2 = StatevectorSampler()

# define circuits, observables and parameter values

Sampler ו-Estimator: ה-primitives החדשות של V2 מתוכננות לקבל קלטים וקטוריים, שבהם ניתן לקבץ Circuits בודדות עם מפרטים בעלי ערכי מערך. כלומר, Circuit אחת יכולה להתבצע עבור מערכים של n קבוצות פרמטרים, n observable, או שניהם (במקרה של estimator). כל קבוצה נקראת primitive unified bloc (pub), וניתן לייצגה כ-tuple: (1 x circuit, [n x observables], [n x parameters]). ממשק V1 לא אפשר את אותה גמישות. במקום זאת, מספר ה-Circuits הקלטיות נאלץ להתאים למספר ה-observables ו- קבוצות הפרמטרים, כפי שמוצג בדוגמאות הבאות (בחר לשונית כדי לראות כל דוגמה):

Estimator, 1 circuit, 4 observables
Sampler, 1 circuit, 3 parameter sets
Estimator, 1 circuit, 4 observables, 2 parameter sets

# executing 1 circuit with 4 observables using Estimator V1
job = estimator_v1.run([circuit] * 4, [obs1, obs2, obs3, obs4])
evs = job.result().values

# executing 1 circuit with 4 observables using Estimator V2
job = estimator_v2.run([(circuit, [obs1, obs2, obs3, obs4])])
evs = job.result()[0].data.evs

# executing 1 circuit with 3 parameter sets using Sampler V1
job = sampler_v1.run([circuit] * 3, [vals1, vals2, vals3])
dists = job.result().quasi_dists

# executing 1 circuit with 3 parameter sets using Sampler V2
job = sampler_v2.run([(circuit, [vals1, vals2, vals3])])
counts = job.result()[0].data.meas.get_counts()

# executing 1 circuit with 4 observables and 2 parameter sets using Estimator V1
job = estimator_v1.run([circuit] * 8, [obs1, obs2, obs3, obs4] * 2, [vals1, vals2] * 4)
evs = job.result().values

# executing 1 circuit with 4 observables and 2 parameter sets using Estimator V2
job = estimator_v2.run([(circuit, [[obs1, obs2, obs3, obs4]], [[vals1], [vals2]])])
evs = job.result()[0].data.evs

ה-primitives של V2 מקבלות מספר PUBs כקלטים, וכל PUB מקבל את התוצאה שלו. זה מאפשר לך להריץ Circuits שונות עם שילובים שונים של פרמטרים/observables, דבר שלא תמיד היה אפשרי בממשק V1:

Sampler, 2 circuits, 1 parameter set
Estimator, 2 circuits, 2 different observables

# executing 2 circuits with 1 parameter set using Sampler V1
job = sampler_v1.run([circuit1, circuit2], [vals1] * 2)
dists = job.result().quasi_dists

# executing 2 circuits with 1 parameter set using Sampler V2
job = sampler_v2.run([(circuit1, vals1), (circuit2, vals1)])
counts1 = job.result()[0].data.meas.get_counts()  # result for pub 1 (circuit 1)
counts2 = job.result()[1].data.meas.get_counts()  # result for pub 2 (circuit 2)

# executing 2 circuits with 2 different observables using Estimator V1
job = estimator_v1.run([circuit1, circuit2] , [obs1, obs2])
evs = job.result().values

# executing 2 circuits with 2 different observables using Estimator V2
job = estimator_v2.run([(circuit1, obs1), (circuit2, obs2)])
evs1 = job.result()[0].data.evs  # result for pub 1 (circuit 1)
evs2 = job.result()[1].data.evs  # result for pub 2 (circuit 2)

Sampler: ה-Sampler של V2 מחזיר כעת דגימות תוצאות מדידה בצורת מחרוזות סיביות או ספירות, במקום התפלגויות ה-quasi-probability מממשק V1. מחרוזות הסיביות מציגות את תוצאות המדידה, תוך שמירה על סדר ה-shots שבו נמדדו. אובייקטי התוצאה של ה-Sampler של V2 מארגנים נתונים לפי שמות הרגיסטר הקלאסי של Circuits הקלט שלהם, לצורך תאימות עם Circuits דינמיות.

# Define quantum circuit with 2 qubits
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()
circuit.draw()

        ┌───┐      ░ ┌─┐
   q_0: ┤ H ├──■───░─┤M├───
        └───┘┌─┴─┐ ░ └╥┘┌─┐
   q_1: ─────┤ X ├─░──╫─┤M├
             └───┘ ░  ║ └╥┘
meas: 2/══════════════╩══╩═
                      0  1

שם הרגיסטר הקלאסי ברירת המחדל

ב-Circuit לעיל, שים לב ששם הרגיסטר הקלאסי מוגדר כברירת מחדל כ-"meas". שם זה ישמש מאוחר יותר לגישה למחרוזות הסיביות של המדידה.

# Run using V1 sampler
result = sampler_v1.run(circuit).result()
quasi_dist = result.quasi_dists[0]
print(f"The quasi-probability distribution is: {quasi_dist}")

The quasi-probability distribution is: {0: 0.5, 3: 0.5}

# Run using V2 sampler
result = sampler_v2.run([circuit]).result()
# Access result data for pub 0
data_pub = result[0].data
# Access bitstrings for the classical register "meas"
bitstrings = data_pub.meas.get_bitstrings()
print(f"The number of bitstrings is: {len(bitstrings)}")
# Get counts for the classical register "meas"
counts = data_pub.meas.get_counts()
print(f"The counts are: {counts}")

The number of bitstrings is: 1024
The counts are: {'00': 523, '11': 501}

Sampler ו-Estimator: עלות הדגימה, שנחשפת בדרך כלל על ידי מימושי V1 דרך אפשרות הריצה shots, היא כעת ארגומנט של שיטת run() של ה-primitives שניתן לציין ברמת PUB. מחלקות הבסיס של V2 חושפות את הארגומנטים בפורמטים שונים מממשק V1:
- BaseSamplerV2.run חושף ארגומנט shots (בדומה לזרימת העבודה הקודמת):
  # Sample two circuits at 128 shots each. sampler_v2.run([circuit1, circuit2], shots=128) # Sample two circuits at different amounts of shots. The "None"s are necessary # as placeholders # for the lack of parameter values in this example. sampler_v2.run([(circuit1, None, 123), (circuit2, None, 456)])
- EstimatorV2.run מכניס ארגומנט precision המציין את פסי השגיאה שמימוש ה-primitive אמור לכוון אליהם עבור הערכות ערכי ציפייה:
  # Estimate expectation values for two PUBs, both with 0.05 precision. estimator_v2.run([(circuit1, obs_array1), (circuit2, obs_array_2)], precision=0.05)

עדכונים בממשק V1

המרה מרומזת מ-BaseOperator צפוף ל- SparsePauliOp ב- ארגומנטי observable של Estimator אינה מותרת עוד. עליך להמיר במפורש ל-SparsePauliOp באמצעות SparsePauliOp.from_operator(operator) במקום זאת.
שימוש ב-PauliList ב- ארגומנטי observable של Estimator אינו מותר עוד. במקום זאת עליך להמיר את הארגומנט במפורש באמצעות SparsePauliOp(pauli_list) תחילה.

qiskit.providers

basicaer

רוב הפונקציונליות במודול qiskit.providers.basicaer הוחלפה ב- מודול החדש qiskit.providers.basic_provider, למעט המחלקות UnitarySimulatorPy ו-StatevectorSimulatorPy שהוסרו; הפונקציונליות שלהן כבר הייתה כלולה ב- מודול quantum_info.

המעבר לנתיבים החדשים הוא פשוט. תוכל להחליף רוב המחלקות ב-qiskit.providers.basicaer במקבילותיהן ב- qiskit.providers.basic_provider (תחליף שקוף). שים לב שלמחלקות הבאות יש נתיבים ושמות חדשים:

הוסר	חלופה
`qiskit.providers.basicaer`	`qiskit.providers.basic_provider`
`BasicAerProvider`	`BasicProvider`
`BasicAerJob`	`BasicProviderJob`
`QasmSimulatorPy`	`BasicSimulator`

מופעים גלובליים

היזהר ממופעים גלובליים בעת המעבר למודול החדש. אין תחליף ל- מופע הגלובלי BasicAer שניתן לייבא ישירות כ-qiskit.BasicAer. פירוש הדבר הוא ש- from qiskit import BasicProvider אינו עוד ייבוא תקף. במקום זאת, מחלקת ה-provider חייבת להיות מיובאת מתת-המודול שלה ומאותחלת על ידי המשתמש:

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("backend_name")

# Current
from qiskit.providers.basic_provider import BasicProvider
backend = BasicProvider().get_backend("backend_name")

ניתן להחליף את סימולטורי unitary ו-statevector ב- מחלקות quantum_info שונות. זהו לא תחליף שקוף, אך השינויים מינימליים. ראה דוגמאות המעבר הבאות:

הוסר	חלופה
`UnitarySimulatorPy`	`quantum_info.Operator`
`StatevectorSimulatorPy`	`quantum_info.Statevector`

הדוגמאות הבאות מציגות את נתיבי המעבר של סימולטורי basicaer.

Statevector simulator
Unitary simulator
QASM simulator

from qiskit import QuantumCircuit

qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1, 2)
qc.measure_all()

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("statevector_simulator")
statevector = backend.run(qc).result().get_statevector()

# Current
qc.remove_final_measurements()  # no measurements allowed
from qiskit.quantum_info import Statevector
statevector = Statevector(qc)

from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1, 2)
qc.measure_all()

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("unitary_simulator")
result = backend.run(qc).result()

# Current
qc.remove_final_measurements()  # no measurements allowed
from qiskit.quantum_info import Operator
result = Operator(qc).data

from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1, 2)
qc.measure_all()

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("qasm_simulator")
result = backend.run(qc).result()

# One current option
from qiskit.providers.basic_provider import BasicProvider
backend = BasicProvider().get_backend("basic_simulator")
result = backend.run(qc).result()

# Another current option is to specify it directly
from qiskit.providers.basic_provider import BasicSimulator
backend = BasicSimulator()
result = backend.run(qc).result()

fake_provider

רוב הרכיבים הגלויים למשתמש של qiskit.providers.fake_provider הועברו לחבילת Python qiskit-ibm-runtime. זה כולל את מחלקות ה-fake provider, את כל ה-Backends המזויפים הספציפיים לסביבה (כגון FakeVigo, FakeNairobiV2 ו-FakeSherbrooke), ואת מחלקות הבסיס של ה-fake backend. לחץ על הלשוניות הבאות כדי לראות את המחלקות המושפעות.

Fake Backends
Fake Providers

כל מחלקה ב-qiskit.providers.fake_provider.backends
fake_provider.fake_backend.FakeBackend
fake_provider.fake_backend.FakeBackendV2

fake_provider.FakeProvider
fake_provider.FakeProviderForBackendV2
fake_provider.FakeProviderFactory

למעבר לנתיב החדש:

התקן את qiskit-ibm-runtime גרסה 0.17.1 ומעלה:
```
pip install 'qiskit-ibm-runtime>=0.17.1'
```

החלף מופעים של qiskit.providers.fake_provider בקוד שלך ב- qiskit_ibm_runtime.fake_provider. לדוגמה:

# Old
from qiskit.providers.fake_provider import FakeProvider
backend1 = FakeProvider().get_backend("fake_ourense")

from qiskit.providers.fake_provider import FakeSherbrooke
backend2 = FakeSherbrooke()

# Alternative
from qiskit_ibm_runtime.fake_provider import FakeProvider
backend1 = FakeProvider().get_backend("fake_ourense")

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke
backend2 = FakeSherbrooke()

מחלקות הבסיס של ה-fake backend הועברו גם הן, אך יש הבדלים קטנים בנתיב הייבוא:

הוסר	חלופה
`qiskit.providers.fake_provider.FakeQasmBackend`	`qiskit_ibm_runtime.fake_provider.fake_qasm_backend.FakeQasmBackend`
`qiskit.providers.fake_provider.FakePulseBackend`	`qiskit_ibm_runtime.fake_provider.fake_pulse_backend.FakePulseBackend`

הערה

אם אתה מסתמך על fake backends לבדיקת יחידה של ספרייה במורד הזרם ויש לך קונפליקטים עם התלות ב-qiskit-ibm-runtime, תוכל גם למצוא חלופות fake backend גנריות חדשות המקוריות ל-Qiskit. אלה כוללות את מחלקות BackendV1 הבאות (תחליפים שקופים):

זוהי מחלקה הניתנת להגדרה שמחזירה מופעי BackendV2:

qiskit.providers.fake_provider.GenericBackendV2

fake_provider (Backends לבדיקות מיוחדות)

מחלקות ה-fake backend למטרות בדיקה מיוחדות ב- qiskit.providers.fake_provider לא הועברו ל-qiskit_ibm_runtime.fake_provider. נתיב המעבר המומלץ הוא להשתמש במחלקה החדשה GenericBackendV2 להגדרת Backend עם מאפיינים דומים או לבנות Target מותאם אישית.

הוסר	חלופה
`fake_provider.FakeBackendV2`	`fake_provider.GenericBackendV2`
`fake_provider.FakeBackend5QV2`	`fake_provider.GenericBackendV2`
`fake_provider.FakeBackendV2LegacyQubitProps`	`fake_provider.GenericBackendV2`
`fake_provider.FakeBackendSimple`	`fake_provider.GenericBackendV2`
`fake_provider.ConfigurableFakeBackend`	`fake_provider.GenericBackendV2`

דוגמה: מעבר למחלקה החדשה GenericBackendV2:

# Legacy path
from qiskit.providers.fake_provider import FakeBackend5QV2
backend = FakeBackend5QV2()

# New path
from qiskit.providers.fake_provider import GenericBackendV2
backend = GenericBackendV2(num_qubits=5)

# Note that this class generates a 5q backend with generic
# properties that serves the same purpose as FakeBackend5QV2
# but will not be identical.

טיפים נוספים למעבר

ייבוא מ-qiskit.providers.aer אינו אפשרי עוד. במקום זאת, ייבא מ-qiskit_aer, שהוא תחליף שקוף. כדי להתקין את qiskit_aer, הרץ:
```
pip install qiskit-aer
```
תמיכה בהרצת עבודות pulse על Backends מ- qiskit.providers.fake_provider הוסרה ב-Qiskit 1.0. הסיבה לכך היא ש-Qiskit Aer הסיר את פונקציונליות הסימולציה שלו עבור עבודות כאלה. עבור עומסי עבודה של סימולציית Hamiltonian ברמה נמוכה, שקול להשתמש בספרייה מיוחדת כגון Qiskit Dynamics.

qiskit.pulse

ParametricPulse

מחלקת הבסיס qiskit.pulse.library.parametric_pulses.ParametricPulse וספריית ה-pulse הוחלפו על ידי qiskit.pulse.SymbolicPulse וספריית ה-pulse המתאימה. SymbolicPulse תומכת בסידור QPY:

from qiskit import pulse, qpy

with pulse.build() as schedule:
    pulse.play(pulse.Gaussian(100, 0.1, 25), pulse.DriveChannel(0))

with open('schedule.qpy', 'wb') as fd:
    qpy.dump(schedule, fd)

הוסר	חלופה
`pulse.library.parametric_pulses.ParametricPulse`	`qiskit.pulse.SymbolicPulse`
`pulse.library.parametric_pulses.Constant`	`pulse.library.symbolic_pulses.Constant`
`pulse.library.parametric_pulses.Drag`	`pulse.library.symbolic_pulses.Drag`
`pulse.library.parametric_pulses.Gaussian`	`pulse.library.symbolic_pulses.Gaussian`
`qiskit.pulse.library.parametric_pulses.GaussianSquare`	`pulse.library.symbolic_pulses.GaussianSquare`

אמפליטודה בעלת ערך מרוכב

אמפליטודה pulse בעלת ערך מרוכב (amp) מוחלפת בצמד (amp, angle). ייצוג זה אינטואיטיבי יותר, במיוחד עבור כמה משימות כיול כגון כיול זווית:

from qiskit import pulse
from qiskit.circuit import Parameter
from math import pi

with pulse.build() as schedule:
    angle = Parameter("θ")
    pulse.play(pulse.Gaussian(100, 0.1, 25, angle=angle), pulse.DriveChannel(0))
schedule.assign_parameters({angle: pi})

הזרקת פעולות Gate של Circuit

הזרקת פעולות Gate של Circuit להקשר ה-pulse builder דרך qiskit.pulse.builder.call אינה אפשרית עוד. הסרה זו משפיעה על ארגומנטי קלט מסוג QuantumCircuit, כמו גם על הפונקציות הבאות:

qiskit.pulse.builder.call_gate
qiskit.pulse.builder.cx
qiskit.pulse.builder.u1
qiskit.pulse.builder.u2
qiskit.pulse.builder.u3
qiskit.pulse.builder.x

אם אתה עדיין רוצה להזריק לוחות זמנים מכויילי Backend, השתמש בתבנית הבאה במקום לקרוא לפקודות Gate.

from qiskit.providers.fake_provider import GenericBackendV2
from qiskit import pulse

backend = GenericBackendV2(num_qubits=5)
sched = backend.target["x"][(qubit,)].calibration

with pulse.build() as only_pulse_scheds:
    pulse.call(sched)

באופן דומה, ניתן להזריק QuantumCircuit ל- הקשר ה-builder על ידי transpiling ותזמון ידני של האובייקט.

from math import pi
from qiskit.compiler import schedule, transpile

qc = QuantumCircuit(2)
qc.rz(pi / 2, 0)
qc.sx(0)
qc.rz(pi / 2, 0)
qc.cx(0, 1)
qc_t = transpile(qc, backend)
sched = schedule(qc_t, backend)
with pulse.build() as only_pulse_scheds:
    pulse.call(sched)

אנו ממליצים לכתוב תוכנית pulse מינימלית עם ה-builder ולצרף אותה ל- QuantumCircuit דרך שיטת QuantumCircuit.add_calibration כ-microcode של הוראת Gate, במקום לכתוב את כל התוכנית עם מודל ה-pulse.

builder.build

הארגומנטים הבאים ב-qiskit.pulse.builder.build הוסרו ללא חלופה.

default_transpiler_settings
default_circuit_scheduler_settings

פונקציות אלה הוסרו גם הן:

qiskit.pulse.builder.active_transpiler_settings
qiskit.pulse.builder.active_circuit_scheduler_settings
qiskit.pulse.builder.transpiler_settings
qiskit.pulse.builder.circuit_scheduler_settings

הסיבה לכך היא שאין עוד אפשרות להזריק אובייקטי Circuit להקשר ה- builder (ראה הזרקת פעולות Gate של Circuit); הגדרות אלה שימשו להמרת אובייקטים שהוזרקו לייצוגי pulse.

library

ספריית ה-pulse הבדידה הוסרה מבסיס הקוד. זה כולל:

qiskit.pulse.library.constant
qiskit.pulse.library.zero
qiskit.pulse.library.square
qiskit.pulse.library.sawtooth
qiskit.pulse.library.triangle
qiskit.pulse.library.cos
qiskit.pulse.library.sin
qiskit.pulse.library.gaussian
qiskit.pulse.library.gaussian_deriv
qiskit.pulse.library.sech
qiskit.pulse.library.sech_deriv
qiskit.pulse.library.gaussian_square
qiskit.pulse.library.drag

במקום זאת, השתמש ב- qiskit.pulse.SymbolicPulse המתאים, עם SymbolicPulse.get_waveform(). לדוגמה, במקום pulse.gaussian(100,0.5,10), השתמש ב- pulse.Gaussian(100,0.5,10).get_waveform(). שים לב שהפאזה של גם Sawtooth וגם Square מוגדרת כך שפאזה של 2\\pi מזיזה במחזור מלא, בניגוד ל- מקבילה הבדידה. שים לב גם שאמפליטודות מרוכבות אינן נתמכות עוד ב- ספריית ה-pulse הסימבולית; השתמש ב-float, amp ו-angle במקום זאת.

ScalableSymbolicPulse

אין עוד אפשרות לטעון אובייקטים qiskit.pulse.ScalableSymbolicPulse של הספרייה עם פרמטר amp מרוכב מקבצי qpy מגרסה 5 או קודמות (Qiskit Terra < 0.23.0). אין צורך בפעולת מעבר, מכיוון ש-amp המרוכב יומר אוטומטית ל-float (amp, angle).

שינוי זה חל על pulses אלה:

qiskit.qasm

מודול מנתח OpenQASM 2 הישן שהיה בעבר ב-qiskit.qasm הוחלף על ידי מודול qiskit.qasm2, המספק מנתח מהיר ומדויק יותר עבור OpenQASM 2. שיטות QuantumCircuit ברמה גבוהה from_qasm_file() ו- from_qasm_str() נשארות זהות, אך ישתמשו במנתח החדש באופן פנימי. עם זאת, הממשק הציבורי למודול qasm2 אינו זהה. בעוד שמודול qiskit.qasm סיפק ממשק לעץ תחביר מופשט שהוחזר על ידי ספריית מנתח ply, qiskit.qasm2 אינו חושף את ה-AST או כל פרטי מימוש ברמה נמוכה יותר על המנתח. הוא במקום זאת מקבל קלט OpenQASM 2 ומפיק אובייקט QuantumCircuit.

לדוגמה, אם בעבר הרצת משהו כזה:

import qiskit.qasm
from qiskit.converters import ast_to_dag, dag_to_circuit

ast = qiskit.qasm.Qasm(filename="myfile.qasm").parse()
dag = ast_to_dag(ast)
qasm_circ = dag_to_circuit(dag)

החלף זאת בבאות:

import qiskit.qasm2

qasm_circ = qiskit.qasm2.load("myfile.qasm")

qiskit.quantum_info

מודול qiskit.quantum_info.synthesis הועבר למיקומים שונים בבסיס הקוד, בעיקר qiskit.synthesis.

הוסר	חלופה
`OneQubitEulerDecomposer`	`qiskit.synthesis.one_qubit.OneQubitEulerDecomposer`
`TwoQubitBasisDecomposer`	`qiskit.synthesis.two_qubits.TwoQubitBasisDecomposer`
`XXDecomposer`	`qiskit.synthesis.two_qubits.XXDecomposer`
`two_qubit_cnot_decompose`	`qiskit.synthesis.two_qubits.two_qubit_cnot_decompose`
`Quaternion`	`qiskit.quantum_info.Quaternion`

העברה זו לא השפיעה על נתיב הייבוא הרגיל של Quaternion, אך אין עוד אפשרות לגשת אליו דרך qiskit.quantum_info.synthesis.

לבסוף, cnot_rxx_decompose הוסרה.

qiskit.test

המודול qiskit.test אינו עוד מודול ציבורי. זה מעולם לא היה מיועד להיות ציבורי, ולא לשימוש מחוץ לחבילת הבדיקות של Qiskit. כל הפונקציונליות הייתה ספציפית ל-Qiskit ואין חלופה מסופקת; אם היית צריך פונקציונליות דומה, עליך לכלול אותה ב- פריסות הבדיקה שלך.

qiskit.tools

המודול qiskit.tools הוסר ב-Qiskit 1.0. רוב הפונקציונליות הזו הוחלפה בפונקציונליות דומה בחבילות אחרות או הוסרה ללא חלופה. היוצא הדופן העיקרי הוא הפונקציה qiskit.tools.parallel_map(), שהועברה ל- מודול qiskit.utils. ניתן להשתמש בה ממיקום חדש זה במקום זאת. לדוגמה:

אם בעבר הרצת:

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

jupyter

תת-המודול qiskit.tools.jupyter הוסר מכיוון שהפונקציונליות במודול זה קשורה לחבילת qiskit-ibmq-provider הישנה, שאינה נתמכת עוד. הוא גם תמך רק ב-BackendV1 ולא בממשק BackendV2 החדש יותר.

monitor

תת-המודול qiskit.tools.monitor הוסר מכיוון שהוא היה קשור ל- חבילת qiskit-ibmq-provider הישנה, שאינה נתמכת עוד (הוא גם תמך רק בממשק BackendV1 ולא בממשק החדש יותר BackendV2). אין חלופה מסופקת לפונקציונליות זו.

visualization

תת-המודול qiskit.tools.visualization הוסר. מודול זה היה הפניה ישנה ממיקום המקורי של מודול ה-visualization של Qiskit ו- הועבר ל-qiskit.visualization ב-Qiskit 0.8.0. אם אתה עדיין משתמש בנתיב זה, עדכן את הייבואים שלך מ- qiskit.tools.visualization ל- qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

events

מודול qiskit.tools.events והכלי progressbar() שהוא חשף הוסרו. הפונקציונליות של מודול זה לא הייתה בשימוש נרחב וניתן לכסותה טוב יותר על ידי חבילות ייעודיות כגון tqdm.

qiskit.transpiler

synthesis

הפריטים במודול qiskit.transpiler.synthesis הועברו למיקומים חדשים:

הוסר	חלופה
`qiskit.transpiler.synthesis.aqc` (למעט `AQCSynthesisPlugin`)	`qiskit.synthesis.unitary.aqc`
`qiskit.transpiler.synthesis.graysynth`	`qiskit.synthesis.synth_cnot_phase_aam`
`qiskit.transpiler.synthesis.cnot_synth`	`qiskit.synthesis.synth_cnot_count_full_pmh`

passes

מעבר ה-Transpiler NoiseAdaptiveLayout הוחלף על ידי VF2Layout ו- VF2PostLayout, שמגדירים פריסה המבוססת על מאפייני הרעש המדווחים של Backend. גם המעבר וגם פלאגין שלב הפריסה המתאים "noise_adaptive" הוסרו מ-Qiskit.

מעבר ה-Transpiler CrosstalkAdaptiveSchedule הוסר מ- בסיס הקוד. מעבר זה לא היה עוד שמיש מכיוון שפעולתו הפנימית הייתה תלויה במאפיינים מותאמים אישית שהוגדרו במטען BackendProperties של מופע BackendV1. מאחר שאין Backends שמגדירים שדות אלה, המעבר הוסר.

passmanager

שיטות ה-append של המחלקות ConditionalController, FlowControllerLinear, ו- DoWhileController הוסרו. במקום זאת, כל המשימות חייבות להיות מסופקות בעת בניית אובייקטי ה-controller.

qiskit.utils

הכלים הבאים ב-qiskit.utils הוסרו ללא תחליף:

qiskit.utils.arithmetic
qiskit.utils.circuit_utils
qiskit.utils.entangler_map
qiskit.utils.name_unnamed_args

פונקציות אלה שימשו באופן בלעדי במודולים qiskit.algorithms ו- qiskit.opflow, שהוסרו גם הם.

qiskit.visualization

המודול qiskit.visualization.qcstyle הוסר. השתמש ב- qiskit.visualization.circuit.qcstyle כתחליף ישיר.

כלי המעבר של Qiskit 1.0​

מופעים ופונקציות גלובליים​

Aer​

BasicAer​

execute​

qiskit.circuit​

QuantumCircuit.qasm​

שערי QuantumCircuit​

qiskit.converters​

qiskit.extensions​

qiskit.primitives​

מעבר מ-V1 ל-V2​

עדכונים בממשק V1​

qiskit.providers​

basicaer​

fake_provider​

fake_provider (Backends לבדיקות מיוחדות)​

טיפים נוספים למעבר​

qiskit.pulse​

ParametricPulse​

אמפליטודה בעלת ערך מרוכב​

הזרקת פעולות Gate של Circuit​

builder.build​

library​

ScalableSymbolicPulse​

qiskit.qasm​

qiskit.quantum_info​

qiskit.test​

qiskit.tools​

jupyter​

monitor​

visualization​

events​

qiskit.transpiler​

synthesis​

passes​

passmanager​

qiskit.utils​

qiskit.visualization​

כלי המעבר של Qiskit 1.0

מופעים ופונקציות גלובליים

Aer

BasicAer

execute

qiskit.circuit

QuantumCircuit.qasm

שערי QuantumCircuit

qiskit.converters

qiskit.extensions

qiskit.primitives

מעבר מ-V1 ל-V2

עדכונים בממשק V1

qiskit.providers

basicaer

fake_provider

fake_provider (Backends לבדיקות מיוחדות)

טיפים נוספים למעבר

qiskit.pulse

ParametricPulse

אמפליטודה בעלת ערך מרוכב

הזרקת פעולות Gate של Circuit

builder.build

library

ScalableSymbolicPulse

qiskit.qasm

qiskit.quantum_info

qiskit.test

qiskit.tools

jupyter

monitor

visualization

events

qiskit.transpiler

synthesis

passes

passmanager

qiskit.utils

qiskit.visualization