Modifications apportées aux fonctionnalités d' v1.0 s de Qiskit

Ce guide décrit les procédures de migration pour les modifications de fonctionnalités les plus importantes de la version v1.0 de Qiskit, classées par module. Utilisez la table des matières située à droite pour accéder au module qui vous intéresse.

Outil de migration Qiskit vers l' v1.0

Pour faciliter le processus de migration, vous pouvez utiliser la fonction flake8-qiskit-migration pour détecter les chemins d'importation supprimés dans votre code et proposer des alternatives.

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

Pour plus d'informations, voir le du projet.

Instances et fonctions globales

Aer

L'objet qiskit.Aer n'est pas disponible dans l' v1.0 Qiskit. Utilisez plutôt le même objet issu de l'espace qiskit_aer de noms, qui est un substitut direct. qiskit_aerPour l'installer, exécutez :

pip install qiskit-aer

BasicAer

L'objet qiskit.BasicAer n'est pas disponible dans l' v1.0 Qiskit. Consultez la basicaer section consacrée à la migration pour connaître les options de migration.

exécuter

La qiskit.execute fonction n'est pas disponible dans Qiskit v1.0. Cette fonction servait d'enveloppe de haut niveau autour des transpile fonctions run et dans Qiskit. Au lieu de qiskit.execute, utilisez la transpile fonction suivie 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)

Alternativement, la primitive Sampler est sémantiquement équivalente à la fonction supprimée qiskit.execute . La classe BackendSampler est un générique pour les backends qui ne supportent pas les primitives :

from qiskit.primitives import BackendSampler

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

qiskit.circuit

QuantumCircuit.qasm

La méthode QuantumCircuit.qasm a été supprimée. Au lieu de cela, utilisez qasm2.dump ou qasm2.dumps.

Pour une sortie formatée par Pygments, regardez l'outil autonome openqasm-pygments autonome, car qasm2.dump et qasm2.dumps ne fournissent pas de sortie colorée 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 portails

Les méthodes d'accès suivantes ont été supprimées au profit de méthodes mieux établies qui ajoutent les mêmes points d'accès plus établies qui ajoutent les mêmes portes :

Les méthodes de circuit suivantes ont été supprimées. Au lieu de cela, ces portes peuvent être appliquées à un circuit avec QuantumCircuit.append.

Par exemple, pour 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

Les méthodes QuantumCircuit suivantes ont également été supprimées :

qiskit.converters

La fonction qiskit.converters.ast_to_dag a été supprimée de Qiskit. Il a converti l'arbre syntaxique abstrait l'arbre syntaxique abstrait généré par l'ancien analyseur OpenQASM 2 en un arbre syntaxique DAGCircuit. Comme l'ancien analyseur OpenQASM 2 a été supprimé (voir qiskit.qasm ), cette fonction n'a plus de raison d'être. Au lieu de cela, analysez vos fichiers OpenQASM 2 en un QuantumCircuit à l'aide de l'outil QuantumCircuit.from_qasm_file ou QuantumCircuit.from_qasm_str (ou le module qiskit.qasm2 module), puis convertir ce QuantumCircuit en un DAGCircuit avec 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

Le module qiskit.extensions n'est plus disponible. La plupart de ses objets ont été intégrés dans la bibliothèque de circuits (qiskit.circuit.library). Pour migrer vers le nouvel emplacement il suffit de remplacer qiskit.extensions par qiskit.circuit.library dans le chemin d'importation de l'objet. Il s'agit d'un remplacement immédiat.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Les classes déplacées vers qiskit.circuit.library sont

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

Les classes suivantes ont été supprimées de la base de code, car leurs fonctions étaient soit redondantes, soit liées au module étant redondantes ou liées au module extensions :

qiskit.primitives

Le changement le plus notable dans le module qiskit.primitives est l'introduction l'introduction de la nouvelle interface de primitives V2. Cette section montre comment migrer votre flux de travail de primitives à primitives, ainsi que les quelques changements qui ont eu lieu flux de travail des primitives V1 vers les primitives V2, ainsi que les quelques changements qui ont eu lieu dans les entrées acceptées par l'interface dans les entrées acceptées par l'interface V1.

Migrer de V1 vers V2

La distinction formelle entre les API de primitives V1 et V2 réside dans les classes de base dont héritent les implémentations de primitives les implémentations de primitives héritent. Pour passer aux nouvelles classes de base, vous pouvez conserver le chemin d'importation original de qiskit.primitives:

Les noms des implémentations du noyau qiskit des primitives V2 (celles qui peuvent être importées de qiskit.primitives), ont été modifiés pour clarifier leur objectif en tant qu'implémentations pouvant être exécutées localement avec un simulateur de vecteur d'état. Les nouveaux noms ne comportent pas le suffixe -V2.

Il y a quelques différences conceptuelles à prendre en compte lors de la migration de V1 à V2. Ces différences sont dictées par la classe de base, mais sont illustrées dans les exemples suivants qui utilisent les implémentations de statevector que l'on trouve à l'adresse 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: Les nouvelles primitives d' V2 s sont conçues pour accepter des entrées vectorisées, ce qui permet de regrouper des circuits individuels avec des spécifications à valeurs matricielles. En d'autres termes, un circuit peut être exécuté pour des tableaux de jeux de n paramètres, n de grandeurs observables, ou les deux (dans le cas de l'estimateur). Chaque groupe est appelé « bloc unifié primitif » (pub) et peut être représenté sous la forme d'un tuple : (1 x circuit, [n x observables], [n x parameters]). L'interface de l' V1 e n'offrait pas la même souplesse. Au contraire, le nombre de circuits d'entrée devait correspondre au nombre d'observables et d'ensembles de paramètres, comme le montrent les exemples suivants (sélectionnez un onglet pour voir chaque exemple) :

# 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 acceptent plusieurs PUBs comme entrées, et chaque PUB obtient son propre résultat. Ceci permet d'exécuter différents circuits avec diverses combinaisons de paramètres et d'observables, ce qui n'était pas toujours possible dans l'interface 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. Échantillonneur : l'échantillonneur «V2 » renvoie désormais des échantillons de résultats de mesure sous forme de chaînes de bits ou de nombres , au lieu des distributions de quasi-probabilité fournies par l'interface «V1 ». Les chaînes de bits indiquent les résultats des mesures, en respectant l'ordre dans lequel celles-ci ont été effectuées. Les objets de résultat de l'échantillonneur « V2 » organisent les données en fonction des noms de registres classiques de leurs circuits d'entrée, afin d' assurer la compatibilité avec les circuits dynamiques.

   # 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

   Nom du registre classique par défaut

   Dans le circuit ci-dessus, remarquez que le nom du registre classique est par défaut "meas". Ce nom sera utilisé ultérieurement pour accéder aux chaînes de bits des mesures.

   # 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 surcharge d'échantillonnage, généralement exposée par les implémentations V1 à travers l'option run, est maintenant un argument de la méthode des primitives par le biais de l'option shots run, est désormais un argument de la méthode primitive run() qui peut être spécifié au niveau PUB niveau. Les classes de base V2 exposent les arguments dans des formats différents de ceux de l'API V1 :

   • BaseSamplerV2.run expose un argument shots (similaire au flux de travail précédent) :

     # 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 introduit un argument precision qui spécifie les barres d'erreur que l'implémentation primitive doit cibler pour les estimations des valeurs d'espérance doit cibler pour les estimations des valeurs d'espérance :

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

Mises à jour dans l'interface d' V1

• Conversion implicite d'un site BaseOperator dense en un site SparsePauliOp en Estimator arguments observables n'est plus autorisée. Vous devez explicitement convertir en SparsePauliOp en utilisant SparsePauliOp.from_operator(operator) à la place.

• L'utilisation d'un PauliList dans les arguments de l'observable de l'estimateur N'est plus autorisée. Au lieu de cela, vous devez convertir explicitement l'argument en utilisant SparsePauliOp(pauli_list) d'abord.

qiskit.providers

basicaer

La plupart des fonctionnalités du module qiskit.providers.basicaer ont été remplacées par le nouveau module remplacée par le nouveau module qiskit.providers.basic_provider à l'exception des classes UnitarySimulatorPy et StatevectorSimulatorPy qui ont été supprimées; leur fonctionnalité était déjà contenue dans le module le quantum_info leur fonctionnalité était déjà contenue dans le module

La migration vers les nouveaux chemins est simple. Vous pouvez remplacer la plupart des classes sur le site qiskit.providers.basicaer par les classes qiskit.providers.basic_provider par leur équivalent (remplacement par des cours à la carte). Notez que les classes suivantes ont de nouveaux chemins et noms :

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

Les simulateurs unitaires et de vecteurs d'état peuvent être remplacés par différentes quantum_info classes. Il ne s'agit pas d'un il ne s'agit pas d'un remplacement immédiat, mais les changements sont minimes. Voir les exemples de migration suivants suivants :

Les exemples suivants montrent les chemins de migration des simulateurs 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()

faux_fournisseur

La plupart des composants qiskit.providers.fake_provider ont été ont été migrés vers le paquet qiskit-ibm-runtime Python. Cela inclut les les fausses classes de fournisseurs, tous les faux backends spécifiques aux appareils (tels que FakeVigo, FakeNairobiV2, et FakeSherbrooke), et les classes de base du faux backend et les classes de base du faux backend. Cliquez sur les onglets suivants pour voir les classes concernées.

Pour migrer vers le nouveau chemin :

1. Installez qiskit-ibm-runtime 0.17.1 ou une version plus récente :

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

2. Remplacez les instances de qiskit.providers.fake_provider dans votre code par qiskit_ibm_runtime.fake_provider. Par exemple :

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

Les classes de base du faux backend ont également été migrées, mais présentent quelques différences dans le chemin d'importation :

fake_provider (backends de test spéciaux)

Les fausses classes de backend à des fins de test spéciales dans qiskit.providers.fake_provider n'ont pas été migrées vers qiskit_ibm_runtime.fake_provider. La voie de migration est d'utiliser le nouveau GenericBackendV2 pour configurer un backend avec des propriétés similaires ou pour créer une cible personnalisée.

Exemple : Migrer vers le nouveau 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.

Autres conseils pour la migration

• L'importation à partir de qiskit.providers.aer n'est plus possible. Au lieu de cela, importez à partir de qiskit_aer, qui le remplace aisément. Pour installer qiskit_aer, exécutez :

  pip install qiskit-aer

qiskit.providers.fake_provider La prise en charge de l'exécution de tâches « pulse » sur les backends a été supprimée dans Qiskit v1.0. En effet, Qiskit Aer a supprimé ses fonctionnalités de simulation pour ce type de tâches. Pour les tâches de simulation d'hamiltoniens de bas niveau, envisagez d'utiliser une bibliothèque spécialisée telle que Qiskit Dynamics.

qiskit.pulse

ParametricPulse

La classe de base qiskit.pulse.library.parametric_pulses.ParametricPulse et la bibliothèque ont été remplacées par qiskit.pulse.SymbolicPulse et la bibliothèque d'impulsions correspondante. SymbolicPulse supports La sérialisation 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)

Amplitude à valeur complexe

L'amplitude de l'impulsion à valeur complexe (amp) est remplacée par un duo (amp, angle). Cette représentation est plus intuitive, en particulier pour certaines tâches d'étalonnage telles que l'étalonnage de l'angle tâches d'étalonnage telles que l'étalonnage des angles :

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

Opérations de porte de circuit d'injection

Injecter des opérations de porte de circuit dans le contexte du constructeur d'impulsions par le biais de qiskit.pulse.builder.call n'est plus possible. Cette suppression concerne les arguments d'entrée de type QuantumCircuit, ainsi que les fonctions suivantes fonctions suivantes :

• 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 vous souhaitez toujours injecter des horaires calibrés par le backend, utilisez le modèle suivant au lieu d'appeler les commandes de la porte.

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)

De même, un QuantumCircuit peut être injecté dans le contexte du constructeur en transpilant et en ordonnançant manuellement l'objet objet.

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)

Nous recommandons de rédiger un programme d'impulsion minimum avec le constructeur et de l'attacher à QuantumCircuit par l'intermédiaire de l'outil QuantumCircuit.add_calibration comme microcode d'une instruction de porte, plutôt que d'écrire tout le programme avec le modèle d'impulsion programme complet avec le modèle d'impulsion.

builder.build

Les arguments suivants dans qiskit.pulse.builder.build ont été supprimés sans pas d'alternative.

• default_transpiler_settings
• default_circuit_scheduler_settings

Ces fonctions ont également été supprimées :

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

En effet, il n'est plus possible d'injecter des objets circuits dans le contexte du constructeur (voir (voir Injecter des opérations de porte de circuit ); ces paramètres étaient destinés à convertir les objets injectés en représentations d'impulsions.

bibliothèque

La bibliothèque des impulsions discrètes a été retirée de la base de code. Comprend :

• 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

Au lieu de cela, utilisez l'option qiskit.pulse.SymbolicPulse, correspondant avec SymbolicPulse.get_waveform(). Par exemple, au lieu de pulse.gaussian(100,0.5,10), utilisez pulse.Gaussian(100,0.5,10).get_waveform(). Il convient de noter que la phase des deux Sawtooth et Square est définie de telle sorte que qu'une phase de 2\pi se décale d'un cycle complet, contrairement à l'équivalent discret discrète. Notez également que les amplitudes complexes ne sont plus prises en charge dans la bibliothèque d'impulsions symboliques la bibliothèque d'impulsions symboliques; utilisez plutôt float, amp, et angle .

ScalableSymbolicPulse

Il n'est plus possible de charger des objets de bibliothèque qiskit.pulse.ScalableSymbolicPulse avec un paramètre complexe amp à partir de fichiers qpy de la version 5 ou antérieure (Qiskit Terra < 0.23.0 ). Aucune action de migration n'est nécessaire, car le site complexe amp sera automatiquement converti en (, ) sera automatiquement converti en float (amp, angle).

Cette modification s'applique à ces impulsions :

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

qiskit.qasm

L'ancien module d'analyseur syntaxique de OpenQASM 2, qui se trouvait précédemment dans qiskit.qasm , a été remplacé par le module d'analyse syntaxique de a été remplacé par le module qiskit.qasm2 qui qui fournit un analyseur syntaxique plus rapide et plus précis pour OpenQASM 2. Les méthodes de haut niveau QuantumCircuit méthodes from_qasm_file() et from_qasm_str() restent inchangés, mais utiliseront le nouvel analyseur en interne. Cependant, l'interface publique du module qasm2 n'est pas la même. Alors que le module qiskit.qasm fournissait une interface avec un arbre syntaxique abstrait renvoyé par la bibliothèque de l'analyseur syntaxique, n'expose pas l'AST ou un niveau inférieur ply parser, qiskit.qasm2 n'expose pas l'AST ni aucun détail d'implémentation de niveau inférieur concernant l'analyseur d'implémentation de niveau inférieur de l'analyseur syntaxique. Au lieu de cela, il prend OpenQASM 2 en entrée et produit un QuantumCircuit objet.

Par exemple, si vous exécutiez auparavant quelque chose comme ceci :

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)

Remplacez-la par ce qui suit :

import qiskit.qasm2

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

qiskit.quantum_info

Le module qiskit.quantum_info.synthesis a été migré à différents endroits de la base de code dans la base de code, principalement qiskit.synthesis.

Ce changement n'a pas affecté le chemin d'importation habituel de Quaternion, mais vous ne pouvez plus y accéder par l'intermédiaire de par l'intermédiaire de qiskit.quantum_info.synthesis.

Enfin, cnot_rxx_decompose a été supprimé.

qiskit.test

Le module qiskit.test n'est plus un module public. Il n'a jamais été prévu de le rendre public, ni à être utilisé en dehors de la suite de tests Qiskit. Toutes les fonctionnalités sont spécifiques à Qiskit et aucune alternative n'est fournie alternative n'est fournie; si vous aviez besoin d'une fonctionnalité similaire, vous devriez l'inclure dans vos propres harnais de test harnais de test.

qiskit.tools

Le qiskit.tools module a été supprimé dans la version v1.0 de Qiskit. La plupart de ces fonctionnalités ont été soit remplacées par des fonctionnalités similaires dans d'autres paquets, soit supprimées sans alternative. La principale exception est la qiskit.tools.parallel_map() fonction, qui a été déplacée vers le qiskit.utils module. On peut désormais l'utiliser à partir de ce nouvel emplacement. Par exemple :

Si vous étiez déjà en cours d'exécution :

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

jupyter

Le sous-module qiskit.tools.jupyter a été supprimé car les fonctionnalités de ce module sont liées à l'ancien paquetage qui n'est plus disponible de ce module est liée à l'ancien paquetage qiskit-ibmq-provider , qui n'est plus supporté plus supporté. En outre, il ne prenait en charge que BackendV1 et non les versions plus récentes BackendV2 plus récente.

surveillance

Le sous-module qiskit.tools.monitor a été supprimé car il était lié à l'ancien paquet qui n'est plus supporté l'ancien paquetage qiskit-ibmq-provider , qui n'est plus supporté (il ne supportait également que l'interface ne supportait que l'interface BackendV1 et non la nouvelle interface BackendV2 plus récente). Il n'y a pas aucune alternative n'est prévue pour cette fonctionnalité.

des données

Le sous-module qiskit.tools.visualization a été supprimé. Ce module était une redirection héritée de l'emplacement original du module de visualisation Qiskit et a été a été déplacé vers qiskit.visualization dans Qiskit 0.8.0. Si vous utilisez toujours ce chemin, mettez à jour vos importations de qiskit.tools.visualization vers qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

événements

Le module qiskit.tools.events et l'utilitaire progressbar() qu'il exposait ont été supprimés. Les fonctionnalités de ce module n'ont pas été largement utilisées et sont mieux couvertes par des paquets dédiés tels que tqdm.

qiskit.transpiler

synthèse

Les éléments du module qiskit.transpiler.synthesis ont été transférés vers de nouveaux emplacements :

Réussites

Le pass transpiler NoiseAdaptiveLayout a été remplacé par VF2Layout et VF2PostLayout, qui définissent une disposition basée sur les caractéristiques de bruit rapportées d'un backend. La passe et le plugin correspondant "noise_adaptive" layout stage ont été supprimés de Qiskit.

La passe de transpilation CrosstalkAdaptiveSchedule a été supprimée de la base de code base de code. Cette passe n'était plus utilisable car son fonctionnement interne dépendait de la définition de propriétés personnalisées dans la charge utile BackendProperties d'une instance de BackendV1 . Comme aucun backend ne définit ces champs, la passe a été supprimée a été supprimé.

gestionnaire de mots de passe

Les méthodes append de la ConditionalController, FlowControllerLinear, et DoWhileController classes ont été supprimées. Au lieu de cela, toutes les tâches doivent être fournies lorsque les objets du contrôleur sont construits sont construits.

qiskit.utils

Les outils suivants ( qiskit.utils ) ont été retirés sans être remplacés :

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

Ces fonctions étaient utilisées exclusivement dans les modules qiskit.algorithms et qiskit.opflow qui ont également été supprimés.

qiskit.visualization

Le module qiskit.visualization.qcstyle a été retiré. Utiliser qiskit.visualization.circuit.qcstyle comme remplacement direct.