Cambios en la función « v1.0 » de Qiskit

Esta guía describe las rutas de migración para los cambios más importantes en las funcionalidades de Qiskit v1.0, organizadas por módulos. Utiliza el índice que aparece a la derecha para ir al módulo que te interese.

Herramienta de migración de Qiskit a v1.0

Para facilitar el proceso de migración, puede utilizar la función flake8-qiskit-migration para detectar rutas de importación eliminadas en su código y sugerir alternativas.

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

Para más información, consulte el del proyecto.

Instancias y funciones globales

AER

El qiskit.Aer objeto no está disponible en Qiskit v1.0. En su lugar, utiliza el mismo objeto del qiskit_aer espacio de nombres, que es un sustituto directo. qiskit_aerPara instalarlo, ejecuta:

pip install qiskit-aer

BasicAer

El qiskit.BasicAer objeto no está disponible en Qiskit v1.0. Consulte la basicaer sección de migración para conocer las opciones de migración.

ejecutar

La qiskit.execute función no está disponible en Qiskit v1.0. Esta función servía como envoltura de alto nivel para las transpile funciones run en Qiskit. En lugar de qiskit.execute, utiliza la transpile función seguida de 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)

Alternativamente, la primitiva Sampler es semánticamente equivalente a la función qiskit.execute eliminada. La clase BackendSampler es una genérica para backends que no soportan primitivas:

from qiskit.primitives import BackendSampler

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

qiskit.circuit

QuantumCircuit.qasm

Se ha eliminado el método QuantumCircuit.qasm. En su lugar, utilice qasm2.dump o qasm2.dumps.

Para obtener una salida con formato Pygments, consulte la aplicación autónoma openqasm-pygments independiente, ya que qasm2.dump y qasm2.dumps no proporcionan salida coloreada 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 puertas

Los siguientes métodos de puerta se han eliminado en favor de métodos más establecidos que añaden las mismas puertas:

Se han eliminado los siguientes métodos de circuito. En cambio, estas puertas pueden aplicarse a un circuito con QuantumCircuit.append.

Por ejemplo, para a 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

También se han eliminado los siguientes métodos de QuantumCircuit :

qiskit.converters

La función qiskit.converters.ast_to_dag ha sido eliminada de Qiskit. Convierte el árbol sintáctico abstracto generado por el analizador sintáctico heredado de OpenQASM 2 en un archivo DAGCircuit. Dado que el parser OpenQASM 2 se ha eliminado (véase qiskit.qasm ), esta función ya no tiene sentido. En su lugar, analice sus archivos OpenQASM 2 en un QuantumCircuit utilizando el QuantumCircuit.from_qasm_file o QuantumCircuit.from_qasm_str constructores (o el qiskit.qasm2 módulo), entonces convertir ese QuantumCircuit en 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

El módulo qiskit.extensions ya no está disponible. La mayoría de sus objetos se han integrado en la biblioteca de circuitos (qiskit.circuit.library). Para migrar a la nueva ubicación, basta con sustituir qiskit.extensions por qiskit.circuit.library en la ruta de importación de objetos. Se trata de una sustitución directa.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Las clases trasladadas a qiskit.circuit.library son:

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

Las siguientes clases se han eliminado del código base, ya que sus funciones eran redundantes o estaban vinculadas al módulo funciones eran redundantes o estaban vinculadas al módulo extensions :

qiskit.primitives

El cambio más notable en el módulo qiskit.primitives módulo es la introducción de la nueva interfaz de primitivas V2. Esta sección muestra cómo migrar su flujo de trabajo de primitivas V1 a primitivas V2, así como los pocos cambios que se han producido en las entradas aceptadas por la interfaz V1.

Migrar de V1 a V2

La distinción formal entre las primitivas V1 y V2 APIs son las clases base de las que heredan las implementaciones de las primitivas. Para pasar a las nuevas clases base, puede mantener la ruta de importación original de qiskit.primitives:

Los nombres de las implementaciones del núcleo qiskit de las primitivas V2 (aquellas importables desde qiskit.primitives), se han modificado para aclarar su propósito como implementaciones que se pueden ejecutar localmente con un backend simulador de vectores de estado. Los nuevos nombres no incluyen el sufijo -V2.

Al migrar de V1 a V2 hay que tener en cuenta algunas diferencias conceptuales. Estas diferencias vienen dictadas por la clase base, pero se muestran en los siguientes ejemplos utilizando las implementaciones statevector que se encuentran en 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: Las nuevas primitivas de « V2 » están diseñadas para aceptar entradas vectorizadas, en las que los circuitos individuales pueden agruparse con especificaciones de valores matriciales. Es decir, se puede ejecutar un ciclo para matrices de conjuntos n de parámetros, n variables observables o ambos (en el caso de Estimator). Cada grupo se denomina «bloque unificado primitivo » (pub) y puede representarse como una tupla: (1 x circuit, [n x observables], [n x parameters]). La interfaz « V1 » no ofrecía la misma flexibilidad. En cambio, el número de circuitos de entrada debía coincidir con el número de observables y conjuntos de parámetros, tal y como se muestra en los siguientes ejemplos (selecciona una pestaña para ver cada ejemplo):

# 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 aceptan múltiples PUBs como entradas, y cada pub obtiene su propio resultado. Este le permite ejecutar diferentes circuitos con varias combinaciones de parámetros/observables, lo que no siempre era posible en la interfaz 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. Muestreador : El muestreador V2 ahora devuelve muestras de resultados de medición en forma de cadenas de bits o recuentos , en lugar de las distribuciones de cuasi-probabilidad de la interfaz V1 . Las cadenas de bits muestran los resultados de las mediciones, conservando el orden en el que se realizaron. Los objetos de resultado del muestreador « V2 » organizan los datos según los nombres clásicos de los registros de sus circuitos de entrada, para garantizar la compatibilidad con los circuitos dinámicos.

   # 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

   Nombre de registro clásico por defecto

   En el circuito anterior, observa que el nombre del registro clásico es por defecto "meas". Este nombre se utilizará más adelante para acceder a las cadenas de bits de medición.

   # 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: La sobrecarga de muestreo, comúnmente expuesta por las implementaciones de V1 a través de la opción de ejecución shots , es ahora un argumento del método de primitivas run() que puede especificarse en el nivel PUB nivel. Las clases base de V2 exponen los argumentos en formatos diferentes a los de la API de V1 :

   • BaseSamplerV2.run expone un argumento shots (similar al flujo de trabajo anterior):

     # 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 argumento precision que especifica las barras de error que la implementación primitiva debe apuntar para las estimaciones de los valores de expectativa:

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

Actualizaciones en la interfaz de V1

• Conversión implícita de un BaseOperator denso a un SparsePauliOp en Estimator argumentos observables ya no está permitida. Debe convertir explícitamente a SparsePauliOp utilizando SparsePauliOp.from_operator(operator) en su lugar.

• Utilizando un PauliList en Ya no se permiten los argumentos observables del estimador. En su lugar, debe convertir explícitamente el argumento utilizando SparsePauliOp(pauli_list) primero.

qiskit.providers

basicaer

La mayor parte de la funcionalidad del módulo qiskit.providers.basicaer se ha sustituido por el nuevo qiskit.providers.basic_provider excepto las clases UnitarySimulatorPy y StatevectorSimulatorPy que se han eliminado; su funcionalidad ya estaba contenida en el módulo quantum_info módulo.

La migración a las nuevas rutas es sencilla. Puede sustituir la mayoría de las clases en qiskit.providers.basicaer por sus clases qiskit.providers.basic_provider (sustitución directa). Tenga en cuenta que las siguientes clases tienen nuevas rutas y nombres:

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

Los simuladores unitarios y de vector de estado pueden sustituirse por diferentes quantum_info clases. No se trata de pero los cambios son mínimos. Consulte los siguientes ejemplos:

Los siguientes ejemplos muestran las rutas de migración de los simuladores de 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()

proveedor_falso

La mayoría de los componentes qiskit.providers.fake_provider componentes se han migrado al paquete qiskit-ibm-runtime Python. Esto incluye las clases clases de proveedores falsos, todos los backends falsos específicos de dispositivos (como FakeVigo FakeNairobiV2 y FakeSherbrooke), y las clases base del falso backend falsas. Haga clic en las pestañas siguientes para ver las clases afectadas.

Para migrar a la nueva ruta:

1. Instale qiskit-ibm-runtime 0.17.1 o posterior:

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

2. Sustituya las instancias de qiskit.providers.fake_provider en su código por qiskit_ibm_runtime.fake_provider. Por ejemplo:

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

Las clases base del falso backend también han sido migradas, pero tienen algunas diferencias en la ruta de importación:

proveedor_falso (backends de pruebas especiales)

Las clases backend falsas para fines de pruebas especiales en qiskit.providers.fake_provider tienen no se han migrado a qiskit_ibm_runtime.fake_provider. Se recomienda es utilizar el nuevo GenericBackendV2 para configurar un backend con propiedades similares o para crear un objetivo personalizado.

Ejemplo: Migrar al nuevo GenericBackendV2 clase:

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

Otros consejos sobre migración

• Ya no es posible importar desde qiskit.providers.aer . En su lugar, importe de qiskit_aer, que es un sustituto directo. Para instalar qiskit_aer, ejecute:

  pip install qiskit-aer

• Se qiskit.providers.fake_provider ha eliminado la compatibilidad con la ejecución de tareas de pulsos en backends en Qiskit v1.0. Esto se debe a que Qiskit Aer ha eliminado su funcionalidad de simulación para este tipo de tareas. Para tareas de simulación de hamiltonianos de bajo nivel, considera la posibilidad de utilizar una biblioteca especializada como Qiskit Dynamics.

qiskit.pulse

ParametricPulse

La clase base qiskit.pulse.library.parametric_pulses.ParametricPulse y la han sido sustituidas por qiskit.pulse.SymbolicPulse y la biblioteca de impulsos correspondiente. SymbolicPulse admite Serialización 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)

Amplitud de valor complejo

La amplitud del impulso de valor complejo (amp) se sustituye por un (amp, angle). Esta representación es más intuitiva, especialmente para algunas tareas de calibración, como la calibración de ángulos:

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

Operaciones de la puerta del circuito de inyección

Inyección de operaciones de puerta de circuito en el contexto del generador de impulsos mediante qiskit.pulse.builder.call ya no es posible. Esta eliminación afecta a los argumentos de entrada de tipo QuantumCircuit, así como a las siguientes funciones:

• 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

Si aún desea inyectar horarios calibrados por el backend, utilice el siguiente en lugar de llamar a los comandos de puerta.

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)

Del mismo modo, un QuantumCircuit puede inyectarse en el contexto del constructor transpilando y programando manualmente el objeto.

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)

Recomendamos escribir un programa de pulso mínimo con el constructor y adjuntarlo a QuantumCircuit a través del QuantumCircuit.add_calibration método como microcódigo de una instrucción de puerta, en lugar de escribir todo el programa con el modelo de pulso.

builder.build

Los siguientes argumentos en qiskit.pulse.builder.build se han eliminado sin sin alternativa.

• default_transpiler_settings
• default_circuit_scheduler_settings

Estas funciones también se han eliminado:

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

Esto se debe a que ya no es posible inyectar objetos de circuito en el contexto del constructor (véase Inyectar operaciones de puerta de circuito ); estos ajustes eran para convertir objetos inyectados en representaciones de pulsos.

biblioteca

La biblioteca de impulsos discretos se ha eliminado de la base de código. Esto incluye:

• 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

En su lugar, utilice el qiskit.pulse.SymbolicPulse, con SymbolicPulse.get_waveform(). Por ejemplo, en lugar de pulse.gaussian(100,0.5,10), utilice pulse.Gaussian(100,0.5,10).get_waveform(). Obsérvese que la fase de ambos Sawtooth y Square se define de forma que que una fase de 2\pi se desplaza un ciclo completo, al contrario que su homólogo discreto discreta. Tenga en cuenta también que las amplitudes complejas ya no son compatibles con la biblioteca de pulsos simbólicos la biblioteca de pulsos simbólicos; utilice float, amp, y angle en su lugar.

ScalableSymbolicPulse

Ya no es posible cargar objetos de biblioteca qiskit.pulse.ScalableSymbolicPulse con un parámetro complejo amp desde archivos qpy de la versión 5 o anteriores (Qiskit Terra < 0.23.0 ). No se requiere ninguna acción de migración, ya que el complejo amp se convertirá se convertirá automáticamente en float (amp, angle).

Este cambio se aplica a estos pulsos:

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

qiskit.qasm

El módulo analizador heredado de OpenQASM 2 que anteriormente se encontraba en qiskit.qasm ha sido sustituido por el nuevo módulo analizador de ha sido sustituido por el módulo qiskit.qasm2 que proporciona un analizador más rápido y preciso para OpenQASM 2. Los métodos QuantumCircuit métodos from_qasm_file() y from_qasm_str() siguen siendo los mismos, pero utilizarán internamente el nuevo analizador sintáctico. Sin embargo, la interfaz del módulo qasm2 no es la misma. Mientras que el módulo qiskit.qasm proporcionaba una interfaz a un árbol sintáctico abstracto devuelto por la biblioteca ply biblioteca del analizador sintáctico, qiskit.qasm2 no expone el AST ni ningún detalles de implementación del analizador sintáctico. En su lugar, toma OpenQASM 2 de entrada y produce un QuantumCircuit objeto.

Por ejemplo, si antes ejecutabas algo así:

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)

Sustitúyalo por lo siguiente:

import qiskit.qasm2

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

qiskit.quantum_info

El módulo qiskit.quantum_info.synthesis se ha migrado a varias ubicaciones en el código base, principalmente qiskit.synthesis.

Este cambio no ha afectado a la ruta de importación habitual de Quaternion, pero ya no se puede acceder a él a través de a través de qiskit.quantum_info.synthesis.

Por último, se ha eliminado cnot_rxx_decompose .

qiskit.test

El módulo qiskit.test ya no es un módulo público. Nunca se pretendió que esto fuera público ni para ser utilizado fuera de la suite de pruebas Qiskit. Toda la funcionalidad era específica de Qiskit y no se proporciona ninguna alternativa alternativa; si necesitas una funcionalidad similar, debes incluirla en tus propios arneses de prueba.

qiskit.tools

El qiskit.tools módulo se eliminó en Qiskit v1.0. La mayor parte de esta funcionalidad fue sustituida por otra similar en otros paquetes o eliminada sin ofrecer ninguna alternativa. La principal excepción es la qiskit.tools.parallel_map() función, que se ha trasladado al módulo qiskit.utils . Se puede utilizar desde esta nueva ubicación. Por ejemplo:

Si antes estabas en marcha:

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

Jupyter

El submódulo qiskit.tools.jupyter ha sido eliminado porque la funcionalidad de este módulo está vinculada al paquete heredado qiskit-ibmq-provider , que ya no se soporta soportado. Además, sólo era compatible con BackendV1 y no con el más reciente BackendV2 más reciente.

supervisor

Se ha eliminado el submódulo qiskit.tools.monitor , ya que estaba vinculado al paquete paquete heredado qiskit-ibmq-provider , que ya no está soportado (también sólo soportaba la interfaz BackendV1 y no la más reciente BackendV2 más reciente). No existe ninguna alternativa para esta función.

visualización

Se ha eliminado el submódulo qiskit.tools.visualization . Este módulo era una redirección heredada de la ubicación original del módulo de visualización Qiskit y se trasladó a qiskit.visualization en Qiskit 0.8.0. Si sigue utilizando esta ruta, actualice sus importaciones de 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)

sucesos

El módulo qiskit.tools.events y la utilidad progressbar() que exponía han sido eliminados. La funcionalidad de este módulo no se utilizaba mucho y está paquetes dedicados como tqdm.

qiskit.transpiler

síntesis

Los elementos del módulo qiskit.transpiler.synthesis se han migrado a nuevas ubicaciones:

Pasa

El pase del transpilador NoiseAdaptiveLayout ha sido sustituido por VF2Layout y VF2PostLayout, que establecen un diseño basado en las características de ruido notificadas de un backend. Tanto el pase como el correspondiente plugin "noise_adaptive" layout stage han sido eliminados de Qiskit.

El transpilador CrosstalkAdaptiveSchedule ha sido eliminado del código base base de código. Este pase ya no era utilizable porque su funcionamiento interno dependía de que se establecieran propiedades personalizadas en la carga útil de BackendProperties de una instancia de BackendV1 . Como no hay backends que establezcan estos campos, se ha eliminado el pass eliminado.

gestor de contraseñas

Los métodos append del ConditionalController, FlowControllerLineary DoWhileController las clases se han eliminado. En su lugar, todas las tareas deben ser proporcionadas cuando los objetos controlador se construyen.

qiskit.utils

Las siguientes herramientas en qiskit.utils han sido retiradas sin reemplazo:

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

Estas funciones se utilizaban exclusivamente en los módulos qiskit.algorithms y qiskit.opflow que también se han eliminado.

qiskit.visualization

Se ha retirado el módulo qiskit.visualization.qcstyle . Utilice qiskit.visualization.circuit.qcstyle como sustitución directa.