Integrasikan sumber kuantum luar dengan Qiskit

SDK Qiskit dibina untuk menyokong pihak ketiga dalam mencipta pembekal luar bagi sumber kuantum.

Ini bermakna mana-mana organisasi yang membangun atau menggunakan sumber pengkomputeran kuantum boleh mengintegrasikan perkhidmatan mereka ke dalam Qiskit dan memanfaatkan pangkalan penggunanya.

Melakukannya memerlukan penciptaan pakej yang menyokong permintaan sumber pengkomputeran kuantum dan mengembalikannya kepada pengguna.

Selain itu, pakej tersebut mesti membolehkan pengguna menghantar kerja dan mendapatkan semula keputusan mereka melalui pelaksanaan objek qiskit.primitives.

Menyediakan akses kepada Backend

Untuk pengguna melakukan transpilasi dan melaksanakan objek QuantumCircuit menggunakan sumber luar, mereka perlu menginstankan objek yang mengandungi Target yang memberikan maklumat tentang kekangan QPU seperti ketersambungannya, Gate asas, dan bilangan Qubit. Ini boleh disediakan melalui antara muka yang serupa dengan QiskitRuntimeService yang membolehkan pengguna membuat permintaan untuk QPU. Objek ini sekurang-kurangnya perlu mengandungi Target, tetapi pendekatan yang lebih mudah ialah mengembalikan instans BackendV2.

Contoh pelaksanaan mungkin kelihatan seperti:

from qiskit.transpiler import Target
from qsikit.providers import BackendV2

class ProviderService:
    """ Class for interacting with a provider's service"""

    def __init__(
        self,
        #Receive arguments for authentication/instantiation
    ):
        """ Initiate a connection with the provider service, given some method
                of authentication """

    def return_target(name: Str) -> Target:
        """ Interact with the service and return a Target object """
        return target

    def return_backend(name: Str) -> BackendV2:
        """ Interact with the service and return a BackendV2 object """
        return backend

Menyediakan antara muka untuk pelaksanaan

Selain menyediakan perkhidmatan yang mengembalikan konfigurasi perkakasan, perkhidmatan yang menyediakan akses kepada sumber QPU luar mungkin juga menyokong pelaksanaan beban kerja kuantum. Mendedahkan keupayaan tersebut boleh dilakukan dengan mencipta pelaksanaan antara muka primitif Qiskit; contohnya BasePrimitiveJob, BaseEstimatorV2 dan BaseSamplerV2 antara lain. Sekurang-kurangnya, antara muka ini perlu menyediakan kaedah untuk pelaksanaan, menanya status kerja, dan mengembalikan keputusan kerja.

Untuk mengendalikan status kerja dan keputusan, SDK Qiskit menyediakan objek DataBin, PubResult, PrimitiveResult, dan BasePrimitiveJob yang perlu digunakan.

Lihat dokumentasi API qiskit.primitives serta pelaksanaan rujukan BackendEstimatorV2 dan BackendSampleV2 untuk maklumat lanjut.

Contoh pelaksanaan primitif Estimator mungkin kelihatan seperti:

from qiskit.primitives import BaseEstimatorV2, BaseSamplerV2, EstimatorPubLike
from qiskit.primitives import DataBin, PubResult, PrimitiveResult, BasePrimitiveJob
from qiskit.providers import BackendV2

class EstimatorImplementation(BaseEstimatorV2):
    """ Class for interacting with the provider's Estimator service """

    def __init__(
        self,
        *,
        backend: BackendV2,
        options: dict
        # Receive other arguments to instantiate an Estimator primitive with the service
    ):
        self._backend = backend
        self._options = options
        self._default_precision = 0.01

    @property
    def backend(self) -> BackendV2:
        """ Return the backend """
        return self._backend

    def run(
        self, pubs: Iterable[EstimatorPubLike], *, precision: float | None = None
    ) -> BasePrimitiveJob[PrimitiveResult[PubResult]]:
    """ Steps to implement:
            1. Define a default precision if none is given
            2. Validate pub format
            3. Instantiate an object which inherits from BasePrimitiveJob
                containing pub and runtime information
            4. Send the job to the execution service of the provider
    """
    job = BasePrimitiveJob(pubs, precision)
    job_with_results = job.submit()
    return job_with_results

Dan pelaksanaan primitif Sampler mungkin kelihatan seperti:

class SamplerImplementation(BaseSamplerV2):
    """ Class for interacting with the provider's Sampler service """

    def __init__(
        self,
        *,
        backend: BackendV2,
        options: dict
        # Receive other arguments to instantiate an Estimator primitive with the service
    ):
        self._backend = backend
        self._options = options
        self._default_shots = 1024

    @property
    def backend(self) -> BackendV2:
        """ Return the Sampler's backend """
        return self._backend

    def run(
        self, pubs: Iterable[SamplerPubLike], *, shots: int | None = None
    ) -> BasePrimitiveJob[PrimitiveResult[SamplerPubResult]]:
    """ Steps to implement:
            1. Define a default number of shots if none is given
            2. Validate pub format
            3. Instantiate an object which inherits from BasePrimitiveJob
                containing pub and runtime information
            4. Send the job to the execution service of the provider
            5. Return the data in some format
    """
    job = BasePrimitiveJob(pubs, shots)
    job_with_results = job.submit()
    return job_with_results