[PYTHON] Erstellen Sie ein Blueqat-Backend ~ Teil 1

Blueqat-Bibliothek für einfache Quantenprogrammierung

Entwickelt sich. https://github.com/Blueqat/Blueqat

Blueqat Backend?

Blueqat hat einen Numpy-Simulator,

――Ich möchte einen schnelleren Simulator ausführen ――Ich möchte die eigentliche Maschine anstelle des Simulators bewegen ――Ich möchte etwas anderes machen

• Holen Sie sich die einheitliche Matrix der Schaltung
• Ausgabe der Schaltung im OpenQ ASM-Format

Es ist so konzipiert, dass Funktionen in Form eines "Backends" hinzugefügt werden können, damit es für solche Zwecke verwendet werden kann.

Es kann zweckmäßig sein, ein geeignetes Backend zu erstellen, wenn "Ich habe selbst einen Simulator erstellt, aber es ist mühsam, eine Schnittstelle zu erstellen".

Dieses Mal werde ich erklären, wie ein Backend für einen Simulator erstellt wird, der OpenQ ASM-Eingaben akzeptieren kann. OpenQASM-Eingaben werden möglicherweise selten akzeptiert, aber wenn möglich, wird die Backend-Erstellung erheblich einfacher.

Backend, das OpenQASM-Eingaben verwendet und das Ergebnis zurückgibt

Wenn Ihr eigener Simulator OpenQ ASM-Eingaben akzeptiert, ist dies der einfachste Weg, diese zu erstellen. Übergeben Sie einfach die Funktion blueqat.backends.qasm_parser_backend_generator.generate_backend an die Funktion, die OpenQASM empfängt und das Ergebnis zurückgibt.

Das IBM Q-Backend erstellt das Backend auf diese Weise. Schauen wir uns das an. https://github.com/Blueqat/Blueqat/blob/master/blueqat/backends/ibmq_backend.py

Schauen Sie sich zunächst alles kurz an

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)

Wenn Sie wie Circuit (). H [0] .m [:] .run (backend = 'ibmq', qiskit_backend = ..., ...) schreiben, ist es _qasm_runner_qiskit (die Schaltung wird in OpenQ ASM konvertiert). , qiskit_backend = ..., ...) wird aufgerufen. Mal sehen, wie es sich beim Aufruf verhält.

    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'")

Dieser Bereich verarbeitet die empfangenen Argumente. Blueqat-Backends akzeptieren häufig ein Argument namens return, in dem Sie angeben können, welche Art von Ergebnis Sie zurückgeben möchten.

Im Standard-Numpy-Backend können Sie den Statusvektor oder das Messergebnis auswählen und in ibmq das Messergebnis, die Schaltung in Qiskit, das Job-Objekt usw. abrufen. Sie können auch ein Objekt zurückgeben, das intern zum Debuggen verwendet wird. Es wird jedoch dringend empfohlen, ein Standardverhalten anzugeben, damit es ohne Rückgabe funktioniert.

    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"`')

Oben, damit Blueqat selbst funktioniert, auch wenn qiskit nicht installiert ist, wird es beim Aufrufen einer Funktion importiert. Außerdem wurde für eine Weile, als ich qiskit importierte, eine Warnung ausgegeben, daher arbeite ich auch daran, sie zu unterdrücken.

    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")

Während der Vorbereitung zum Ausführen des Qiskit-Simulators geben einige Rückgaben Ergebnisse zurück, bevor der Simulator ausgeführt wird.

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

Ich verwende einen Qiskit-Simulator. Wenn Sie return angegeben haben, um einen Qiskit-Job zurückzugeben, wird der Job zurückgegeben.

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

Es nimmt das Ergebnis aus dem Job, formatiert es in das von anderen Blueqat-Backends verwendete Format und gibt das Ergebnis zurück.

ibmq_backend = generate_backend(_qasm_runner_qiskit)

Erstellen Sie ein Backend, indem Sie die oben gezeigte Funktion übergeben.

Registrierung und Verwendung des Backends

Das erstellte Backend kann nur mit Blueqat verwendet werden, wenn es registriert ist.

Backend-Registrierung

from blueqat import BlueqatGlobalSetting
# BlueqatGlobalSetting.register_backend(Backend-Name,Backend)
BlueqatGlobalSetting.register_backend(”myibmq”, ibmq_backend)

Ich konnte ein Backend mit dem Namen "myibmq" registrieren.

Verwenden Sie das Backend

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

Sie können die in Form von "run_with_ backend name ()" registrierte verwenden.

Setzen Sie das Backend auf Standard

BlueqatGlobalSetting.set_default_backend(”myibmq”)

Ich konnte das registrierte Backend als Standard festlegen.

Zusammenfassung

Es stellt sich heraus, dass die Blueqat-Unterstützung mit einem Simulator, der OpenQ ASM als Eingabe akzeptiert, ziemlich einfach ist.

Auch wenn dies nicht der Fall ist, kann Blueqat mit geringem Aufwand implementiert werden. Wir werden uns das in Zukunft ansehen.