Skip to main content
IBM Quantum Platform

Notes de publication de Qiskit 0.18

0.18.3

Terra 0.13.0

Aucun changement

Aer 0.5.1

Mise à niveau

  • Modifie la façon dont les passes de transpilation sont gérées dans les classes de contrôleurs C++, de sorte que chaque passe doit être appelée explicitement. Cela permet de mieux personnaliser le moment où chaque passe doit être appelée, et avec quels paramètres. Cela permet notamment de définir des paramètres différents pour la passe d'optimisation de la fusion des portes en fonction de la méthode de simulation QasmController.
  • Ajouter gate_length_units kwarg à qiskit.providers.aer.noise.NoiseModel.from_device() pour spécifier gate_lengths dans la fonction de modèle de bruit du dispositif afin de gérer les conversions d'unités pour le code interne.
  • Ajout de la porte Controlled-Y ("cy") au jeu de portes supporté par les méthodes du simulateur de stabilisateur.
  • Pour le backend d'Aer, la validation jsonschema des objets qobj en entrée de terra est maintenant opt-in au lieu d'être activée par défaut. Si vous souhaitez activer la validation jsonschema du qobj, définissez le kwarg validate sur la méthode qiskit.providers.aer.QasmSimualtor.run() pour l'objet backend à True.

Corrections des erreurs

  • Supprimer "extended_stabilizer" des méthodes de simulation sélectionnées automatiquement. Ceci est nécessaire car la méthode du stabilisateur étendu n'est pas exacte et peut donner des résultats incorrects pour certains circuits, à moins que l'utilisateur ne sache comment optimiser ses paramètres de configuration.

    La méthode automatique ne sélectionne plus que les méthodes "stabilisateur", "matrice_densité" et "vecteur d'état". Si un circuit non-Clifford trop grand pour la méthode statevector est exécuté, une exception sera levée, suggérant d'essayer d'utiliser explicitement les méthodes "extended_stabilizer" ou "matrix_product_state" à la place.

  • Corrige les classes de contrôleurs de manière à ce que la passe de transpilation ReduceBarrier soit appliquée en premier. Cela empêche les instructions de barrière d'empêcher la troncature des qubits inutilisés si la seule instruction définie sur ces qubits est une barrière.

  • Désactive la fusion des portes pour la méthode de simulation de l'état du produit matriciel, car cela entraînait des problèmes avec des résultats incorrects dans certains cas.

  • Correction d'une erreur dans la conversion de l'unité de temps de la porte pour le modèle de bruit du dispositif avec des erreurs de relaxation thermique et des erreurs de porte. La probabilité d'erreur de dépolarisation était calculée avec un temps de porte en microsecondes, tandis que pour la relaxation thermique, elle était calculée en nanosecondes. De ce fait, aucune erreur de dépolarisation n'a été appliquée car les unités incorrectes auraient donné l'impression que l'appareil était limité par la cohérence.

  • Correction d'un bug dans la composition incorrecte de QuantumErrors lorsque les qubits des instructions composées sont différents.

  • Correction d'un problème où la porte "diagonale" est vérifiée comme étant unitaire avec une tolérance trop élevée. Les diagonales générées à partir de fonctions Numpy échouaient souvent au test.

  • Correction de la passe d'optimisation du circuit de suppression des barrières à appliquer avant la trucation des qubits. Ceci corrige un problème où les barrières insérées par le transpondeur Terra à travers des qubits autrement inactifs les empêchaient d'être tronqués.

Ignis 0.3.0

Aucun changement

Aqua 0.6.6

Aucun changement

IBM 0.6.1 du fournisseur Q

Aucun changement

0.18.0

Terra 0.13.0

Prélude

La version 0.13.0 comprend de nombreux changements importants. Les points forts de cette version sont les suivants

Pour le transpileur, nous avons changé la bibliothèque de graphes utilisée pour construire la classe qiskit.dagcircuit.DAGCircuit qui est la structure de données sous-jacente à toutes les opérations, pour qu'elle soit basée sur retworkx afin d'améliorer considérablement les performances. La vitesse de transpilation des circuits dans la version 0.13.0 devrait être significativement plus rapide que dans les versions précédentes.

Le style de construction des instructions Pulse a été considérablement simplifié. Désormais, Command s est obsolète et un ensemble unifié de Instruction est pris en charge.

Le module qiskit.quantum_info comprend plusieurs nouvelles fonctions pour générer des opérateurs aléatoires (tels que les Cliffords et les canaux quantiques) et pour calculer la norme de diamant des canaux quantiques; des mises à jour des modules Statevector et DensityMatrix afin de prendre en charge le calcul des probabilités de mesure et l'échantillonnage des mesures; et plusieurs nouvelles classes sont basées sur la représentation symplectique des matrices de Pauli. Ces nouvelles classes comprennent les opérateurs de Clifford (Clifford), les matrices de N-qubits qui sont éparses dans la base de Pauli (SparsePauliOp), les listes de Pauli (PauliTable) et les listes de stabilisateurs (StabilizerTable).

Cette version propose également une documentation largement améliorée pour l'ensemble de Qiskit, y compris une documentation améliorée pour les éléments suivants qiskit.circuit, qiskit.pulse et qiskit.quantum_info et les modules

En outre, la dénomination des objets et des méthodes des portails a été mise à jour afin d'être plus cohérente QuantumCircuit ont été mis à jour pour être plus cohérents. De ce fait, plusieurs classes et méthodes ont été dépréciées au fur et à mesure de l'adoption d'un système de dénomination plus cohérent.

Pour plus de détails sur tous les changements apportés dans cette version, voir les notes de version détaillées ci-dessous.

Nouvelles fonctions

  • Ajout d'un nouveau module de bibliothèque de circuits qiskit.circuit.library. Il s'agira d'un lieu pour les constructeurs de circuits courants qui peuvent être utilisés comme éléments de base pour des circuits ou des applications plus importants.

  • La classe qiskit.providers.BaseJob comporte quatre nouvelles méthodes :

    • done()
    • running()
    • cancelled()
    • in_final_state()

    Ces méthodes sont utilisées pour vérifier si un travail se trouve dans un état donné.

  • Ajouter la possibilité de spécifier un contrôle conditionné à la présence d'un qubit dans l'état fondamental. L'état des qubits de contrôle est représenté par un nombre entier. Par exemple :

    from qiskit import QuantumCircuit
from qiskit.extensions.standard import XGate

qc = QuantumCircuit(4)
cgate = XGate().control(3, ctrl_state=6)
qc.append(cgate, [0, 1, 2, 3])

    Crée une porte à quatre qubits où le quatrième qubit est inversé si le premier qubit est dans l'état fondamental et que les deuxième et troisième qubits sont dans l'état excité. Si ctrl_state est None, le contrôle est conditionné à l'excitation de tous les qubits de contrôle.

  • Un nouveau widget jupyter, %circuit_library_info a été ajouté à qiskit.tools.jupyter. Ce widget est utilisé pour visualiser les détails des circuits construits à partir de la bibliothèque de circuits. Par exemple

    from qiskit.circuit.library import XOR
import qiskit.tools.jupyter
circuit = XOR(5, seed=42)
%circuit_library_info circuit

  • Une nouvelle option kwarg, formatted , a été ajoutée à qiskit.circuit.QuantumCircuit.qasm() . Lorsqu'elle vaut True , la méthode imprime une version syntaxiquement mise en évidence (à l'aide de pygments) sur stdout et renvoie None (ce qui diffère du comportement normal consistant à renvoyer le code QASM sous forme de chaîne de caractères).

  • Une nouvelle option kwarg, filename , a été ajoutée à qiskit.circuit.QuantumCircuit.qasm(). Lorsqu'elle est définie sur un chemin, la méthode écrit le code QASM dans ce fichier. Il continuera ensuite à produire normalement.

  • Une nouvelle instruction SetFrequency qui permet aux utilisateurs de modifier la fréquence de PulseChannel. Cela se fait de la manière suivante :

    from qiskit.pulse import Schedule
from qiskit.pulse import SetFrequency

sched = pulse.Schedule()
sched += SetFrequency(5.5e9, DriveChannel(0))

    Dans cet exemple, la fréquence de toutes les impulsions avant la commande SetFrequency sera la fréquence par défaut et toutes les impulsions appliquées au canal d'entraînement zéro après la commande SetFrequency seront à 5.5 GHz. Les utilisateurs de SetFrequency doivent tenir compte des éventuelles limitations matérielles.

  • Une nouvelle méthode, assign_parameters() a été ajoutée à la classe qiskit.circuit.QuantumCircuit classe. Cette méthode accepte un dictionnaire de paramètres contenant à la fois des flottants et des objets Parameters dans un seul dictionnaire. En d'autres termes, cette nouvelle méthode vous permet de lier des flottants, des paramètres ou les deux dans un seul dictionnaire.

    De plus, en utilisant le kwarg inplace , il peut être spécifié que vous pouvez éventuellement modifier le circuit original en place. Par défaut, cette valeur est fixée à False et une copie du circuit original sera renvoyée par la méthode.

  • Une nouvelle méthode num_nonlocal_gates() a été ajoutée à la classe qiskit.circuit.QuantumCircuit a vu l'ajout d'une nouvelle méthode. Cette méthode renvoie le nombre de portes d'un circuit impliquant 2 qubits ou plus. Ces portes sont plus coûteuses en termes de temps et d'erreurs à mettre en œuvre.

  • La qiskit.circuit.QuantumCircuit méthode iso() pour ajouter une porte Isometry au circuit a un nouvel alias. Vous pouvez désormais appeler qiskit.circuit.QuantumCircuit.isometry() en plus d'appeler iso.

  • Un attribut description a été ajouté à la classe CouplingMap pour stocker une brève description des différentes cartes de couplage (par exemple, carte complète, grille, ligne, etc.).

  • Une nouvelle méthode compose() a été ajoutée à la classe DAGCircuit pour composer deux circuits par l'intermédiaire de leurs DAG.

    dag_left.compose(dag_right, edge_map={right_qubit0: self.left_qubit1,
                                  right_qubit1: self.left_qubit4,
                                  right_clbit0: self.left_clbit1,
                                  right_clbit1: self.left_clbit0})
                ┌───┐                    ┌─────┐┌─┐
lqr_1_0: ───┤ H ├───     rqr_0: ──■──┤ Tdg ├┤M├
            ├───┤               ┌─┴─┐└─┬─┬─┘└╥┘
lqr_1_1: ───┤ X ├───     rqr_1: ┤ X ├──┤M├───╫─
         ┌──┴───┴──┐            └───┘  └╥┘   ║
lqr_1_2: ┤ U1(0.1) ├  +  rcr_0: ════════╬════╩═  =
         └─────────┘                    ║
lqr_2_0: ─────■─────     rcr_1: ════════╩══════
            ┌─┴─┐
lqr_2_1: ───┤ X ├───
            └───┘
lcr_0:   ═══════════

lcr_1:   ═══════════

            ┌───┐
lqr_1_0: ───┤ H ├──────────────────
            ├───┤        ┌─────┐┌─┐
lqr_1_1: ───┤ X ├─────■──┤ Tdg ├┤M├
         ┌──┴───┴──┐  │  └─────┘└╥┘
lqr_1_2: ┤ U1(0.1) ├──┼──────────╫─
         └─────────┘  │          ║
lqr_2_0: ─────■───────┼──────────╫─
            ┌─┴─┐   ┌─┴─┐  ┌─┐   ║
lqr_2_1: ───┤ X ├───┤ X ├──┤M├───╫─
            └───┘   └───┘  └╥┘   ║
lcr_0:   ═══════════════════╩════╬═
                                 ║
lcr_1:   ════════════════════════╩═

  • Les backends fictifs de qiskit.test.mock disposent désormais d'une méthode run() fonctionnelle qui renvoie des résultats similaires à ceux des appareils réels. Si qiskit-aer est installé, une simulation sera exécutée avec un modèle de bruit construit à partir de l'instantané de l'appareil dans le faux backend. Dans le cas contraire, qiskit.providers.basicaer.QasmSimulatorPy sera utilisé pour effectuer une simulation idéale. En outre, si une expérience sur les impulsions est transmise à run et que qiskit-aer est installé, PulseSimulator sera utilisé pour simuler les calendriers des impulsions.

  • La qiskit.result.Result() méthode get_counts() renvoie désormais une liste de tous les comptages disponibles lorsqu'il y a plusieurs circuits dans un travail. Cela fonctionne lorsque get_counts() est appelé sans arguments.

    La principale raison d'être de cette fonction était de présenter tous les résultats de plusieurs circuits dans le même histogramme. Par exemple, il est désormais possible de faire quelque chose comme :

    from qiskit import execute
from qiskit import QuantumCircuit
from qiskit.providers.basicaer import BasicAer
from qiskit.visualization import plot_histogram

sim = BasicAer.get_backend('qasm_simulator')

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
result = execute([qc, qc, qc], sim).result()

plot_histogram(result.get_counts())

  • Un nouveau kwarg, initial_state , a été ajouté à la fonction qiskit.visualization.circuit_drawer() et à la méthode QuantumCircuit méthode draw(). Lorsqu'il est défini sur True , l'état initial sera inclus dans les visualisations de circuits pour tous les backends. Par exemple :

    from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.measure_all()
circuit.draw(output='mpl', initial_state=True)

  • Il est désormais possible d'insérer un appelable dans un qiskit.pulse.InstructionScheduleMap qui renvoie un nouveau qiskit.pulse.Schedule lorsqu'il est appelé avec des paramètres. Par exemple :

    def test_func(x):
   sched = Schedule()
   sched += pulse_lib.constant(int(x), amp_test)(DriveChannel(0))
   return sched

inst_map = InstructionScheduleMap()
inst_map.add('f', (0,), test_func)
output_sched = inst_map.get('f', (0,), 10)
assert output_sched.duration == 10

  • Deux nouvelles classes de portails, qiskit.extensions.iSwapGate et qiskit.extensions.DCXGate, ainsi que leurs QuantumCircuit méthodes iswap() et dcx() ont été ajoutées aux extensions standard. Ces portes, qui sont localement équivalentes les unes aux autres, peuvent être utilisées pour mettre en œuvre des interactions XY particulières. Une brève motivation pour ces portes peut être trouvée dans : arxiv.org/abs/quant-ph/0209035

  • La classe qiskit.providers.BaseJob dispose désormais d'une nouvelle méthode wait_for_final_state() qui demande l'état de la tâche jusqu'à ce qu'elle atteigne un état final (tel que DONE ou ERROR). Cette méthode prend également une option callback kwarg qui prend un Python callable qui sera appelé à chaque itération de la boucle d'interrogation.

  • Les attributs search_width et search_depth de la passe qiskit.transpiler.passes.LookaheadSwap peuvent désormais être définis lors de l'initialisation de la passe. Un espace de recherche plus large peut souvent conduire à des circuits plus optimisés, au prix d'un temps d'exécution plus long.

  • Le nombre de qubits dans BackendConfiguration est maintenant accessible par la propriété num_qubits. Auparavant, il n'était accessible que par l'intermédiaire de l'attribut n_qubits .

  • Deux nouvelles méthodes, angles() et angles_and_phase()ont été ajoutées à la classe qiskit.quantum_info.OneQubitEulerDecomposer ont été ajoutées à la classe Ces méthodes renverront les paramètres pertinents sans validation, et l'appel à l'objet OneQubitEulerDecomposer effectuera la synthèse complète avec validation.

  • Une base de décomposition RR a été ajoutée à la base de décomposition pour décomposer une unité arbitraire en deux circuits qiskit.quantum_info.OneQubitEulerDecomposer pour décomposer une unité arbitraire 2x2 en un circuit à deux RGate .

  • Ajoute la possibilité de définir qargs pour les objets qui sont des sous-classes de la classe abstraite BaseOperator . Cela se fait en appelant l'objet op(qargs) (où op est une classe d'opérateur) et renvoie une copie superficielle de l'objet original avec une propriété qargs définie. Lorsqu'un tel objet est utilisé avec la fonction compose() ou dot() la valeur interne de qargs est utilisée lorsque la méthode qargs kwarg n'est pas utilisée. Cela permet de composer des sous-systèmes à l'aide d'opérateurs binaires, par exemple :

    from qiskit.quantum_info import Operator

init = Operator.from_label('III')
x = Operator.from_label('X')
h = Operator.from_label('H')
init @ x([0]) @ h([1])

  • Ajoute la classe qiskit.quantum_info.Clifford au module quantum_info. Cet opérateur est une représentation symplectique efficace d'un opérateur unitaire à N qubits du groupe de Clifford. Cette classe comprend une to_circuit() pour la compilation en une QuantumCircuit de portes de Clifford avec un nombre minimal de portes CX pour un maximum de 3 qubits. Elle fournit également une compilation générale pour N > 3 qubits, mais cette méthode n'est pas optimale pour le nombre de portes à deux qubits.

  • Ajoute qiskit.quantum_info.SparsePauliOp une classe d'opérateurs. Il s'agit d'une représentation efficace d'une matrice à N qubits qui est peu dense dans la base de Pauli et qui utilise une adresse qiskit.quantum_info.PauliTable et un vecteur de coefficients complexes pour sa structure de données.

    Cette classe prend en charge la plupart des fonctionnalités de la classe qiskit.quantum_info.Operator de sorte que SparsePauliOp les objets peuvent être tensoriés, composés, multipliés scalairement, ajoutés et soustraits.

    Les tableaux Numpy ou les objets Operator peuvent être convertis en SparsePauliOp à l'aide de la méthode :class:`~qiskit.quantum_info.SparsePauliOp.from_operator. SparsePauliOp peut être converti en une matrice csr_sparse ou en un tableau Numpy dense à l'aide de la méthode to_matrix ou vers un objet Operator en utilisant la méthode to_operator méthode.

    A SparsePauliOp peut être itéré sur ses composantes et coefficients PauliTable , ses coefficients et ses étiquettes de chaînes de Pauli à l'aide de la méthode label_iter() et les composantes (denses ou éparses) de la matrice à l'aide de la méthode matrix_iter() méthode.

  • Ajouter qiskit.quantum_info.diamond_norm() fonction permettant de calculer la norme de diamant (norme de trace complètement bornée) d'un canal quantique. Ceci peut être utilisé pour calculer la distance entre deux canaux quantiques en utilisant diamond_norm(chan1 - chan2).

  • Une nouvelle classe qiskit.quantum_info.PauliTable a été ajoutée. Il s'agit d'une représentation symplectique efficace d'une liste d'opérateurs de Pauli à N-qubits. Voici quelques caractéristiques de cette classe :

    • PauliTable peuvent être composés, et tensored qui renverra un objet PauliTable avec la combinaison de l'opération ( compose(), dot(), expand(), tensor()) entre chaque élément du premier tableau, avec chaque élément du second tableau.
    • L'addition de deux tableaux agit comme une concaténation de liste des termes de chaque tableau (+).
    • Les tableaux de Pauli peuvent être triés par ordre lexicographique (produit tensoriel) ou par poids de Pauli (sort()).
    • Les éléments en double peuvent être comptés et supprimés (unique()).
    • Le site PauliTable peut être parcouru soit dans sa représentation native de tableau booléen symplectique, soit sous forme d'étiquettes de chaînes de Pauli (label_iter()), soit sous forme de tableau Numpy dense ou de matrices CSR clairsemées (matrix_iter()).
    • Vérification de la commutation entre des éléments de la table de Pauli et une autre table de Pauli (commutes()) ou de Pauli (commutes_with_all())

    Voir la documentation de l'API de la classe qiskit.quantum_info.PauliTable pour plus de détails.

  • Ajoute la classe qiskit.quantum_info.StabilizerTable . Il s'agit d'une sous-classe de la classe qiskit.quantum_info.PauliTable qui comprend un vecteur de phase booléen ainsi que le tableau de la table de Pauli. Il s'agit d'une liste d'opérateurs stabilisateurs qui sont des opérateurs de Pauli réels avec un coefficient de +1 ou -1. Les matrices des stabilisateurs étant réelles, la matrice des étiquettes de "Y" est définie comme suit : [[0, 1], [-1, 0]]. Voir la documentation de l'API pour plus d'informations.

  • Ajoute qiskit.quantum_info.pauli_basis() qui renvoie une base de Pauli à N qubits sous la forme d'un objet qiskit.quantum_info.PauliTable . L'ordre de cette base peut être soit lexicographique standard (produit tensoriel), soit le nombre de termes de Pauli non identiques (poids).

  • Ajoute qiskit.quantum_info.ScalarOp classe d'opérateur qui représente un multiple scalaire d'un opérateur d'identité. Elle peut être utilisée pour initialiser une identité sur des sous-systèmes de dimension arbitraire et sera implicitement convertie en d'autres sous-classes de BaseOperator (telles qu'une identité de type qiskit.quantum_info.Operator ou qiskit.quantum_info.SuperOp) lorsqu'elle est composée ou ajoutée à ces sous-classes.

    Exemple : Opérateur d'identité

    from qiskit.quantum_info import ScalarOp, Operator

X = Operator.from_label('X')
Z = Operator.from_label('Z')

init = ScalarOp(2 ** 3)  # 3-qubit identity
op = init @ X([0]) @ Z([1]) @ X([2])  # Op XZX

  • Une nouvelle méthode, reshape()a été ajoutée à la classe qiskit.quantum_innfo.Operator . Elle renvoie une copie peu profonde d'une sous-classe d'opérateur dont les dimensions d'entrée ou de sortie du sous-système ont été remodelées. Les dimensions combinées de tous les sous-systèmes doivent être identiques à celles de l'opérateur d'origine, faute de quoi une exception sera levée.

  • Ajoute qiskit.quantum_info.random_clifford() pour générer un opérateur aléatoire qiskit.quantum_info.Clifford opérateur.

  • Ajouter qiskit.quantum_info.random_quantum_channel() pour générer un canal quantique aléatoire de rang fixe dans l'espace Choi-rang fixe dans la représentation Stinespring représentation.

  • Ajouter qiskit.quantum_info.random_hermitian() pour générer un Hermitien aléatoire Operator.

  • Ajouter qiskit.quantum_info.random_statevector() pour générer un fichier aléatoire Statevector.

  • Ajoute qiskit.quantum_info.random_pauli_table() pour générer un qiskit.quantum_info.PauliTable aléatoire.

  • Ajoute qiskit.quantum_info.random_stabilizer_table() pour générer un qiskit.quantum_info.StabilizerTable aléatoire.

  • Ajouter un attribut num_qubits aux classes qiskit.quantum_info.StateVector et qiskit.quantum_info.DensityMatrix classes. Elle renvoie le nombre de qubits pour les états à N qubits et renvoie None pour les états non qubits.

  • Ajoute to_dict() et to_dict() pour convertir qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix en dictionnaire de notation Bra-Ket.

    Exemple

    from qiskit.quantum_info import Statevector

state = Statevector.from_label('+0')
print(state.to_dict())
    from qiskit.quantum_info import DensityMatrix

state = DensityMatrix.from_label('+0')
print(state.to_dict())

  • Ajoute probabilities() et probabilities() à qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix qui renvoient un tableau de probabilités de résultats de mesures dans la base de calcul pour les sous-systèmes spécifiés.

    Exemple

    from qiskit.quantum_info import Statevector

state = Statevector.from_label('+0')
print(state.probabilities())
    from qiskit.quantum_info import DensityMatrix

state = DensityMatrix.from_label('+0')
print(state.probabilities())

  • Ajoute probabilities_dict() et probabilities_dict() à qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix qui renvoient un tableau de type dictionnaire de comptage des probabilités des résultats de mesure dans la base de calcul pour les sous-systèmes spécifiés.

    from qiskit.quantum_info import Statevector

state = Statevector.from_label('+0')
print(state.probabilities_dict())
    from qiskit.quantum_info import DensityMatrix

state = DensityMatrix.from_label('+0')
print(state.probabilities_dict())

  • Ajouter sample_counts() et sample_memory() aux méthodes Statevector et DensityMatrix pour l'échantillonnage des résultats des mesures sur les sous-systèmes.

    Exemple :

    Générer un dictionnaire de comptages par échantillonnage à partir d'un vecteur d'état

    from qiskit.quantum_info import Statevector

psi = Statevector.from_label('+0')
shots = 1024

# Sample counts dictionary
counts = psi.sample_counts(shots)
print('Measure both:', counts)

# Qubit-0
counts0 = psi.sample_counts(shots, [0])
print('Measure Qubit-0:', counts0)

# Qubit-1
counts1 = psi.sample_counts(shots, [1])
print('Measure Qubit-1:', counts1)

    Retourne le tableau des résultats des mesures pour chaque échantillon

    from qiskit.quantum_info import Statevector

psi = Statevector.from_label('-1')
shots = 10

# Sample memory
mem = psi.sample_memory(shots)
print('Measure both:', mem)

# Qubit-0
mem0 = psi.sample_memory(shots, [0])
print('Measure Qubit-0:', mem0)

# Qubit-1
mem1 = psi.sample_memory(shots, [1])
print('Measure Qubit-1:', mem1)

  • Ajoute une méthode measure() à la méthode qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix aux classes d'états quantiques. Cela permet d'échantillonner un seul résultat de mesure à partir des sous-systèmes spécifiés et de réduire le vecteur d'état à l'état de la base de calcul après la mesure. Par exemple

    from qiskit.quantum_info import Statevector

psi = Statevector.from_label('+1')

# Measure both qubits
outcome, psi_meas = psi.measure()
print("measure([0, 1]) outcome:", outcome, "Post-measurement state:")
print(psi_meas)

# Measure qubit-1 only
outcome, psi_meas = psi.measure([1])
print("measure([1]) outcome:", outcome, "Post-measurement state:")
print(psi_meas)

  • Ajoute une méthode reset() à la méthode qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix aux classes d'états quantiques. Cela permet de réinitialiser certains ou tous les sous-systèmes à l'état ∣0⟩|0\rangle. Par exemple

    from qiskit.quantum_info import Statevector

psi = Statevector.from_label('+1')

# Reset both qubits
psi_reset = psi.reset()
print("Post reset state: ")
print(psi_reset)

# Reset qubit-1 only
psi_reset = psi.reset([1])
print("Post reset([1]) state: ")
print(psi_reset)

  • Une nouvelle fonction de visualisation qiskit.visualization.visualize_transition() pour visualiser les transitions de porte d'un seul qubit a été ajoutée. Il prend en compte un circuit à qubit unique et renvoie une animation des transitions d'état des qubits sur une sphère de Bloch. Pour utiliser cette fonction, vous devez avoir installé les dépendances et configuré globalement un animateur matplotlib. Vous pouvez vous référer à la documentation de matplotlib pour plus de détails à ce sujet. Cependant, dans le cas par défaut, il suffit de s'assurer que FFmpeg est installé pour utiliser cette fonction.

    Il prend en charge les circuits comportant les portes suivantes :

    • HGate
    • XGate
    • YGate
    • ZGate
    • RXGate
    • RYGate
    • RZGate
    • SGate
    • SdgGate
    • TGate
    • TdgGate
    • U1Gate

    Par exemple :

    from qiskit.visualization import visualize_transition
from qiskit import *

qc = QuantumCircuit(1)
qc.h(0)
qc.ry(70,0)
qc.rx(90,0)
qc.rz(120,0)

visualize_transition(qc, fpg=20, spg=1, trace=True)

  • execute() a un nouveau kwarg schedule_circuit. Le réglage de schedule_circuit=True permet de programmer le circuit en une seule fois Schedule. Cela permet aux utilisateurs qui construisent des objets qiskit.circuit.QuantumCircuit d'utiliser des méthodes d'ordonnancement personnalisées, telles que les méthodes as_late_as_possible et as_soon_as_possible . Par exemple :

    job = execute(qc, backend, schedule_circuit=True,
              scheduling_method="as_late_as_possible")

  • Une nouvelle variable d'environnement QISKIT_SUPPRESS_PACKAGING_WARNINGS peut être mise à Y ou y qui supprimera les avertissements à propos de qiskit-aer et qiskit-ibmq-provider qui ne sont pas installés au moment de l'importation. Ceci est utile pour les utilisateurs qui n'utilisent que qiskit-terra (ou pas qiskit-aer et/ou qiskit-ibmq-provider) et les avertissements ne sont pas une indication d'un problème potentiel d'empaquetage. Vous pouvez définir la variable d'environnement à N ou n pour vous assurer que les avertissements sont toujours activés même si le fichier de configuration de l'utilisateur est configuré pour les désactiver.

  • Une nouvelle option de fichier de configuration utilisateur, suppress_packaging_warnings , a été ajoutée. Lorsqu'il est défini sur true dans le fichier de configuration de l'utilisateur, comme par exemple :

    [default]
suppress_packaging_warnings = true

    cela supprimera les avertissements concernant qiskit-aer et qiskit-ibmq-provider qui ne sont pas installés au moment de l'importation. Ceci est utile pour les utilisateurs qui n'utilisent que qiskit-terra (ou pas qiskit-aer et/ou qiskit-ibmq-provider) et les avertissements ne sont pas une indication d'un problème potentiel d'empaquetage. Si le fichier de configuration de l'utilisateur est configuré pour désactiver les avertissements, il est possible d'y déroger en définissant QISKIT_SUPPRESS_PACKAGING_WARNINGS comme N ou n

  • qiskit.compiler.transpile() a deux nouveaux kwargs, layout_method et routing_method. Ils vous permettent de sélectionner une méthode particulière pour le placement et le routage de circuits sur des architectures contraignantes. Par exemple :

    transpile(circ, backend, layout_method='dense',
          routing_method='lookahead')

    va s'exécuter DenseLayout la passe de mise en page et LookaheadSwap la passe de routage.

  • Le style de construction des instructions Pulse a été considérablement simplifié.

    Avec le style précédent, Command s était appelé avec des canaux pour faire un Instruction. L'utilisation des commandes et des instructions a été un point de confusion. C'était le style précédent :

    sched += Delay(5)(DriveChannel(0))
sched += ShiftPhase(np.pi)(DriveChannel(0))
sched += SamplePulse([1.0, ...])(DriveChannel(0))
sched += Acquire(100)(AcquireChannel(0), MemorySlot(0))

    ou, de manière équivalente (bien que moins utilisée) :

    sched += DelayInstruction(Delay(5), DriveChannel(0))
sched += ShiftPhaseInstruction(ShiftPhase(np.pi), DriveChannel(0))
sched += PulseInstruction(SamplePulse([1.0, ...]), DriveChannel(0))
sched += AcquireInstruction(Acquire(100), AcquireChannel(0),
                            MemorySlot(0))

    Désormais, plutôt que de construire une commande et une instruction, chaque commande a été transférée dans une instruction :

    sched += Delay(5, DriveChannel(0))
sched += ShiftPhase(np.pi, DriveChannel(0))
sched += Play(SamplePulse([1.0, ...]), DriveChannel(0))
sched += SetFrequency(5.5, DriveChannel(0))  # New instruction!
sched += Acquire(100, AcquireChannel(0), MemorySlot(0))

  • Il existe maintenant une instruction Play qui prend en compte la description d'une enveloppe d'impulsion et d'un canal. Il existe une nouvelle classe Pulse dans le site pulse_lib , à partir de laquelle la description de l'enveloppe d'impulsion devrait être sous-classée.

    Par exemple :

    Play(SamplePulse([0.1]*10), DriveChannel(0))
Play(ConstantPulse(duration=10, amp=0.1), DriveChannel(0))

Mise à niveau

  • La méthode qiskit.dagcircuit.DAGNodepop qui était obsolète dans la version 0.9.0 a été supprimée. Si vous utilisez cette méthode, vous pouvez utiliser la déclaration del ou la fonction delattr() de Python pour effectuer la même tâche.

  • Une nouvelle exigence facultative de visualisation, pygments, a été ajoutée. Il est utilisé pour mettre en évidence la syntaxe du code OpenQASM 2.0 dans les widgets Jupyter et, éventuellement, pour la méthode qiskit.circuit.QuantumCircuit.qasm() méthode. Il doit être installé (avec pip install pygments ou pip install qiskit-terra[visualization]) avant d'utiliser le widget %circuit_library_info dans qiskit.tools.jupyter ou le kwarg formatted dans la méthode qasm() méthode.

  • L'option pulse buffer que l'on trouve dans qiskit.pulse.Channel et qiskit.pulse.Schedule était obsolète dans Terra 0.11.0 et a été supprimée. Pour ajouter un délai sur un canal ou dans une programmation, spécifiez-le explicitement dans votre programmation avec un délai :

    sched = Schedule()
sched += Delay(5)(DriveChannel(0))

  • PulseChannelSpecqui était obsolète dans Terra 0.11.0, a été supprimée. Utilisez plutôt BackendConfiguration :

    config = backend.configuration()
drive_chan_0 = config.drives(0)
acq_chan_0 = config.acquires(0)

    ou faire référence au canal directement, par exemple DriveChannel(index).

  • Le chemin d'importation était obsolète dans Terra 0.10.0 et a été supprimé : pour PulseChannel, DriveChannel, MeasureChannel, et ControlChannel, utilisez from qiskit.pulse.channels import X à la place de from qiskit.pulse.channels.pulse_channels import X.

  • La passe qiskit.transpiler.passes.CSPLayout (introduite dans la version 0.11.0 ) a été ajoutée au gestionnaire de passes prédéfinies pour les niveaux d'optimisation 2 et 3. Pour le niveau 2, la limite d'appel est fixée à 1 000 et le délai d'attente à 10 secondes. Pour le niveau 3, la limite d'appels est de 10 000 et le délai d'attente est de 1 minute.

    Maintenant que la passe est incluse dans les gestionnaires de passes prédéfinis, le paquet python-constraint n'est plus une dépendance optionnelle et a été ajouté à la liste des exigences.

  • La classe TranspileConfig qui était précédemment utilisée pour définir la configuration de l'exécution d'un qiskit.transpiler.PassManager a été supprimée et remplacée par une nouvelle classe qiskit.transpile.PassManagerConfig. Ce nouveau cours a été structuré de manière à ne contenir que les informations nécessaires à la construction d'un PassManager. Les attributs de cette classe sont les suivants

    • initial_layout
    • basis_gates
    • coupling_map
    • backend_properties
    • seed_transpiler

  • La fonction transpile_circuit dans qiskit.transpiler a été supprimée. Pour transposer un circuit avec un PassManager personnalisé, vous devez maintenant utiliser la méthode run() de l'objet :class:~qiskit.transpiler.PassManager`.

  • La QuantumCircuit méthode draw() et qiskit.visualization.circuit_drawer() n'incluront plus l'état initial inclus par défaut dans les visualisations. Si vous souhaitez conserver l'état initial dans la visualisation de sortie, vous devez définir le kwarg initial_state sur True. Par exemple, en cours d'exécution :

    from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.measure_all()
circuit.draw(output='text')

    L'état initial n'est plus pris en compte. Si vous souhaitez le conserver, vous pouvez vous présenter :

    from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.measure_all()
circuit.draw(output='text', initial_state=True)

  • qiskit.compiler.transpile() (et qiskit.execute.execute(), qui utilise transpile en interne) lèvera désormais une erreur lorsque le kwarg pass_manager est défini et qu'une valeur est définie pour d'autres kwargs déjà définis dans un objet instancié PassManager instancié. Auparavant, ces kwargs conflictuels étaient ignorés et les valeurs de l'instance PassManager étaient utilisées. Par exemple :

    from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.pass_manager_config import PassManagerConfig
from qiskit.transpiler import preset_passmanagers
from qiskit.compiler import transpile

qc = QuantumCircuit(5)

config = PassManagerConfig(basis_gates=['u3', 'cx'])
pm = preset_passmanagers.level_0_pass_manager(config)
transpile(qc, optimization_level=3, pass_manager=pm)

    soulèvera désormais une erreur, alors qu'avant cette version, la valeur de pm était utilisée silencieusement et la valeur du kwarg optimization_level était ignorée. Les kwargs transpile concernés sont les suivants :

    • optimization_level
    • basis_gates
    • coupling_map
    • seed_transpiler
    • backend_properties
    • initial_layout
    • layout_method
    • routing_method
    • backend

  • Les Operator, Clifford, SparsePauliOp,, PauliTable, StabilizerTable, les classes d'opérateurs ont une méthode call ajoutée qui leur permet d'assigner un qargs à l'opérateur pour l'utiliser avec la méthode compose(), dot(), evolve(),\+\, et - .

  • La méthode d'addition de la classe qiskit.quantum_info.Operatoraccepte désormais un kwarg qarg pour permettre d'ajouter un opérateur plus petit à un plus grand en supposant des identités dans les autres sous-systèmes (comme pour qargs dans les sous-systèmes compose() et dot() ). Cela permet d'ajouter des sous-systèmes en utilisant la méthode d'appel comme pour la composition. Ce support est ajouté à toutes les sous-classes de BaseOperator (ScalarOp, Operator, QuantumChannel).

    Par exemple :

    from qiskit.quantum_info import Operator, ScalarOp

ZZ = Operator.from_label('ZZ')

# Initialize empty Hamiltonian
n_qubits = 10
ham = ScalarOp(2 ** n_qubits, coeff=0)

# Add 2-body nearest neighbour terms
for j in range(n_qubits - 1):
    ham = ham + ZZ([j, j+1])

  • La classe BaseOperator a été mise à jour afin que l'addition, la soustraction et la multiplication scalaire ne soient plus des méthodes abstraites. Cela signifie qu'il n'est plus nécessaire de les mettre en œuvre dans les sous-classes si elles ne sont pas prises en charge. La classe de base émettra un message NotImplementedError si les méthodes ne sont pas définies.

  • La fonction qiskit.quantum_info.random_density_matrix() renvoie maintenant un objet aléatoire DensityMatrix aléatoire. Dans les versions précédentes, il renvoyait un tableau numpy.

  • Les qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix ne copient plus le tableau d'entrée s'il est déjà du bon type.

  • fastjsonschema est ajouté comme dépendance. Cette méthode est utilisée pour accélérer la validation des dictionnaires qobj par rapport au schéma JSON lorsque la méthode to_dict() est appelée sur les objets qobj avec le mot-clé validate fixé à True.

  • Les classes de construction qobj dans qiskit.qobj ne seront plus validées par rapport au jsonschema qobj par défaut. Il s'agit notamment des classes suivantes :

    Si vous comptez sur cette validation ou si vous souhaitez les valider par rapport au schéma qobj, vous pouvez le faire en définissant le kwarg validate sur True on to_dict() de l'une ou l'autre des classes Qobj de haut niveau QasmQobj ou PulseQobj. Par exemple :

    qui validera le dictionnaire de sortie par rapport au jsonschema Qobj.

  • Le dictionnaire de sortie de qiskit.qobj.QasmQobj.to_dict() et qiskit.qobj.PulseQobj.to_dict() n'est plus dans un format permettant une sérialisation directe en json, comme le prévoit l'API d'IBMQ. Ces objets Qobj sont le format actuel que nous utilisons pour transmettre les expériences aux fournisseurs/backends et, bien que le fait de disposer d'un format de dictionnaire pouvant être transmis directement à l'API IBMQ ait été modérément utile pour qiskit-ibmq-provider, il a rendu les choses plus difficiles pour les autres fournisseurs. Surtout pour les fournisseurs qui enveloppent les simulateurs locaux. À l'avenir, les définitions de ce qui est transmis entre les fournisseurs et le format de requête de l'API IBMQ seront davantage découplées (d'une manière rétrocompatible), ce qui devrait alléger le fardeau de l'écriture des fournisseurs et des backends.

    En pratique, la seule différence fonctionnelle entre la sortie de ces méthodes et les versions précédentes est que les nombres complexes sont représentés avec le type complex et que les tableaux numpy ne sont plus convertis silencieusement en liste. Si vous appeliez auparavant json.dumps() directement sur la sortie de to_dict() après cette version, un encodeur json personnalisé sera nécessaire pour gérer ces cas. Par exemple :

    import json

from qiskit.circuit import ParameterExpression
from qiskit import qobj

my_qasm = qobj.QasmQobj(
    qobj_id='12345',
    header=qobj.QobjHeader(),
    config=qobj.QasmQobjConfig(shots=1024, memory_slots=2,
                               max_credits=10),
    experiments=[
        qobj.QasmQobjExperiment(instructions=[
            qobj.QasmQobjInstruction(name='u1', qubits=[1],
                                     params=[0.4]),
            qobj.QasmQobjInstruction(name='u2', qubits=[1],
                                     params=[0.4, 0.2])
        ])
    ]
)
qasm_dict = my_qasm.to_dict()

class QobjEncoder(json.JSONEncoder):
    """A json encoder for pulse qobj"""
    def default(self, obj):
        # Convert numpy arrays:
        if hasattr(obj, 'tolist'):
            return obj.tolist()
        # Use Qobj complex json format:
        if isinstance(obj, complex):
            return (obj.real, obj.imag)
        if isinstance(obj, ParameterExpression):
            return float(obj)
        return json.JSONEncoder.default(self, obj)

json_str = json.dumps(qasm_dict, cls=QobjEncoder)

    générera une chaîne json de la même manière que json.dumps(my_qasm.to_dict()) l'a fait dans les versions précédentes.

  • CmdDef est obsolète depuis Terra 0.11.0 et a été supprimée. Veuillez continuer à utiliser InstructionScheduleMap au lieu de

  • Les méthodes cmds et cmd_qubits dans InstructionScheduleMap sont obsolètes depuis Terra 0.11.0 et ont été supprimées. Veuillez utiliser instructions et qubits_with_instruction à la place.

  • PulseDefaults ont rapporté qubit_freq_est et meas_freq_est en Hz plutôt qu'en GHz depuis le lancement de Terra 0.11.0. L'avertissement qui notifiait ce changement a été supprimé.

  • Le support précédemment déprécié (dans la version 0.11.0 ) pour le passage dans les paramètres de types,, (nœud AST QASM) et a été supprimé qiskit.circuit.Instruction de types sympy.Basic, sympy.Expr, qiskit.qasm.node.node.Node (nœud AST QASM) et sympy.Matrix a été supprimée. Les types de paramètres d'instruction pris en charge sont les suivants :

  • Les propriétés suivantes de BackendConfiguration:

    • dt
    • dtm
    • rep_time

    ont toutes des unités de secondes. Avant la publication de 0.11.0, dt et dtm , les unités étaient des nanosecondes. Avant la publication de 0.12.0, rep_time avait des unités de microsecondes. Les avertissements prévenant les utilisateurs de ces changements ont été retirés du site BackendConfiguration.

  • Une nouvelle exigence a été ajoutée à la liste des exigences, retworkx. Il s'agit d'une bibliothèque de graphes sous licence Apache 2.0 dont l'API est similaire à celle de networkx et qui est utilisée pour accélérer considérablement les opérations dans le cadre du transpileur qiskit.dagcircuit.DAGCircuit dans le cadre du transpileur. Il existe des binaires publiés sur PyPI pour toutes les plateformes supportées par Qiskit Terra mais si vous utilisez une plateforme où il n'y a pas de binaires précompilés publiés, référez-vous à la documentation de retworkx pour des instructions sur l'installation par pip à partir de sdist.

    Si vous rencontrez des problèmes avec le transpiler ou la classe DAGCircuit dans le cadre de la transition, vous pouvez revenir à l'ancienne implémentation de networkx en définissant la variable d'environnement USE_RETWORKX sur N. Cette option sera supprimée dans la version 0.14.0.

Remarques concernant la dépréciation

  • Le fait de passer les données au constructeur de qiskit.dagcircuit.DAGNode sous la forme d'un dictionnaire arg data_dict est obsolète et sera supprimé dans une prochaine version. Au lieu de cela, vous devez maintenant passer les champs en tant que kwargs au constructeur. Par exemple, le comportement précédent de :

    from qiskit.dagcircuit import DAGNode

data_dict = {
    'type': 'in',
    'name': 'q_0',
}
node = DAGNode(data_dict)

    devrait maintenant être :

    from qiskit.dagcircuit import DAGNode

node = DAGNode(type='in', name='q_0')

  • La dénomination des objets et des méthodes du portail a été mise à jour pour être plus cohérente. Les modifications suivantes ont été apportées :

    • Les portes de Pauli ont toutes une seule lettre majuscule (I, X, Y, Z)
    • Les portes de Pauli paramétrées (c'est-à-dire les rotations) sont précédées de la lettre majuscule R (RX, RY, RZ)
    • Une version contrôlée précède la lettre majuscule C (CX, CRX, CCX)
    • Les portes sont nommées en fonction de leur action, et non de leurs noms alternatifs (CCX, et non Toffoli)

    Les anciens noms sont obsolètes et seront supprimés dans une prochaine version. Voici une liste des modifications indiquant l'ancienne et la nouvelle classe, l'attribut du nom et les méthodes. Si une nouvelle colonne est vide, il n'y a pas de changement.

    Ancienne classe
    Nouvelle classe
    Attribut de l'ancien nom
    Nouvel attribut de nom
    Ancienne qiskit.circuit.QuantumCircuit méthode
    Nouvelle qiskit.circuit.QuantumCircuit méthode
    ToffoliGateCCXGateccxccx() et toffoli()
    CrxGateCRXGatecrxcrx()
    CryGateCRYGatecrycry()
    CrzGateCRZGatecrzcrz()
    FredkinGateCSwapGatecswapcswap() et fredkin()
    Cu1GateCU1Gatecu1cu1()
    Cu3GateCU3Gatecu3cu3()
    CnotGateCXGatecxcx() et cnot()
    CyGateCYGatecycy()
    CzGateCZGateczcz()
    DiagGateDiagonalGatediagdiagonaldiag_gatediagonal()
    IdGateIGateidideni() et id()
    Isometryisoisometryiso()isometry() et iso()
    UCGUCGatemultiplexerucguc()
    UCRotUCPauliRotGate
    UCXUCRXGateucrotXucrxucxucrx()
    UCYUCRYGateucrotyucryucyucry()
    UCZUCRZGateucrotzucrzuczucrz()

  • Le kwarg period pour la fonction square(), sawtooth(), et triangle() dans qiskit.pulse.pulse_lib est maintenant déprécié et sera supprimé dans une prochaine version. Au lieu de cela, vous devez maintenant utiliser freq kwarg pour régler la fréquence.

  • Les méthodes DAGCircuit.compose_back() et DAGCircuit.extend_back() sont obsolètes et seront supprimées dans une prochaine version. Vous devez plutôt utiliser la méthode qiskit.dagcircuit.DAGCircuit.compose() qui est une méthode plus générale et plus souple offrant les mêmes fonctionnalités.

  • Le kwarg callback du constructeur de la classe qiskit.transpiler.PassManager a été déprécié et sera supprimé dans une prochaine version. Au lieu de le définir au niveau de l'objet lors de la création, il doit maintenant être défini en tant que paramètre kwarg dans la méthode qiskit.transpiler.PassManager.run() méthode.

  • Les mots-clés n_qubits et numberofqubits sont obsolètes dans Terra et remplacés par num_qubits. Les anciens noms seront supprimés dans une prochaine version. Les objets concernés par cette modification sont énumérés ci-dessous :

    Classe
    Ancienne méthode
    Nouvelle méthode
    QuantumCircuitn_qubitsnum_qubits()
    Paulinumberofqubitsnum_qubits()
    Fonction
    Vieil argument
    Nouvel argument
    random_circuit()n_qubitsnum_qubits
    MSGaten_qubitnum_qubits

  • La fonction qiskit.quantum_info.synthesis.euler_angles_1q est désormais obsolète. Elle a été remplacée par la classe qiskit.quantum_info.OneQubitEulerDecomposer qui offre la même fonctionnalité :

    OneQubitEulerDecomposer().angles(mat)

  • Le kwarg pass_manager pour le qiskit.compiler.transpile() a été déprécié et sera supprimé dans une prochaine version. Par la suite, la meilleure façon de transpiler un circuit avec un objet personnalisé est d'utiliser l'objet personnalisé PassManager est d'utiliser la méthode run() de l'objet PassManager .

  • La fonction qiskit.quantum_info.random_state() est obsolète et sera supprimée dans une prochaine version. Au lieu de cela, vous devez utiliser la fonction qiskit.quantum_info.random_statevector() fonction.

  • Les méthodes add, subtract, et multiply de l'application qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix sont obsolètes et seront supprimées dans une prochaine version. Vous devriez plutôt utiliser les opérateurs binaires +, -, * .

  • Supprime qiskit.quantum_info.Statevector.to_counts(), qiskit.quantum_info.DensityMatrix.to_counts(), et qiskit.quantum_info.counts.state_to_counts(). Ces fonctions sont remplacées par les méthodes de la classe qiskit.quantum_info.Statevector.probabilities_dict() et qiskit.quantum_info.DensityMatrix.probabilities_dict().

  • SamplePulse et ParametricPulse s (par exemple Gaussian) sont maintenant des sous-classes de Pulse et ont été déplacées vers qiskit.pulse.pulse_lib. Le chemin précédent via pulse.commands est déprécié et sera supprimé dans une prochaine version.

  • DelayInstruction a été déprécié et remplacé par Delay. Cette nouvelle instruction a été reprise de la précédente Command Delay. Le modèle de migration est le suivant :

    Delay(<duration>)(<channel>) -> Delay(<duration>, <channel>)
DelayInstruction(Delay(<duration>), <channel>)
    -> Delay(<duration>, <channel>)

    Jusqu'à la fin de la période de dépréciation, l'ancienne syntaxe Delay d'appel d'une commande sur un canal sera également prise en charge :

    Delay(<phase>)(<channel>)

    La nouvelle instruction Delay ne prend pas en charge l'attribut command .

  • FrameChange et FrameChangeInstruction ont été dépréciés et remplacés par ShiftPhase. Les changements sont les suivants :

    FrameChange(<phase>)(<channel>) -> ShiftPhase(<phase>, <channel>)
FrameChangeInstruction(FrameChange(<phase>), <channel>)
    -> ShiftPhase(<phase>, <channel>)

    Jusqu'à la fin de la période de dépréciation, l'ancienne syntaxe FrameChange pour l'appel d'une commande sur un canal sera prise en charge :

    ShiftPhase(<phase>)(<channel>)

  • La méthode call de SamplePulse et ParametricPulse a été supprimée. La migration se déroule comme suit :

    Pulse(<*args>)(<channel>) -> Play(Pulse(*args), <channel>)

  • AcquireInstruction a été supprimée et remplacée par Acquire. Les changements sont les suivants :

    Acquire(<duration>)(<**channels>) -> Acquire(<duration>, <**channels>)
AcquireInstruction(Acquire(<duration>), <**channels>)
    -> Acquire(<duration>, <**channels>)

    Jusqu'à la fin de la période de dépréciation, l'ancienne syntaxe Acquire, qui consiste à appeler la commande sur un canal, sera prise en charge :

    Acquire(<duration>)(<**channels>)

Corrections des erreurs

  • La passe de transpiler BarrierBeforeFinalMeasurements inclus dans les niveaux de transpilation prédéfinis lors du ciblage d'un dispositif physique, insérait auparavant une barrière sur les seuls qubits mesurés. Dans certains cas, cela a permis au transpondeur d'insérer un échange après une opération de mesure, ce qui a rendu le circuit invalide pour les appareils actuels. La passe a été mise à jour pour que la barrière insérée couvre tous les qubits de l'appareil. Corrige #3937

  • Lors de l'extension d'une instance QuantumCircuit (extension) avec un autre circuit (extension), le circuit est pris en référence. Si un circuit est prolongé par lui-même, cela conduit à une boucle infinie, car le destinataire et l'extension sont identiques. Ce problème a été résolu en copiant l'extension s'il s'agit du même objet que le bénéficiaire de l'extension. Corrige #3811

  • Correction d'un cas dans qiskit.result.Result.get_counts()où les résultats d'une expérience ne pouvaient pas être référencés si l'expérience était initialisée en tant que Schedule sans nom. Corrige #2753

  • Auparavant, le remplacement des objets Parameter dans un circuit par de nouveaux objets Parameter avant de décomposer un circuit, les valeurs substituées n'étaient pas correctement substituées dans les portes décomposées. Ce problème a été résolu de manière à ce que la liaison et la décomposition puissent se produire dans n'importe quel ordre.

  • Le backend de sortie matplotlib pour la fonction qiskit.visualization.circuit_drawer() fonction et qiskit.circuit.QuantumCircuit.draw() a été corrigé pour rendre correctement CU1Gate gates. Corrige #3684

  • Un bogue dans qiskit.circuit.QuantumCircuit.from_qasm_str() et qiskit.circuit.QuantumCircuit.from_qasm_file() lors du chargement de QASM avec des portes personnalisées a été corrigé. Chargement de ce QASM :

    OPENQASM 2.0;
include "qelib1.inc";
gate rinv q {sdg q; h q; sdg q; h q; }
qreg q[1];
rinv q[0];

    est équivalent au circuit suivant :

    rinv_q = QuantumRegister(1, name='q')
rinv_gate = QuantumCircuit(rinv_q, name='rinv')
rinv_gate.sdg(rinv_q)
rinv_gate.h(rinv_q)
rinv_gate.sdg(rinv_q)
rinv_gate.h(rinv_q)
rinv = rinv_gate.to_instruction()
qr = QuantumRegister(1, name='q')
expected = QuantumCircuit(qr, name='circuit')
expected.append(rinv, [qr[0]])

    Corrige #1566

  • Permettre aux instructions de circuits quantiques d'avoir des valeurs de paramètres de liste. Ce paramètre est utilisé dans Aer for expectation value snapshot parameters (paramètres d'instantané de la valeur d'attente), par exemple params = [[1.0, 'I'], [1.0, 'X']]] pour ⟨I+X⟩\langle I + X\rangle.

  • Auparavant, pour les circuits contenant des portes composites (celles créées par l'intermédiaire de qiskit.circuit.QuantumCircuit.to_gate() ou qiskit.circuit.QuantumCircuit.to_instruction() ou leurs convertisseurs correspondants), la tentative de lier le circuit plus d'une fois avait pour conséquence que seule la première valeur de liaison était appliquée à tous les circuits lors de la transposition. Ce problème a été résolu de manière à ce que les valeurs fournies pour les liaisons suivantes soient correctement respectées.

Autres remarques

Aer 0.5.0

Ajouté

  • Ajout d'un support pour la porte diagonale terra
  • Ajout de la prise en charge des qobj paramétrés

Fixe

  • Ajout de postfix pour linux sur Raspberry Pi
  • Gérer les entrées de tableaux numpy à partir de qobj

Ignis 0.3.0

Ajouté

  • documentation d'API
  • CNOT-Dihedral randomized benchmarking (analyse comparative aléatoire)
  • Module d'accréditation pour l'accréditation de sortie des appareils bruyants
  • Calibrations d'impulsions pour les qubits uniques
  • Discriminateur d'impulsions
  • Circuits de vérification de l'intrication
  • Tomographie des portes pour les ensembles de portes à un seul qubit
  • Ajout de fonctions utilitaires d'évaluation aléatoire calculate_1q_epg, calculate_2q_epg pour calculer l'erreur de 1 et 2 qubits par porte à partir de l'erreur par Clifford
  • Ajout de fonctions utilitaires d'évaluation aléatoire calculate_1q_epc, calculate_2q_epc pour calculer l'erreur de 1 et 2 qubits par Clifford à partir de l'erreur par porte

Changé

  • Prise en charge des étiquettes entières pour les qubits en tomographie
  • Prise en charge des étiquettes entières pour l'atténuation des erreurs de mesure

Obsolète

  • La fonction twoQ_clifford_error est obsolète. Utilisez plutôt calculate_2q_epc .
  • Python 3.5 dans qiskit-ignis est obsolète. Le support sera supprimé à la date de fin de vie de la version de la communauté python en amont, qui est le 13/09/2020.

Aqua 0.6.5

Aucun changement

IBM 0.6.0 du fournisseur Q

Aucun changement

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