Skicka Q#-program med Visual Studio Code

Skicka Q#-jobb till Azure Quantum

Lär dig hur du använder VS Code för att köra, felsöka och skicka ett Q#-program till Azure Quantum.

Förutsättningar

Installationsinformation finns i Installera QDK på VS Code.

• En Azure Quantum-arbetsyta i din Azure-prenumeration. Information om hur du skapar en arbetsyta finns i Skapa en Azure Quantum-arbetsyta.
• Den senaste versionen av Visual Studio Code eller öppna VS Code på webben.
• Den senaste versionen av Azure Quantum Development Kit-tillägget.

Läs in ett Q#-exempelprogram

1. I VS Code väljer du Fil > Ny textfil och sparar filen som RandomNum.qs.

2. Öppna RandomNum.qs och skriv sampleoch välj sedan Slumpmässigt bitexempel i listan med alternativ och spara filen.

   

Köra ett Q#-program

1. Om du vill testa att köra programmet lokalt i den inbyggda simulatorn klickar du på Kör från listan med kommandon bredvid startpunktsåtgärden eller trycker på Ctrl+F5. Dina utdata visas i felsökningskonsolen.

2. Om du vill felsöka programmet innan du skickar det till Azure Quantum klickar du på Felsöka från listan med kommandon bredvid startpunktsåtgärden eller trycker på F5. Använd felsökningskontrollerna överst för att gå över, till och ut ur koden. Mer information om felsökning av Q#-program finns i Testa och felsöka.

   

Visualisera frekvens histogrammet

Frekvens histogrammet representerar fördelningen av resultat som erhålls från att köra ett kvantprogram flera gånger, eller "shots". Varje stapel i histogrammet motsvarar ett möjligt utfall och dess höjd representerar antalet gånger som resultatet observeras. Frekvens histogrammet hjälper till att visualisera sannolikhetsfördelningen för dessa resultat.

1. Välj Visa –> Kommandopalett och skriv "histogram" som ska ta upp alternativet Q#: Kör fil och visa histogram . Du kan också klicka på Histogram från listan med kommandon bredvid startpunktsåtgärden. Välj det här alternativet om du vill öppna histogramfönstret Q#.

   

2. Ange ett antal bilder för att köra programmet, till exempel 100 bilder, och tryck på Retur. Histogrammet visas i fönstret Q#-histogram.

3. Klicka på ikonen för inställningar längst upp till vänster för att visa alternativ.

   

4. Klicka på ett fält för att visa procentandelen av resultatet. I det här fallet finns det två möjliga utfall, 0 och 1, och procentandelen av varje utfall är nära 50 %.

   

Visualisera kvantkretsen

Kvantkretsdiagram är en visuell representation av kvantåtgärder. De visar flödet av kvantbitar genom kvantprogrammet, inklusive de grindar och mätningar som tillämpas på dem. Mer information finns i Kvantkretsdiagram i Visual Studio Code.

1. Välj Visa –> Kommandopalett och skriv "krets" som ska ta upp alternativet Q#: Visa krets . Du kan också klicka på Krets från listan med kommandon bredvid startpunktsåtgärden.

   

2. Kretsen visas i Q#-kretsfönstret. Kretsdiagrammet visar ett qubitregister som initieras till tillståndet |0⟩. Sedan tillämpas en Hadamard-grind, H, på kvantbiten, följt av en mätningsåtgärd som representeras av en mätarsymbol. Mer information finns i Konventioner för kvantkretsar.

   

Anslut till Azure Quantum och skicka ditt jobb

Du kan ansluta och skicka jobb direkt från VS Code. I det här exemplet skickar du ett jobb till Rigetti-simulatorn.

1. Välj Visa –> Kommandopalett och skriv Q#: Anslut till en Azure Quantum-arbetsyta. Tryck på Retur.

2. Välj Azure-konto och följ anvisningarna för att ansluta till önskad katalog, prenumeration och arbetsyta.

   Kommentar

   Om du har en anslutningssträng kan du välja Anslutningssträng och klistra in anslutningssträng som motsvarar din Azure Quantum-arbetsyta. Mer information finns i Ansluta till en Quantum-arbetsyta med hjälp av en anslutningssträng.

3. När du är ansluten expanderar du Quantum Workspaces i explorer-fönstret.

4. Expandera din arbetsyta och expandera Rigetti-providern.

   Kommentar

   Om det uppstår problem med att ansluta till Azure Quantum visas en varningsikon bredvid arbetsytans namn. Hovra över arbetsytans namn för att visa felinformation.

5. Välj rigetti.sim.qvm som din target.

   

6. Välj uppspelningsikonen till höger om target namnet för att börja skicka det aktuella Q#-programmet. Om du får ett popup-fönster väljer du Ändra QIR-profilen target och fortsätter.

   

7. Lägg till ett namn för att identifiera jobbet.

8. Lägg till antalet bilder eller antalet gånger som programmet körs.

9. Tryck på Retur för att skicka jobbet. Jobbstatusen visas längst ned på skärmen.

10. Expandera Jobb och hovra över jobbet, vilket visar tid och status för ditt jobb.

11. Om du vill visa resultatet väljer du molnikonen bredvid jobbnamnet för att ladda ned resultatet från din arbetsytelagring och visa det i VS Code.

    

Skicka Jupyter Notebooks-jobb till Azure Quantum

Lär dig hur du använder VS Code för att köra, felsöka och skicka en Q# Jupyter Notebook till Azure Quantum. Stegen i den här artikeln gäller även för Jupyter Notebooks på din lokala Jupyter-server eller dina notebook-filer i Azure Quantum-portalen.

Förutsättningar

Installationsinformation finns i Installera QDK på VS Code.

• En Azure Quantum-arbetsyta i din Azure-prenumeration. Information om hur du skapar en arbetsyta finns i Skapa en Azure Quantum-arbetsyta.

• En Python-miljö med Python och Pip installerade.

• VS Code med Tilläggen Azure Quantum Development Kit, Python och Jupyter installerade.

• Paketen Azure Quantum qsharp, och och azure-quantum och paketet ipykernel qsharp-widgets.

  python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
  

Kör och testa programmet i den lokala simulatorn

1. I VS Code väljer du Visa > kommandopalett och väljer Skapa: Ny Jupyter Notebook.

2. I det övre högra hörnet identifierar och visar VS Code den version av Python och den virtuella Python-miljön som har valts för notebook-filen. Om du har flera Python-miljöer kan du behöva välja en kernel med hjälp av kernelväljaren längst upp till höger. Om ingen miljö har identifierats kan du läsa mer i Jupyter Notebooks i VS Code .

3. I den första cellen i notebook-filen kör du följande Python-kod för att importera nödvändiga moduler:

   import qsharp
   import azure.quantum
   

   • Modulen qsharp aktiverar det %%qsharp magiska kommandot som gör att du kan ange Q#-kod direkt i en cell.
   • Modulen azure-quantum ger anslutning till din Azure Quantum-arbetsyta.

   Kommentar

   Om Jupyter Python-kerneln ipykernel inte identifieras uppmanar VS Code dig att installera den.

4. Lägg till en annan cell och ange den här Q#-koden som returnerar ett användardefinierad antal slumpmässiga bitar:

   Kommentar

   Observera att när du skriver in det magiska kommandot %%qsharpändrar notebook-cellen typ från Python till Q#.

   %%qsharp
   
   operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
       }
       return results
   }
   

5. Om du vill testa åtgärden kan du använda eval metoden, som kan anropa alla Q#-åtgärder som tidigare definierats i notebook-filen:

   qsharp.eval("RandomNBits(4)")
   

   [Zero, One, One, Zero]
   

6. Om du vill köra programmet till den lokala simulatorn använder du run metoden . Ange , shotseller antal gånger som programmet ska köras, och simulatorn returnerar resultatet som en Python-lista.

   qsharp.run("RandomNBits(4)", shots=10)
   

   [[One, One, One, One],
   [Zero, Zero, One, Zero],
   [One, Zero, Zero, One],
   [Zero, One, Zero, Zero],
   [One, Zero, One, One],
   [One, Zero, One, Zero],
   [One, One, One, Zero],
   [One, One, One, One],
   [Zero, Zero, Zero, One],
   [One, Zero, Zero, One]]
   

Visualisera kvantkretsen

Du kan visualisera kvantkretsar med hjälp av qsharp-widgets paketet. Det här paketet innehåller en widget som renderar ett kvantkretsdiagram som en SVG-avbildning. Mer information finns i Kvantkretsdiagram med Jupyter Notebooks.

Lägg till följande kod i en ny cell för att visualisera kretsen:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Mer information finns i Konventioner för kvantkretsar.

Kompilera jobbet med basprofilen

När du kör program på den lokala kvantsimulatorn kan du skicka alla typer av Q#-program. Azure Quantum-maskinvaran targets har dock ännu inte stöd för alla funktioner som krävs för att köra alla Q#-program. För att kunna kompilera och skicka Q#-program till Azure Quantum måste du ange din target profil för att berätta för Q# vilka funktioner din target maskinvara stöder. För närvarande är det basprofilen. Mer information finns i Profiltyper i Azure Quantum.

Så här initierar du Q#-tolken igen och kompilerar programmet med basprofilen:

1. init Använd metoden för att ange profilen:

   qsharp.init(target_profile=qsharp.TargetProfile.Base)
   

2. Eftersom du initierade tolken igen måste du köra koden igen med den nya profilen:

   %%qsharp
   
   operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
       }
       return results
   }
   

3. Använd compile sedan metoden för att ange den åtgärd eller funktion som är startpunkten för ditt program. Detta kompilerar koden till QIR-format, som sedan kan skickas till valfri kvantmaskinvara:

   MyProgram = qsharp.compile("RandomNBits(4)")
   

Anslut till Azure Quantum och skicka ditt jobb

Nu när programmet har kompilerats till rätt format skapar du ett azure.quantum.Workspace objekt för att ansluta till Azure Quantum. Du använder resurs-ID:t för din Azure Quantum-arbetsyta för att ansluta. Resurs-ID och plats kan kopieras från översiktssidan för arbetsytan i Azure Portal.

1. I en ny cell fyller du i ditt resurs-ID och din plats från Azure Quantum-arbetsytan:

   MyWorkspace = azure.quantum.Workspace(
       resource_id = "MyResourceID",
       location = "MyLocation"
   )
   

2. get_targets Använd metoden för att se tillgänglig maskinvara targets på din arbetsyta:

   MyTargets = MyWorkspace.get_targets()
   print("This workspace's targets:")
   MyTargets
   

3. Välj :rigetti.sim.qvmtarget

   MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")
   

4. Slutligen använder du submit metoden för att skicka programmet med dess parametrar och visa resultatet:

   job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
   job.get_results()
   

   {'[0, 1, 1, 1]': 0.08,
    '[1, 1, 0, 0]': 0.1,
    '[0, 0, 1, 0]': 0.04,
    '[0, 1, 0, 0]': 0.05,
    '[1, 0, 1, 0]': 0.05,
    '[1, 0, 0, 0]': 0.07,
    '[0, 1, 0, 1]': 0.07,
    '[1, 0, 1, 1]': 0.07,
    '[0, 0, 0, 0]': 0.08,
    '[1, 1, 1, 0]': 0.05,
    '[0, 0, 0, 1]': 0.1,
    '[0, 0, 1, 1]': 0.04,
    '[0, 1, 1, 0]': 0.09,
    '[1, 0, 0, 1]': 0.04,
    '[1, 1, 1, 1]': 0.05,
    '[1, 1, 0, 1]': 0.02}
   

5. Alla egenskaper för jobbet är tillgängliga i job.details, till exempel:

   print(job.details)
   print("\nJob name:", job.details.name)
   print("Job status:", job.details.status)
   print("Job ID:", job.details.id)
   

   {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
   Job name: MyQuantumJob
   Job status: Succeeded
   Job ID: 0150202e-9638-11ee-be2f-b16153380354
   

Ytterligare jobbinformation

azure.quantum Python-paketet innehåller ytterligare metoder för att visa mer detaljerade jobbdata.

• job.get_results_histogram(): Den här metoden returnerar en ordlista över utfall och antal skott för varje unik mätning. Resultatet för föregående jobb skulle till exempel vara

  print(job.get_results_histogram()) 
  

  {   
      '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
      '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
      '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
      '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
      '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
      '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
      '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
      '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
      '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
      '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
      '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
      '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
      '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
      '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
      '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
      '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
  }
  

• job.get_results_shots() : Den här metoden returnerar en lista över varje skottresultat. Resultatet för föregående jobb skulle till exempel vara

  print(job.get_results_shots()) 
  

  [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]
  

Skicka Python med Q#-jobb till Azure Quantum

Lär dig hur du använder VS Code för att skriva ett Python-program som anropar Q#-åtgärder, ansluter till Azure med Hjälp av Python-kommandon eller Azure CLI och skickar ditt jobb.

Förutsättningar

Installationsinformation finns i Installera QDK på VS Code.

• En Azure Quantum-arbetsyta i din Azure-prenumeration. Information om hur du skapar en arbetsyta finns i Skapa en Azure Quantum-arbetsyta.
• En Python-miljö med Python och Pip installerade.
• VS Code med Azure Quantum Development Kit och Python-tillägget installerat.
• Azure Quantum qsharp och azure-quantum paket.
• Azure CLI med det senaste Azure Quantum-tillägget installerat.

Skapa och importera Q#-åtgärder

qsharp Med paketet kan du lagra dina funktioner och åtgärder i Q#-filer och skapa Q#-projekt som gör att du kan anropa någon av dem från din Python-kod. Detta är särskilt användbart när du behöver starta ett program som tar indataparametrar.

1. Följ stegen för att skapa ett Q#-projekt.

2. Öppna en ny textfil, lägg till följande Q#-kod som returnerar ett användar angivet antal slumpmässiga bitar och spara filen i katalogen /src i projektet som Source.qs.

   
       operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
       }
       return results
   }
   

3. I projektrotmappen (med filen qsharp.json ) öppnar du en annan fil och sparar den som randomNum.py.

4. Lägg till följande kod för att importera modulerna qsharp och azure.quantum .

   import qsharp
   import azure.quantum
   

5. Lägg sedan till kod för att definiera Q#-projektrotmappen och testa körningen av target åtgärden på den lokala simulatorn. Åtgärden anropas av <namnrymden.<>operation_name( )>, och i det här fallet skickar du in antalet slumpmässiga bitar som ska returneras.

   Kommentar

   Eftersom inget namnområde angavs i Source.qsanvänder kompilatorn filnamnet som standardnamnområde – Source.RandomNBits(). Mer information finns i Projekt och implicita namnområden.

   qsharp.init(project_root = '../MyProjectRootFolder')
   print(qsharp.eval("Source.RandomNBits(4)"))
   

   [Zero, One, One, Zero]
   

6. Du kan också testa åtgärden med run metoden, som skickar ytterligare shots en parameter, och returnerar resultatet i en Python-lista. I randomNum.pyersätter du föregående utskriftsuttryck med följande:

   result = qsharp.run("Source.RandomNBits(4)", shots=10)
   for x in result:
       print(x)
   

   [[One, One, One, One],
   [Zero, Zero, One, Zero],
   [One, Zero, Zero, One],
   [Zero, One, Zero, Zero],
   [One, Zero, One, One],
   [One, Zero, One, Zero],
   [One, One, One, Zero],
   [One, One, One, One],
   [Zero, Zero, Zero, One],
   [One, Zero, Zero, One]]
   

Kompilera jobbet med basprofilen

När du kör program på den lokala kvantsimulatorn kan du skicka alla typer av Q#-program. Azure Quantum-maskinvaran targets har dock ännu inte stöd för alla funktioner som krävs för att köra alla Q#-program. För att kunna kompilera och skicka Q#-program till Azure Quantum måste du ange din target profil för att berätta för Q# vilka funktioner som maskinvaran target stöder. För närvarande är det antingen profilen Base eller Adpative_RI . Mer information finns i Profiltyper i Azure Quantum.

1. init Använd metoden för att ange profilen:

   qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)
   

   Kommentar

   Eftersom du initierar om qsharp-tillståndet måste du ange parametern project_root igen så att kompilatorn vet var åtgärden ska hittas RandomNBits . Detta kunde också ha gjorts i steg 5 i föregående procedur.

2. Använd compile sedan metoden för att ange den åtgärd eller funktion som är startpunkten för programmet. Det kompilerade programmet kan sedan skickas till valfri kvantmaskinvara:

   MyProgram = qsharp.compile("Source.RandomNBits(4)")
   

Anslut till Azure Quantum och skicka ditt jobb

Du kan ansluta till Azure Quantum och skicka jobbet med hjälp av ett Python-skapat Workspace objekt, eller ansluta och skicka ditt jobb med Hjälp av Azure CLI. Om du använder Azure CLI måste du spara det kompilerade programmet som en textfil och skicka filen med ett CLI-kommando.