Vai al contenuto principale

Modifiche alle funzionalità di Qiskit 1.0

Questa guida descrive i percorsi di migrazione per i cambiamenti più importanti nelle funzionalità di Qiskit 1.0, organizzati per modulo. Usa il sommario sul lato destro per navigare al modulo che ti interessa.

Strumento di migrazione Qiskit 1.0​

Per semplificare il processo di migrazione, puoi usare lo strumento flake8-qiskit-migration per rilevare i percorsi di importazione rimossi nel tuo codice e suggerire alternative.

Se hai pipx installato, esegui semplicemente il seguente comando.

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

Questo installerà il pacchetto in un ambiente virtuale temporaneo ed eseguirà il controllo sul tuo codice.

Limitazioni

Questo strumento rileva solo i percorsi di importazione rimossi. Non rileva l'uso di metodi rimossi (come QuantumCircuit.qasm) né di argomenti. Non è in grado di tenere traccia di assegnazioni come qk = qiskit, anche se gestisce alias come import qiskit as qk.

Per ulteriori informazioni, consulta il repository del progetto.

Istanze e funzioni globali​

Aer​

L'oggetto qiskit.Aer non è disponibile in Qiskit 1.0. Usa invece lo stesso oggetto dal namespace qiskit_aer, che è un sostituto diretto. Per installare qiskit_aer, esegui:

pip install qiskit-aer

BasicAer​

L'oggetto qiskit.BasicAer non è disponibile in Qiskit 1.0. Consulta la sezione di migrazione basicaer per le opzioni di migrazione.

execute​

La funzione qiskit.execute non è disponibile in Qiskit 1.0. Questa funzione era un wrapper di alto livello attorno alle funzioni transpile e run di Qiskit. Al posto di qiskit.execute, usa la funzione transpile seguita da 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)

In alternativa, la primitiva Sampler è semanticamente equivalente alla funzione qiskit.execute rimossa. La classe BackendSampler è un wrapper generico per i backend che non supportano le primitive:

from qiskit.primitives import BackendSampler

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

qiskit.circuit​

QuantumCircuit.qasm​

Il metodo QuantumCircuit.qasm è stato rimosso. Usa invece qasm2.dump o qasm2.dumps.

Per l'output formattato con Pygments, consulta il pacchetto standalone openqasm-pygments, poiché qasm2.dump e qasm2.dumps non forniscono output colorato con 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)

gate di QuantumCircuit​

I seguenti metodi gate sono stati rimossi a favore di metodi più consolidati che aggiungono gli stessi gate:

RimossoAlternativa
QuantumCircuit.cnotQuantumCircuit.cx
QuantumCircuit.toffoliQuantumCircuit.ccx
QuantumCircuit.fredkinQuantumCircuit.cswap
QuantumCircuit.mctQuantumCircuit.mcx
QuantumCircuit.iQuantumCircuit.id
QuantumCircuit.squQuantumCircuit.unitary

I seguenti metodi del circuito sono stati rimossi. Questi gate possono invece essere applicati a un circuito con QuantumCircuit.append.

RimossoAlternativa (append)
QuantumCircuit.diagonalDiagonalGate
QuantumCircuit.hamiltonianHamiltonianGate
QuantumCircuit.isometryIsometry
QuantumCircuit.isoIsometry
QuantumCircuit.ucUCGate
QuantumCircuit.ucrxUCRXGate
QuantumCircuit.ucryUCRYGate
QuantumCircuit.ucrzUCRZGate

Ad esempio, per un 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

Sono stati rimossi anche i seguenti metodi di QuantumCircuit:

RimossoAlternativa
QuantumCircuit.bind_parametersQuantumCircuit.assign_parameters
QuantumCircuit.snapshotLe istruzioni di salvataggio di qiskit-aer

qiskit.converters​

La funzione qiskit.converters.ast_to_dag è stata rimossa da Qiskit. Essa convertiva l'albero sintattico astratto generato dal vecchio parser OpenQASM 2 in un DAGCircuit. Poiché il vecchio parser OpenQASM 2 è stato rimosso (vedi qiskit.qasm), questa funzione non ha più uno scopo. Invece, analizza i tuoi file OpenQASM 2 in un QuantumCircuit usando i metodi costruttori QuantumCircuit.from_qasm_file o QuantumCircuit.from_qasm_str (o il modulo qiskit.qasm2), quindi converti quel QuantumCircuit in un DAGCircuit con 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​

Il modulo qiskit.extensions non è più disponibile. La maggior parte dei suoi oggetti è stata integrata nella libreria dei circuiti (qiskit.circuit.library). Per migrare alla nuova posizione, sostituisci semplicemente qiskit.extensions con qiskit.circuit.library nel percorso di importazione dell'oggetto. È un sostituto diretto.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Le classi spostate in qiskit.circuit.library sono:

Le seguenti classi sono state rimosse dal codice sorgente, poiché le loro funzioni erano ridondanti o legate al modulo extensions:

RimossoAlternativa
SingleQubitUnitaryqiskit.circuit.library.UnitaryGate
SnapshotUsa le istruzioni di salvataggio di qiskit-aer
ExtensionErrorUna classe di errore pertinente

qiskit.primitives​

Il cambiamento più rilevante nel modulo qiskit.primitives è l' introduzione della nuova interfaccia primitive V2. Questa sezione mostra come migrare il tuo flusso di lavoro dalle primitive V1 alle primitive V2, nonché i pochi cambiamenti avvenuti negli input accettati dall'interfaccia V1.

nota

A partire dalla versione 1.0, ci riferiremo all'interfaccia primitive precedente alla 1.0 come "primitive V1".

Migrazione da V1 a V2​

La distinzione formale tra le API delle primitive V1 e V2 è rappresentata dalle classi base da cui ereditano le implementazioni delle primitive. Per passare alle nuove classi base, puoi mantenere il percorso di importazione originale da qiskit.primitives:

Migra daSostituisci con
BaseEstimatorBaseEstimatorV2
BaseSamplerBaseSamplerV2

I nomi delle implementazioni core di Qiskit delle primitive V2 (quelle importabili da qiskit.primitives), sono stati modificati per chiarire il loro scopo come implementazioni eseguibili localmente con un Backend simulatore a vettore di stato. I nuovi nomi non includono il suffisso -V2.

Migra daSostituisci con
qiskit.primitives.Estimatorqiskit.primitives.StatevectorEstimator
qiskit.primitives.Samplerqiskit.primitives.StatevectorSampler

Ci sono alcune differenze concettuali da considerare quando si migra da V1 a V2. Queste differenze sono dettate dalla classe base, ma vengono illustrate negli esempi seguenti usando le implementazioni a vettore di stato presenti in qiskit.primitives:

nota

Per gli esempi seguenti, assume le seguenti importazioni e inizializzazioni delle 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
  1. Sampler e Estimator: Le nuove primitive V2 sono progettate per accettare input vettorizzati, dove singoli circuito possono essere raggruppati con specifiche a forma di array. Ovvero, un circuito può essere eseguito per array di n set di parametri, n osservabili, o entrambi (nel caso dell'estimator). Ogni gruppo è chiamato primitive unified bloc (pub) e può essere rappresentato come una tupla: (1 x circuit, [n x observables], [n x parameters]). L'interfaccia V1 non consentiva la stessa flessibilità. Il numero di circuito in input doveva invece corrispondere al numero di osservabili e set di parametri, come mostrato negli esempi seguenti (seleziona una scheda per vedere ogni esempio):
# 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

Le primitive V2 accettano più PUB come input, e ogni PUB ottiene il proprio risultato. Questo ti permette di eseguire circuito diversi con varie combinazioni di parametri/osservabili, il che non era sempre possibile nell'interfaccia V1:

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

  1. Sampler: Il Sampler V2 ora restituisce campioni di esiti di misura sotto forma di bitstring o conteggi, invece delle distribuzioni di quasi-probabilità dell'interfaccia V1. Le bitstring mostrano gli esiti delle misure, preservando l'ordine dei shot in cui sono stati misurati. Gli oggetti risultato del Sampler V2 organizzano i dati in termini dei nomi dei registri classici dei circuiti in input, per compatibilità con i circuiti dinamici.

    # 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
    Nome predefinito del registro classico

    Nel circuito sopra, nota che il nome del registro classico è "meas" per impostazione predefinita. Questo nome verrà usato in seguito per accedere alle bitstring di misura.

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

  2. Sampler e Estimator: Il sovraccarico di campionamento, comunemente esposto dalle implementazioni V1 tramite l'opzione di esecuzione shots, è ora un argomento del metodo run() delle primitive che può essere specificato a livello di PUB. Le classi base V2 espongono gli argomenti in formati diversi rispetto all'API V1:

    • BaseSamplerV2.run espone un argomento shots (simile al flusso di lavoro precedente):

      # 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 introduce un argomento precision che specifica le barre di errore che l'implementazione della primitiva dovrebbe raggiungere per le stime dei valori attesi:

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

Aggiornamenti nell'interfaccia V1​

qiskit.providers​

basicaer​

La maggior parte delle funzionalità nel modulo qiskit.providers.basicaer è stata sostituita con il nuovo modulo qiskit.providers.basic_provider, eccetto le classi UnitarySimulatorPy e StatevectorSimulatorPy che sono state rimosse; la loro funzionalità era già contenuta nel modulo quantum_info.

La migrazione ai nuovi percorsi è semplice. Puoi sostituire la maggior parte delle classi in qiskit.providers.basicaer con la loro controparte in qiskit.providers.basic_provider (sostituto diretto). Nota che le seguenti classi hanno nuovi percorsi e nomi:

RimossoAlternativa
qiskit.providers.basicaerqiskit.providers.basic_provider
BasicAerProviderBasicProvider
BasicAerJobBasicProviderJob
QasmSimulatorPyBasicSimulator
Istanze globali

Fai attenzione alle istanze globali quando migri al nuovo modulo. Non esiste un sostituto per l'istanza globale BasicAer che poteva essere importata direttamente come qiskit.BasicAer. Ciò significa che from qiskit import BasicProvider non è più un import valido. Invece, la classe provider deve essere importata dal suo sottomodulo e istanziata dall'utente:

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

I simulatori unitario e a vettore di stato possono essere sostituiti con diverse classi di quantum_info. Non si tratta di un sostituto diretto, ma i cambiamenti sono minimi. Consulta i seguenti esempi di migrazione:

RimossoAlternativa
UnitarySimulatorPyquantum_info.Operator
StatevectorSimulatorPyquantum_info.Statevector

Gli esempi seguenti mostrano i percorsi di migrazione dei simulatori 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)

fake_provider​

La maggior parte dei componenti rivolti agli utenti in qiskit.providers.fake_provider è stata migrata al pacchetto Python qiskit-ibm-runtime. Ciò include le classi fake provider, tutti i fake backend specifici per dispositivo (come FakeVigo, FakeNairobiV2 e FakeSherbrooke), e le classi base dei fake backend. Fai clic sulle schede seguenti per vedere le classi coinvolte.

  • Qualsiasi classe in qiskit.providers.fake_provider.backends
  • fake_provider.fake_backend.FakeBackend
  • fake_provider.fake_backend.FakeBackendV2

Per migrare al nuovo percorso:

  1. Installa qiskit-ibm-runtime versione 0.17.1 o successiva:

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

  2. Sostituisci le occorrenze di qiskit.providers.fake_provider nel tuo codice con qiskit_ibm_runtime.fake_provider. Ad esempio:

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

Anche le classi base dei fake backend sono state migrate, ma presentano alcune differenze nel percorso di importazione:

RimossoAlternativa
qiskit.providers.fake_provider.FakeQasmBackendqiskit_ibm_runtime.fake_provider.fake_qasm_backend.FakeQasmBackend
qiskit.providers.fake_provider.FakePulseBackendqiskit_ibm_runtime.fake_provider.fake_pulse_backend.FakePulseBackend
nota

Se dipendi dai fake backend per il testing unitario di una libreria downstream e hai conflitti con la dipendenza qiskit-ibm-runtime, puoi trovare anche nuove alternative di fake backend generici nativi di Qiskit. Queste includono le seguenti classi BackendV1 (sostituti diretti):

Questa è una classe configurabile che restituisce istanze BackendV2:

fake_provider (backend di testing speciali)​

Le classi fake backend per scopi di testing speciali in qiskit.providers.fake_provider non sono state migrate a qiskit_ibm_runtime.fake_provider. Il percorso di migrazione consigliato è usare la nuova classe GenericBackendV2 per configurare un backend con proprietà simili o per costruire un target personalizzato.

RimossoAlternativa
fake_provider.FakeBackendV2fake_provider.GenericBackendV2
fake_provider.FakeBackend5QV2fake_provider.GenericBackendV2
fake_provider.FakeBackendV2LegacyQubitPropsfake_provider.GenericBackendV2
fake_provider.FakeBackendSimplefake_provider.GenericBackendV2
fake_provider.ConfigurableFakeBackendfake_provider.GenericBackendV2

Esempio: Migra alla nuova classe 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.

Altri suggerimenti per la migrazione​

  • Non è più possibile importare da qiskit.providers.aer. Importa invece da qiskit_aer, che è un sostituto diretto. Per installare qiskit_aer, esegui:

    pip install qiskit-aer

  • Il supporto per l'esecuzione di job pulse sui backend di qiskit.providers.fake_provider è stato rimosso in Qiskit 1.0. Ciò è dovuto al fatto che Qiskit Aer ha rimosso la sua funzionalità di simulazione per tali job. Per carichi di lavoro di simulazione Hamiltoniana di basso livello, considera l'uso di una libreria specializzata come Qiskit Dynamics.

qiskit.pulse​

ParametricPulse​

La classe base qiskit.pulse.library.parametric_pulses.ParametricPulse e la libreria di pulse sono state sostituite da qiskit.pulse.SymbolicPulse e dalla corrispondente libreria di pulse. SymbolicPulse supporta la serializzazione 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)
RimossoAlternativa
pulse.library.parametric_pulses.ParametricPulseqiskit.pulse.SymbolicPulse
pulse.library.parametric_pulses.Constantpulse.library.symbolic_pulses.Constant
pulse.library.parametric_pulses.Dragpulse.library.symbolic_pulses.Drag
pulse.library.parametric_pulses.Gaussianpulse.library.symbolic_pulses.Gaussian
qiskit.pulse.library.parametric_pulses.GaussianSquarepulse.library.symbolic_pulses.GaussianSquare

Ampiezza a valore complesso​

L'ampiezza del pulse a valore complesso (amp) è stata sostituita da una coppia (amp, angle). Questa rappresentazione è più intuitiva, specialmente per alcune attività di calibrazione come la calibrazione dell'angolo:

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

Iniezione di operazioni gate del circuito​

Non è più possibile iniettare operazioni gate del circuito nel contesto del pulse builder tramite qiskit.pulse.builder.call. Questa rimozione riguarda gli argomenti in input di tipo QuantumCircuit, nonché le seguenti funzioni:

  • 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

Se vuoi ancora iniettare schedule calibrate dal backend, usa il seguente schema invece di chiamare i comandi 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)

Analogamente, un QuantumCircuit può essere iniettato nel contesto del builder transpilando e schedulando manualmente l'oggetto.

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)

Ti consigliamo di scrivere un programma pulse minimo con il builder e allegarlo a QuantumCircuit tramite il metodo QuantumCircuit.add_calibration come microcodice di un'istruzione gate, invece di scrivere l'intero programma con il modello pulse.

builder.build​

I seguenti argomenti in qiskit.pulse.builder.build sono stati rimossi senza alternativa.

  • default_transpiler_settings
  • default_circuit_scheduler_settings

Sono state rimosse anche queste funzioni:

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

Ciò è dovuto al fatto che non è più possibile iniettare oggetti circuito nel contesto del builder (vedi Iniezione di operazioni gate del circuito); queste impostazioni servivano per convertire gli oggetti iniettati in rappresentazioni pulse.

library​

La libreria di pulse discreta è stata rimossa dal codice sorgente. Ciò include:

  • 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

Usa invece il corrispondente qiskit.pulse.SymbolicPulse, con SymbolicPulse.get_waveform(). Ad esempio, invece di pulse.gaussian(100,0.5,10), usa pulse.Gaussian(100,0.5,10).get_waveform(). Nota che la fase sia di Sawtooth che di Square è definita in modo tale che una fase di 2\\pi corrisponde a uno spostamento di un ciclo completo, contrariamente alla controparte discreta. Nota anche che le ampiezze complesse non sono più supportate nella libreria di pulse simbolica; usa invece float, amp e angle.

ScalableSymbolicPulse​

Non è più possibile caricare oggetti qiskit.pulse.ScalableSymbolicPulse dalla libreria con un parametro amp complesso da file qpy versione 5 o precedente (Qiskit Terra < 0.23.0). Non è necessaria alcuna azione di migrazione, poiché amp complesso viene automaticamente convertito in float (amp, angle).

Questa modifica riguarda questi pulse:

qiskit.qasm​

Il vecchio modulo parser OpenQASM 2 precedentemente in qiskit.qasm è stato sostituito dal modulo qiskit.qasm2, che fornisce un parser più veloce e accurato per OpenQASM 2. I metodi di alto livello di QuantumCircuit from_qasm_file() e from_qasm_str() rimangono invariati, ma useranno internamente il nuovo parser. Tuttavia, l'interfaccia pubblica del modulo qasm2 non è la stessa. Mentre il modulo qiskit.qasm forniva un'interfaccia a un albero sintattico astratto restituito dalla libreria di parser ply, qiskit.qasm2 non espone l'AST né alcun dettaglio di implementazione di livello inferiore sul parser. Prende invece l'input OpenQASM 2 e produce un oggetto QuantumCircuit.

Ad esempio, se in precedenza eseguivi qualcosa del genere:

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)

Sostituiscilo con il seguente:

import qiskit.qasm2

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

qiskit.quantum_info​

Il modulo qiskit.quantum_info.synthesis è stato migrato in varie posizioni nel codice sorgente, principalmente in qiskit.synthesis.

RimossoAlternativa
OneQubitEulerDecomposerqiskit.synthesis.one_qubit.OneQubitEulerDecomposer
TwoQubitBasisDecomposerqiskit.synthesis.two_qubits.TwoQubitBasisDecomposer
XXDecomposerqiskit.synthesis.two_qubits.XXDecomposer
two_qubit_cnot_decomposeqiskit.synthesis.two_qubits.two_qubit_cnot_decompose
Quaternionqiskit.quantum_info.Quaternion

Questo spostamento non ha influito sul percorso di importazione usuale di Quaternion, ma non puoi più accedervi tramite qiskit.quantum_info.synthesis.

Infine, cnot_rxx_decompose è stato rimosso.

qiskit.test​

Il modulo qiskit.test non è più un modulo pubblico. Non era mai stato pensato come pubblico, né per essere usato al di fuori della suite di test di Qiskit. Tutte le funzionalità erano specifiche di Qiskit e non viene fornita alcuna alternativa; se hai bisogno di funzionalità simili, devi includerle nel tuo harness di test.

qiskit.tools​

Il modulo qiskit.tools è stato rimosso in Qiskit 1.0. La maggior parte di questa funzionalità è stata sostituita da funzionalità simili in altri pacchetti o rimossa senza alternativa. L'eccezione principale è la funzione qiskit.tools.parallel_map(), che è stata spostata nel modulo qiskit.utils. Può essere usata da questa nuova posizione. Ad esempio:

Se in precedenza eseguivi:

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

jupyter​

Il sottomodulo qiskit.tools.jupyter è stato rimosso perché la funzionalità in questo modulo era legata al vecchio pacchetto qiskit-ibmq-provider, che non è più supportato. Supportava inoltre solo BackendV1 e non la più recente interfaccia BackendV2.

monitor​

Il sottomodulo qiskit.tools.monitor è stato rimosso perché era legato al vecchio pacchetto qiskit-ibmq-provider, che non è più supportato (supportava anche solo l'interfaccia BackendV1 e non la più recente BackendV2). Non viene fornita alcuna alternativa per questa funzionalità.

visualization​

Il sottomodulo qiskit.tools.visualization è stato rimosso. Questo modulo era un redirect legacy dalla posizione originale del modulo di visualizzazione di Qiskit ed era stato spostato in qiskit.visualization in Qiskit 0.8.0. Se stai ancora usando questo percorso, aggiorna i tuoi import da qiskit.tools.visualization a qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

events​

Il modulo qiskit.tools.events e l'utilità progressbar() che esponeva sono stati rimossi. La funzionalità di questo modulo non era ampiamente usata ed è meglio coperta da pacchetti dedicati come tqdm.

qiskit.transpiler​

synthesis​

Gli elementi nel modulo qiskit.transpiler.synthesis sono stati migrati in nuove posizioni:

RimossoAlternativa
qiskit.transpiler.synthesis.aqc (eccetto AQCSynthesisPlugin)qiskit.synthesis.unitary.aqc
qiskit.transpiler.synthesis.graysynthqiskit.synthesis.synth_cnot_phase_aam
qiskit.transpiler.synthesis.cnot_synthqiskit.synthesis.synth_cnot_count_full_pmh

passes​

Il pass del Transpiler NoiseAdaptiveLayout è stato sostituito da VF2Layout e VF2PostLayout, che impostano un layout in base alle caratteristiche di rumore riportate da un backend. Sia il pass che il plugin dello stage di layout "noise_adaptive" corrispondente sono stati rimossi da Qiskit.

Il pass del Transpiler CrosstalkAdaptiveSchedule è stato rimosso dal codice sorgente. Questo pass non era più utilizzabile perché il suo funzionamento interno dipendeva da proprietà personalizzate impostate nel payload BackendProperties di un'istanza BackendV1. Poiché nessun backend imposta questi campi, il pass è stato rimosso.

passmanager​

I metodi append delle classi ConditionalController, FlowControllerLinear e DoWhileController sono stati rimossi. Invece, tutte le operazioni devono essere fornite quando gli oggetti controller vengono costruiti.

qiskit.utils​

I seguenti strumenti in qiskit.utils sono stati rimossi senza sostituzione:

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

Queste funzioni erano usate esclusivamente nei moduli qiskit.algorithms e qiskit.opflow, che sono stati anch'essi rimossi.

qiskit.visualization​

Il modulo qiskit.visualization.qcstyle è stato rimosso. Usa qiskit.visualization.circuit.qcstyle come sostituto diretto.