Änderungen an den Funktionen von Qiskit „ v1.0 “

Dieser Leitfaden beschreibt Migrationspfade für die wichtigsten Funktionsänderungen in Qiskit v1.0, gegliedert nach Modulen. Nutzen Sie das Inhaltsverzeichnis auf der rechten Seite, um zu dem Modul zu gelangen, das Sie interessiert.

Qiskit-Migrationstool für „ v1.0 “

Um den Migrationsprozess zu erleichtern, können Sie die flake8-qiskit-migration tool verwenden, um entfernte Importpfade in Ihrem Code zu erkennen und Alternativen vorzuschlagen.

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

# 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

Weitere Informationen finden Sie auf der Website des Projekts repository.

Globale Instanzen und Funktionen

Aer

Das qiskit.Aer Objekt ist in Qiskit v1.0 nicht verfügbar. Verwenden Sie stattdessen das gleiche Objekt aus dem qiskit_aer Namespace, das ein direkter Ersatz ist. Führen Sie zur Installation qiskit_aer folgenden Befehl aus:

pip install qiskit-aer

BasicAer

Das qiskit.BasicAer Objekt ist in Qiskit v1.0 nicht verfügbar. Informationen zu den Migrationsoptionen finden Sie im basicaerAbschnitt „Migration “.

ausführen

Die qiskit.execute Funktion ist in Qiskit v1.0 nicht verfügbar. Diese Funktion diente als hochrangiger Wrapper für die transpile Funktionen run und in Qiskit. qiskit.executeVerwenden Sie anstelle von die transpile Funktion, gefolgt von 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)

Alternativ dazu ist das Sampler primitiv semantisch äquivalent zur entfernten qiskit.execute funktion. Die Klasse BackendSampler ist eine generischer Wrapper für Backends, die keine Primitive unterstützen:

from qiskit.primitives import BackendSampler

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

qiskit.circuit

QuantumCircuit.qasm

Die Methode QuantumCircuit.qasm wurde entfernt. Verwenden Sie stattdessen qasm2.dump oder qasm2.dumps.

Für Pygments-formatierte Ausgabe, schauen Sie sich das Standalone openqasm-pygments paket, da qasm2.dump und qasm2.dumps keine mit Pygments gefärbte Ausgabe bieten.

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 Tore

Die folgenden Gattermethoden wurden zugunsten etablierterer Methoden entfernt methoden entfernt, die die gleichen Gates anhängen:

Die folgenden Schaltungsmethoden wurden entfernt. Stattdessen können diese Gatter auf eine Schaltung mit QuantumCircuit.append angewendet werden.

Zum Beispiel, für eine DiagonalGate:

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

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

Die folgenden QuantumCircuit Methoden wurden ebenfalls entfernt:

qiskit.converters

Die Funktion qiskit.converters.ast_to_dag wurde aus Qiskit entfernt. Er konvertiert den abstrakte Syntaxbaum, der vom alten OpenQASM 2 Parser erzeugt wurde, in einen DAGCircuit. Da der Legacy OpenQASM 2-Parser entfernt wurde (siehe qiskit.qasm ), erfüllt diese funktion nicht länger von Nutzen. Parsen Sie stattdessen Ihre OpenQASM 2 Dateien in QuantumCircuit unter Verwendung der QuantumCircuit.from_qasm_file oder QuantumCircuit.from_qasm_str konstruktormethoden (oder das qiskit.qasm2 modul), dann konvertieren Sie diese QuantumCircuit in eine DAGCircuit mit 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

Das Modul qiskit.extensions ist nicht mehr verfügbar. Die meisten seiner Objekte wurden in die Schaltkreisbibliothek integriert (qiskit.circuit.library). Für die Migration zum neuen Ort zu migrieren, ersetzen Sie einfach qiskit.extensions durch qiskit.circuit.library im Pfad für den Objektimport. Dies ist ein Drop-in-Ersatz.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Die Klassen, die nach qiskit.circuit.library sind:

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

Die folgenden Klassen wurden aus der Codebasis entfernt, da ihre funktionen entweder redundant oder mit dem Modul extensions verknüpft waren:

qiskit.primitives

Die auffälligste Änderung im qiskit.primitives modul ist die einführung der neuen Schnittstelle für Primitive V2. Dieser Abschnitt zeigt, wie Sie Ihren arbeitsablaufs von den Primitiven V1 auf die Primitiven V2, sowie die wenigen Änderungen, die sich bei den Eingaben, die von der Schnittstelle V1 akzeptiert werden.

Migrieren Sie von V1 zu V2

Der formale Unterschied zwischen den Primitiven V1 und V2 APIs sind die Basisklassen, von denen primitiv-Implementierungen erben. Um zu den neuen Basisklassen überzugehen, können Sie Folgendes beibehalten den ursprünglichen Importpfad von qiskit.primitives beibehalten:

Die Namen der qiskit-Kernimplementierungen der V2 -Primitive (die von qiskit.primitives importiert werden können), wurden geändert, um ihren Zweck als Implementierungen zu verdeutlichen, die lokal mit einem Zustandsvektor-Simulator-Backend. Die neuen Namen enthalten nicht das Suffix -V2.

Bei der Migration von V1 auf V2 gibt es einige konzeptionelle Unterschiede zu beachten. Diese Unterschiede sind durch die Basisklasse vorgegeben, werden aber in den folgenden Beispielen anhand der statevector implementierungen, die in qiskit.primitives zu finden sind:

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

1. Sampler and Estimator: Die neuen Primitive „ V2 “ sind so konzipiert, dass sie vektorisierte Eingaben akzeptieren, wobei einzelne Schaltungen mit Array-Werten gruppiert werden können. Das heißt, ein Durchlauf kann für Arrays von n Parametersätzen, n Observablen oder beidem (im Fall von „Estimator“) ausgeführt werden. Jede Gruppe wird als „primitive unified bloc “ (pub) bezeichnet und kann als Tupel dargestellt werden: (1 x circuit, [n x observables], [n x parameters]). Die Schnittstelle „ V1 “ bot nicht dieselbe Flexibilität. Stattdessen musste die Anzahl der Eingangsschaltungen mit der Anzahl der Observablen und Parametersätze übereinstimmen, wie die folgenden Beispiele zeigen (wählen Sie eine Registerkarte aus, um das jeweilige Beispiel anzuzeigen):

# 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

V2 primitive akzeptieren mehrere PUBs als Eingaben, und jeder Pub erhält sein eigenes Ergebnis. Diese können Sie verschiedene Schaltkreise mit unterschiedlichen Kombinationen von Parametern/Beobachtungswerten ausführen, was mit der Schnittstelle V1 nicht immer möglich war:

# 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)

2. Sampler : Der Sampler „V2 “ gibt nun Messwerte in Form von Bitstrings oder Zählwerten zurück, anstatt der Quasi-Wahrscheinlichkeitsverteilungen aus der Schnittstelle „V1 “. Die Bitstrings zeigen die Messergebnisse an, wobei die Reihenfolge beibehalten wird, in der sie gemessen wurden. Die Ergebnisobjekte des „ V2 “-Samplers ordnen die Daten nach den klassischen Registernamen ihrer Eingangsschaltungen, um die Kompatibilität mit dynamischen Schaltungen zu gewährleisten.

   # 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
   Klassischer Standard-Registername

   Beachten Sie in der obigen Schaltung, dass der Name des klassischen Registers standardmäßig "meas" lautet. Dieser Name wird später für den Zugriff auf die Messungs-Bitstrings verwendet.

   # 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}

3. Sampler and Estimator: Der Stichproben-Overhead, der üblicherweise von V1 -Implementierungen durch die Option shots run, ist jetzt ein Argument der Methode primitives run() und kann auf der Ebene PUB ebene angegeben werden kann. Die V2 Basisklassen stellen die Argumente in Formaten zur Verfügung, die sich von denen der V1 API unterscheiden:

   • BaseSamplerV2.run stellt ein shots -Argument zur Verfügung (ähnlich wie beim vorherigen Arbeitsablauf):

     # 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 führt ein precision Argument ein, das die Fehlerbalken angibt, die die primitive Implementierung für die Schätzung von Erwartungswerten anstreben sollte:

     # Estimate expectation values for two PUBs, both with 0.05 precision.
     estimator_v2.run([(circuit1, obs_array1), 
       (circuit2, obs_array_2)], precision=0.05
       )

Aktualisierungen in der Benutzeroberfläche „ V1 “

• Implizite Konvertierung von einer dichten BaseOperator zu einer SparsePauliOp in Estimator beobachtbaren Argumenten ist nicht mehr erlaubt. Sie sollten explizit in eine SparsePauliOp umwandeln, indem Sie SparsePauliOp.from_operator(operator) stattdessen.

• Mit einer PauliList in Estimator beobachtbaren Argumente ist nicht mehr erlaubt. Stattdessen sollten Sie das Argument explizit konvertieren, indem Sie SparsePauliOp(pauli_list) zuerst.

qiskit.providers

Basicaer

Die meisten Funktionen des Moduls qiskit.providers.basicaer wurden ersetzt durch das neue qiskit.providers.basic_provider modul ersetzt, mit Ausnahme der Klassen UnitarySimulatorPy und StatevectorSimulatorPy klassen, die entfernt wurden; ihre Funktionalität war bereits in dem quantum_info modul enthalten.

Die Umstellung auf die neuen Pfade ist einfach zu bewerkstelligen. Sie können die meisten klassen in qiskit.providers.basicaer durch ihre qiskit.providers.basic_provider gegenstück ersetzen (Drop-in-Ersatz). Beachten Sie, dass die folgenden Klassen neue Pfade und Namen haben:

# 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")

Die unitären und Zustandsvektor-Simulatoren können ersetzt werden durch verschiedene quantum_info klassen ersetzt werden. Es handelt sich nicht um einen es handelt sich nicht um einen sofortigen Ersatz, aber die Änderungen sind minimal. Siehe die folgenden Migrations beispiele:

Die folgenden Beispiele zeigen die Migrationspfade der Simulatoren von basicaer .

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()

gefälschter Anbieter

Die meisten der benutzerseitigen qiskit.providers.fake_provider komponenten wurden wurden auf das Paket qiskit-ibm-runtime Python migriert. Dazu gehören die gefälschte Anbieterklassen, alle gerätespezifischen gefälschten Backends (wie z. B FakeVigo, FakeNairobiV2 und FakeSherbrooke), und die gefälschten Backend basisklassen. Klicken Sie sich durch die folgenden Registerkarten, um die betroffenen Klassen zu sehen.

Um zum neuen Pfad zu migrieren:

1. Installieren Sie qiskit-ibm-runtime 0.17.1 oder höher:

   pip install 'qiskit-ibm-runtime>=0.17.1'

2. Ersetzen Sie Instanzen von qiskit.providers.fake_provider in Ihrem Code durch qiskit_ibm_runtime.fake_provider. Zum Beispiel:

   # 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()

Die Fake-Backend-Basisklassen wurden ebenfalls migriert, weisen aber einige Unterschiede im Importpfad auf:

fake_provider (spezielle Test-Backends)

Die gefälschten Backend-Klassen für spezielle Testzwecke in qiskit.providers.fake_provider haben wurden nicht nach qiskit_ibm_runtime.fake_provider migriert. Der empfohlene migrationspfad ist die Verwendung des neuen GenericBackendV2 klasse zu verwenden, um ein Backend mit ähnlichen Eigenschaften zu konfigurieren oder ein eigenes ziel zu erstellen.

Beispiel: Migrieren Sie zum neuen GenericBackendV2 klasse:

# 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.

Weitere Tipps zur Migration

• Der Import von qiskit.providers.aer ist nicht mehr möglich. Importieren Sie stattdessen von qiskit_aer, was ein sofortiger Ersatz ist. Um qiskit_aer zu installieren, ausführen:

  pip install qiskit-aer

• Die Unterstützung für die Ausführung von Pulse-Jobs auf Backends von qiskit.providers.fake_provider has wurde in Qiskit v1.0 entfernt. Das liegt daran, dass Qiskit Aer seine Simulationsfunktionen für solche Jobs entfernt hat. Für Simulationsaufgaben auf niedriger Ebene im Bereich der Hamilton-Mechanik sollten Sie den Einsatz einer spezialisierten Bibliothek wie Qiskit Dynamics in Betracht ziehen.

qiskit.pulse

ParametricPulse

Die Basisklasse qiskit.pulse.library.parametric_pulses.ParametricPulse und die pulse library wurden ersetzt durch qiskit.pulse.SymbolicPulse und die entsprechende Impulsbibliothek ersetzt. SymbolicPulse unterstützt QPY-Serialisierung :

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)

Komplexwertige Amplitude

Die komplexwertige Impulsamplitude (amp) wird durch ein (amp, angle) duo ersetzt. Diese Darstellung ist intuitiver, insbesondere für einige kalibrierungsaufgaben wie der Winkelkalibrierung:

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})

Injektionsschaltkreis-Gate-Operationen

Injektion von Schaltkreis-Gate-Operationen in den Pulse-Builder-Kontext durch qiskit.pulse.builder.call ist nicht mehr möglich. Diese Beseitigung betrifft die Eingabeargumente des Typs QuantumCircuit, sowie die folgenden Funktionen:

• 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

Wenn Sie dennoch Backend-kalibrierte Zeitpläne injizieren möchten, verwenden Sie das folgende muster, anstatt Gate-Befehle aufzurufen.

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)

In ähnlicher Weise kann ein QuantumCircuit kann in den Builder-Kontext injiziert werden, indem das Objekt manuell transpiliert und eingeplant wird objekts.

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)

Wir empfehlen, ein minimales Impulsprogramm mit dem Builder zu schreiben und es an QuantumCircuit über die QuantumCircuit.add_calibration methode als Mikrocode einer Gatteranweisung anzuhängen, anstatt das gesamte programm mit dem Impulsmodell zu schreiben.

builder.build

Die folgenden Argumente in qiskit.pulse.builder.build wurden ersatzlos gestrichen keine Alternative.

• default_transpiler_settings
• default_circuit_scheduler_settings

Diese Funktionen wurden ebenfalls entfernt:

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

Dies liegt daran, dass es nicht mehr möglich ist, Schaltungsobjekte in den Builder-Kontext einzufügen (siehe Einfügen von Schaltungsgatteroperationen ); diese Einstellungen dienten dazu, eingefügte Objekte in Impulsdarstellungen umzuwandeln.

Bibliothek

Die diskrete Pulsbibliothek wurde aus der Codebasis entfernt. Diese beinhalten:

• 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

Verwenden Sie stattdessen die entsprechende qiskit.pulse.SymbolicPulse, mit SymbolicPulse.get_waveform(). Verwenden Sie zum Beispiel anstelle von pulse.gaussian(100,0.5,10) pulse.Gaussian(100,0.5,10).get_waveform(). Beachten Sie, dass die Phase der beiden Sawtooth und Square so definiert ist dass eine Phase von 2\pi sich um einen vollen Zyklus verschiebt, im Gegensatz zum diskreten gegenstück. Beachten Sie auch, dass komplexe Amplituden nicht mehr von der der symbolischen Impulsbibliothek nicht mehr unterstützt werden; verwenden Sie stattdessen float, amp und angle .

ScalableSymbolicPulse

Es ist nicht mehr möglich, Bibliotheksobjekte qiskit.pulse.ScalableSymbolicPulse objekte mit einem komplexen amp Parameter aus qpy-Dateien der Version 5 oder früher zu laden (Qiskit Terra < 0.23.0 ). Es sind keine Migrationsmaßnahmen erforderlich, da komplexe amp automatisch in float umgewandelt wird (amp, angle).

Diese Änderung gilt für diese Impulse:

• qiskit.pulse.Constant
• qiskit.pulse.Drag
• qiskit.pulse.Gaussian
• qiskit.pulse.GaussianSquare

qiskit.qasm

Das alte OpenQASM 2 Parsermodul, das zuvor unter qiskit.qasm zu finden war, wurde durch wurde ersetzt durch das qiskit.qasm2 modul ersetzt, das einen schnelleren und genaueren Parser für OpenQASM 2 bietet. Die hochrangigen QuantumCircuit methoden from_qasm_file() und from_qasm_str() bleiben gleich, verwenden aber intern den neuen Parser. Allerdings ist die öffentliche schnittstelle für das Modul qasm2 ist jedoch nicht die gleiche. Während das qiskit.qasm modul eine Schnittstelle zu einem abstrakten Syntaxbaum bietet, der von der ply parser-Bibliothek zurückgegeben wird, stellt qiskit.qasm2 weder den AST noch irgendwelche details zur Implementierung des Parsers. Stattdessen nimmt er OpenQASM 2 als Eingabe und gibt ein QuantumCircuit objekt aus.

Zum Beispiel, wenn Sie zuvor etwas wie dieses ausgeführt haben:

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)

Ersetzen Sie diese Zeile durch Folgendes:

import qiskit.qasm2

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

qiskit.quantum_info

Das Modul qiskit.quantum_info.synthesis wurde an verschiedene Stellen in der Codebasis migriert stellen in der Codebasis verschoben, hauptsächlich qiskit.synthesis.

Diese Verschiebung hat keine Auswirkungen auf den üblichen Importpfad von Quaternion, aber Sie können nicht mehr über über qiskit.quantum_info.synthesis zugreifen.

Schließlich wurde cnot_rxx_decompose entfernt.

qiskit.test

Das Modul qiskit.test ist nicht länger ein öffentliches Modul. Dies war nie für die Öffentlichkeit bestimmt, noch außerhalb der Qiskit-Testsuite verwendet werden. Alle Funktionen sind spezifisch für Qiskit und keine wenn Sie eine ähnliche Funktionalität benötigen, sollten Sie sie in Ihre eigenen test-Kabelbäume aufnehmen.

qiskit.tools

Das qiskit.tools Modul wurde in Qiskit v1.0 entfernt. Der Großteil dieser Funktionen wurde entweder durch ähnliche Funktionen in anderen Paketen ersetzt oder ohne Alternative entfernt. Die wichtigste Ausnahme bildet dieqiskit.tools.parallel_map()Funktion, die in dasqiskit.utilsModul verlagert wurde Es kann stattdessen von diesem neuen Standort aus genutzt werden. Zum Beispiel:

Wenn Sie vorher schon gelaufen sind:

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

Jupyter

Das Submodul qiskit.tools.jupyter wurde entfernt, weil die Funktionalität in diesem Modul an das alte Paket qiskit-ibmq-provider gebunden ist, das nicht mehr nicht mehr unterstützt wird. Außerdem unterstützte es nur BackendV1 und nicht die neueren BackendV2 schnittstelle.

überwachen

Das Submodul qiskit.tools.monitor wurde entfernt, da es mit dem qiskit-ibmq-provider Paket gebunden war, das nicht mehr unterstützt wird (es unterstützte auch unterstützte nur die BackendV1 Schnittstelle und nicht die neuere BackendV2 schnittstelle). Es gibt es gibt keine Alternative für diese Funktion.

visualisierung

Das Submodul qiskit.tools.visualization wurde entfernt. Dieses Modul war eine weiterleitung vom ursprünglichen Standort des Qiskit-Visualisierungsmoduls und wurde wurde verschoben nach qiskit.visualization in Qiskit 0.8.0. Wenn Sie immer noch diesen Pfad verwenden, aktualisieren Sie Ihre Importe von qiskit.tools.visualization auf qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Ereignisse

Das Modul qiskit.tools.events und das damit verbundene Dienstprogramm progressbar() wurden entfernt. Die Funktionalität dieses Moduls wurde nicht häufig genutzt und wird besser durch spezielle Pakete wie tqdm.

qiskit.transpiler

Synthese

Die Elemente des Moduls qiskit.transpiler.synthesis wurden an neue Orte verlagert:

Bestanden

Der NoiseAdaptiveLayout transpiler pass wurde ersetzt durch VF2Layout und VF2PostLayout, ersetzt, die ein Layout auf der Grundlage der gemeldeten Rauscheigenschaften eines backend. Sowohl der Pass als auch das entsprechende "noise_adaptive" layout stage plugin wurden aus Qiskit entfernt.

Der CrosstalkAdaptiveSchedule Transpiler-Pass wurde aus der Codebasis entfernt code-Basis entfernt. Dieser Pass war nicht mehr verwendbar, da sein interner Betrieb davon abhängig war, dass benutzerdefinierte Eigenschaften in der BackendProperties Nutzlast einer BackendV1 -Instanz gesetzt wurden. Da keine Backends diese Felder setzen, wurde der Pass entfernt.

Passmanager

Die append Methoden der ConditionalController, FlowControllerLinear, und DoWhileController klassen wurden entfernt. Stattdessen müssen alle Aufgaben bei der Konstruktion der Controller objekte konstruiert werden.

qiskit.utils

Die folgenden Werkzeuge auf qiskit.utils wurden ersatzlos gestrichen:

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

Diese Funktionen wurden ausschließlich in den Modulen qiskit.algorithms und qiskit.opflow modulen verwendet, die ebenfalls entfernt worden sind.

qiskit.visualization

Das Modul qiskit.visualization.qcstyle ist entfernt worden. Verwenden Sie qiskit.visualization.circuit.qcstyle als direkten Ersatz.