Kom igång med Q#-program och Visual Studio Code

I den här artikeln hittar du stegen för att använda VC Code för att skapa och skicka Q#-, Jupyter Notebook- eller Python-kvantberäkningsjobb till Azure Quantum med VS 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 modern 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äsa in ett Q#-exempelprogram

1. I VS Code väljer du Arkiv > 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.

   

Anteckning

Du kan också öppna en egen Q#-fil. Om du kör ett äldre Q#-program och stöter på fel läser du Testa och felsöka eller Migrera dina program till modern QDK.

Köra ett Q#-program

1. Om du vill testa att köra programmet lokalt i den inbyggda simulatorn klickar du på Kör i listan med kommandon nedan @EntryPoint()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ök i listan med kommandon nedan @EntryPoint()eller trycker på F5. Använd felsökningskontrollerna överst för att gå över, in i och ut ur koden. Mer information om felsökning av Q#-program finns i Testa och felsöka.

   

Rita frekvens histogrammet

Frekvensens histogram representerar fördelningen av resultat från körning av ett kvantprogram flera gånger, eller "skott". Varje stapel i histogrammet motsvarar ett möjligt resultat och dess höjd representerar antalet gånger som resultatet observeras. Histogrammet frequency hjälper till att visualisera sannolikhetsfördelningen för dessa resultat.

1. Välj Visa –> Kommandopalett och skriv "histogram" som ska öppna alternativet Q#: Kör filen och visa histogram . Du kan också klicka på Histogram i listan med kommandon under @EntryPoint(). Välj det här alternativet för att öppna histogramfönstret Q#.

   

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

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 %.

   

Tips

Du kan zooma histogrammet med hjälp av musrullningshjulet eller en styrplattans gest. När du zoomar in kan du panorera diagrammet genom att trycka på Alt medan du rullar.

Ansluta 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.

   Anteckning

   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 .

   Anteckning

   Om det uppstår problem med att ansluta till Azure Quantum visas en varningsikon bredvid namnet på arbetsytan. 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 namnet target 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 jobbet.

11. Om du vill visa resultatet väljer du molnikonen bredvid jobbnamnet för att ladda ned resultaten från din arbetsytelagring och visa den 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 notebook-filer i Azure Quantum-portalen.

Förutsättningar

Installationsinformation finns i Installera modern 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, Python och Jupyter-tillägg installerade.
• Azure Quantum qsharp och azure-quantum paketen ipykernel och paketet.

Köra och testa programmet i den lokala simulatorn

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

2. Längst upp till höger identifierar och visar VS Code den version av Python och den virtuella Python-miljö som valdes 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

   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.

   Anteckning

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

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

   %%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 . shotsAnge , eller antal gånger som programmet ska köras, så returnerar simulatorn 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]]
   

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 om Q#-tolken 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. compile Använd 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)")
   

Ansluta 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 arbetsytans översiktssida 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()
   

   {'Histogram': ['[0, 0, 0, 0]',
     0.3,
     '[1, 0, 0, 0]',
     0.1,
     '[1, 1, 1, 1]',
     0.3,
     '[0, 1, 1, 1]',
     0.3]}
   

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
   

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 modern 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 dina 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ändardefinierad antal slumpmässiga bitar och spara filen i projektet som source.qs.

   Anteckning

   Observera att den här Q#-koden inte har en @EntryPoint funktion som ett Q#-program (se Skicka Q#-jobb till Azure Quantum), men den kräver ett namnområde, till skillnad från en Jupyter Notebook (se Skicka Jupyter Notebook jobb till Azure Quantum).

   namespace Sample {
   
     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. Öppna en annan fil i samma mapp och spara 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#-projektets rotmapp och testkör target åtgärden på den lokala simulatorn. Åtgärden anropas efter <namnområde>.<operation_name( )>, och i det här fallet skickar du in antalet slumpmässiga bitar som ska returneras.

   qsharp.init(project_root = '/MyProjectRootFolder')
   print(qsharp.eval("Sample.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 den tidigare utskriftssatsen med följande:

   result = qsharp.run("Sample.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 din target maskinvara stöder. För närvarande är det basprofilen. Mer information finns i Profiltyper i Azure Quantum.

Anteckning

Endast för Q#-program i VS Code anger VS Code basprofilen automatiskt.

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

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

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

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

Ansluta 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 jobbet 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 hjälp av ett CLI-kommando.

Använda Python

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 arbetsytans översiktssida i Azure Portal.

1. Lägg till följande kod randomNum.pyi och fyll i ditt resurs-ID och din plats från Azure Quantum-arbetsytan:

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

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

   MyTargets = workspace.get_targets()
   print("This workspace's targets:")
   for x in MyTargets:
       print(x)
   

3. Välj :rigetti.sim.qvmtarget

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

4. Slutligen använder du submit metoden för att skicka in programmet med dess parametrar. Jobbresultatet returneras som en Python-ordlista.

   job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
   results = job.get_results()
   print("\nResults: ", results)
   

5. Så här extraherar du bara värdena och visar dem:

   resultList = results.get("Histogram")
   for x in resultList:
       print(x)
   

   [0, 0, 0, 0]
   0.3
   [1, 0, 0, 0]
   0.1
   [1, 1, 1, 1]
   0.3
   [0, 1, 1, 1]
   0.3
   

6. 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': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
   Job name: MyPythonJob
   Job status: Succeeded
   Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f
   

Använda Azure CLI

Om du vill skicka ett jobb till Azure Quantum med Azure CLI måste du skicka en fysisk fil med programmet som du just kompilerade.

1. Lägg till följande kod i randomNum.py filen. Då öppnas en textfil och ditt kompilerade program skrivs till rätt format.

   file = open("compiled_output.txt", "w")
   file.write(MyProgram._ll_str)
   file.close()
   

2. Om du vill skicka jobbet till Azure Quantum loggar du in med Azure CLI:

   az login
   

3. Se till att du kör den senaste versionen av Azure CLI-tillägget quantum :

   az extension add --upgrade --name quantum
   

4. Ange den prenumeration som du vill använda från de som är associerade med ditt Azure-konto. Du hittar även ditt prenumerations-ID i översikten över din arbetsyta i Azure Portal.

   az account set -s <MySubscriptionID>
   

5. Visa dina tillgängliga arbetsytor med:

   az quantum workspace list
   

6. Du kan använda quantum workspace set för att välja en standardarbetsyta som du vill använda för att lista och skicka jobb.

   az quantum workspace set \
      -g <MyResourceGroup> \
      -w <MyWorkspace> \
      -l <MyLocation> \
      -o table
   

7. Visa tillgängliga targets i din arbetsyta med:

   az quantum target list -o table
   

8. Skicka jobbet med kommandot job submit .

   • --target-id kan vara valfri target. I det här exemplet använder du rigetti.sim.qvmtarget.
   • --job-name kan vara vilken sträng som helst.
   • --job-input-format är alltid qir.v1.
   • --job-input-file är namnet på textfilen som du skapade i steg 1.
   • --entry-point är alltid ENTRYPOINT__main

   az quantum job submit \
       --target-id rigetti.sim.qvm \
       --job-name MyQuantumJob \
       --job-input-format qir.v1 \
       --job-input-file compiled_output.txt \
       --entry-point ENTRYPOINT__main
   

9. Om du vill kontrollera jobbets status kopierar du ID :t från utdata från det sista steget och använder job show kommandot :

   az quantum job show --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table
   

   Name      Id                                    Status     Target           Submission time                   Completion time                  
   --------  ------------------------------------  ---------  ---------------  --------------------------------  -------------------------------- 
   MyQuantumJob  b2f07cc4-b49b-40b0-b63b-9a4885e5fef5  Succeeded  rigetti.sim.qvm  2023-12-11T05:33:23.187773+00:00  2023-12-11T05:33:29.252742+00:00 
   

10. Om du vill visa utdata för jobbet använder du job output kommandot :

    az quantum job output --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table
    

    Result        Frequency
    ------------  -----------  ----------------------
    [0, 1, 1, 1]  1.00000000   |████████████████████|
    

Nästa steg

• Arbeta med Azure Quantum-jobb
• Leverantörer av kvantberäkning