Skip to main content
IBM Quantum Platform

Notes de publication de Qiskit 0.12

0.12.0

Terra 0.9

Prélude

La version 0.9 comprend de nombreuses nouvelles fonctionnalités et de nombreuses corrections de bugs. Les plus grands changements de cette version sont de nouvelles capacités de débogage pour PassManagers. Il s'agit notamment d'une fonction permettant de visualiser un site PassManager,, de la possibilité d'ajouter une fonction de rappel à un site PassManager, et de l'enregistrement des passes exécutées dans le site PassManager. En outre, cette version standardise la façon dont vous pouvez définir une disposition initiale pour votre circuit. Vous pouvez donc maintenant utiliser initial_layout le paramètre kwarg sur qiskit.compiler.transpile() et qiskit.execute() et les qubits du circuit seront disposés sur les qubits désirés de l'appareil. La visualisation des circuits le montrera désormais clairement lors de la visualisation d'un circuit qui a été transposé avec une mise en page.

Nouvelles fonctions

  • Un objet DAGCircuit (c'est-à-dire la représentation graphique d'un QuantumCircuit où les dépendances d'opérations sont explicites) peut maintenant être visualisé avec la méthode .draw() . Ceci est conforme à la philosophie de Qiskit, qui est de faciliter la visualisation. Les autres objets qui supportent la méthode .draw() sont QuantumCircuit, PassManager, et Schedule.

  • Ajout d'une nouvelle fonction de visualisation qiskit.visualization.plot_error_map() pour tracer la carte des erreurs pour un backend donné. Il prend un objet backend du fournisseur qiskit-ibmq et trace la carte d'erreurs actuelle pour ce dispositif.

  • Les sites qiskit.QuantumCircuit.draw() et qiskit.visualization.circuit_drawer() permettent désormais d'annoter les qubits dans la visualisation avec des informations sur la disposition. Si l'objet QuantumCircuit dessiné comprend des métadonnées de mise en page (qui ne sont normalement définies que sur le circuit issu des appels à transpile() ), cette mise en page sera affichée par défaut sur le diagramme. Cette opération est effectuée pour tous les tiroirs de circuits. Par exemple :

    from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, 'userqr')
cr = ClassicalRegister(2, 'c0')
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.y(qr[0])
qc.x(qr[1])
qc.measure(qr, cr)

# Melbourne coupling map
coupling_map = [[1, 0], [1, 2], [2, 3], [4, 3], [4, 10], [5, 4],
                [5, 6], [5, 9], [6, 8], [7, 8], [9, 8], [9, 10],
                [11, 3], [11, 10], [11, 12], [12, 2], [13, 1],
                [13, 12]]
qc_result = transpile(qc, basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
                      coupling_map=coupling_map, optimization_level=0)
qc.draw(output='text')

    produira un diagramme du type :

                      ┌──────────┐┌──────────┐┌───┐┌──────────┐┌──────────────────┐┌─┐
   (userqr0) q0|0>┤ U2(0,pi) ├┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├┤ U3(pi,pi/2,pi/2) ├┤M├───
                  ├──────────┤└──────────┘└─┬─┘├──────────┤└─┬─────────────┬──┘└╥┘┌─┐
   (userqr1) q1|0>┤ U2(0,pi) ├──────────────■──┤ U2(0,pi) ├──┤ U3(pi,0,pi) ├────╫─┤M├
                  └──────────┘                 └──────────┘  └─────────────┘    ║ └╥┘
  (ancilla0) q2|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla1) q3|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla2) q4|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla3) q5|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla4) q6|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla5) q7|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla6) q8|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla7) q9|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
 (ancilla8) q10|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
 (ancilla9) q11|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
(ancilla10) q12|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
(ancilla11) q13|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
          c0_0: 0 ══════════════════════════════════════════════════════════════╩══╬═
                                                                                   ║
          c0_1: 0 ═════════════════════════════════════════════════════════════════╩═

    Si vous ne souhaitez pas que la disposition soit affichée sur les circuits transposés (ou tout autre circuit avec un jeu de disposition), il existe un nouveau mot-clé booléen pour les deux fonctions, with_layout (dont la valeur par défaut est True), qui, lorsqu'il est défini sur False , désactive l'annotation de la disposition dans les circuits de sortie.

  • Une nouvelle passe d'analyse CountOpsLongest a été ajoutée pour récupérer le nombre d'opérations sur le chemin le plus long du DAGCircuit. Lorsqu'elle est utilisée, elle ajoute une clé count_ops_longest_path au dictionnaire de l'ensemble des propriétés. Vous pouvez l'ajouter à votre gestionnaire de passe avec quelque chose comme :

    from qiskit.transpiler.passes import CountOpsLongestPath
from qiskit.transpiler.passes import CxCancellation
from qiskit.transpiler import PassManager

pm = PassManager()
pm.append(CountOpsLongestPath())

    puis accéder au chemin le plus long via la valeur de l'ensemble de propriétés avec quelque chose comme :

    pm.append(
    CxCancellation(),
    condition=lambda property_set: property_set[
        'count_ops_longest_path'] < 5)

    qui fixera une condition sur ce passage en se basant sur le chemin le plus long.

  • Deux nouvelles fonctions, sech() et sech_deriv() , ont été ajoutées au module de la bibliothèque des impulsions qiskit.pulse.pulse_lib pour créer respectivement un objet SamplePulse sécante hyperbolique non normalisée et un objet SamplePulse derviative sécante hyperbolique non normalisée.

  • Une nouvelle option kwarg vertical_compression a été ajoutée à la méthode QuantumCircuit.draw() et à la fonction qiskit.visualization.circuit_drawer() . Cette option ne fonctionne qu'avec le backend text . Cette option peut être définie sur high, medium (par défaut) ou low pour ajuster la quantité d'espace vertical utilisée par la visualisation de sortie.

  • Une nouvelle option booléenne kwarg idle_wires a été ajoutée à la méthode QuantumCircuit.draw() et à la fonction qiskit.visualization.circuit_drawer() . Il fonctionne pour tous les fonds de tiroirs. Lorsque idle_wires est défini comme Faux dans un appel de tiroir, le tiroir ne dessine pas de bits qui n'ont pas d'éléments de circuit dans la visualisation du circuit quantique de sortie.

  • Une nouvelle fonction de visualisation PassManager qiskit.visualization.pass_mamanger_drawer() a été ajoutée. Cette fonction prend en charge un objet PassManager et génère un diagramme de contrôle de toutes les passes exécutées dans l'objet PassManager.

  • Lorsque vous créez un site PassManager, vous pouvez désormais spécifier une fonction de rappel qui, si elle est spécifiée, sera exécutée après chaque passe. Cette fonction reçoit un ensemble de kwargs à chaque appel avec l'état du gestionnaire de passe après chaque exécution de passe. Ces kwargs sont actuellement les suivants :

    • pass_ (Pass) : la passe en cours d'exécution
    • dag (DAGCircuit) : la sortie dag de la passe
    • time (float) : le temps d'exécution de la passe
    • property_set (PropertySet) : l'ensemble des propriétés
    • count (int) : l'index pour l'exécution de la passe

    Cependant, il convient de noter que si ces arguments sont définis pour la version 0.9, ils exposent les aspects internes du gestionnaire de passe et sont susceptibles d'être modifiés dans les versions ultérieures.

    Par exemple, vous pouvez l'utiliser pour créer une fonction de rappel qui visualisera la sortie du circuit après l'exécution de chaque passe :

    from qiskit.transpiler import PassManager

def my_callback(**kwargs):
    print(kwargs['dag'])

pm = PassManager(callback=my_callback)

    En outre, vous pouvez spécifier la fonction de rappel lorsque vous utilisez qiskit.compiler.transpile():

    from qiskit.compiler import transpile

def my_callback(**kwargs):
    print(kwargs['pass'])

transpile(circ, callback=my_callback)

  • Une nouvelle méthode filter() a été ajoutée à la classe qiskit.pulse.Schedule . Cela permet de filtrer les instructions dans un calendrier. Par exemple, filtrer par type d'instruction :

    from qiskit.pulse import Schedule
from qiskit.pulse.commands import Acquire
from qiskit.pulse.commands import AcquireInstruction
from qiskit.pulse.commands import FrameChange

sched = Schedule(name='MyExperiment')
sched.insert(0, FrameChange(phase=-1.57)(device))
sched.insert(60, Acquire(5))
acquire_sched = sched.filter(instruction_types=[AcquireInstruction])

  • Méthodes de décomposition supplémentaires pour plusieurs types de portes. Ces méthodes utiliseront différentes techniques de décomposition pour décomposer une porte en une séquence de CNOT et de portes à qubit unique. Les méthodes suivantes sont ajoutées :

    Méthode
    Description
    QuantumCircuit.iso()Ajouter une isométrie arbitraire de m à n qubits à un circuit. Cela permet d'attacher des unités arbitraires sur n qubits (m=n) ou de préparer n'importe quel état de n qubits ( m=0 )
    QuantumCircuit.diag_gate()Ajouter une porte diagonale au circuit
    QuantumCircuit.squ()Décomposer une unité arbitraire 2x2 en trois portes de rotation et l'ajouter à un circuit
    QuantumCircuit.ucg()Attachez une porte à contrôle uniforme (également appelée porte multiplexée) à un circuit
    QuantumCircuit.ucx()Attachez une porte de rotation Rx uniformément contrôlée (également appelée multiplexée) à un circuit
    QuantumCircuit.ucy()Attachez une porte de rotation Ry uniformément contrôlée (également appelée multiplexée) à un circuit
    QuantumCircuit.ucz()Attachez une porte de rotation Rz uniformément contrôlée (également appelée multiplexée) à un circuit

  • Ajout des algorithmes Gray-Synth et Patel-Markov-Hayes pour la synthèse des circuits linéaires CNOT-Phase et CNOT uniquement. Ces fonctions permettent de synthétiser des circuits composés uniquement de portes CNOT à partir d'une fonction linéaire ou un circuit composé uniquement de portes CNOT et de portes de phase à partir d'une description matricielle.

  • Une nouvelle fonction random_circuit a été ajoutée au module qiskit.circuit.random . Cette fonction génère un circuit aléatoire d'une taille spécifiée en sélectionnant au hasard différentes portes et en les ajoutant au circuit. Par exemple, vous pouvez l'utiliser pour générer un circuit de 5 qubits avec une profondeur de 10 utilisant :

    from qiskit.circuit.random import random_circuit

circ = random_circuit(5, 10)

  • Un nouveau kwarg output_names a été ajouté à la fonction qiskit.compiler.transpile() . Ce kwarg prend une chaîne ou une liste de chaînes et les utilise comme valeur du nom du circuit pour les circuits de sortie qui sont renvoyés par l'appel à transpile() . Par exemple :

    from qiskit.compiler import transpile
my_circs = [circ_a, circ_b]
tcirc_a, tcirc_b = transpile(my_circs,
                             output_names=['Circuit A', 'Circuit B'])

    l'attribut name sur tcirc_a et tcirc_b sera respectivement 'Circuit A' et 'Circuit B' .

  • Une nouvelle méthode equiv() a été ajoutée aux classes qiskit.quantum_info.Operator et qiskit.quantum_info.Statevector . Ces méthodes permettent de vérifier si un deuxième objet Operator ou Statevector est équivalent jusqu'à la phase globale.

  • Le fichier de configuration de l'utilisateur comporte plusieurs nouvelles options :

    • Le champ circuit_drawer accepte désormais une valeur automatique. Lorsqu'il est défini comme valeur pour le champ circuit_drawer , le backend du tiroir par défaut sera mpl s'il est disponible, sinon le backend texte sera utilisé.
    • Un nouveau champ circuit_mpl_style peut être utilisé pour définir le style par défaut utilisé par le tiroir de circuit de matplotlib. Les valeurs valables pour ce champ sont bw et default pour définir le style noir et blanc ou le style de couleur par défaut, respectivement.
    • Un nouveau champ transpile_optimization_level peut être utilisé pour définir le niveau d'optimisation par défaut du transpondeur à utiliser pour les appels à qiskit.compiler.transpile(). La valeur peut être réglée sur 0, 1, 2 ou 3.

  • Introduction d'une nouvelle commande d'impulsion Delay qui peut être insérée dans une impulsion Schedule. Cette commande accepte un duration et peut être ajoutée à n'importe quel Channel. D'autres commandes ne peuvent pas être programmées sur un canal pendant un délai.

    Le délai peut être ajouté comme n'importe quelle autre commande d'impulsion. Par exemple :

    from qiskit import pulse

drive_channel = pulse.DriveChannel(0)
delay = pulse.Delay(20)

sched = pulse.Schedule()
sched += delay(drive_channel)

Mise à niveau

  • Le module qiskit._util , précédemment obsolète, a été supprimé. qiskit.util doit être utilisé à la place.

  • La méthode QuantumCircuit.count_ops() renvoie désormais un objet OrderedDict au lieu d'un objet dict. Cela devrait être compatible avec la plupart des cas d'utilisation puisque OrderedDict est une sous-classe de dict . Toutefois, les contrôles de type et les autres contrôles de classe pourraient devoir être mis à jour.

  • La méthode DAGCircuit.width() renvoie maintenant le nombre total de bits quantiques et de bits classiques. Auparavant, il ne renvoyait que le nombre de bits quantiques. Si vous n'avez besoin que du nombre de bits quantiques, vous pouvez utiliser DAGCircuit.num_qubits() .

  • La fonction DAGCircuit.num_cbits() a été supprimée. Au lieu de cela, vous pouvez utiliser DAGCircuit.num_clbits().

  • Les bits quantiques et les bits classiques individuels ne sont plus représentés sous la forme de tuples (register, index) . Ce sont maintenant des instances des classes Qubit et Clbit. Si vous avez affaire à des éléments individuels, veillez à mettre à jour les vérifications d'usage ou de type pour rechercher ces nouvelles classes au lieu des tuples.

  • Les classes de passeurs prédéfinies qiskit.transpiler.preset_passmanagers.default_pass_manager et qiskit.transpiler.preset_passmanagers.default_pass_manager_simulator (qui étaient les précédents passeurs par défaut pour les appels qiskit.compiler.transpile() ) ont été supprimées. Si vous utilisiez manuellement ces gestionnaires de laissez-passer, passez à la nouvelle valeur par défaut, qiskit.transpile.preset_passmanagers.level1_pass_manager.

  • Le laissez-passer LegacySwap a été supprimé. Si vous l'utilisiez dans un gestionnaire de passe personnalisé, il peut être remplacé par le passe StochasticSwap , qui est une version plus rapide et plus stable. Tous les gestionnaires de laissez-passer prédéfinis ont été mis à jour pour utiliser le laissez-passer StochasticSwap au lieu du laissez-passer LegacySwap.

  • Les méthodes qiskit.dagcircuit.DAGCircuit suivantes ont été supprimées :

    • DAGCircuit.get_qubits() - Utilisez plutôt DAGCircuit.qubits()

    • DAGCircuit.get_bits() - Utilisez plutôt DAGCircuit.clbits()

    • DAGCircuit.qasm() - Utilisez une combinaison de qiskit.converters.dag_to_circuit() et QuantumCircuit.qasm(). Par exemple :

      from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import dag_to_circuit
my_dag = DAGCircuit()
qasm = dag_to_circuit(my_dag).qasm()

    • DAGCircuit.get_op_nodes() - Utilisez plutôt DAGCircuit.op_nodes() . Notez que le type de retour est une liste d'objets DAGNode pour op_nodes() au lieu de la liste de tuples précédemment renvoyée par get_op_nodes().

    • DAGCircuit.get_gate_nodes() - Utilisez plutôt DAGCircuit.gate_nodes() . Notez que le type de retour est une liste d'objets DAGNode pour gate_nodes() au lieu de la liste de tuples précédemment renvoyée par get_gate_nodes().

    • DAGCircuit.get_named_nodes() - Utilisez plutôt DAGCircuit.named_nodes() . Notez que le type de retour est une liste d'objets DAGNode pour named_nodes() au lieu de la liste des node_ids précédemment renvoyée par get_named_nodes().

    • DAGCircuit.get_2q_nodes() - Utilisez plutôt DAGCircuit.twoQ_gates() . Notez que le type de retour est une liste d'objets DAGNode pour twoQ_gates() au lieu de la liste de data_dicts précédemment renvoyée par get_2q_nodes().

    • DAGCircuit.get_3q_or_more_nodes() - Utilisez plutôt DAGCircuit.threeQ_or_more_gates() . Notez que le type de retour est une liste d'objets DAGNode pour threeQ_or_more_gates() au lieu de la liste de tuples précédemment renvoyée par get_3q_or_more_nodes().

  • Les méthodes qiskit.dagcircuit.DAGCircuit suivantes ne prennent plus en charge l'acceptation d'un node_id en tant que paramètre. Cette disposition a été supprimée et seuls les objets DAGNode sont désormais acceptés en entrée :

    • successors()
    • predecessors()
    • ancestors()
    • descendants()
    • bfs_successors()
    • quantum_successors()
    • remove_op_node()
    • remove_ancestors_of()
    • remove_descendants_of()
    • remove_nonancestors_of()
    • remove_nondescendants_of()
    • substitute_node_with_dag()

  • La méthode qiskit.dagcircuit.DAGCircuit rename_register() a été supprimée. Ce dernier était inutilisé par tout le code qiskit. Si vous l'utilisiez en externe, vous devrez la réimplémenter en tant que fonction externe.

  • La propriété qiskit.dagcircuit.DAGCircuit multi_graph a été supprimée. L'accès direct à l'objet networkx multi_graph sous-jacent n'est plus pris en charge. L'API fournie par la classe DAGCircuit doit être utilisée à la place.

  • La classe d'exception dépréciée qiskit.qiskiterror.QiskitError a été supprimée. Au lieu de cela, vous devez utiliser qiskit.exceptions.QiskitError.

  • Les kwargs booléens, ignore_requires et ignore_preserves du constructeur qiskit.transpiler.PassManager ont été supprimés. Ces options ne sont plus valables.

  • Le module qiskit.tools.logging a été retiré. Ce module n'était utilisé par personne et n'ajoutait rien aux interfaces fournies par le module logging de la bibliothèque standard de Python. Si vous souhaitez définir un formatage personnalisé pour la journalisation, utilisez plutôt le module logging de la bibliothèque standard.

  • La classe CompositeGate a été supprimée. Au lieu de cela, vous devez créer directement un objet d'instruction à partir d'un circuit et l'ajouter à votre circuit. Par exemple, vous pouvez exécuter quelque chose comme :

    custom_gate_circ = qiskit.QuantumCircuit(2)
custom_gate_circ.x(1)
custom_gate_circ.h(0)
custom_gate_circ.cx(0, 1)
custom_gate = custom_gate_circ.to_instruction()

  • Les kwargs précédemment dépréciés, seed et config pour qiskit.compiler.assemble() ont été supprimés et remplacés par seed_simulator et run_config respectivement.

  • Les convertisseurs qiskit.converters.qobj_to_circuits() et qiskit.converters.circuits_to_qobj() , précédemment obsolètes, ont été supprimés. Utilisez plutôt qiskit.assembler.disassemble() et qiskit.compiler.assemble() .

  • Le kwarg seed_mapper pour qiskit.compiler.transpile() a été supprimé. Au lieu de cela, vous devez utiliser seed_transpiler

  • Les kwargs seed, seed_mapper, config, et circuits pour la fonction qiskit.execute() ont été supprimés. Utilisez plutôt les arguments seed_simulator, seed_transpiler, run_config, et experiments respectivement.

  • Le module qiskit.tools.qcvv , précédemment obsolète, a été supprimé. Utilisez qiskit-ignis à la place.

  • Les fonctions précédemment obsolètes qiskit.transpiler.transpile() et qiskit.transpiler.transpile_dag() ont été supprimées. Au lieu de cela, vous devez utiliser qiskit.compiler.transpile. Si vous utilisiez transpile_dag() , vous pouvez le remplacer par la course à pied :

    circ = qiskit.converters.dag_to_circuit(dag)
out_circ = qiskit.compiler.transpile(circ)
qiskit.converters.circuit_to_dag(out_circ)

  • La fonction qiskit.compile() , précédemment dépréciée, a été supprimée et vous devez utiliser qiskit.compiler.transpile() et qiskit.compiler.assemble().

  • La magie de cellule jupyter %%qiskit_progress_bar de qiskit.tools.jupyter a été remplacée par une magie de ligne. Cela a été fait pour mieux refléter la façon dont la magie est utilisée et comment elle fonctionne. Si vous utilisiez la magie de cellule %%qiskit_progress_bar dans un carnet existant, vous devrez la remplacer par la magie de ligne %qiskit_progress_bar . Tout le reste devrait se comporter de manière identique.

  • La fonction obsolète qiskit.tools.qi.qi.random_unitary_matrix() a été supprimée. Vous devriez plutôt utiliser la fonction qiskit.quantum_info.random.random_unitary() .

  • La fonction obsolète qiskit.tools.qi.qi.random_density_matrix() a été supprimée. Vous devriez plutôt utiliser la fonction qiskit.quantum_info.random.random_density_matrix() .

  • La fonction obsolète qiskit.tools.qi.qi.purity() a été supprimée. Vous devriez plutôt utiliser la fonction qiskit.quantum_info.purity() .

  • La méthode QuantumCircuit._attach() , obsolète, a été supprimée. Vous devriez plutôt utiliser QuantumCircuit.append() .

  • La méthode qiskit.qasm.Qasm get_filename() a été supprimée. Vous pouvez utiliser la méthode return_filename() à la place.

  • Le module qiskit.mapper , obsolète, a été supprimé. La liste des fonctions et des classes avec leurs alternatives est la suivante :

    • qiskit.mapper.CouplingMap: qiskit.transpiler.CouplingMap doit être utilisé à la place.
    • qiskit.mapper.Layout: qiskit.transpiler.Layout doit être utilisé à la place
    • qiskit.mapper.compiling.euler_angles_1q(): qiskit.quantum_info.synthesis.euler_angles_1q() doit être utilisé à la place
    • qiskit.mapper.compiling.two_qubit_kak(): qiskit.quantum_info.synthesis.two_qubit_cnot_decompose() doit être utilisé à la place.

    Les classes d'exception dépréciées qiskit.mapper.exceptions.CouplingError et qiskit.mapper.exceptions.LayoutError n'ont pas d'alternative puisqu'elles ne servent à rien sans le module qiskit.mapper .

  • Le module qiskit.pulse.samplers a été déplacé vers qiskit.pulse.pulse_lib.samplers. Vous devrez mettre à jour les importations de qiskit.pulse.samplers vers qiskit.pulse.pulse_lib.samplers.

  • seaborn est désormais une dépendance de la fonction qiskit.visualization.plot_state_qsphere(). Il est nécessaire de générer des cartes de couleurs angulaires appropriées pour la visualisation. La cible d'installation des extras qiskit-terra[visualization] a été mise à jour pour installer seaborn>=0.9.0 . Si vous utilisez des visualisations et plus particulièrement la fonction plot_state_qsphere() , vous pouvez l'utiliser pour installer seaborn ou simplement lancer manuellement pip install seaborn>=0.9.0

  • Les fonctions précédemment obsolètes qiksit.visualization.plot_state et qiskit.visualization.iplot_state ont été supprimées. Au lieu de cela, vous devez utiliser la fonction spécifique à chaque type de tracé. Vous pouvez vous référer aux tableaux suivants pour faire correspondre les fonctions obsolètes aux nouvelles fonctions équivalentes :

    Qiskit Terra 0.6
    Qiskit Terra 0.7 +
    plot_state(rho)tracé de l'état de la ville (rho)
    plot_state(rho, method='city')tracé de l'état de la ville (rho)
    plot_state(rho, method='paulivec')tracé de l'état de Paulivec(rho)
    plot_state(rho, method='qsphere')plot_state_qsphere(rho)
    plot_state(rho, method='bloch')plot_bloch_multivector(rho)
    plot_state(rho, method='hinton')plot_state_hinton(rho)

  • Les dépendances pylatexenc et pillow pour les backends latex et latex_source ne sont plus listées comme des exigences. Si vous comptez utiliser les tiroirs de circuit latex, assurez-vous que les deux paquets sont installés ou utilisez les outils supplémentaires setuptools pour les installer en même temps que qiskit-terra :

    pip install qiskit-terra[visualization]

  • La racine de l'espace de noms qiskit émettra désormais un avertissement lors de l'importation si qiskit.IBMQ ou qiskit.Aer n'a pas pu être configuré. Cela se produira chaque fois qu'un élément de l'espace de noms qiskit sera importé. Ces avertissements ont été ajoutés pour que les utilisateurs sachent d'emblée s'ils utilisent qiskit et que les paquets qiskit-aer et qiskit-ibmq-provider n'ont pas pu être trouvés. Il n'est pas toujours évident de savoir si les paquets sont manquants ou si python packaging/pip a installé un élément de manière incorrecte jusqu'à ce que vous alliez les utiliser et que vous obteniez un ImportError vide. Ces avertissements devraient indiquer clairement si ces alias couramment utilisés sont manquants.

    Cependant, pour les utilisateurs qui choisissent de ne pas utiliser qiskit-aer ou qiskit-ibmq-provider, cela peut causer du bruit supplémentaire. Pour ces utilisateurs, ces avertissements peuvent être facilement supprimés en utilisant la bibliothèque standard de Python warnings. Les utilisateurs peuvent supprimer les avertissements en plaçant ces deux lignes avant toute importation de qiskit :

    import warnings
warnings.filterwarnings('ignore', category=RuntimeWarning,
                        module='qiskit')

    Cela supprimera les avertissements émis si qiskit-aer ou qiskit-ibmq-provider ne sont pas installés, mais préservera tous les autres avertissements émis par qiskit ou tout autre paquetage.

Remarques concernant la dépréciation

  • Les portes U et CX ont été supprimées. Si vous utilisez ces portes dans votre code, vous devez les mettre à jour pour utiliser u3 et cx à la place. Par exemple, si vous utilisez les fonctions de porte de circuit circuit.u_base() et circuit.cx_base() , vous devez les mettre à jour en circuit.u3() et circuit.cx() respectivement.

  • La porte u0 a été dépréciée au profit de l'utilisation de plusieurs portes iden et sera supprimée à l'avenir. Si vous utilisez la porte u0 dans votre circuit, vous devez mettre à jour vos appels pour utiliser iden. Par exemple, si vous utilisiez circuit.u0(2) dans votre circuit auparavant, vous devez le mettre à jour :

    circuit.iden()
circuit.iden()

    à la place.

  • La classe qiskit.pulse.DeviceSpecification est désormais obsolète. Au lieu de cela, vous devez utiliser qiskit.pulse.PulseChannelSpec.

  • L'accès à une classe qiskit.circuit.Qubit, qiskit.circuit.Clbit, ou qiskit.circuit.Bit par index est obsolète (pour des raisons de compatibilité avec les tuples (register, index) que ces classes ont remplacés). Vous devez plutôt utiliser les attributs register et index .

  • Transmettre un bit à la méthode qiskit.QuantumCircuit append sous la forme d'un tuple (register, index) est déprécié. Au lieu de cela, il convient d'utiliser directement des objets binaires.

  • L'accès aux éléments d'un objet qiskit.transpiler.Layout avec un tuple (register, index) est obsolète. Au lieu de cela, il convient d'utiliser directement un objet bit.

  • La méthode du constructeur qiskit.transpiler.Layout qiskit.transpiler.Layout.from_tuplelist() est obsolète. Au lieu de cela, il convient d'utiliser le constructeur qiskit.transpiler.Layout.from_qubit_list() .

  • Le module qiskit.pulse.ops est obsolète. Toutes les fonctions qu'il offre :

    • union
    • flatten
    • shift
    • insert
    • append

    ont des méthodes équivalentes disponibles directement dans les classes qiskit.pulse.Schedule et qiskit.pulse.Instruction . Ces méthodes doivent être utilisées à la place.

  • La méthode qiskit.qasm.Qasm get_tokens() est obsolète. Vous devez plutôt utiliser la méthode generate_tokens() .

  • La méthode qiskit.qasm.qasmparser.QasmParser get_tokens() est obsolète. Vous devez plutôt utiliser la méthode read_tokens() .

  • La méthode as_dict() pour la classe Qobj est obsolète et sera supprimée à l'avenir. Vous devriez plutôt remplacer les appels à ce système par to_dict() .

Corrections des erreurs

  • La définition du site CU3Gate a été modifiée pour être équivalente à la définition canonique d'un site contrôlé U3Gate.

  • La gestion de la mise en page dans le gestionnaire de passe a été normalisée. Cette modification corrige plusieurs problèmes signalés concernant la gestion de la mise en page. Le paramètre initial_layout kwarg sur qiskit.compiler.transpile() et qiskit.execute() va maintenant placer vos qubits du circuit sur les qubits souhaités sur le dispositif lors de la transposition des circuits.

  • La prise en charge des unitaires n-qubits a été ajoutée au simulateur BasicAer et unitary (arbitrary unitary gates) a été ajouté à l'ensemble des portes de base pour les simulateurs

  • Le site qiskit.visualization.plost_state_qsphere() a été mis à jour afin de résoudre plusieurs problèmes. La visualisation de la sphère Q sera désormais générée correctement et les aspects suivants ont été mis à jour :

    • Tous les états de base complémentaires sont antipodaux

    • La phase est indiquée par la couleur de la ligne et du marqueur sur la surface de la sphère

    • La probabilité est indiquée par la translucidité de la ligne et le volume du marqueur sur

      surface de la sphère

Autres remarques

  • La valeur par défaut de PassManager pour qiskit.compiler.transpile() et qiskit.execute() a été modifiée en gestionnaire de passage de niveau d'optimisation 1 défini à qiskit.transpile.preset_passmanagers.level1_pass_manager.

  • Tous les backends de dessinateurs de circuits expriment désormais les paramètres des portes d'un circuit sous forme de fractions communes de pi dans la visualisation de sortie. Si la valeur d'un paramètre peut être exprimée sous la forme d'une fraction de pi, celle-ci sera utilisée à la place de l'équivalent numérique.

  • Lors de l'utilisation de qiskit.assembler.assemble_schedules() , si vous n'indiquez pas le nombre d'emplacements mémoire à utiliser, ce nombre sera déduit sur la base du nombre d'acquisitions dans les calendriers d'entrée.

  • L'avertissement de dépréciation concernant la propriété qiskit.dagcircuit.DAGCircuit node_counter a été supprimé. Le changement de comportement faisant l'objet de l'avertissement a été mis en œuvre lorsque l'avertissement a été ajouté, de sorte qu'avertir qu'il a changé ne sert à rien.

  • Les appels à PassManager.run() émettent désormais des messages de journalisation python au niveau INFO pour chaque exécution de passe. Ces messages comprendront le nom de la passe et le temps d'exécution total de la passe. Python la journalisation standard de Qiskit-Terra a été utilisée parce qu'elle permet à la journalisation de Qiskit-Terra de s'intégrer de manière standard à d'autres applications et bibliothèques. Toute la journalisation du transpondeur se fait dans l'espace de noms qiskit.transpiler , tel qu'il est utilisé par logging.getLogger('qiskit.transpiler). Par exemple, pour activer la journalisation au niveau DEBUG pour le transpilateur, vous pouvez exécuter :

    import logging

logging.basicConfig()
logging.getLogger('qiskit.transpiler').setLevel(logging.DEBUG)

    qui définira le niveau de journalisation du transpileur à DEBUG et configurera ces messages pour qu'ils soient imprimés sur stderr.

Aer 0.3

  • Il existe un nouveau simulateur de matrice de densité très performant qui peut être utilisé en conjonction avec nos modèles de bruit, afin de mieux simuler les scénarios du monde réel.
  • Nous avons ajouté un simulateur Matrix Product State (MPS). MPS permet une simulation efficace de plusieurs classes de circuits quantiques, même en présence de fortes corrélations et d'états fortement enchevêtrés. Dans les cas qui se prêtent à la MPS, des circuits de plusieurs centaines de qubits et plus peuvent être simulés exactement, par exemple pour obtenir des valeurs d'espérance d'observables.
  • Les instantanés peuvent être réalisés dans tous nos simulateurs.
  • Désormais, nous pouvons également mesurer des circuits d'échantillonnage avec des erreurs de lecture, et non plus seulement des circuits idéaux.
  • Nous avons augmenté certaines optimisations de circuits en fonction de la présence de bruit.
  • De meilleures approximations de l'erreur à 2 qubits ont été incluses.
  • Inclus quelques outils pour rendre certaines simulations bruyantes plus faciles à réaliser et plus rapides à simuler.
  • Performances accrues pour les simulations nécessitant moins de précision numérique en virgule flottante.

Ignis 0.2

Nouvelles fonctions

Corrections des erreurs

  • Correction d'un bug dans l'erreur d'ajustement du RB
  • Correction d'un bug dans l'outil de caractérisation lors de la sélection d'un index de qubit à ajuster

Autres remarques

  • L'atténuation des mesures fonctionne désormais en parallèle lorsqu'elle est appliquée à plusieurs résultats
  • Les valeurs d'estimation pour les monteurs RB sont améliorées

Aqua 0.6

Ajouté

  • Portes de Toffoli en phase relative rccx (avec 2 contrôles) et rcccx (avec 3 contrôles).

  • Forme variationnelle RYCRX

  • Un nouveau mode 'basic-no-ancilla' pour mct.

  • Les portes de rotation multicontrôlées mcrx, mcry, et mcrz en tant que porte générale u3 ne sont pas prises en charge par la mise en œuvre du code gris

  • Chimie : Support à coquille ouverte ROHF

    • Pris en charge par tous les pilotes : Gaussian16, PyQuante, PySCF et PSI4
    • HartreeFock l'état initial, la forme variationnelle de l'UCCSD et la réduction de deux qubits pour le mappage de la parité prennent désormais en charge différents nombres de particules alpha et bêta pour la prise en charge de l'enveloppe ouverte

  • Chimie : Support UHF à coquille ouverte

    • Pris en charge par tous les pilotes : Gaussian16, PyQuante, PySCF et PSI4
    • QMolecule étendu pour inclure les intégrales, les coefficients, etc. pour les bêta séparés

  • Chimie : QMolecule étendu aux intégrales dans la base des orbitales atomiques pour faciliter l'accès commun à celles-ci pour l'expérimentation

    • Pris en charge par tous les pilotes : Gaussian16, PyQuante, PySCF et PSI4

  • Chimie : Configuration supplémentaire des pilotes PyQuante et PySCF

    • Contrôles de la tolérance de convergence et de l'itération de convergence maximale.
    • Pour PySCF choix initial

  • Chimie : Traitement des sorties ajoutées au journal de débogage à partir des calculs de PyQuante et PySCF (les sorties de Gaussian16 et PSI4 ont déjà été ajoutées au journal de débogage)

  • Chimie : Fusionné qiskit-chemistry dans qiskit-aqua

  • Ajouter les classes MatrixOperator, WeightedPauliOperator et TPBGroupedPauliOperator .

  • Ajouter la fonction evolution_instruction pour obtenir une instruction sans registre de l'évolution du temps.

  • Ajout du module op_converter pour unifier l'endroit chargé de convertir les différents types d'opérateurs.

  • Ajout de la classe Z2Symmetries qui encapsule les informations sur les symétries de Z2 et possède des méthodes d'aide pour l'effilage d'un Opérateur.

  • Estimation de l'amplitude : ajout du post-traitement du maximum de vraisemblance et du calcul de l'intervalle de confiance.

  • Estimation de l'amplitude par maximum de vraisemblance (MLAE) : Mise en œuvre d'un nouvel algorithme pour l'estimation de l'amplitude basé sur l'estimation du maximum de vraisemblance, qui réduit le nombre de qubits requis et la profondeur du circuit.

  • Ajout de circuits de Pauli-rotation linéairement et polynomialement contrôlés (par morceaux).

  • Ajouter q_equation_of_motion pour étudier l'état excité d'une molécule, et ajouter deux algorithmes pour préparer l'état de référence.

Changé

  • Améliorer le mode mct's 'basic' en utilisant des portes de Toffoli en phase relative pour construire des résultats intermédiaires.
  • Adaptez-vous à la nouvelle classe Qubit de Qiskit Terra.
  • Empêcher QPE/IQPE de modifier les objets d'entrée Operator .
  • La dépendance à l'égard de PyEDA a été supprimée; les opérations logiques sous-jacentes des oracles correspondants sont désormais gérées par SymPy.
  • Refondre la classe Operator , chaque représentation a sa propre classe MatrixOperator, WeightedPauliOperator et TPBGroupedPauliOperator.
  • Le power dans evolution_instruction était appliqué sur le thêta sur la porte CRZ directement, la nouvelle version répète les circuits pour implémenter la puissance.
  • CircuitCache est désactivé par défaut et peut être défini via la variable d'environnement now QISKIT_AQUA_CIRCUIT_CACHE.

Corrections des erreurs

  • Un bogue qui faisait que TruthTableOracle construisait des circuits incorrects pour les tables de vérité ne comportant qu'une seule valeur 1 .
  • Un bogue causé par l'indéterminisme de PyEDA.
  • Un bogue dans le calcul de translation et d'étirement de QPE/IQPE.
  • Chimie : Correction de la cartographie de Bravyi-Kitaev lorsque le nombre de qubits n'est pas une puissance de 2
  • Configurer initial_layout dans QuantumInstance via une liste.

Supprimé

  • La porte de rotation générale multicontrôlée mcu3 est supprimée et remplacée par les portes de rotation multicontrôlées mcrx, mcry, et mcrz

Obsolète

  • La classe Operator est obsolète, au profit des classes MatrixOperator, WeightedPauliOperator et TPBGroupedPauliOperator.

IBM 0.3 du fournisseur Q

Pas de modification

Cette page a-t-elle été utile ?
Signaler un bogue, une coquille ou proposer du contenu sur GitHub.