Modifiche alle funzionalità di Qiskit nell' v1.0

La presente guida descrive i percorsi di migrazione relativi alle modifiche più significative apportate alle funzionalità di Qiskit v1.0, organizzate per modulo. Utilizza l'indice a destra per passare al modulo che ti interessa.

Strumento di migrazione Qiskit v1.0

Per facilitare il processo di migrazione, è possibile utilizzare l'opzione flake8-qiskit-migration per individuare i percorsi di importazione rimossi nel codice e suggerire alternative.

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

Per ulteriori informazioni, consultare il repository del progetto del progetto.

Istanze e funzioni globali

Aer

qiskit.Aer L'oggetto non è disponibile in Qiskit v1.0. Utilizza invece lo stesso oggetto del qiskit_aer namespace, che è un sostituto diretto. qiskit_aerPer installarlo, eseguire:

pip install qiskit-aer

BasicAer

qiskit.BasicAer L'oggetto non è disponibile in Qiskit v1.0. Consulta la basicaer sezione dedicata alla migrazione per conoscere le opzioni di migrazione.

esegui

La qiskit.execute funzione non è disponibile in Qiskit v1.0. Questa funzione fungeva da wrapper di alto livello attorno alle transpile funzioni run in Qiskit. Invece di qiskit.execute, usa la transpile funzione 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 rimossa qiskit.execute . 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. Utilizzare invece qasm2.dump o qasm2.dumps.

Per l'output formattato da Pygments, si può consultare il programma standalone openqasm-pygments indipendente, poiché qasm2.dump e qasm2.dumps non forniscono un output colorato da 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 cancelli

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

I seguenti metodi di circuito sono stati eliminati. Invece, queste porte possono essere applicate a un circuito con QuantumCircuit.append.

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

Sono stati rimossi anche i seguenti metodi QuantumCircuit :

qiskit.converters

La funzione qiskit.converters.ast_to_dag è stata rimossa da Qiskit. Converte l'albero l'albero della sintassi astratta generato dal parser legacy OpenQASM 2 in un DAGCircuit. Poiché il parser legacy OpenQASM 2 è stato rimosso (vedere qiskit.qasm ), questa non serve più a nulla. Invece, analizzare i file OpenQASM 2 in un file un QuantumCircuit utilizzando il file QuantumCircuit.from_qasm_file o QuantumCircuit.from_qasm_str o i metodi del costruttore (o il modulo qiskit.qasm2 modulo), poi convertire QuantumCircuit in un oggetto 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 integrati nella libreria dei circuiti (qiskit.circuit.library). Per migrare alla è sufficiente sostituire qiskit.extensions con qiskit.circuit.library nel percorso di importazione degli oggetti. Si tratta di una sostituzione a scomparsa.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Le classi spostate in qiskit.circuit.library sono:

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

Le seguenti classi sono state rimosse dalla base di codice, in quanto le loro funzioni erano ridondanti o legate al modulo extensions :

qiskit.primitives

La modifica più rilevante del modulo qiskit.primitives modulo è l'introduzione l'introduzione della nuova interfaccia primitiva V2. Questa sezione mostra come migrare il flusso di lavoro da primitive V1 a primitive V2, nonché le poche modifiche apportate agli input accettati dall'interfaccia negli input accettati dall'interfaccia V1.

Migrazione da V1 a V2

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

I nomi delle implementazioni del nucleo di qiskit delle primitive di V2 (quelle importabili da qiskit.primitives), sono stati modificati per chiarire il loro scopo come implementazioni che possono essere eseguite localmente con un backend simulatore di vettori di stato. I nuovi nomi non includono il suffisso -V2.

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

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: Le nuove primitive di V2 sono progettate per accettare input vettorializzati, in cui i singoli circuiti possono essere raggruppati con specifiche a valori vettoriali. In altre parole, un ciclo può essere eseguito su insiemi di n parametri, n grandezze osservabili o entrambi (nel caso di Estimator). Ogni gruppo è denominato «blocco unificato primitivo » (pub) e può essere rappresentato come una tupla: (1 x circuit, [n x observables], [n x parameters]). L'interfaccia V1 non offriva la stessa flessibilità. Il numero dei circuiti di ingresso doveva invece corrispondere al numero di osservabili e di insiemi di parametri, come illustrato negli esempi seguenti (selezionare una scheda per visualizzare ciascun 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

# 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 accetta più PUB come input e ogni pub ottiene il proprio risultato. Questo consente di eseguire circuiti diversi con varie combinazioni di parametri/osservabili, 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)

# 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 : il sampler V2 ora restituisce campioni dei risultati di misurazione sotto forma di stringhe di bit o conteggi , anziché le distribuzioni di quasi-probabilità dell'interfaccia V1 . Le stringhe di bit mostrano i risultati delle misurazioni, mantenendo l'ordine in cui sono state effettuate. Gli oggetti risultato del Sampler dell' V2 organizzano i dati in base ai nomi dei registri classici dei rispettivi circuiti di ingresso, per garantire la 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 del registro classico predefinito

   Nel circuito sopra riportato, si noti che il nome del registro classico è predefinito a "meas". Questo nome verrà utilizzato in seguito per accedere alle stringhe di bit delle misure.

   # 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: L'overhead di campionamento, comunemente esposto dalle implementazioni di V1 attraverso l'opzione shots run, è ora un argomento del metodo primitives run() che può essere specificato al livello PUB livello. Le classi di base di V2 espongono gli argomenti in formati diversi da quelli dell'API di 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 per le stime dei valori di aspettativa:

     # 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 dell' V1

• Conversione implicita da un BaseOperator denso ad un SparsePauliOp in Estimator argomenti osservabili non è più consentita. È necessario convertire esplicitamente in un elemento SparsePauliOp utilizzando SparsePauliOp.from_operator(operator) al suo posto.

• Utilizzando un PauliList in Gli argomenti osservabili dell'Estimatore non sono più consentiti. Si dovrebbe invece convertire esplicitamente l'argomento utilizzando SparsePauliOp(pauli_list) prima.

qiskit.providers

basicaer

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

La migrazione ai nuovi percorsi è semplice. È possibile sostituire la maggior parte delle classi in qiskit.providers.basicaer con le loro classi qiskit.providers.basic_provider (sostituzione a cascata). Si noti che le seguenti classi hanno nuovi percorsi e nomi:

# 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 unitari e di vettore di stato possono essere sostituiti con diverse quantum_info classi. Non si tratta di una sostituzione non si tratta di una sostituzione immediata, ma le modifiche sono minime. Vedere i seguenti esempi di migrazione esempi di migrazione:

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

fornitore_falso

La maggior parte dei componenti rivolti all'utente qiskit.providers.fake_provider sono stati è stata migrata al pacchetto qiskit-ibm-runtime Python. Questo include le le classi dei falsi provider, tutti i falsi backend specifici per i dispositivi (come ad esempio FakeVigo, FakeNairobiV2 e FakeSherbrooke) e le classi di base dei falsi backend di base. Fare clic sulle schede seguenti per vedere le classi interessate.

Per migrare al nuovo percorso:

1. Installare il sito qiskit-ibm-runtime 0.17.1 o successivo:

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

2. Sostituite le istanze di qiskit.providers.fake_provider nel vostro 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 di base del falso backend sono state migrate, ma presentano alcune differenze nel percorso di importazione:

fake_provider (backend di test speciali)

Le false classi del backend per scopi speciali di test in qiskit.providers.fake_provider non sono non sono state migrate a qiskit_ibm_runtime.fake_provider. Il percorso di migrazione è quello di utilizzare il nuovo GenericBackendV2 per configurare un backend con proprietà simili o per costruire un target personalizzato personalizzato.

Esempio: Migrare al nuovo GenericBackendV2 classe:

# 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 consigli sulla migrazione

• L'importazione da qiskit.providers.aer non è più possibile. Si può invece importare da qiskit_aer, che lo sostituisce senza problemi. Per installare qiskit_aer, eseguire:

  pip install qiskit-aer

• Il supporto per l'esecuzione di lavori Pulse sui backend di qiskit.providers.fake_provider has è stato rimosso in Qiskit v1.0. Questo perché Qiskit Aer ha eliminato la sua funzionalità di simulazione per tali attività. Per i carichi di lavoro relativi alla simulazione dell'Hamiltoniano a basso livello, si consiglia di utilizzare una libreria specializzata come Qiskit Dynamics.

qiskit.pulse

ParametricPulse

La classe base qiskit.pulse.library.parametric_pulses.ParametricPulse e la libreria sono state sostituite da qiskit.pulse.SymbolicPulse e la corrispondente libreria di impulsi. SymbolicPulse supporti 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)

Amplitudine a valore complesso

L'ampiezza dell'impulso a valore complesso (amp) è sostituita da una (amp, angle) duo. Questa rappresentazione è più intuitiva, soprattutto per alcune compiti 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})

Operazioni di gate del circuito di iniezione

Iniezione di operazioni di gate di circuito nel contesto del costruttore di impulsi tramite qiskit.pulse.builder.call non è più possibile. Questa rimozione riguarda gli argomenti di ingresso di tipo QuantumCircuit, così come le funzioni 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 si desidera comunque iniettare orari calibrati dal backend, utilizzare il seguente schema invece di chiamare i comandi di 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)

Allo stesso modo, un QuantumCircuit può essere iniettato nel contesto del costruttore, transpilando e schedulando manualmente l'oggetto 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)

Si consiglia di scrivere un programma di impulso minimo con il costruttore e di allegarlo a QuantumCircuit attraverso l'opzione QuantumCircuit.add_calibration metodo come microcodice di un'istruzione gate, piuttosto che scrivere l'intero programma con il modello a impulsi programma con il modello a impulsi.

builder.build

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

• default_transpiler_settings
• default_circuit_scheduler_settings

Anche queste funzioni sono state rimosse:

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

Questo perché non è più possibile iniettare oggetti di circuito nel contesto del costruttore (si veda nel contesto del costruttore (vedere Iniezione di operazioni di gate di circuito di circuiti); queste impostazioni servivano per conversione degli oggetti iniettati in rappresentazioni di impulsi.

libreria

La libreria degli impulsi discreti è stata rimossa dalla base di codice. Ciò comprende:

• 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

Utilizzare invece il corrispondente qiskit.pulse.SymbolicPulse, con SymbolicPulse.get_waveform(). Ad esempio, invece di pulse.gaussian(100,0.5,10), utilizzare pulse.Gaussian(100,0.5,10).get_waveform(). Si noti che la fase di entrambi Sawtooth e Square è definita in modo tale che una fase di 2\pi si sposta di un ciclo intero, contrariamente alla controparte discreta discreto. Si noti inoltre che le ampiezze complesse non sono più supportate nella libreria di nella libreria degli impulsi simbolici; utilizzate invece float, amp e angle .

ScalableSymbolicPulse

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

Questa modifica si applica a questi impulsi:

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

qiskit.qasm

Il modulo parser legacy di OpenQASM 2, precedentemente presente in qiskit.qasm , è stato sostituito dal modulo è stato sostituito dal modulo qiskit.qasm2 che fornisce un parser più veloce e più accurato per OpenQASM 2. I metodi di alto livello QuantumCircuit metodi 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 per un albero sintattico astratto restituito dalla libreria di ply parser, qiskit.qasm2 non espone l'AST o qualsiasi altro livello inferiore di dettagli di implementazione del parser. Prende invece in ingresso OpenQASM 2 e un oggetto QuantumCircuit oggetto.

Ad esempio, se in precedenza si eseguiva qualcosa di simile:

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)

Sostituirlo 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 diverse in varie posizioni della base di codice, per lo più qiskit.synthesis.

Questo spostamento non ha influito sul consueto percorso di importazione di Quaternion, ma non è più possibile accedervi attraverso attraverso qiskit.quantum_info.synthesis.

Infine, cnot_rxx_decompose è stato rimosso.

qiskit.test

Il modulo qiskit.test non è più un modulo pubblico. Non è mai stato pensato per essere pubblico, né per essere utilizzato al di fuori della suite di test Qiskit. Tutte le funzionalità sono specifiche di Qiskit e non sono fornite alternative se avete bisogno di una funzionalità simile, dovrete includerla nei vostri test.

qiskit.tools

Il qiskit.tools modulo è stato rimosso in Qiskit v1.0. La maggior parte di queste funzionalità è stata o sostituita da funzionalità simili presenti in altri pacchetti, oppure rimossa senza alcuna alternativa. L'eccezione principale è la qiskit.tools.parallel_map() funzione, che è stata spostata nel modulo qiskit.utils . Si può invece utilizzare da questa nuova posizione. Ad esempio:

Se in precedenza era in esecuzione:

# 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é le funzionalità di questo modulo di questo modulo è legata al pacchetto legacy qiskit-ibmq-provider , che non è più supportato più supportato. Inoltre supportava solo BackendV1 e non il più recente BackendV2 interfaccia.

monitorare

Il sottomodulo qiskit.tools.monitor è stato rimosso perché era legato al pacchetto pacchetto qiskit-ibmq-provider , che non è più supportato (inoltre supportava solo l'interfaccia supportava solo l'interfaccia BackendV1 e non la più recente BackendV2 più recente). Non c'è non ci sono alternative per questa funzionalità.

visualizzazione

Il sottomodulo qiskit.tools.visualization è stato rimosso. Questo modulo era un questo modulo era un reindirizzamento dalla posizione originale del modulo di visualizzazione di Qiskit e è stato spostato in qiskit.visualization in Qiskit 0.8.0. Se si utilizza ancora questo percorso, aggiornare le importazioni 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)

eventi

Il modulo qiskit.tools.events e l'utilità progressbar() che esso esponeva sono stati rimossi. La funzionalità di questo modulo non è stata molto utilizzata ed è meglio coperte da pacchetti dedicati come tqdm.

qiskit.transpiler

sintesi

Le voci del modulo qiskit.transpiler.synthesis sono state migrate in nuove posizioni:

Esiti positivi

Il passaggio del transpiler NoiseAdaptiveLayout è stato sostituito da VF2Layout e VF2PostLayout, che impostano un layout basato sulle caratteristiche di rumore segnalate di un backend. Sia il passaggio che il corrispondente plugin "noise_adaptive" layout stage sono stati rimossi da Qiskit.

Il passaggio del transpiler CrosstalkAdaptiveSchedule è stato rimosso dalla base di codice codice base. Questo passaggio non era più utilizzabile perché il suo funzionamento interno dipendeva dall'impostazione di proprietà personalizzate nel payload di BackendProperties di un'istanza di BackendV1 . Poiché nessun backend imposta questi campi, il passaggio è stato rimosso è stato rimosso.

gestore di pass

I metodi append del programma ConditionalController, FlowControllerLinear, e DoWhileController classi sono state rimosse. Invece, tutti i compiti devono essere forniti quando gli oggetti controllore vengono costruiti.

qiskit.utils

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

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

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

qiskit.visualization

Il modulo qiskit.visualization.qcstyle è stato rimosso. Utilizzare qiskit.visualization.circuit.qcstyle come sostituzione diretta.