Tutoriel : Envoyer un programme QIR à l’estimateur de ressources Azure Quantum

  • Article

L’estimateur de ressources Azure Quantum est basé sur Quantum Intermediate Representation (QIR), une spécification entièrement interopérable pour les programmes quantiques. QIR sert d’interface commune entre les langages et frameworks de programmation quantique et targetles plateformes de calcul quantiques. Étant donné que l’estimateur de ressources prend un programme QIR comme entrée, il prend en charge n’importe quelle langue qui traduit en QIR. Par exemple, il peut être utilisé par des SDK quantiques populaires et des langages tels que Q# et Qiskit. Dans ce tutoriel, vous allez écrire et envoyer un programme QIR à l’estimateur de ressources. Ce tutoriel utilise PyQIR pour générer le QIR. Toutefois, vous pouvez utiliser n’importe quelle autre source de QIR.

Ce didacticiel vous montre comment effectuer les opérations suivantes :

  • Connectez-vous au service Azure Quantum.
  • Définir une fonction pour créer un travail d’estimation des ressources à partir du code de bits QIR
  • Créer un bitcode QIR à l’aide du générateur PyQIR
  • Envoyer un travail QIR à l’estimateur de ressources

Inscrivez-vous à un abonnement d’essai Azure gratuit pendant 30 jours.

Prérequis

Créer un notebook dans votre espace de travail

  1. Connectez-vous au Portail Azure et sélectionnez votre espace de travail Quantum Azure.
  2. Sous Opérations, sélectionnez Notebooks
  3. Cliquez sur Mes blocs-notes , puis cliquez sur Ajouter un nouveau.
  4. Dans Type de noyau, sélectionnez IPython.
  5. Tapez un nom pour le fichier, puis cliquez sur Créer un fichier.

Quand votre nouveau notebook s’ouvre, il crée automatiquement le code de la première cellule, en fonction de vos informations d’abonnement et d’espace de travail.

from azure.quantum import Workspace
workspace = Workspace ( 
    resource_id = "", # Your resource_id 
    location = ""  # Your workspace location (for example, "westus") 
)

Notes

Sauf indication contraire, vous devez exécuter chaque cellule dans l’ordre de création pour éviter les problèmes de compilation.

Cliquez sur l’icône triangulaire « lecture » à gauche de la cellule pour exécuter le code.

Charger les importations requises

Tout d’abord, vous devez importer certaines classes et fonctions Python à partir de azure.quantum, qiskitet pyqir. Vous n’utiliserez pas Qiskit pour créer des circuits quantiques directement, mais vous allez utiliser AzureQuantumJob, qui est basé sur l’écosystème Qiskit. Vérifiez que vous utilisez la dernière version de Qiskit. Pour plus d’informations, consultez Mettre à jour le package Python azure-quantum.

from azure.quantum.qiskit import AzureQuantumProvider
from azure.quantum.qiskit.job import AzureQuantumJob
from pyqir.generator import BasicQisBuilder, SimpleModule

Se connecter au service Azure Quantum

Ensuite, créez un objet à l’aide AzureQuantumProvider de l’objet workspace de la cellule précédente pour vous connecter à votre espace de travail Azure Quantum.

provider = AzureQuantumProvider(workspace)

Définir une fonction pour créer un travail d’estimation des ressources à partir de QIR

L’estimateur de ressources est un target fournisseur d’informatique quantique Microsoft. L’utilisation de l’estimateur de ressources est exactement la même chose que l’envoi d’un travail à un autre fournisseur de logiciels et de targets matériel dans Azure Quantum : définissez votre programme, définissez un targetet soumettez votre travail pour le calcul.

Lorsque vous envoyez une demande d’estimation des ressources pour votre programme, vous pouvez spécifier certains target paramètres.

  • errorBudget - le budget d’erreur global autorisé
  • qecScheme - le schéma de correction d’erreur quantique (QEC)
  • qubitParams - les paramètres qubit physiques
  • constraints : contraintes au niveau du composant

Pour plus d’informations sur les paramètres d’entrée, consultez Paramètres cibles de l’estimateur de ressources.

Pour cet exemple, vous allez implémenter une fonction générique qui prend comme entrée l’objet provider qui se connecte à votre espace de travail Azure Quantum et le bitcode QIR du programme quantique. Il retourne en conséquence un travail Azure Quantum. Les paramètres de l’estimateur target de ressources peuvent être passés via mot clé arguments à la fonction.

def resource_estimation_job_from_qir(provider: AzureQuantumProvider, bitcode: bytes, **kwargs):
    """A generic function to create a resource estimation job from QIR bitcode"""

    # Find the Resource Estimator target from the provider
    backend = provider.get_backend('microsoft.estimator')

    # You can provide a name for the job via keyword arguments; if not,
    # use QIR job as a default name
    name = kwargs.pop("name", "QIR job")

    # Wxtract some job specific arguments from the backend's configuration
    config = backend.configuration()
    blob_name = config.azure["blob_name"]
    content_type = config.azure["content_type"]
    provider_id = config.azure["provider_id"]
    output_data_format = config.azure["output_data_format"]

    # Finally, create the Azure Quantum jon object and return it
    return AzureQuantumJob(
        backend=backend,
        target=backend.name(),
        name=name,
        input_data=bitcode,
        blob_name=blob_name,
        content_type=content_type,
        provider_id=provider_id,
        input_data_format="qir.v1",
        output_data_format=output_data_format,
        input_params = kwargs,
        metadata={}
    )

Exécuter un exemple de programme quantique

Ensuite, créez un code de bits QIR à l’aide du générateur PyQIR. Cet exemple crée une porte S contrôlée à l’aide de trois portes T et de deux portes CNOT.

module = SimpleModule("Controlled S", num_qubits=2, num_results=0)
qis = BasicQisBuilder(module.builder)

[a, b] = module.qubits[0:2]
qis.t(a)
qis.t(b)
qis.cx(a, b)
qis.t_adj(b)
qis.cx(a, b)

Vous pouvez utiliser la fonction que vous avez définie ci-dessus avec la bitcode() fonction de PyQIR pour générer un travail d’estimation des ressources. Vous pouvez également passer des arguments spécifiques à l’estimateur de ressources. Cet exemple utilise errorBudget pour définir le taux d’erreur sur 5 %. Pour plus d’informations sur les target paramètres, consultez Paramètres cibles de l’estimateur de ressources.

job = resource_estimation_job_from_qir(provider, module.bitcode(), errorBudget=0.05)
result = job.result()
result

Cette fonction crée une table qui affiche le nombre global de ressources physiques. Vous pouvez inspecter plus en détail les détails des coûts en réduisant les groupes qui ont plus d’informations. Par exemple, si vous réduisez le groupe de paramètres de qubit logique , vous pouvez voir plus facilement que la distance du code de correction d’erreur est 15.

Paramètre qubit logique Valeur
Schéma QEC surface_code
Distance du code 5
Qubits physiques 50
Temps de cycle logique 2us
Taux d’erreur qubit logique 3.00E-5
Préfacteur de croisement 0,03
Seuil de correction d’erreur 0,01
Formule de temps de cycle logique (4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
Formule qubits physiques 2 * codeDistance * codeDistance

Dans le groupe Paramètres de qubit physique, vous pouvez voir les propriétés de qubit physique qui ont été supposées pour cette estimation. Par exemple, le temps nécessaire pour effectuer une mesure à qubit unique et une porte à qubit unique est supposé être respectivement de 100 ns et de 50 ns.

Paramètre qubit physique Valeur
Nom du qubit qubit_gate_ns_e3
Jeu d’instructions GateBased
Temps de mesure d’un qubit 100 ns
Heure de la porte T 50 ns
Taux d’erreur de la porte T 0,001
Taux d’erreur de mesure d’un qubit 0,001
Heure de la porte à qubit unique 50 ns
Taux d’erreur à qubit unique 0,001
Délai de porte à deux qubits 50 ns
Taux d’erreur à deux qubits 0,001

Pour plus d’informations, consultez la liste complète des données de sortie pour l’estimateur de ressources.

Contenu connexe

Continuez à explorer d’autres algorithmes et techniques quantiques :