Notes de publication de Qiskit 0.34

0.34.2

Terra 0.19.2

Prélude

Qiskit Terra 0.19.2 est principalement une version de correction de bogues, mais est aussi maintenant livré avec des roues construites pour Python 3.10 sur toutes les plateformes majeures.

Nouvelles fonctions

Ajout de la prise en charge de l'exécution avec Python 3.10. Il s'agit notamment de publier des binaires précompilés à l'adresse PyPI pour Python 3.10 sur les plates-formes prises en charge.

Mise à niveau

A partir de Python 3.10, Qiskit Terra aura un support réduit pour les plateformes 32-bit. Il s'agit de Linux i686 et de Windows 32 bits. Ces plateformes avec Python 3.10 sont maintenant au niveau 3 au lieu du niveau 2 (selon les niveaux définis dans : https://qiskit.org/documentation/getting_started.html #platform-support) C'est parce que les dépendances en amont Numpy et Scipy ont abandonné le support pour eux. Qiskit publiera toujours des binaires précompilés pour ces plateformes, mais nous ne sommes pas en mesure de tester les paquets avant de les publier, et vous aurez besoin d'un compilateur C/C++ pour que pip puisse construire leurs dépendances à partir des sources. Si vous utilisez l'une de ces plateformes, nous vous recommandons d'utiliser Python 3.7, 3.8, ou 3.9.

Corrections des erreurs

Correction d'un bogue où la fonction CVaRMeasurement tentait de convertir une PauliSumOp en une matrice dense pour vérifier si elle était diagonale. Pour les grands opérateurs (> 16 qubits), ce calcul était extrêmement coûteux et soulevait une erreur s'il n'était pas explicitement activé à l'aide de qiskit.utils.algorithm_globals.massive = True. La vérification est désormais efficace, même pour un grand nombre de qubits.
DAGCircuit.draw() et la fonction associée dag_drawer() affiche désormais un message d'erreur plus utile lorsque le nom de fichier fourni n'est pas valide.
QuantumCircuit.add_register() n'entraînera plus de doubles références AncillaQubit dans un circuit lorsqu'on lui donne un numéro d'identification AncillaRegister dont les bits sont déjà présents.
Conversion fixe de QuantumCircuitavec des conditions classiques sur des Clbit en Instructionlors de l'utilisation de la fonction circuit_to_instruction() ou la méthode QuantumCircuit.to_instruction() méthode. Par exemple, le texte suivant fonctionnera désormais :
```
from qiskit.circuit import QuantumCircuit, Qubit, Clbit

qc = QuantumCircuit([Qubit(), Clbit()])
qc.h(0).c_if(qc.clbits[0], 0)
qc.to_instruction()
```
Les registres rejetteront désormais correctement les bits en double. Correction #7446.
Le backend fictif FakeOpenPulse2Q dispose désormais de T2 et d'erreurs de lecture pour ses qubits. Il s'agit de valeurs arbitraires, correspondant approximativement à des backends réels au moment de sa création.

Fixer l'ordre des qubits des évolutions de 2 qubits dans la formule de synthèse PauliEvolutionGatesi elle est utilisée avec une formule de synthèse de produit. Par exemple, auparavant, l'évolution des IIZ + IZI + IZZ

from qiskit.circuit.library import PauliEvolutionGate
from qiskit.opflow import I, Z
operator = (I ^ I ^ Z) + (I ^ Z ^ I) + (I ^ Z ^ Z)
print(PauliEvolutionGate(operator).definition.decompose())

Produit

     ┌───────┐
q_0: ┤ Rz(2) ├────────
     ├───────┤
q_1: ┤ Rz(2) ├─■──────
     └───────┘ │ZZ(2)
q_2: ──────────■──────

alors qu'il donne maintenant correctement

     ┌───────┐
q_0: ┤ Rz(2) ├─■──────
     ├───────┤ │ZZ(2)
q_1: ┤ Rz(2) ├─■──────
     └───────┘
q_2: ─────────────────

Correction d'un problème dans les tiroirs de circuit latex et mpl lorsque les noms de registre comportant plusieurs traits de soulignement ne s'affichaient pas correctement.
Les nombres négatifs dans les sorties de tableaux des tiroirs apparaîtront désormais comme des nombres décimaux au lieu de fractions avec des numérateurs et des dénominateurs importants. Comme les nombres positifs, il s'agit toujours de fractions si le rapport est entre de petits nombres.
Correction d'un problème avec la méthode Target.get_non_global_operation_names() lorsqu'elle est exécutée sur une cible et qu'elle soulève incorrectement une exception sur les cibles avec des opérations globales idéales. Auparavant, si cette méthode était appelée sur une cible contenant des opérations idéales définies globalement, où les propriétés de l'instruction sont fixées à None, cette méthode soulevait une exception au lieu de traiter cette instruction comme globale.
Correction d'un problème avec la fonction transpile() qui pouvait échouer lorsqu'on lui passait un objet Target directement avec le kwarg target .
Correction d'un problème avec la fonction transpile() qui pouvait échouer lorsque l'argument backend était un BackendV2 ou un Target via le kwarg target qui contenait des opérations idéales définies globalement.
Correction d'un problème où le traçage de sphères de Bloch pouvait provoquer l'affichage de AttributeError dans Jupyter ou en essayant de réduire la taille des figures avec Matplotlib 3.3 ou 3.4 (mais pas 3.5 ). Par exemple, le code suivant se planterait auparavant avec un message :
```
AttributeError: 'Arrow3D' object has no attribute '_path2d'
```
mais il fonctionnera désormais avec toutes les versions actuelles de Matplotlib :
```
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector([0, 1, 0]).savefig("tmp.png", bbox_inches='tight')
```
Correction d'un bug dans PauliSumOp.permute() où l'objet sur lequel la méthode est appelée était permuté sur place, au lieu de renvoyer une copie permutée. Ce bogue ne s'est produit que pour les permutations qui ont laissé le nombre de qubits dans l'opérateur inchangé.
Correction de la méthode PauliEvolutionGate.inverse() , qui calculait auparavant l'inverse en inversant le temps d'évolution. L'inverse n'est correct que si l'opérateur évolue exactement. En particulier, cela a conduit à ce que l'inverse des évolutions temporelles basées sur la trotterisation soit incorrect.
La méthode QuantumInstance.execute() ne mutera plus son entrée si elle reçoit une liste de circuits.

Correction de la sérialisation QPY des instructions personnalisées qui avaient une définition explicite de no-op. Auparavant, ces portes étaient écrites et lues de la même manière que s'il s'agissait de portes opaques (sans définition). Ils feront désormais correctement l'aller-retour avec une définition vide. Par exemple, le texte suivant sera désormais correct :

import io
from qiskit.circuit import Instruction, QuantumCircuit, qpy_serialization

# This instruction is explicitly defined as a one-qubit gate with no
# operations.
empty = QuantumCircuit(1, name="empty").to_instruction()
# This instruction will perform some operations that are only known
# by the hardware backend.
opaque = Instruction("opaque", 1, 0, [])

circuit = QuantumCircuit(2)
circuit.append(empty, [0], [])
circuit.append(opaque, [1], [])

qpy_file = io.BytesIO()
qpy_serialization.dump(circuit, qpy_file)
qpy_file.seek(0)
new_circuit = qpy_serialization.load(qpy_file)[0]

# Previously both instructions in `new_circuit` would now be opaque, but
# there is now a correct distinction.
circuit == new_circuit

Ajout d'un attribut BackendV2.provider aux implémentations de la classe BackendV2 classe abstraite. Auparavant, BackendV2 pouvaient être initialisés avec un fournisseur, mais celui-ci n'était pas accessible aux utilisateurs.
Correction de la prise en charge de la classe QuantumInstance lorsqu'elle est exécutée avec un backend BackendV2 backend. Auparavant, les tentatives d'utilisation d'un QuantumInstance avec un BackendV2 aurait entraîné une erreur.
Correction d'un bug dans VQE où les paramètres de l'ansatz étaient toujours explicitement triés par leur nom en ASCII si l'ansatz était redimensionné. Cela a entraîné un désordre dans l'ordre des valeurs optimisées dans l'attribut optimal_point de l'objet de résultat.

En particulier, ce bogue se produisait si aucun ansatz n'était défini par l'utilisateur et que le VQE choisissait une valeur par défaut avec 11 paramètres libres ou plus.
Arrêt de l'analyseur dans QuantumCircuit.from_qasm_str() et from_qasm_file() d'accepter les programmes OpenQASM qui s'identifiaient comme provenant d'une version linguistique autre que 2.0. Cet analyseur ne concerne que OpenQASM 2.0; la prise en charge des circuits importés de OpenQASM 3.0 sera ajoutée dans une prochaine version.
Correction de la sérialisation QPY des objets QuantumCircuit contenant des instructions de flux de contrôle. Auparavant, si l'on tentait de sérialiser un circuit contenant IfElseOp, WhileLoopOpou ForLoopOp la sérialisation échouait. Correction #7583.
Correction de la sérialisation QPY de QuantumCircuit contenant des sous-ensembles de bits d'un QuantumRegister ou ClassicalRegister. Auparavant, si l'on essayait de sérialiser un circuit comme celui-ci, ces bits étaient traités de manière incorrecte comme des bits autonomes Qubit ou Clbit sans avoir de registre défini. Par exemple, si vous essayez de sérialiser un circuit comme :
```
import io
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.qpy_serialization import load, dump

qr = QuantumRegister(2)
qc = QuantumCircuit([qr[0]])
qc.x(0)
with open('file.qpy', 'wb') as fd:
    dump(qc, fd)
```
lorsque ce circuit est chargé, les registres seront correctement remplis, même si le circuit ne contient qu'un sous-ensemble des bits du registre.
QFT sera désormais averti s'il est instancié ou construit avec des paramètres qui lui feront perdre de la précision, plutôt que de soulever un OverflowError. Cela peut se produire si le nombre de qubits est très élevé (un peu plus de 1000) sans que le degré d'approximation soit aussi élevé. Le circuit sera maintenant construit avec succès, mais certains angles peuvent être impossibles à distinguer de zéro, en raison des limitations des nombres à virgule flottante en double précision.

Aer 0.10.3

Prélude

Qiskit Aer 0.10.3 est principalement une version de correction de bogues, corrigeant plusieurs bogues qui ont été découverts depuis la version 0.10.2. Cependant, cette version introduit également la possibilité de fonctionner avec Python 3.10, y compris les roues binaires précompilées sur toutes les plateformes majeures. Cette version comprend également des roues binaires précompilées pour arm64 sur macOS.

Nouvelles fonctions

Ajout de la prise en charge de l'exécution avec Python 3.10. Il s'agit notamment de publier des binaires précompilés à l'adresse PyPI pour Python 3.10 sur les plates-formes prises en charge.
Ajout de la prise en charge des systèmes M1 macOS. Les binaires précompilés pour les versions supportées de Python >= 3.8 sur arm64 macOS seront désormais publiés sur PyPI pour cette version et les versions futures.

Mise à niveau

Qiskit Aer ne prend plus totalement en charge les plates-formes 32 bits sur Python >= 3.10. Il s'agit de Linux i686 et de Windows 32 bits. Ces plateformes avec Python 3.10 sont maintenant au niveau 3 au lieu du niveau 2 (selon les niveaux définis dans : https://qiskit.org/documentation/getting_started.html #platform-support) C'est parce que les dépendances en amont Numpy et Scipy ont abandonné le support pour eux. Qiskit publiera toujours des binaires précompilés pour ces plateformes, mais nous ne sommes pas en mesure de tester les paquets avant de les publier, et vous aurez besoin d'un compilateur C/C++ pour que pip puisse construire leurs dépendances à partir des sources. Si vous utilisez l'une de ces plateformes, nous vous recommandons d'utiliser Python 3.7, 3.8, ou 3.9.

Corrections des erreurs

Correction d'un bogue dans RelaxationNoisePass où les durées d'instruction étaient toujours supposées être en unités de temps dt, indépendamment de l'unité réelle de l'isntruction. La conversion des unités est désormais correctement gérée pour toutes les unités de durée d'instruction.

Voir #1453 pour plus de détails.
Correction d'un problème avec LocalNoisePass pour les fonctions de bruit qui renvoient un QuantumCircuit pour le bruit op. Elles ont été ajoutées au DAG sous la forme d'une instruction de circuit opaque qui doit être déroulée pour être simulée. Cette correction les compose de manière à ce que les instructions de circuit soient ajoutées au nouveau DAG et puissent être simulées sans déroulement supplémentaire si toutes les instructions de circuit sont prises en charge par le simulateur.

Voir #1447 pour plus de détails.
Les transpilations multi-threads pour générer des portes diagonales fonctionneront désormais correctement si le nombre de portes d'un circuit dépasse fusion_parallelization_threshold. Auparavant, différents threads fusionnaient parfois le même élément en plusieurs blocs, ce qui entraînait des résultats incorrects.
Correction d'un bogue concernant la troncature des circuits dans les Qobjs paramétrés. Auparavant, les paramètres des QObj paramétrés pouvaient être mal résolus si les qubits non utilisés de leurs circuits étaient tronqués, car les indices des paramètres n'étaient pas mis à jour après la suppression des instructions sur les qubits non mesurés.

Voir #1427 pour plus de détails.

Ignis 0.7.0

Pas de modification

IBM 0.18.3 du fournisseur Q

Pas de modification

0.34.1

Terra 0.19.1

Pas de modification

Aer 0.10.2

Corrections des erreurs

Correction de la simulation des boucles for lorsque le paramètre de boucle n'était pas utilisé dans le corps de la boucle. Par exemple, ce code, qui échouait auparavant, réussira désormais :

import qiskit
from qiskit.providers.aer import AerSimulator

qc = qiskit.QuantumCircuit(2)
with qc.for_loop(range(4)) as i:
    qc.h(0)
    qc.cx(0, 1)

AerSimulator(method="statevector").run(qc)

Corrige un bogue dans QuantumError.to_dict() où les instructions de circuit à N qubits où l'instruction assemblée s'appliquait toujours aux qubits [0, ..., N-1] plutôt qu'aux qubits de l'instruction. Ce bogue affecte également les modèles de bruit de l'appareil et du faux backend.

Voir le numéro 1415 pour plus de détails.

Ignis 0.7.0

Pas de modification

IBM 0.18.3 du fournisseur Q

Pas de modification

0.34.0

Qiskit 0.34.0 inclut une version ponctuelle de Qiskit Aer : version 0.10.1, qui corrige les régressions de performance de la version 0.10.0 qui ont été découvertes immédiatement après la sortie de la version. Voir ci-dessous les notes de mise à jour de Qiskit Aer 0.10.0 et 0.10.1.

Terra 0.19.1

Pas de modification

Aer 0.10.1

Prélude

Le patch Qiskit Aer 0.10.1 corrige les régressions de performance introduites dans Qiskit Aer 0.10.0.

Corrections des erreurs

Correction d'une régression des performances dans les simulations bruyantes due à une forte augmentation de la surcharge de sérialisation pour le chargement des modèles de bruit de Python en C++, résultant d'appels multiprocessus imbriqués non intentionnels à Python. Voir le numéro 1407 pour plus de détails.

Aer 0.10.0

Prélude

La version de Qiskit Aer 0.10 comprend plusieurs améliorations des performances et du modèle de bruit. En voici quelques exemples :

Amélioration des performances pour les simulations parallèles sur GPU et HPC
Prise en charge de la simulation de circuits contenant des instructions de flux de contrôle QASM 3.0
Prise en charge du bruit de relaxation sur les circuits programmés dans les modèles de bruit de fond
Prise en charge des passes de transposition créées par l'utilisateur pour définir des erreurs de porte et des modèles de bruit personnalisés, et les insérer dans les circuits.

Nouvelles fonctions

Ajout de la prise en charge des instructions de flux de contrôle QASM 3.0 introduites dans Qiskit-Terra 0.19.0. Les instructions prises en charge sont ForLoopOp, WhileLoopOp, ContinueLoopOp, BreakLoopOp, IfElseOp.
Ajout d'une optimisation de la simulation par lots pour les simulations GPU. Cette fonction optionnelle utilise la mémoire disponible sur un ou plusieurs GPU pour exécuter plusieurs plans de simulation en parallèle, ce qui permet d'améliorer considérablement les performances des simulations à plusieurs plans avec des modèles de bruit et/ou des mesures intermédiaires.

Cette option est activée par défaut lors de l'utilisation de device="GPU" et d'une simulation method de "statevector" ou "density_matrix" avec AerSimulator. Il peut être désactivé en définissant batched_shots_gpu=False dans les options du simulateur.

Cette optimisation est particulièrement bénéfique pour les nombres de qubits faibles à moyens, lorsque la mémoire du GPU est suffisante pour exécuter plusieurs simulations en parallèle. Le nombre maximum de qubits actifs du circuit pour activer cette optimisation peut être configuré en utilisant l'option du simulateur batch_shots_gpu_max_qubits . La valeur par défaut de cette option est 16.
Ajout de la nouvelle option max_shot_size à un exécuteur personnalisé pour exécuter en parallèle plusieurs prises de vue d'un circuit bruyant.

Par exemple, la configuration de max_shot_size avec un exécuteur personnalisé :
```
backend = AerSimulator(
   max_shot_size=1, max_job_size=1, executor=custom_executor)
job = backend.run(circuits)
```
divise les prises de vue d'un circuit bruyant en plusieurs circuits. Une fois que tous les plans individuels ont été exécutés, les résultats du travail sont automatiquement combinés en un seul objet qui est renvoyé par Result qui est renvoyé par job.result().
Ajout de l'option du simulateur mps_swap_direction qui permet à l'utilisateur de déterminer la direction des échanges internes, lorsqu'ils sont insérés pour une porte à 2 qubits. Les valeurs possibles sont "mps_swap_right" et "mps_swap_left". Le sens des permutations peut affecter les performances, en fonction du circuit.
Mise en œuvre d'une nouvelle optimisation de l'échantillonnage des mesures pour la méthode de simulation "matrix_product_state" du site AerSimulator. Actuellement, cet algorithme n'est utilisé que lorsque tous les qubits sont mesurés et que l'option simulateur mps_sample_measure_algorithm est réglée sur "mps_probabilities".
Amélioration de la performance de l'instruction de mesure pour la méthode de simulation "matrix_product_state" du AerSimulator.
Ajout d'une instruction SaveClifford permettant d'enregistrer l'état de la méthode de simulation des stabilisateurs sous forme d'objet Clifford objet.

Notez que cette instruction est essentiellement équivalente à l'instruction SaveStabilizer , mais cette dernière renvoie l'état sauvegardé sous la forme d'un objet StabilizerState au lieu d'un objet Clifford au lieu d'un objet.
Ajout de deux passes de transpilation pour l'insertion d'erreurs quantiques dépendantes des instructions dans les circuits :
- qiskit.providers.aer.noise.LocalNoisePass
- qiskit.providers.aer.noise.RelaxationNoisePass
La passe LocalNoisePass peut être utilisée pour mettre en œuvre des modèles de bruit paramétrés personnalisés en définissant une fonction génératrice de bruit de la forme
```
def fn(
    inst: Instruction,
    qubits: Optional[List[int]] = None,
) -> InstructionLike
```
qui renvoie une instruction de bruit (par exemple, une instruction QuantumError ou autre) qui peut dépendre de n'importe quelle propriété ou paramètre de l'instruction et des arguments qubit.

Cette fonction peut être appliquée à toutes les instructions d'un circuit ou à un sous-ensemble spécifique (voir la documentation de LocalNoisePass pour plus de détails)

Le RelaxationNoisePass est un cas particulier du LocalNoisePass utilisant une fonction de bruit prédéfinie qui renvoie un produit tensoriel de thermal_relaxation_error() sur chaque qubit dans une instruction, dépendant de la durée de l'instruction et des paramètres de constante de temps de relaxation fournis pour la passe.
Le modèle de base du bruit du dispositif mis en œuvre par NoiseModel.from_backend() et AerSimulator.from_backend() a été amélioré pour permettre l'ajout d'erreurs de relaxation dépendant de la durée sur les portes de retard du circuit à l'aide de RelaxationNoisePass.

Pour activer ce bruit lors de simulations bruyantes, vous devez d'abord programmer votre circuit pour qu'il insère des instructions de retard programmé de la manière suivante :
```
backend = AerSimulator.from_backend(ibmq_backend)
scheduled_circuit = qiskit.transpile(
    circuit, backend=backend, scheduling_method='asap')
result = backend.run(scheduled_circuit).result()
```
Si le circuit est transpilé sans être programmé (et ne contient pas non plus d'instructions de retard), la simulation bruyante n'inclura pas l'effet des erreurs de relaxation de retard. Dans ce cas, la simulation sera équivalente à la simulation précédente de qiskit-aer 0.9 où le bruit de relaxation est uniquement ajouté aux instructions de porte en fonction de leur durée, telle qu'elle est obtenue à partir des propriétés de l'arrière-plan.

Le constructeur de QuantumError accepte désormais plusieurs nouveaux types d'entrées en tant qu'argument de noise_ops , par exemple :

import numpy as np

from qiskit import QuantumCircuit
from qiskit.circuit.library import IGate, XGate, Reset
from qiskit.quantum_info import Kraus
from qiskit.providers.aer.noise import QuantumError

# Quantum channels
kraus = Kraus([
    np.array([[1, 0], [0, np.sqrt(1 - 0.9)]], dtype=complex),
    np.array([[0, 0], [0, np.sqrt(0.9)]], dtype=complex)
])
print(QuantumError(kraus))

# Construction from a QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
error = QuantumError(qc)

# Construction from a tuple of (Instruction, List[int]), where the list of
# integers represents the qubits.
error = QuantumError((Reset(), [0]))

# Construction from an iterable of objects in the same form as above, but
# where each also has an associated probability.
error = QuantumError([
    ((IGate(), [0]), 0.9),
    ((XGate(), [0]), 0.1),
])

# A short-hand for the iterable form above, where the qubits are implicit,
# and each instruction is over all qubits.
error = QuantumError([(IGate(), 0.9), (XGate(), 0.1)])

Notez que le format d'entrée original basé sur JSON est obsolète.

Ajout d'une fonction utilitaire qiskit.providers.aer.utils.transform_noise_model() pour construire un modèle de bruit en appliquant une fonction fournie à tous les QuantumErrors du modèle de bruit.
Ajout de deux fonctions utilitaires qiskit.providers.aer.utils.transpile_quantum_error() et qiskit.providers.aer.utils.transpile_noise_model() pour transposer les circuits contenus dans QuantumError, et toutes les erreurs dans NoiseModel.
Ajout de la possibilité d'ajouter des objets QuantumError directement à un fichier QuantumCircuit sans la convertir en instruction Kraus instruction.

Les circuits contenant des erreurs quantiques peuvent désormais être exécutés sur les simulateurs AerSimulator et QasmSimulator en remplacement ou en complément de la construction d'un NoiseModel pour définir les instructions de circuits bruyants.

Exemple :
```
from qiskit import QuantumCircuit
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import pauli_error

error_h = pauli_error([('I', 0.95), ('X', 0.05)])
error_cx = pauli_error([('II', 0.9), ('XX', 0.1)])

qc = QuantumCircuit(3)
qc.h(0)
qc.append(error_h, [0])
qc.cx(0, 1)
qc.append(error_cx, [0, 1])
qc.cx(0, 2)
qc.append(error_cx, [0, 2])
qc.measure_all()

backend = AerSimulator(method='stabilizer')
result = backend.run(qc).result()
result.get_counts(0)
```
Les circuits contenant des erreurs quantiques peuvent également être évalués en utilisant le canal quantique quantum_info canal quantique et DensityMatrix classes.

Mise à niveau

Le type de retour de plusieurs instructions de sauvegarde a été modifié pour être les classes Qiskit Terra correspondantes plutôt que des tableaux ou des dictionnaires NumPy bruts. Les types qui ont changé sont les suivants
- save_statevector() est désormais retourné sous la forme d'un Statevector
- save_density_matrix() est désormais retourné sous la forme d'un DensityMatrix
- save_stabilizer() est désormais retourné sous la forme StabilizerState
- save_unitary() est désormais retourné sous la forme Operator
- save_superop() est désormais retourné sous la forme SuperOp
- save_probabilities_dict() est désormais retourné sous la forme d'un ProbDistribution
La valeur par défaut de standard_gates a été remplacée par None pour toutes les fonctions de qiskit.providers.aer.noise.errors.standard_errors , car ces fonctions ont été mises à jour de manière à utiliser des portes standard par défaut.
Lorsqu'un argument non pris en charge est fourni à approximate_quantum_error(), ce dernier lèvera désormais un NoiseError au lieu d'un RuntimeError.

Remarques concernant la dépréciation

L'utilisation des méthodes et attributs de NumPy ndarray sur le type de retour de save_statevector(), save_density_matrix(), save_unitary(), et save_superop() a été dépréciée et cessera de fonctionner dans une prochaine version. Ces instructions renvoient désormais des qiskit.quantum_info pour leurs types de retour. Une compatibilité rétrospective partielle avec le traitement de ces objets en tant que tableaux NumPy est mise en œuvre en transférant les méthodes vers le tableau interne pendant la période de dépréciation.
Le fait de passer un objet BackendProperties pour l'argument backend de NoiseModel.from_backend() a été déprécié, car il est incompatible avec les bruits de retard dépendant de la durée, et sera supprimé dans une prochaine version. Passez un objet Qiskit Terra BackendV1 à la place.
L'option number_of_qubits du constructeur de QuantumError a été abandonnée au profit d'une détermination automatique de la dimension.
Suppression de l'option standard_gates du constructeur QuantumError en faveur de l'externalisation de cette fonctionnalité de changement de base. Dans de nombreux cas, vous pouvez transformer n'importe quelle erreur en une erreur définie uniquement avec des portes spécifiques à l'aide de approximate_quantum_error().
Dépréciation de l'option standard_gates de toutes les fonctions de qiskit.providers.aer.noise.errors.standard_errors en faveur d'un retour des erreurs sous la forme d'un mélange de portes standard autant que possible par défaut.
Toutes les fonctions de errorutils ont été dépréciées parce qu'il s'agit de fonctions d'aide destinées à être utilisées uniquement pour mettre en œuvre des fonctions de qiskit.providers.aer.noise.errors.standard_errors et qu'elles auraient dû être fournies en tant que fonctions privées.
Déclassement de l'option standard_gates de NoiseModel.from_backend() en faveur de l'externalisation de cette fonctionnalité de changement de base.
Déclassé NoiseModel.from_dict() pour rendre le modèle de bruit indépendant du format Qobj (JSON).
Dépréciation de toutes les variables, fonctions et classes publiques de qiskit.providers.aer.noise.utils.noise_transformation , à l'exception de approximate_quantum_error() et approximate_noise_model(), car il s'agit de fonctions d'aide destinées à être utilisées uniquement pour l'implémentation des fonctions de approximate_* et qui auraient dû être fournies en tant que fonctions privées.
Déclassé remap_noise_model() puisque le code C++ tronque et remappe automatiquement les modèles de bruit s'il tronque les circuits.

Autres remarques

Des changements dans la mise en œuvre de la fonction approximate_quantum_error() peuvent modifier l'erreur approximative résultante par rapport à Qiskit Aer 0.9.

Ignis 0.7.0

Pas de modification

IBM 0.18.3 du fournisseur Q

Corrections des erreurs

Correction fournie dans #1100 pour un problème avec l'encodage et le décodage JSON lors de l'utilisation de ParameterExpressions en conjonction avec Qiskit Terra 0.19.1 et plus. Auparavant, les instances Parameter reconstruites à partir de la sortie JSON avaient des identifiants uniques différents, ce qui les rendait inégales par rapport à l'entrée. Ils disposeront désormais des identités de soutien correctes.

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.