Så här installerar och använder du resursberäknaren Microsoft Quantum

Resursberäknaren Microsoft Quantum är en del av Microsoft Quantum Development Kit (QDK). I den här artikeln får du lära dig hur du installerar kvantresursestimatorn och kör en uppskattning för ett enkelt Q#-program med en standardarkitekturmodell.

Förutsättningar

Om du vill följa stegen i den här artikeln måste du ha följande installerat:

• Den senaste versionen av Visual Studio Code (VS Code)
• Den senaste versionen av QDK-tillägget som installerats i VS Code
• De senaste versionerna Python av tillägget och Jupyter-tillägget i VS Code

Installera kvantresursberäknaren

Resursberäknaren är tillgänglig via modulen qdk.qrePython . Om du vill använda resursestimatorn installerar du den senaste versionen av qdkPython paketet med extra:qre

pip install --upgrade "qdk[qre]"

Kör en enkel resursuppskattning med standardinställningar

Om du vill utföra en grundläggande resursuppskattning skickar du en programmodell, en maskinvaruarkitekturmodell och en felkorrigeringsmodell till resursberäknaren. Kör sedan resursberäknaren för att hämta resultatet. I följande exempel körs resursestimatorn från Jupyter Notebook i VS Code.

Skapa en programmodell

I det här exemplet använder du algoritmen för 1D Ising-modellen från Q#-exemplen i QDK VS Code-tillägget. Eller använd något av dina befintliga Q#-program.

Skriva ett Q#-program

1. I VS Code skapar du en ny textfil och sparar filen som ising-1d-sample.qs.
2. På den första raden i filen anger du exempel för att ta upp Q#-exempelprogramlistan.
3. Välj Exempel på Ising Model (Simple 1D) och spara sedan filen.

Skapa ett program

Använd Q#-programmet för att skapa en programmodell för resursestimatorn.

1. Om du vill skapa en ny Jupyter Notebook fil i VS Code öppnar du kommandopaletten och anger Skapa: Ny Jupyter Notebook.

2. I den första notebook-cellen utvärderar du Q#-programmet.

   from pathlib import Path
   from qdk import qsharp
   
   qsharp.eval(Path("ising-1d-sample.qs").read_text(encoding="utf-8"))
   

   Den här koden skapar ett Main objekt i qdk.code namnområdet som innehåller Q#-programmet.

3. I en ny cell skapar du ett resursestimatorprogram från Q#-programmet.

   import qdk
   from qdk.qre.application import QSharpApplication
   
   app = QSharpApplication(qdk.code.Main)
   

Skapa en arkitekturmodell

För maskinvaruarkitekturen använder du den standardmodell GateBased som resursberäknaren levereras med. Modellen GateBased kräver indata för felfrekvens, gatetid och mättid.

I en ny cell skapar du en gatebaserad arkitektur med en felfrekvens på $10^{-4}$, en gatetid på 100 ns och en mättid på 500 ns.

from qdk.qre.models import GateBased

# Times are in units of nanoseconds
arch = GateBased(error_rate=1e-4, gate_time=100, measurement_time=500)

Kör en uppskattning

Om du vill köra en uppskattning använder du estimate funktionen och skickar följande indata:

• Application
• Architecture
• Fråga om fysisk instruktionsuppsättning (ISA)
• Maximal felfrekvens

ISA-frågan talar om för resursberäknaren vilka kombinationer av felkorrigeringskod och T-fabriksdestillationsprotokoll som ska utvärderas. Resursestimatorn hittar den Pareto-gränsoptimerade uppsättningen resultat från dessa kombinationer. I det här exemplet använder du det standardprotokoll SurfaceCode för QEC och RoundBasedFactory destillation som resursberäknaren levereras med.

from qdk.qre import estimate
from qdk.qre.models import SurfaceCode, RoundBasedFactory

results = estimate(app, arch, isa_query=SurfaceCode.q() * RoundBasedFactory.q(), max_error=0.01)```

Visa resultaten

Om du vill visa optimala kombinationer av antal fysiska kvantbitar och programkörningstid använder du as_frame metoden för att visa uppskattningsresultaten i en Pandas DataFrame.

results.as_frame()

För att plotta resultaten använder du plot_estimates-metoden och anger en enhet för körtid.

from qdk.qre import plot_estimates

plot_estimates(results, figsize=(6, 4), runtime_unit="ms")