Aller au contenu principal

Changements de caractéristiques dans Qiskit 1.0

Ce guide décrit les chemins de migration pour les changements de caractéristiques les plus importants dans Qiskit 1.0, organisés par module. Utilise la table des matières du côté droit pour naviguer vers le module qui t'intéresse.

Outil de migration Qiskit 1.0​

Pour faciliter le processus de migration, tu peux utiliser l'outil flake8-qiskit-migration pour détecter les chemins d'importation supprimés dans ton code et suggérer des alternatives.

Si tu as pipx installé, exécute simplement la commande suivante.

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

Cela installera le paquet dans un environnement virtuel temporaire et l'exécutera sur ton code.

Limitations

Cet outil ne détecte que les chemins d'importation supprimés. Il ne détecte pas l'utilisation de méthodes supprimées (comme QuantumCircuit.qasm) ni d'arguments. Il ne peut pas non plus suivre les affectations comme qk = qiskit, bien qu'il puisse gérer les alias comme import qiskit as qk.

Pour plus d'informations, consulte le dépôt du projet.

Instances et fonctions globales​

Aer​

L'objet qiskit.Aer n'est pas disponible dans Qiskit 1.0. À la place, utilise le même objet de l'espace de noms qiskit_aer, qui est un remplacement direct. Pour installer qiskit_aer, exécute :

pip install qiskit-aer

BasicAer​

L'objet qiskit.BasicAer n'est pas disponible dans Qiskit 1.0. Consulte la section de migration basicaer pour les options de migration.

execute​

La fonction qiskit.execute n'est pas disponible dans Qiskit 1.0. Cette fonction servait de wrapper de haut niveau autour des fonctions transpile et run de Qiskit. À la place de qiskit.execute, utilise la fonction transpile 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 qiskit.execute supprimée. La classe BackendSampler est un wrapper générique pour les backends qui ne prennent pas en charge 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. À la place, utilise qasm2.dump ou qasm2.dumps.

Pour la sortie formatée par Pygments, consulte le paquet autonome openqasm-pygments, car qasm2.dump et qasm2.dumps ne fournissent pas de sortie colorée par 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)

Portes de QuantumCircuit​

Les méthodes de porte suivantes ont été supprimées en faveur de méthodes plus établies qui ajoutent les mêmes portes :

SuppriméAlternative
QuantumCircuit.cnotQuantumCircuit.cx
QuantumCircuit.toffoliQuantumCircuit.ccx
QuantumCircuit.fredkinQuantumCircuit.cswap
QuantumCircuit.mctQuantumCircuit.mcx
QuantumCircuit.iQuantumCircuit.id
QuantumCircuit.squQuantumCircuit.unitary

Les méthodes de circuit suivantes ont également été supprimées. À la place, ces portes peuvent être appliquées à un circuit avec QuantumCircuit.append.

SuppriméAlternative (append)
QuantumCircuit.diagonalDiagonalGate
QuantumCircuit.hamiltonianHamiltonianGate
QuantumCircuit.isometryIsometry
QuantumCircuit.isoIsometry
QuantumCircuit.ucUCGate
QuantumCircuit.ucrxUCRXGate
QuantumCircuit.ucryUCRYGate
QuantumCircuit.ucrzUCRZGate

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

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

SuppriméAlternative
QuantumCircuit.bind_parametersQuantumCircuit.assign_parameters
QuantumCircuit.snapshotLes instructions de sauvegarde de qiskit-aer

qiskit.converters​

La fonction qiskit.converters.ast_to_dag a été supprimée de Qiskit. Elle convertissait l' arbre de syntaxe abstraite généré par l'analyseur hérité OpenQASM 2 en DAGCircuit. Comme l'analyseur hérité OpenQASM 2 a été supprimé (voir qiskit.qasm), cette fonction n'a plus de but. À la place, analyse tes fichiers OpenQASM 2 dans un QuantumCircuit en utilisant les méthodes de constructeur QuantumCircuit.from_qasm_file ou QuantumCircuit.from_qasm_str (ou le module qiskit.qasm2), puis convertis ce QuantumCircuit en 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, remplace simplement qiskit.extensions par qiskit.circuit.library dans le chemin d'importation de l'objet. C'est un remplacement direct.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Les classes transférées à qiskit.circuit.library sont :

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

SuppriméAlternative
SingleQubitUnitaryqiskit.circuit.library.UnitaryGate
SnapshotUtilise les instructions de sauvegarde de qiskit-aer
ExtensionErrorUne classe d'erreur pertinente

qiskit.primitives​

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

remarque

À partir de la version 1.0, nous nous référerons à l'interface des primitives avant 1.0 comme "primitives V1".

Migre de V1 à V2​

La distinction formelle entre les API des primitives V1 et V2 sont les classes de base dont héritent les implémentations de primitives. Pour passer aux nouvelles classes de base, tu peux conserver le chemin d'importation d'origine de qiskit.primitives :

Migrer deRemplacer par
BaseEstimatorBaseEstimatorV2
BaseSamplerBaseSamplerV2

Les noms des implémentations principales de 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 qui peuvent s'exécuter localement avec un backend simulateur de vecteur d'état. Les nouveaux noms n'incluent pas le suffixe -V2.

Migrer deRemplacer par
qiskit.primitives.Estimatorqiskit.primitives.StatevectorEstimator
qiskit.primitives.Samplerqiskit.primitives.StatevectorSampler

Il y a quelques différences conceptuelles à considérer lors de la migration de V1 à V2. Ces différences sont dictées par la classe de base, mais sont montrées dans les exemples suivants en utilisant les implémentations de vecteur d'état trouvées dans qiskit.primitives :

remarque

Pour les exemples suivants, suppose les importations et les initialisations de primitives suivantes :

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 et Estimator : Les nouveaux primitives V2 sont conçus pour accepter les entrées vectorisées, où un seul circuit peut être groupé avec des spécifications de valeurs de tableau. C'est-à-dire qu'un circuit peut s'exécuter pour des tableaux de n ensembles de paramètres, n observables, ou les deux (dans le cas de l'estimateur). Chaque groupe s'appelle un bloc primitif unifié (pub), et peut être représenté sous la forme d'un tuple : (1 x circuit, [n x observables], [n x parameters]). L'interface V1 ne permettait pas la même flexibilité. À la place, 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électionne 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

Les primitives V2 acceptent plusieurs PUBs comme entrées, et chaque pub obtient son propre résultat. Cela te permet d'exécuter différents Circuits avec diverses combinaisons de paramètres/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)

  1. Sampler : Le Sampler V2 retourne maintenant les résultats de mesure sous la forme de chaînes de bits ou comptages, au lieu des distributions de quasi-probabilité de l'interface V1. Les chaînes de bits montrent les résultats de mesure, en préservant l'ordre des tirs dans lesquels ils ont été mesurés. Les objets de résultat du Sampler V2 organisent les données selon les noms de registres classiques de leurs circuits d'entrée, pour 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 par défaut du registre classique

    Dans le circuit ci-dessus, remarque que le nom du registre classique est par défaut "meas". Ce nom sera utilisé plus tard pour accéder aux chaînes de bits de mesure.

    # 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 et Estimator : La surcharge d'échantillonnage, couramment exposée par les implémentations V1 par l'option d'exécution shots, est maintenant un argument de la méthode run() des primitives qui peut être spécifié au niveau du PUB. Les classes de base V2 exposent les arguments dans des formats différents 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 la implémentation primitive doit cibler pour les estimations de valeurs d'attente :

      # 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 V1​

qiskit.providers​

basicaer​

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

La migration vers les nouveaux chemins est directe. Tu peux remplacer la plupart des classes de qiskit.providers.basicaer par leur homologue de qiskit.providers.basic_provider (remplacement direct). Note que les classes suivantes ont de nouveaux chemins et noms :

SuppriméAlternative
qiskit.providers.basicaerqiskit.providers.basic_provider
BasicAerProviderBasicProvider
BasicAerJobBasicProviderJob
QasmSimulatorPyBasicSimulator
Instances globales

Sois prudent avec les instances globales lors de la migration vers le nouveau module. Il n'existe pas de remplacement pour l'instance globale BasicAer qui pourrait être importée directement comme qiskit.BasicAer. Cela signifie que from qiskit import BasicProvider n'est plus une importation valide. À la place, la classe du fournisseur doit être importée de son sous-module et instanciée par l'utilisateur :

# 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 unitaire et de vecteur d'état peuvent être remplacés par des classes quantum_info différentes. Ce n'est pas un remplacement direct, mais les changements sont minimes. Consulte les exemples de migration suivants :

SuppriméAlternative
UnitarySimulatorPyquantum_info.Operator
StatevectorSimulatorPyquantum_info.Statevector

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

fake_provider​

La plupart des composants orientés utilisateur de qiskit.providers.fake_provider ont été migrés vers le paquet Python qiskit-ibm-runtime. Cela inclut les classes de fournisseur faux, tous les backends faux spécifiques aux appareils (comme FakeVigo, FakeNairobiV2 et FakeSherbrooke), et les classes de base de backends faux. Clique sur les onglets suivants pour voir les classes affectées.

  • N'importe quelle classe dans qiskit.providers.fake_provider.backends
  • fake_provider.fake_backend.FakeBackend
  • fake_provider.fake_backend.FakeBackendV2

Pour migrer vers le nouveau chemin :

  1. Installe qiskit-ibm-runtime 0.17.1 ou ultérieur :

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

  2. Remplace les instances de qiskit.providers.fake_provider dans ton 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 de backends faux ont également été migrées, mais ont quelques différences dans le chemin d'importation :

SuppriméAlternative
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
remarque

Si tu dépends des backends faux pour les tests unitaires dans une bibliothèque en aval et que tu as des conflits avec la dépendance qiskit-ibm-runtime, tu peux aussi trouver de nouvelles alternatives de backends faux génériques natifs de Qiskit. Celles-ci incluent les classes BackendV1 suivantes (remplacements directs) :

C'est une classe configurable qui retourne des instances BackendV2 :

fake_provider (backends spéciaux pour les tests)​

Les classes de backend faux pour les buts spéciaux de test dans qiskit.providers.fake_provider n'ont pas été migrées vers qiskit_ibm_runtime.fake_provider. Le chemin de migration recommandé est d'utiliser la nouvelle classe GenericBackendV2 pour configurer un backend avec des propriétés similaires ou pour construire un target personnalisé.

SuppriméAlternative
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

Exemple : Migre vers la nouvelle 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.

Autres conseils de migration​

  • Il n'est plus possible d'importer depuis qiskit.providers.aer. À la place, importe depuis qiskit_aer, qui est un remplacement direct. Pour installer qiskit_aer, exécute :

    pip install qiskit-aer

  • En Qiskit 1.0, le support pour exécuter les travaux de pulse sur les backends de qiskit.providers.fake_provider a été supprimé. C'est parce que Qiskit Aer a supprimé ses fonctionnalités de simulation pour ce type de travaux. Pour les charges de travail de simulation hamiltonienne de bas niveau, considère utiliser une bibliothèque spécialisée comme Qiskit Dynamics.

qiskit.pulse​

ParametricPulse​

La classe de base qiskit.pulse.library.parametric_pulses.ParametricPulse et la bibliothèque de pulses ont été remplacées par qiskit.pulse.SymbolicPulse et la bibliothèque de pulses correspondante. SymbolicPulse supporte 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)
SuppriméAlternative
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

Amplitudes de valeur complexe​

L'amplitude de pulse de valeur complexe (amp) est remplacée par le couple (amp, angle). Cette représentation est plus intuitive, en particulier pour certaines tâches d'étalonnage comme l'étalonnage d'angle :

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

Injection d'opérations de porte de circuit​

Il n'est plus possible d'injecter des opérations de porte de circuit dans le contexte du constructeur de pulse par le biais de qiskit.pulse.builder.call. Cette suppression affecte les arguments d'entrée de type QuantumCircuit, ainsi que les 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 tu veux toujours injecter des schedules étalonnés par le backend, utilise le motif suivant au lieu d'appeler des commandes de 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 la même manière, un QuantumCircuit peut être injecté dans le contexte du constructeur en transpilant et en programmant manuellement l' 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 te recommandons d'écrire un programme de pulse minimal avec le constructeur et de l'attacher au QuantumCircuit par le biais de la méthode QuantumCircuit.add_calibration comme microcode d'une instruction de porte, plutôt que d'écrire le programme complet avec le modèle de pulse.

builder.build​

Les arguments suivants de qiskit.pulse.builder.build ont été supprimés sans 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

C'est parce qu'il n'est plus possible d'injecter des objets de circuit dans le contexte du constructeur (consulte Injection d'opérations de porte de circuit) ; ces paramètres servaient à convertir les objets injectés en représentations de pulse.

library​

La bibliothèque de pulses discrets a été supprimée de la base de code. Cela 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

À la place, utilise le qiskit.pulse.SymbolicPulse correspondant avec SymbolicPulse.get_waveform(). Par exemple, au lieu de pulse.gaussian(100,0.5,10), utilise pulse.Gaussian(100,0.5,10).get_waveform(). Note que la phase de Sawtooth et de Square est définie de telle manière qu' une phase de 2\\pi décale un cycle complet, contrairement à son homologue discret. Note également que les amplitudes complexes ne sont plus supportées dans la bibliothèque de pulses symboliques ; utilise float, amp et angle à la place.

ScalableSymbolicPulse​

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

Ce changement affecte les pulses suivants :

qiskit.qasm​

Le module hérité de l'analyseur OpenQASM 2 qui était dans qiskit.qasm a été remplacé par le module qiskit.qasm2, qui fournit un analyseur plus rapide et plus précis pour OpenQASM 2. Les méthodes de haut niveau de QuantumCircuit from_qasm_file() et from_qasm_str() restent les mêmes, 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 à un arbre de syntaxe abstraite retourné par la bibliothèque d'analyse ply, qiskit.qasm2 n'expose pas l'AST ni aucun détail d'implémentation de bas niveau sur l'analyseur. À la place, il prend les entrées en OpenQASM 2 et retourne un objet QuantumCircuit.

Par exemple, si tu exécutais précédemment 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)

Remplace-le 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é vers plusieurs emplacements dans la base de code, principalement vers qiskit.synthesis.

SuppriméAlternative
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

Ce changement n'a pas affecté le chemin d'importation habituel de Quaternion, mais tu ne peux plus y accéder via 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é destiné à être public ni à être utilisé en dehors de la suite de tests de Qiskit. Toute la fonctionnalité était spécifique à Qiskit et aucune alternative n'est fournie ; si tu avais besoin d'une fonctionnalité similaire, tu devrais l'inclure dans tes propres cadres de test.

qiskit.tools​

Le module qiskit.tools a été supprimé dans Qiskit 1.0. La plupart de cette fonctionnalité a été remplacée par une fonctionnalité équivalente dans d'autres paquets ou supprimée sans alternative. La principale exception est la fonction qiskit.tools.parallel_map(), qui a été transférée au module qiskit.utils. Tu peux l'utiliser à partir de ce nouvel emplacement. Par exemple :

Si tu exécutais précédemment :

# 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 la fonctionnalité de ce module était liée au paquet hérité qiskit-ibmq-provider, qui n'est plus supporté. De plus, il ne supportait que BackendV1 et non l'interface plus récente BackendV2.

monitor​

Le sous-module qiskit.tools.monitor a été supprimé car il était lié au paquet hérité qiskit-ibmq-provider, qui n'est plus supporté (il n'était pas non plus compatible avec l'interface BackendV1, seulement avec la plus récente BackendV2). Aucune alternative n'est fournie pour cette fonctionnalité.

visualization​

Le sous-module qiskit.tools.visualization a été supprimé. Ce module était une redirection héritée depuis l'emplacement d'origine du module de visualisation de Qiskit, qui a été transféré à qiskit.visualization dans Qiskit 0.8.0. Si tu utilises toujours ce chemin, mets à jour tes importations de qiskit.tools.visualization à qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

events​

Le module qiskit.tools.events et l'utilitaire progressbar() qu'il exposait ont été supprimés. La fonctionnalité de ce module n'était pas largement utilisée et est mieux couverte par des paquets dédiés comme tqdm.

qiskit.transpiler​

synthesis​

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

SuppriméAlternative
qiskit.transpiler.synthesis.aqc (sauf 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​

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

Le transpiler pass CrosstalkAdaptiveSchedule a été supprimé de la base de code. Ce pass n'était plus utilisable car son opération interne dépendait des propriétés personnalisées définies dans la charge BackendProperties d'une instance BackendV1. Comme aucun backend ne définit ces champs, le pass a été supprimé.

passmanager​

Les méthodes append des classes ConditionalController, FlowControllerLinear et DoWhileController ont été supprimées. À la place, toutes les tâches doivent être fournies lors de la construction des objets contrôleurs.

qiskit.utils​

Les outils suivants de qiskit.utils ont été supprimés sans remplacement :

  • 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é supprimé. Utilise qiskit.visualization.circuit.qcstyle comme remplacement direct.