Créer un backend Blueqat ~ Partie 1

Bibliothèque Blueqat pour une programmation quantique facile

Se développe. https://github.com/Blueqat/Blueqat

Backend Blueqat?

Blueqat a un simulateur numpy,

――Je veux exécuter un simulateur plus rapide ――Je veux déplacer la machine réelle au lieu du simulateur ――Je veux faire quelque chose de différent

• Obtenez la matrice unitaire du circuit
• Sortie du circuit au format OpenQ ASM

Il est conçu pour que des fonctions puissent être ajoutées sous forme de "back-end" afin de pouvoir être utilisé à de telles fins.

Il peut être pratique de créer un backend approprié dans certains cas, par exemple "J'ai fait un simulateur moi-même, mais il est difficile de créer une interface".

Cette fois, je vais vous expliquer comment créer un backend pour un simulateur qui peut accepter l'entrée OpenQ ASM. Les entrées OpenQASM peuvent être rarement acceptées, mais si possible, la création du backend sera considérablement plus facile.

Backend qui prend l'entrée OpenQASM et renvoie le résultat

Si votre propre simulateur accepte l'entrée OpenQ ASM, c'est le moyen le plus simple de le créer. Passez simplement la fonction blueqat.backends.qasm_parser_backend_generator.generate_backend à la fonction qui reçoit OpenQASM et renvoie le résultat.

Le backend IBM Q crée le backend de cette façon, jetons donc un œil. https://github.com/Blueqat/Blueqat/blob/master/blueqat/backends/ibmq_backend.py

Tout d'abord, jetez un coup d'œil à tout

def _qasm_runner_qiskit(qasm, qiskit_backend=None, shots=None, returns=None, **kwargs):
    if returns is None:
        returns = "shots"
    elif returns not in ("shots", "draw", "_exception",
                         "qiskit_circuit", "qiskit_job", "qiskit_result"):
        raise ValueError("`returns` shall be None, 'shots', 'draw', " +
                         "'qiskit_circuit', 'qiskit_job', 'qiskit_result' or '_exception'")

    import_error = None
    try:
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            from qiskit import Aer, QuantumCircuit, execute
    except Exception as e:
        import_error = e

    if import_error:
        if returns == "_exception":
            return e
        if isinstance(import_error, ImportError):
            raise ImportError("Cannot import qiskit. To use this backend, please install qiskit." +
                              " `pip install qiskit`.")
        else:
            raise ValueError("Unknown error raised when importing qiskit. To get exception, " +
                             'run this backend with arg `returns="_exception"`')
    else:
        if returns == "_exception":
            return None
        qk_circuit = QuantumCircuit.from_qasm_str(qasm)
        if returns == "qiskit_circuit":
            return qk_circuit
        if returns == "draw":
            return qk_circuit.draw(**kwargs)
        if shots is None:
            shots = 1024
        if qiskit_backend is None:
            qiskit_backend = Aer.get_backend("qasm_simulator")
        job = execute(qk_circuit, backend=qiskit_backend, shots=shots, **kwargs)
        if returns == "qiskit_job":
            return job
        result = job.result()
        if returns == "qiskit_result":
            return result
        counts = Counter({bits[::-1]: val for bits, val in result.get_counts().items()})
        return counts

ibmq_backend = generate_backend(_qasm_runner_qiskit)

Si vous écrivez comme Circuit (). H [0] .m [:] .run (backend = 'ibmq', qiskit_backend = ..., ...), c'est `_qasm_runner_qiskit (le circuit est converti en OpenQ ASM). , qiskit_backend = ..., ...) ʻest appelé. Voyons comment il se comporte lorsqu'il est appelé.

    if returns is None:
        returns = "shots"
    elif returns not in ("shots", "draw", "_exception",
                         "qiskit_circuit", "qiskit_job", "qiskit_result"):
        raise ValueError("`returns` shall be None, 'shots', 'draw', " +
                         "'qiskit_circuit', 'qiskit_job', 'qiskit_result' or '_exception'")

Cette zone traite les arguments reçus. Les backends Blueqat acceptent souvent un argument appelé retours, dans lequel vous pouvez spécifier le type de résultat que vous souhaitez renvoyer.

Dans le backend numpy par défaut, vous pouvez sélectionner le vecteur d'état ou le résultat de la mesure, et dans ibmq, vous pouvez obtenir le résultat de la mesure, le circuit dans Qiskit, l'objet Job, etc. Vous pouvez également renvoyer un objet utilisé en interne pour le débogage. Cependant, il est fortement recommandé de fournir un comportement par défaut afin qu'il fonctionne sans retour.

    import_error = None
    try:
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            from qiskit import Aer, QuantumCircuit, execute
    except Exception as e:
        import_error = e

    if import_error:
        if returns == "_exception":
            return e
        if isinstance(import_error, ImportError):
            raise ImportError("Cannot import qiskit. To use this backend, please install qiskit." +
                              " `pip install qiskit`.")
        else:
            raise ValueError("Unknown error raised when importing qiskit. To get exception, " +
                             'run this backend with arg `returns="_exception"`')

Ci-dessus, afin de faire fonctionner Blueqat lui-même même si qiskit n'est pas installé, il est importé lors de l'appel d'une fonction. De plus, pendant un certain temps, lorsque j'ai importé qiskit, un avertissement a été émis, je travaille donc également à le supprimer.

    else:
        if returns == "_exception":
            return None
        qk_circuit = QuantumCircuit.from_qasm_str(qasm)
        if returns == "qiskit_circuit":
            return qk_circuit
        if returns == "draw":
            return qk_circuit.draw(**kwargs)
        if shots is None:
            shots = 1024
        if qiskit_backend is None:
            qiskit_backend = Aer.get_backend("qasm_simulator")

Lors de la préparation de l'exécution du simulateur Qiskit, certains retours renvoient des résultats avant d'exécuter le simulateur.

        job = execute(qk_circuit, backend=qiskit_backend, shots=shots, **kwargs)
        if returns == "qiskit_job":
            return job

J'utilise un simulateur Qiskit. Si vous avez spécifié renvoie un travail Qiskit, il renverra le travail.

        result = job.result()
        if returns == "qiskit_result":
            return result
        counts = Counter({bits[::-1]: val for bits, val in result.get_counts().items()})
        return counts

Il prend le résultat du travail, le met en forme dans le format utilisé par les autres backends Blueqat et renvoie le résultat.

ibmq_backend = generate_backend(_qasm_runner_qiskit)

Passez la fonction que nous avons vue ci-dessus pour créer le backend.

Enregistrement et utilisation du backend

Le backend créé ne peut pas être utilisé avec Blueqat sauf s'il est enregistré.

Inscription backend

from blueqat import BlueqatGlobalSetting
# BlueqatGlobalSetting.register_backend(Nom du backend,Back end)
BlueqatGlobalSetting.register_backend(”myibmq”, ibmq_backend)

J'ai pu enregistrer un backend avec le nom myibmq.

Utilisez le back-end

Circuit().h[0].m[:].run_with_myibmq()
#Ou
Circuit().h[0].m[:].run(backend=”myibmq”)

Vous pouvez utiliser celui enregistré sous la forme de run_with_ backend name ().

Définir le backend par défaut

BlueqatGlobalSetting.set_default_backend(”myibmq”)

J'ai pu définir le backend enregistré par défaut.

Résumé

Il s'avère que le support de Blueqat est assez facile avec un simulateur qui accepte OpenQ ASM en entrée.

Même si ce n'est pas le cas, Blueqat peut être implémenté avec un petit effort. Nous examinerons cela à l'avenir.