Qiskit 0.15 Versionshinweise

0.15.0

Terra- 0.12.0

Vorspiel

Die Version 0.12.0 enthält mehrere neue Funktionen und Fehlerkorrekturen. Die größte Änderung in dieser Version ist die Hinzufügung der Unterstützung von parametrischen Impulsen zu OpenPulse. Dies sind Impulsbefehle, die zur Beschreibung eines Impulses Parameter statt Abtastpunkte verwenden. 0.12.0 ist auch die erste Version, die Unterstützung für Python 3.8 bietet. Es markiert auch den Beginn der Verwerfung der Unterstützung für Python 3.5, die entfernt wird, wenn die Upstream-Community die Unterstützung einstellt.

Neue Funktionen

Der Pass qiskit.transpiler.passes.CSPLayout wurde um zwei neue Parameter erweitert: call_limit und time_limit. Mit diesen Optionen lässt sich die Dauer des Durchlaufs begrenzen. Die Option call_limit begrenzt die Anzahl der Aufrufe der rekursiven Funktion im Backtracking Solver. In ähnlicher Weise begrenzt time_limit die Dauer (in Sekunden), die der Solver laufen darf. Die Standardwerte sind 1000 Anrufe bzw. 10 Sekunden.

qiskit.pulse.Acquire kann nun auf ein einzelnes Qubit angewendet werden. Dadurch wird die Impulsprogrammierung konsistenter und übersichtlicher, da sich nun alle Operationen auf einen einzigen Kanal beziehen. Zum Beispiel:

acquire = Acquire(duration=10)
schedule = Schedule()
schedule.insert(60, acquire(AcquireChannel(0), MemorySlot(0), RegisterSlot(0)))
schedule.insert(60, acquire(AcquireChannel(1), MemorySlot(1), RegisterSlot(1)))

Eine neue Methode qiskit.transpiler.CouplingMap.draw() wurde hinzugefügt zu qiskit.transpiler.CouplingMap hinzugefügt, um ein Graphviz-Bild aus dem Diagramm der Kopplungskarte zu erzeugen. Zum Beispiel:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap(
    [[0, 1], [1, 0], [1, 2], [1, 3], [2, 1], [3, 1], [3, 4], [4, 3]])
coupling_map.draw()
```
Auf OpenPulse wurden parametrische Impulse hinzugefügt. Dies sind Impulsbefehle, die parametrisiert sind und vom Backend verstanden werden. Beliebige Impulsformen werden weiterhin durch den Befehl SamplePulse unterstützt. Die neuen unterstützten Pulsklassen sind:
- qiskit.pulse.ConstantPulse
- qiskit.pulse.Drag
- qiskit.pulse.Gaussian
- qiskit.pulse.GaussianSquare
Sie können wie alle anderen Pulse-Befehle verwendet werden. Beispiel:
```
from qiskit.pulse import (Schedule, Gaussian, Drag, ConstantPulse,
                          GaussianSquare)

sched = Schedule(name='parametric_demo')
sched += Gaussian(duration=25, sigma=4, amp=0.5j)(DriveChannel(0))
sched += Drag(duration=25, amp=0.1, sigma=5, beta=4)(DriveChannel(1))
sched += ConstantPulse(duration=25, amp=0.3+0.1j)(DriveChannel(1))
sched += GaussianSquare(duration=1500, amp=0.2, sigma=8,
                        width=140)(MeasureChannel(0)) << sched.duration
```
Der resultierende Zeitplan ähnelt einem SamplePulse Zeitplan, der mit qiskit.pulse.pulse_lib erstellt wurde. Die Methode qiskit.pulse.Schedule.draw() kann weiterhin wie gewohnt verwendet werden. Der Befehl wird jedoch mit der Methode qiskit.pulse.ParametricPulse.get_sample_pulse() in eine SamplePulse umgewandelt, so dass der angezeigte Impuls die kontinuierliche Funktion möglicherweise nicht auf die gleiche Weise abtastet wie das Backend.

Diese Funktion kann verwendet werden, um Pulse-Programme für jedes Backend zu erstellen, aber die Pulse werden in SamplePulse Objekte umgewandelt, wenn das Backend keine parametrischen Pulse unterstützt. Backends, die sie unterstützen, erhalten das folgende neue Attribut:
```
backend.configuration().parametric_pulses: List[str]
# e.g. ['gaussian', 'drag', 'constant']
```
Beachten Sie, dass das Backend nicht alle in Qiskit definierten parametrischen Pulse unterstützen muss.

Wenn das Backend parametrische Impulse unterstützt und der Impulszeitplan mit ihnen erstellt wird, ist das zusammengesetzte Qobj deutlich kleiner. Die Größe einer PulseQobj, die vollständig mit parametrischen Impulsen aufgebaut ist, hängt nur von der Anzahl der Anweisungen ab, während die Größe einer PulseQobj, die auf andere Weise aufgebaut ist, mit der Dauer der Anweisungen wächst (da für jede Probe ein Wert angegeben werden muss).

Hilfsprogramme qiskit.scheduler.measure() und qiskit.scheduler.measure_all() zum Modul qiskit.scheduler hinzugefügt. Diese Funktionen geben ein qiskit.pulse.Schedule objekt zurück, das Qubits mit OpenPulse misst. Zum Beispiel:

from qiskit.scheduler import measure, measure_all

measure_q0_schedule = measure(qubits=[0], backend=backend)
measure_all_schedule = measure_all(backend)
measure_custom_schedule = measure(qubits=[0],
                                  inst_map=backend.defaults().instruction_schedule_map,
                                  meas_map=[[0]],
                                  qubit_mem_slots={0: 1})

Impuls qiskit.pulse.Schedule objekte haben jetzt bessere Darstellungen, die für einfache Zeitpläne gültige Python Ausdrücke sein sollten.
Die qiskit.circuit.QuantumCircuit methoden qiskit.circuit.QuantumCircuit.measure_active(), qiskit.circuit.QuantumCircuit.measure_all(), und qiskit.circuit.QuantumCircuit.remove_final_measurements() haben jetzt einen Zusatz kwarg inplace. Wenn inplace auf False eingestellt ist, gibt die Funktion eine geänderte Kopie der Schaltung zurück. Dies unterscheidet sich vom Standardverhalten, das das Schaltkreisobjekt an Ort und Stelle ändert und nichts zurückgibt.
Der Klasse wurden mehrere neue Konstruktormethoden hinzugefügt qiskit.transpiler.CouplingMap klasse hinzugefügt, um Objekte mit grundlegenden Qubit-Kopplungsgraphen zu erstellen. Die neuen Konstruktormethoden sind:
Um beispielsweise eine Kopplungskarte von 5 Qubits zu erhalten, die in einer linearen Kette verbunden sind, können Sie jetzt die neuen Konstruktoren verwenden:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap.from_line(5)
coupling_map.draw()
```
Einführung eines neuen Passes qiskit.transpiler.passes.CrosstalkAdaptiveSchedule. Mit diesem Durchgang sollen die Auswirkungen des Übersprechens auf ein Programm reduziert werden. Es verwendet Daten zur Charakterisierung des Übersprechens aus dem Backend, um Gatter zu planen. Wenn ein Gatterpaar ein hohes Übersprechen aufweist, werden sie mit Hilfe einer Barriere in Reihe geschaltet. Naive Serialisierung ist schädlich, weil sie Dekohärenzfehler verursacht. Daher wird in diesem Durchgang ein SMT-Optimierungsansatz verwendet, um einen Zeitplan zu berechnen, der die Auswirkungen des Übersprechens und der Dekohärenzfehler minimiert.

Als Eingabe dient eine Schaltung, die bereits auf das Backend übertragen wurde, d.h. die Schaltung ist in Form von physikalischen Qubits ausgedrückt und Swap-Gates wurden eingefügt und bei Bedarf in CNOTs zerlegt. Unter Verwendung dieser Schaltung und der Daten zur Charakterisierung des Übersprechens wird eine Z3 -Optimierung verwendet, um eine neue geplante Schaltung als Ergebnis zu konstruieren.

Zur Verwendung des Passes in einem Stromkreis:
```
dag = circuit_to_dag(circ)
pass_ = CrosstalkAdaptiveSchedule(backend_prop, crosstalk_prop)
scheduled_dag = pass_.run(dag)
scheduled_circ = dag_to_circuit(scheduled_dag)
```
backend_prop ist ein qiskit.providers.models.BackendProperties objekt für das Ziel-Backend. crosstalk_prop ist ein Diktat, das die bedingten Fehlerquoten angibt. Für zwei Gatter g1 und g2 gibt crosstalk_prop[g1][g2] die bedingte Fehlerrate von g1 an, wenn g1 und g2 gleichzeitig ausgeführt werden. Eine Methode zur Erzeugung von crosstalk_prop wird in einer zukünftigen Version von qiskit-ignis hinzugefügt werden. Bis dahin müssen Sie entweder die Übersprechungseigenschaften Ihres Geräts bereits kennen oder Ihre eigenen Experimente zur Gerätecharakterisierung manuell durchführen.
Im voreingestellten Passmanager für die Optimierungsstufe 1, qiskit.transpiler.preset_passmanagers.level_1_pass_manager() wenn qiskit.transpiler.passes.TrivialLayout layoutpass nicht perfekt zu einer bestimmten Schaltung passt, wird qiskit.transpiler.passes.DenseLayout layoutpass stattdessen verwendet.
Hinzufügen einer neuen abstrakten Methode qiskit.quantum_info.Operator.dot() zur abstrakten Klasse BaseOperator hinzugefügt, so dass sie für alle Implementierungen dieser abstrakten Klasse enthalten ist, einschließlich qiskit.quantum_info.Operator und QuantumChannel (z.B., qiskit.quantum_info.Choi) Objekte. Diese Methode gibt die rechte Operatormultiplikation a.dot(b) $= a \cdot b$ zurück. Dies ist gleichbedeutend mit dem Aufruf der Methode operator qiskit.quantum_info.Operator.compose() methode mit dem auf True gesetzten kwarg front .
Hinzugefügt qiskit.quantum_info.average_gate_fidelity() und qiskit.quantum_info.gate_error() funktionen zum qiskit.quantum_info modul für die Arbeit mit qiskit.quantum_info.Operator und QuantumChannel (z.B., qiskit.quantum_info.Choi) Objekten.

Hinzufügen der qiskit.quantum_info.partial_trace() funktion zu der qiskit.quantum_info die mit qiskit.quantum_info.Statevector und qiskit.quantum_info.DensityMatrix quantenzustandsklassen funktioniert. Zum Beispiel:

from qiskit.quantum_info.states import Statevector
from qiskit.quantum_info.states import DensityMatrix
from qiskit.quantum_info.states import partial_trace

psi = Statevector.from_label('10+')
partial_trace(psi, [0, 1])
rho = DensityMatrix.from_label('10+')
partial_trace(rho, [0, 1])

Wenn qiskit.circuit.QuantumCircuit.draw() oder qiskit.visualization.circuit_drawer() mit dem with_layout kwarg auf True (Standardeinstellung) aufgerufen wird, werden die physikalischen Qubits nun als ganze Zahlen dargestellt, um sie klar von den virtuellen Qubits zu unterscheiden.

Beispiel:
```
from qiskit import QuantumCircuit
from qiskit import transpile
from qiskit.test.mock import FakeVigo

qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
transpiled_qc = transpile(qc, FakeVigo())
transpiled_qc.draw(output='mpl')
```
Neue Funktionen zur Zustandsmessung im qiskit.quantum_info modul hinzugefügt: qiskit.quantum_info.entropy(), qiskit.quantum_info.mutual_information(), qiskit.quantum_info.concurrence(), und qiskit.quantum_info.entanglement_of_formation(). Diese Funktionen arbeiten mit den qiskit.quantum_info.Statevector und qiskit.quantum_info.DensityMatrix klassen.
Die Zerlegungsmethoden für Ein-Qubit-Gatter in qiskit.quantum_info.synthesis.one_qubit_decompose.OneQubitEulerDecomposer wurden erweitert und umfassen nun auch die 'ZXZ' Basis, die durch drei Rotationen um die Z,X,Z-Achse gekennzeichnet ist. Dies bedeutet nun, dass ein allgemeiner 2x2 Operator in die folgenden Basen zerlegt werden kann: U3, U1X, ZYZ, ZXZ, XYX, ZXZ.

Bekannte Probleme

Das Ausführen von Funktionen, die qiskit.tools.parallel_map() (zum Beispiel qiskit.execute.execute(), qiskit.compiler.transpile(), und qiskit.transpiler.PassManager.run()), funktionieren möglicherweise nicht, wenn sie von einem Skript aufgerufen werden, das außerhalb eines if __name__ == '__main__': -Blocks läuft, wenn Python 3.8 auf MacOS verwendet wird. Andere Umgebungen sind von diesem Problem nicht betroffen. Dies ist auf Änderungen in der Art und Weise zurückzuführen, wie parallele Prozesse von Python 3.8 auf MacOS gestartet werden. Wenn RuntimeError oder AttributeError von Skripten ausgelöst werden, die parallel_map() direkt aufrufen, oder wenn sie eine Funktion aufrufen, die sie intern mit Python 3.8 auf MacOS verwendet, sollte das Problem durch Einbetten der Skriptaufrufe in if __name__ == '__main__': umgangen werden. Zum Beispiel:
```
from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure([0,1], [0,1])
# making another circuit: superpositions
qc2 = QuantumCircuit(2, 2)
qc2.h([0,1])
qc2.measure([0,1], [0,1])
execute([qc1, qc2], BasicAer.get_backend('qasm_simulator'))
```
geändert werden in
```
from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

def main():
    qc1 = QuantumCircuit(2, 2)
    qc1.h(0)
    qc1.cx(0, 1)
    qc1.measure([0,1], [0,1])
    # making another circuit: superpositions
    qc2 = QuantumCircuit(2, 2)
    qc2.h([0,1])
    qc2.measure([0,1], [0,1])
    execute([qc1, qc2], BasicAer.get_backend('qasm_simulator'))

if __name__ == '__main__':
    main()
```
wenn bei Python 3.8 auf MacOS Fehler auftreten.

Anmerkungen zu Upgrades

Der Wert des Parameters rep_time für das Konfigurationsobjekt des Pulse-Backends wird jetzt in Sekunden und nicht mehr in Mikrosekunden angegeben. Das erste Mal, wenn ein PulseBackendConfiguration Objekt initialisiert wird, wird es eine einzige Warnung an den Benutzer ausgeben, um dies anzuzeigen.
Das Argument rep_time für qiskit.compiler.assemble() nimmt jetzt einen Wert in Sekunden und nicht in Mikrosekunden an. Dies wurde getan, um die Einheiten mit allem anderen in Puls zu machen. Wenn Sie einen Wert für rep_time übergeben haben, stellen Sie sicher, dass Sie den Wert aktualisieren, um diese Änderung zu berücksichtigen.
Der Wert der Eigenschaft base_gate von qiskit.circuit.ControlledGate objekten wurde von der Klasse des Basistors auf eine Instanz der Klasse des Basistors geändert.
Die Eigenschaft base_gate_name von qiskit.circuit.ControlledGate wurde entfernt; Sie können den Namen des Basistors durch Zugriff auf base_gate.name auf dem Objekt erhalten. Zum Beispiel:
```
from qiskit import QuantumCircuit
from qiskit.extensions import HGate

qc = QuantumCircuit(3)
cch_gate = HGate().control(2)
base_gate_name = cch_gate.base_gate.name
```
Geändert qiskit.quantum_info.Operator magische Methoden, so dass __mul__ (das von Pythons Multiplikationsoperation ausgeführt wird, wenn die linke Seite der Operation definiert ist) die rechte Matrixmultiplikation implementiert (d.h. qiskit.quantum_info.Operator.dot()), und __rmul__ (das von Pythons Multiplikationsoperation von der rechten Seite der Operation ausgeführt wird, wenn auf der linken Seite nicht __mul__ definiert ist) implementiert die skalare Multiplikation (d.h. qiskit.quantum_info.Operator.multiply()). Bisher haben beide Methoden die Skalarmultiplikation implementiert.
Das zweite Argument der qiskit.quantum_info.process_fidelity() funktion, target, ist jetzt optional. Wird keine Zieleinheit angegeben, so wird die Prozesstreue des Eingangskanals mit dem Identitätsoperator zurückgegeben.
qiskit.compiler.assemble() respektiert nun den konfigurierten max_shots Wert für ein Backend. Wenn ein Wert für shots kwarg angegeben wird, der die in der Backend-Konfiguration eingestellte maximale Anzahl von Schüssen überschreitet, löst die Funktion jetzt eine QiskitError Ausnahme aus. Wenn kein shots-Argument angegeben wird, ist der Standardwert entweder 1024 (das vorherige Verhalten) oder max_shots vom Backend, je nachdem, welcher Wert niedriger ist.

Hinweise zu veralteten Versionen

Methoden zum Hinzufügen von Gates zu einer qiskit.circuit.QuantumCircuit mit abgekürzten Schlüsselwortargumenten (z.B. ctl, tgt) wurden umbenannt, um ihre Schlüsselwortargumente anschaulicher zu machen (z.B. control_qubit, target_qubit). Die alten Namen sind veraltet. Nachstehend finden Sie eine Tabelle mit den alten und neuen Aufrufsignaturen für die Methoden von QuantumCircuit .

Anweisungstyp	Frühere Unterschrift	Neue Signatur
`qiskit.extensions.HGate`	`qc.h(q)`	`qc.h(qubit)`
`qiskit.extensions.CHGate`	`qc.ch(ctl, tgt)`	`qc.ch((control_qubit, target_qubit))`
`qiskit.extensions.IdGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.r(theta, phi, q)`	`qc.r(theta, phi, qubit)`
`qiskit.extensions.RXGate`	`qc.rx(theta, q)`	`qc.rx(theta, qubit)`
`qiskit.extensions.CrxGate`	`qc.crx(theta, ctl, tgt)`	`qc.crx(theta, control_qubit, target_qubit)`
`qiskit.extensions.RYGate`	`qc.ry(theta, q)`	`qc.ry(theta, qubit)`
`qiskit.extensions.CryGate`	`qc.cry(theta, ctl, tgt)`	`qc.cry(theta, control_qubit, target_qubit)`
`qiskit.extensions.RZGate`	`qc.rz(phi, q)`	`qc.rz(phi, qubit)`
`qiskit.extensions.CrzGate`	`qc.crz(theta, ctl, tgt)`	`qc.crz(theta, control_qubit, target_qubit)`
`qiskit.extensions.SGate`	`qc.s(q)`	`qc.s(qubit)`
`qiskit.extensions.SdgGate`	`qc.sdg(q)`	`qc.sdg(qubit)`
`qiskit.extensions.FredkinGate`	`qc.cswap(ctl, tgt1, tgt2)`	`qc.cswap(control_qubit, target_qubit1, target_qubit2)`
`qiskit.extensions.TGate`	`qc.t(q)`	`qc.t(qubit)`
`qiskit.extensions.TdgGate`	`qc.tdg(q)`	`qc.tdg(qubit)`
`qiskit.extensions.U1Gate`	`qc.u1(theta, q)`	`qc.u1(theta, qubit)`
`qiskit.extensions.Cu1Gate`	`qc.cu1(theta, ctl, tgt)`	`qc.cu1(theta, control_qubit, target_qubit)`
`qiskit.extensions.U2Gate`	`qc.u2(phi, lam, q)`	`qc.u2(phi, lam, qubit)`
`qiskit.extensions.U3Gate`	`qc.u3(theta, phi, lam, q)`	`qc.u3(theta, phi, lam, qubit)`
`qiskit.extensions.Cu3Gate`	`qc.cu3(theta, phi, lam, ctl, tgt)`	`qc.cu3(theta, phi, lam, control_qubit, target_qubit)`
`qiskit.extensions.XGate`	`qc.x(q)`	`qc.x(qubit)`
`qiskit.extensions.CnotGate`	`qc.cx(ctl, tgt)`	`qc.cx(control_qubit, target_qubit)`
`qiskit.extensions.ToffoliGate`	`qc.ccx(ctl1, ctl2, tgt)`	`qc.ccx(control_qubit1, control_qubit2, target_qubit)`
`qiskit.extensions.YGate`	`qc.y(q)`	`qc.y(qubit)`
`qiskit.extensions.CyGate`	`qc.cy(ctl, tgt)`	`qc.cy(control_qubit, target_qubit)`
`qiskit.extensions.ZGate`	`qc.z(q)`	`qc.z(qubit)`
`qiskit.extensions.CzGate`	`qc.cz(ctl, tgt)`	`qc.cz(control_qubit, target_qubit)`

Die Ausführung von qiskit.pulse.Acquire auf mehreren Qubits ist veraltet und wird in einer zukünftigen Version entfernt werden. Außerdem sind die Parameter qiskit.pulse.AcquireInstruction mem_slots und reg_slots veraltet. Stattdessen sollten reg_slot und mem_slot verwendet werden.
Das Attribut der qiskit.providers.models.PulseDefaults klasse circuit_instruction_map ist veraltet und wird in einer zukünftigen Version entfernt werden. Stattdessen sollten Sie das neue Attribut instruction_schedule_map verwenden. Dies geschah, um dem Typ des Wertes des Attributs zu entsprechen, der ein InstructionScheduleMap ist.

Der Befehl qiskit.pulse.PersistentValue ist veraltet und wird in einer zukünftigen Version entfernt werden. Eine ähnliche Funktionalität kann mit dem Befehl qiskit.pulse.ConstantPulse (einer der neuen parametrischen Impulse) erreicht werden. Vergleichen Sie das Folgende:

from qiskit.pulse import Schedule, PersistentValue, ConstantPulse, \
                         DriveChannel

# deprecated implementation
sched_w_pv = Schedule()
sched_w_pv += PersistentValue(value=0.5)(DriveChannel(0))
sched_w_pv += PersistentValue(value=0)(DriveChannel(0)) << 10

# preferred implementation
sched_w_const = Schedule()
sched_w_const += ConstantPulse(duration=10, amp=0.5)(DriveChannel(0))

Python 3.5 unterstützung in qiskit-terra ist veraltet. Die Unterstützung wird in der ersten Veröffentlichung nach dem End-of-Life-Datum der Upstream-Community Python für diese Version (13.09.2020) eingestellt.
Der require_cptp kwarg der Funktion qiskit.quantum_info.process_fidelity() funktion ist veraltet und wird in einer zukünftigen Version entfernt werden. Er wird durch zwei separate kwargs require_cp und require_tp ersetzt.
Die Einstellung des Parameters scale für qiskit.circuit.QuantumCircuit.draw() und qiskit.visualization.circuit_drawer() als erstes Positionsargument ist veraltet und wird in einer zukünftigen Version entfernt werden. Stattdessen sollten Sie scale als Schlüsselwortargument verwenden.

Das Modul qiskit.tools.qi.qi ist veraltet und wird in einer zukünftigen Version entfernt werden. Die Legacy-Funktionen des Moduls wurden alle durch Funktionen und Klassen des qiskit.quantum_info modul ersetzt. Nachfolgend finden Sie eine Tabelle mit den veralteten Funktionen und deren Ersatz:

Veraltet	Ersatzwert
`qiskit.tools.partial_trace()`	`qiskit.quantum_info.partial_trace()`
`qiskit.tools.choi_to_pauli()`	`qiskit.quantum_info.Choi` und `quantum_info.PTM`
`qiskit.tools.chop()`	`numpy.round`
`qiskit.tools.qi.qi.outer`	`numpy.outer`
`qiskit.tools.concurrence()`	`qiskit.quantum_info.concurrence()`
`qiskit.tools.shannon_entropy()`	`qiskit.quantum_info.shannon_entropy()`
`qiskit.tools.entropy()`	`qiskit.quantum_info.entropy()`
`qiskit.tools.mutual_information()`	`qiskit.quantum_info.mutual_information()`
`qiskit.tools.entanglement_of_formation()`	`qiskit.quantum_info.entanglement_of_formation()`
`qiskit.tools.is_pos_def()`	`quantum_info.operators.predicates.is_positive_semidefinite_matrix`

Das Modul qiskit.quantum_info.states.states ist veraltet und wird in einer zukünftigen Version entfernt werden. Die Legacy-Funktionen des Moduls wurden alle durch Funktionen und Klassen des qiskit.quantum_info modul ersetzt.

Veraltet
Ersatzwert
qiskit.quantum_info.states.states.basis_state qiskit.quantum_info.Statevector.from_label()
qiskit.quantum_info.states.states.projector qiskit.quantum_info.DensityMatrix
Der Parameter scaling der Methode draw() für die Objekte Schedule und Pulse wurde veraltet und wird in einer zukünftigen Version entfernt. Stattdessen sollte der neue Parameter scale verwendet werden. Dies geschah, um ein einheitliches Argument zwischen Impuls- und Schaltkreiszeichnungen zu haben. Zum Beispiel:
```
#The consistency in parameters is seen below
#For circuits
circuit = QuantumCircuit()
circuit.draw(scale=0.2)
#For pulses
pulse = SamplePulse()
pulse.draw(scale=0.2)
#For schedules
schedule = Schedule()
schedule.draw(scale=0.2)
```

Veraltet	Ersatzwert
`qiskit.quantum_info.states.states.basis_state`	`qiskit.quantum_info.Statevector.from_label()`
`qiskit.quantum_info.states.states.projector`	`qiskit.quantum_info.DensityMatrix`

Fehlerkorrekturen

Zuvor hatte der Aufruf von qiskit.circuit.QuantumCircuit.bind_parameters() vor der Zerlegung einer Schaltung dazu führen, dass die gebundenen Werte nicht korrekt in die zerlegten Gatter eingesetzt werden. Dies wurde so gelöst, dass Bindung und Abbau in beliebiger Reihenfolge erfolgen können. Behebt Problem #2482 und Problem #3509
Der Collect2qBlocks Pass hatte bisher bei der Entscheidung, ob ein Tor in einen bestehenden Block eingebaut werden soll, die klassischen Bedingungen nicht berücksichtigt. In einigen Fällen führte dies dazu, dass die klassischen Bedingungen beim Transpilieren mit optimization_level=3 verloren gingen. Dieses Problem wurde behoben, so dass klassisch konditionierte Gatter nie in einem Block enthalten sind. Behebt Problem #3215
Alle Ausgabearten für die Stromkreisschubladen in qiskit.circuit.QuantumCircuit.draw() und qiskit.visualization.circuit_drawer() haben eine feste und/oder verbesserte Unterstützung für zeichnungsgesteuerte benutzerdefinierte Gatter. Behebt Problem #3546, Problem #3763 und Problem #3764
Erklärungen und Beispiele wurden der Dokumentation für die qiskit.circuit.QuantumCircuit methoden zum Hinzufügen von Gates hinzugefügt: qiskit.circuit.QuantumCircuit.ccx(), qiskit.circuit.QuantumCircuit.ch(), qiskit.circuit.QuantumCircuit.crz(), qiskit.circuit.QuantumCircuit.cswap(), qiskit.circuit.QuantumCircuit.cu1(), qiskit.circuit.QuantumCircuit.cu3(), qiskit.circuit.QuantumCircuit.cx(), qiskit.circuit.QuantumCircuit.cy(), qiskit.circuit.QuantumCircuit.cz(), qiskit.circuit.QuantumCircuit.h(), qiskit.circuit.QuantumCircuit.iden(), qiskit.circuit.QuantumCircuit.rx(), qiskit.circuit.QuantumCircuit.ry(), qiskit.circuit.QuantumCircuit.rz(), qiskit.circuit.QuantumCircuit.s(), qiskit.circuit.QuantumCircuit.sdg(), qiskit.circuit.QuantumCircuit.swap(), qiskit.circuit.QuantumCircuit.t(), qiskit.circuit.QuantumCircuit.tdg(), qiskit.circuit.QuantumCircuit.u1(), qiskit.circuit.QuantumCircuit.u2(), qiskit.circuit.QuantumCircuit.u3(), qiskit.circuit.QuantumCircuit.x(), qiskit.circuit.QuantumCircuit.y(), qiskit.circuit.QuantumCircuit.z(). Behebt Problem #3400
Korrekturen bei der Behandlung von Parametern für komplexe Zahlen in der Schaltkreisvisualisierung. Behebt Problem #3640

Sonstige Anmerkungen

Die Transpilerpässe im Verzeichnis qiskit.transpiler.passes wurden in Unterverzeichnisse aufgeteilt, um sie besser nach Funktionen zu kategorisieren. Sie sind nach wie vor alle über den Namensraum qiskit.transpiler.passes zugänglich.

Aer- 0.4.0

Hinzugefügt

NoiseModel.from_backend zur Erstellung eines grundlegenden Geräuschmodells für ein IBMQ-Backend hinzugefügt (#569)

Es wurden Multi-GPU-fähige Simulationsmethoden zu QasmSimulator, StatevectorSimulator und UnitarySimulator hinzugefügt. Der qasm-Simulator verfügt über gpu-Versionen der Dichtematrix- und Zustandsvektor-Methoden und kann über "method": "density_matrix_gpu" oder "method": "statevector_gpu" in backend_options aufgerufen werden. Die Methode statevector simulator gpu kann über "method": "statevector_gpu" aufgerufen werden. Die GPU-Methode des unitären Simulators kann über "method": "unitary_gpu" aufgerufen werden. Diese Backends verwenden CUDA und benötigen einen NVidia-Grafikprozessor.(#544)

PulseSimulator Backend hinzugefügt (#542)

Die Klassen PulseSystemModel und HamiltonianModel wurden hinzugefügt, um Modelle zu repräsentieren, die in PulseSimulator verwendet werden können (#496, #493)

duffing_model_generators hinzugefügt, um PulseSystemModel Objekte aus einer Liste von Parametern zu erzeugen (#516)

ODE-Funktionslöser nach C++ migriert (#442, #350)

High-Level-Impuls-Simulator-Tests hinzugefügt (#379)

CMake BLAS_LIB_PATH Flag, um den Pfad für die BLAS-Bibliothek zu setzen (#543)

Geändert

Die Struktur des Verzeichnisses src wurde geändert, um den Quellcode des Simulators zu organisieren. Simulator-Controller-Header wurden nach src/controllers verschoben und Simulator-Methoden-State-Header befinden sich in src/simulators (#544)

Mehrere Funktionen wurden an einen anderen Ort verschoben (#568): * Der Inhalt von qiskit.provider.aer.noise.errors wurde in das Modul qiskit.providers.noise verschoben. * Der Inhalt von qiskit.provider.aer.noise.utils wurde in das Modul qiskit.provider.aer.utils verschoben.

Die Optimierung zum Zusammenfassen aufeinanderfolgender Gatter in einer Schaltung (Fusion) wurde standardmäßig aktiviert (#579).

Veraltet

Veraltete utils.qobj_utils Funktionen (#568)

Veraltet qiskit.providers.aer.noise.device.basic_device_noise_model. Sie wird durch die Methode NoiseModel.from_backend (#569) abgelöst

Entfernt

Die Methoden NoiseModel.as_dict, QuantumError.as_dict, ReadoutError.as_dict und QuantumError.kron , die in 0.3 (#568) veraltet waren, wurden entfernt.

Ignis- 0.2

Keine Änderung

Aqua- 0.6

Keine Änderung

IBM Q Anbieter 0.4.6

Hinzugefügt

Mehrere neue Methoden wurden zu IBMQBackend hinzugefügt:
- wait_for_final_state() blockiert, bis der Auftrag abgeschlossen ist. Sie benötigt eine Callback-Funktion, die sie nach jeder Abfrage aufruft, um Feedback zu geben.
- active_jobs() gibt die an ein Backend übermittelten Aufträge zurück, die sich derzeit in einem nicht abgeschlossenen Status befinden.
- job_limit() gibt das Auftragslimit für ein Backend zurück.
- remaining_jobs_count() gibt die Anzahl der Aufträge zurück, die Sie an das Backend übermitteln können, bevor das Auftragslimit erreicht ist.
QueueInfo hat jetzt eine neue Methode format() , die eine formatierte Zeichenkette mit den Warteschlangeninformationen zurückgibt.
IBMQJob hat jetzt drei neue Methoden: done(), running(), und cancelled() , die zur Angabe des Auftragsstatus verwendet werden.
qiskit.providers.ibmq.ibmqbackend.IBMQBackend.run() akzeptiert jetzt einen optionalen Parameter job_tags. Wenn angegeben, werden dem Job die job_tags zugewiesen, die später als Filter in qiskit.providers.ibmq.ibmqbackend.IBMQBackend.jobs() verwendet werden können.
IBMQJobManager verfügt jetzt über eine neue Methode retrieve_job_set() , mit der Sie einen zuvor übermittelten Auftragssatz anhand der Auftragssatz-ID abrufen können.

Geändert

Die Hierarchie von Exception wurde durch mehr spezialisierte Klassen verfeinert. Sie können jedoch weiterhin ihre übergeordneten Ausnahmen abfangen (z. B. IBMQAccountError). Außerdem wurde die Ausnahmeklasse IBMQApiUrlError durch IBMQAccountCredentialsInvalidUrl und IBMQAccountCredentialsInvalidToken ersetzt.

Veraltet

Die Verwendung von Proxy-URLs ohne Protokoll (z. B. http://) ist aufgrund der jüngsten Änderungen von Python veraltet.

War diese Seite hilfreich?

Melden Sie auf GitHub einen Fehler, einen Tippfehler oder fordern Sie Inhalte an.