Wprowadzenie do programów języka Q# i Visual Studio Code

W tym artykule przedstawiono kroki tworzenia i przesyłania kodu VC# Jupyter Notebook lub zadań obliczeń kwantowych w języku Python do usługi Azure Quantum przy użyciu programu VS Code.

Przesyłanie zadań języka Q# do usługi Azure Quantum

Dowiedz się, jak używać programu VS Code do uruchamiania, debugowania i przesyłania programu Q# do usługi Azure Quantum.

Wymagania wstępne

Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Instalowanie nowoczesnego zestawu QDK w programie VS Code.

• Obszar roboczy usługi Azure Quantum w subskrypcji platformy Azure. Aby utworzyć obszar roboczy, zobacz Twórca obszar roboczy usługi Azure Quantum.
• Najnowsza wersja Visual Studio Code lub otwórz program VS Code w sieci Web.
• Najnowsza wersja rozszerzenia zestawu Azure Quantum Development Kit .

Ładowanie przykładowego programu języka Q#

1. W programie VS Code wybierz pozycję Plik > nowy plik tekstowy i zapisz plik jako RandomNum.qs.

2. Otwórz plik RandomNum.qs i wpisz sample, a następnie wybierz pozycję Przykład losowy bit z listy opcji i zapisz plik.

   

Uwaga

Możesz również otworzyć własny plik języka Q#. Jeśli uruchomisz starszy program języka Q# i wystąpią błędy, zobacz Testowanie i debugowanie lub Migrowanieprogramów do nowoczesnego zestawu QDK.

Uruchamianie programu W języku Q#

1. Aby przetestować uruchamianie programu lokalnie na wbudowanym symulatorze, kliknij pozycję Uruchom z listy poleceń poniżej @EntryPoint()lub naciśnij klawisze Ctrl+F5. Dane wyjściowe zostaną wyświetlone w konsoli debugowania.

2. Aby debugować program przed przesłaniem go do usługi Azure Quantum, kliknij pozycję Debuguj z listy poleceń poniżej @EntryPoint()lub naciśnij klawisz F5. Użyj kontrolek debugowania u góry, aby przejść do kodu i z niego. Aby uzyskać więcej informacji na temat debugowania programów języka Q#, zobacz Testowanie i debugowanie.

   

Wizualizowanie histogramu częstotliwości

Histogram częstotliwości reprezentuje rozkład wyników uzyskanych z wielokrotnego uruchamiania programu kwantowego lub "strzałów". Każdy słupek w histogramie odpowiada możliwemu wynikowi, a jego wysokość reprezentuje liczbę obserwowanych wyników. Histogram częstotliwości pomaga wizualizować rozkład prawdopodobieństwa tych wyników.

1. Wybierz pozycję Widok —> paleta poleceń i wpisz "histogram", który powinien spowodować wyświetlenie pliku Q#: Uruchom plik i pokaż opcję histogramu . Możesz również kliknąć pozycję Histogram z listy poleceń poniżej @EntryPoint(). Wybierz tę opcję, aby otworzyć okno histogramu języka Q#.

   

2. Wprowadź kilka strzałów do wykonania programu, na przykład 100 strzałów, a następnie naciśnij klawisz Enter. Histogram zostanie wyświetlony w oknie histogramu języka Q#.

3. Kliknij ikonę ustawień w lewym górnym rogu, aby wyświetlić opcje.

   

4. Kliknij pasek, aby wyświetlić procent tego wyniku. W tym przypadku istnieją dwa możliwe wyniki, 0 i 1, a procent każdego wyniku jest zbliżony do 50%.

   

Porada

Histogram można powiększyć za pomocą kółka przewijania myszy lub gestu klawiatury. Po powiększeniu wykres można przesuwać, naciskając klawisze "Alt" podczas przewijania.

Wizualizowanie obwodu kwantowego

Diagramy obwodów kwantowych to wizualna reprezentacja operacji kwantowych. Pokazują one przepływ kubitów za pośrednictwem programu kwantowego, w tym bram i pomiarów zastosowanych do nich. Aby uzyskać więcej informacji, zobacz Diagramy obwodów kwantowych w Visual Studio Code.

1. Wybierz pozycję Widok —> paleta poleceń i wpisz "circuit", który powinien wyświetlić opcję Q#: Pokaż obwód . Możesz również kliknąć pozycję Obwód z listy poleceń poniżej @EntryPoint().

   

2. Obwód jest wyświetlany w oknie obwodu języka Q#. Na diagramie obwodu przedstawiono jeden rejestr kubitów, który został zainicjowany do stanu |0⟩. Następnie brama Hadamarda , H, jest stosowana do kubitu, a następnie operacji pomiaru, która jest reprezentowana przez symbol miernika. Aby uzyskać więcej informacji, zobacz Konwencje obwodów kwantowych.

   

Nawiązywanie połączenia z usługą Azure Quantum i przesyłanie zadania

Zadania można łączyć i przesyłać bezpośrednio z programu VS Code. W tym przykładzie prześlesz zadanie do symulatora platformy Rigetti.

1. Wybierz pozycję Widok —> paleta poleceń i wpisz Q#: Połącz się z obszarem roboczym usługi Azure Quantum. Naciśnij klawisz Enter.

2. Wybierz pozycję Konto platformy Azure i postępuj zgodnie z monitami, aby nawiązać połączenie z preferowanym katalogiem, subskrypcją i obszarem roboczym.

   Uwaga

   Jeśli masz parametry połączenia, możesz wybrać pozycję Parametry połączenia i wkleić parametry połączenia odpowiadające obszarowi roboczemu usługi Azure Quantum. Aby uzyskać więcej informacji, zobacz Nawiązywanie połączenia z obszarem roboczym Quantum przy użyciu parametry połączenia.

3. Po nawiązaniu połączenia w okienku Eksplorator rozwiń węzeł Obszary robocze kwantowe.

4. Rozwiń obszar roboczy i rozwiń dostawcę usługi Rigetti .

   Uwaga

   Jeśli występuje problem podczas nawiązywania połączenia z usługą Azure Quantum, obok nazwy obszaru roboczego zostanie wyświetlona ikona ostrzeżenia. Umieść kursor na nazwie obszaru roboczego, aby wyświetlić informacje o błędzie.

5. Wybierz pozycję rigetti.sim.qvm jako .target

   

6. Wybierz ikonę odtwarzania po prawej stronie target nazwy, aby rozpocząć przesyłanie bieżącego programu w języku Q#. Jeśli pojawi się wyskakujące okienko, wybierz pozycję Zmień profil QIR target i kontynuuj.

   

7. Dodaj nazwę, aby zidentyfikować zadanie.

8. Dodaj liczbę zdjęć lub liczbę uruchomień programu.

9. Naciśnij klawisz Enter, aby przesłać zadanie. Stan zadania będzie wyświetlany w dolnej części ekranu.

10. Rozwiń węzeł Zadania i umieść kursor na zadaniu, który wyświetla czas i stan zadania.

11. Aby wyświetlić wyniki, wybierz ikonę chmury obok nazwy zadania, aby pobrać wyniki z magazynu obszaru roboczego i wyświetlić je w programie VS Code.

    

Przesyłanie zadań notesów Jupyter Do usługi Azure Quantum

Dowiedz się, jak używać programu VS Code do uruchamiania, debugowania i przesyłania Jupyter Notebook języka Q# do usługi Azure Quantum. Kroki opisane w tym artykule dotyczą również notesów Jupyter Notebook na lokalnym serwerze Jupyter lub notesach w witrynie Azure Quantum Portal.

Wymagania wstępne

Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Instalowanie nowoczesnego zestawu QDK w programie VS Code.

• Obszar roboczy usługi Azure Quantum w subskrypcji platformy Azure. Aby utworzyć obszar roboczy, zobacz Twórca obszar roboczy usługi Azure Quantum.

• Środowisko języka Python z zainstalowanym językiem Python i programem Pip .

• Program VS Code z zainstalowanymi rozszerzeniami Azure Quantum Development Kit, Python i Jupyter .

• Pakiet Azure Quantum qsharp, qsharp-widgetsi azure-quantum oraz ipykernel pakiet.

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

Uruchamianie i testowanie programu w symulatorze lokalnym

1. W programie VS Code wybierz pozycję Wyświetl > paletę poleceń i wybierz pozycję Twórca: Nowy Jupyter Notebook.

2. W prawym górnym rogu program VS Code wykryje i wyświetli wersję języka Python oraz wirtualne środowisko języka Python wybrane dla notesu. Jeśli masz wiele środowisk języka Python, może być konieczne wybranie jądra przy użyciu selektora jądra w prawym górnym rogu. Jeśli nie wykryto żadnego środowiska, zobacz Notesy Jupyter Notebook w programie VS Code , aby uzyskać informacje o instalacji.

3. W pierwszej komórce notesu uruchom następujący kod języka Python, aby zaimportować niezbędne moduły:

   import qsharp
   import azure.quantum
   

   • Moduł qsharp aktywuje %%qsharp polecenie magic, które umożliwia wprowadzanie kodu języka Q# bezpośrednio do komórki.
   • Moduł azure-quantum zapewnia łączność z obszarem roboczym usługi Azure Quantum.

   Uwaga

   Jeśli nie wykryto jądra ipykernel języka Python programu Jupyter, program VS Code wyświetli monit o jego zainstalowanie.

4. Dodaj kolejną komórkę i wprowadź ten kod języka Q#, który zwraca określoną przez użytkownika liczbę bitów losowych:

   Uwaga

   Zwróć uwagę, że gdy tylko wpiszesz polecenie %%qsharpmagic, komórka notesu zmieni typ z języka Python na 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. Aby przetestować operację, możesz użyć eval metody , która może wywołać dowolną operację języka Q# zdefiniowaną wcześniej w notesie:

   qsharp.eval("RandomNBits(4)")
   

   [Zero, One, One, Zero]
   

6. Aby uruchomić program do symulatora lokalnego, użyj run metody . Określ , shotslub liczbę razy do uruchomienia programu, a symulator zwraca wyniki jako listę języka Python.

   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]]
   

Wizualizowanie obwodu kwantowego

Obwody kwantowe można wizualizować przy użyciu qsharp-widgets pakietu. Ten pakiet udostępnia widżet, który renderuje diagram obwodu kwantowego jako obraz SVG. Aby uzyskać więcej informacji, zobacz Diagramy obwodów kwantowych z notesami Jupyter Notebook.

Dodaj następujący kod do nowej komórki, aby zwizualizować obwód:

from qsharp_widgets import Circuit

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

Aby uzyskać więcej informacji, zobacz Konwencje obwodów kwantowych.

Kompilowanie zadania przy użyciu profilu podstawowego

Po uruchomieniu programów w lokalnym symulatorze kwantowym można przesłać dowolny typ programu języka Q#. Jednak sprzęt targets Azure Quantum nie obsługuje jeszcze pełnych możliwości wymaganych do uruchamiania wszystkich programów języka Q#. Aby skompilować i przesłać programy języka Q# do usługi Azure Quantum, należy ustawić target profil, aby poinformować język Q# o możliwościach target , które obsługuje sprzęt. Obecnie jest to profil podstawowy. Aby uzyskać więcej informacji, zobacz Typy profilów w usłudze Azure Quantum.

Aby ponownie zainicjować interpreter języka Q# i skompilować program przy użyciu profilu podstawowego:

1. Użyj metody , init aby ustawić profil:

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

2. Ponieważ ponownie zainicjowaliśmy interpreter, musisz ponownie uruchomić kod przy użyciu nowego profilu:

   %%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. Następnie użyj compile metody , aby określić operację lub funkcję, która jest punktem wejścia do programu. Spowoduje to skompilowanie kodu w formacie QIR, który można następnie przesłać do dowolnego sprzętu kwantowego:

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

Nawiązywanie połączenia z usługą Azure Quantum i przesyłanie zadania

Teraz, gdy program został skompilowany w poprawnym formacie, utwórz obiekt, aby nawiązać połączenie z usługą azure.quantum.Workspace Azure Quantum. Aby nawiązać połączenie, użyjesz identyfikatora zasobu obszaru roboczego usługi Azure Quantum. Identyfikator zasobu i lokalizacja można skopiować ze strony przeglądu obszaru roboczego w Azure Portal.

1. W nowej komórce wypełnij identyfikator zasobu i lokalizację z obszaru roboczego usługi Azure Quantum:

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

2. get_targets Użyj metody , aby wyświetlić dostępny sprzęt targets w obszarze roboczym:

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

3. Wybierz element rigetti.sim.qvmtarget:

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

4. Na koniec użyj submit metody , aby przesłać program z jego parametrami i wyświetlić wyniki:

   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. Wszystkie właściwości zadania są dostępne w programie job.details, na przykład:

   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
   

Przesyłanie języka Python z zadaniami języka Q# do usługi Azure Quantum

Dowiedz się, jak używać programu VS Code do pisania programu w języku Python, który wywołuje operacje języka Q#, nawiązywać połączenie z platformą Azure przy użyciu poleceń języka Python lub interfejsu wiersza polecenia platformy Azure i przesyłać zadanie.

Wymagania wstępne

Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Instalowanie nowoczesnego zestawu QDK w programie VS Code.

• Obszar roboczy usługi Azure Quantum w subskrypcji platformy Azure. Aby utworzyć obszar roboczy, zobacz Twórca obszar roboczy usługi Azure Quantum.
• Środowisko języka Python z zainstalowanym językiem Python i programem Pip .
• Program VS Code z zainstalowanym rozszerzeniem Azure Quantum Development Kit i Python .
• Usługa Azure Quantum qsharp i azure-quantum pakiety.
• Interfejs wiersza polecenia platformy Azure z zainstalowanym najnowszym rozszerzeniem Usługi Azure Quantum.

Twórca i zaimportuj operacje języka Q#

qsharp Pakiet umożliwia przechowywanie funkcji i operacji w plikach języka Q# oraz tworzenie projektów języka Q#, które umożliwiają wywołanie dowolnej z nich z poziomu kodu języka Python. Jest to szczególnie przydatne, gdy trzeba uruchomić program, który przyjmuje parametry wejściowe.

1. Postępuj zgodnie z instrukcjami, aby utworzyć projekt języka Q#.

2. Otwórz nowy plik tekstowy, dodaj następujący kod języka Q#, który zwraca określoną przez użytkownika liczbę bitów losowych i zapisz plik w projekcie jako source.qs.

   Uwaga

   Pamiętaj, że ten kod w języku Q# nie ma @EntryPoint funkcji takiej jak program języka Q# (zobacz Przesyłanie zadań języka Q# do usługi Azure Quantum), ale wymaga przestrzeni nazw, w przeciwieństwie do Jupyter Notebook (zobacz Przesyłanie zadań Jupyter Notebook do usługi 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. W tym samym folderze otwórz inny plik i zapisz go jako randomNum.py.

4. Dodaj następujący kod, aby zaimportować qsharp moduły i azure.quantum .

   import qsharp
   import azure.quantum
   

5. Następnie dodaj kod, aby zdefiniować folder główny projektu języka Q# i przetestować uruchomienie target operacji w symulatorze lokalnym. Operacja jest wywoływana przez <przestrzeń nazw>.<operation_name( )>, a w tym przypadku przekazujesz liczbę losowych bitów do zwrócenia.

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

   [Zero, One, One, Zero]
   

6. Możesz również przetestować operację za pomocą run metody , która przekazuje dodatkowy shots parametr i zwraca wyniki na liście języka Python. W randomNum.pypliku zastąp poprzednią instrukcję print następującym kodem:

   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]]
   

Kompilowanie zadania przy użyciu profilu podstawowego

Po uruchomieniu programów w lokalnym symulatorze kwantowym można przesłać dowolny typ programu języka Q#. Jednak sprzęt targets Azure Quantum nie obsługuje jeszcze pełnych możliwości wymaganych do uruchamiania wszystkich programów języka Q#. Aby skompilować i przesłać programy języka Q# do usługi Azure Quantum, należy ustawić target profil, aby poinformować język Q# o możliwościach, które target obsługuje twój sprzęt. Obecnie jest to profil podstawowy. Aby uzyskać więcej informacji, zobacz Typy profilów w usłudze Azure Quantum.

Uwaga

W przypadku programów w języku Q# tylko w programie VS Code program VS Code automatycznie ustawia profil podstawowy.

1. Użyj metody , init aby ustawić profil:

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

2. Następnie użyj compile metody , aby określić operację lub funkcję, która jest punktem wejścia do programu. Skompilowany program można następnie przesłać do dowolnego sprzętu kwantowego:

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

Nawiązywanie połączenia z usługą Azure Quantum i przesyłanie zadania

Możesz nawiązać połączenie z usługą Azure Quantum i przesłać zadanie przy użyciu obiektu utworzonego Workspace w języku Python lub połączyć się i przesłać zadanie przy użyciu interfejsu wiersza polecenia platformy Azure. Użycie interfejsu wiersza polecenia platformy Azure wymaga zapisania skompilowanego programu jako pliku tekstowego i przesłania tego pliku przy użyciu polecenia interfejsu wiersza polecenia.

Korzystanie z języka Python

Teraz, gdy program został skompilowany w poprawnym formacie, utwórz obiekt, aby nawiązać połączenie z usługą azure.quantum.Workspace Azure Quantum. Aby nawiązać połączenie, użyjesz identyfikatora zasobu obszaru roboczego usługi Azure Quantum. Identyfikator zasobu i lokalizacja można skopiować ze strony przeglądu obszaru roboczego w Azure Portal.

1. Dodaj następujący kod do randomNum.pypliku , wypełniając identyfikator zasobu i lokalizację z obszaru roboczego usługi Azure Quantum:

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

2. get_targets Użyj metody , aby wyświetlić dostępny sprzęt targets w obszarze roboczym:

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

3. Wybierz element rigetti.sim.qvmtarget:

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

4. Na koniec użyj submit metody , aby przesłać program z jego parametrami. Wyniki zadania są zwracane jako słownik języka Python.

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

5. Aby wyodrębnić tylko wartości i wyświetlić je:

   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. Wszystkie właściwości zadania są dostępne w programie job.details, na przykład:

   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
   

Przy użyciu interfejsu wiersza polecenia platformy Azure

Aby przesłać zadanie do usługi Azure Quantum przy użyciu interfejsu wiersza polecenia platformy Azure, musisz przesłać plik fizyczny programu, który właśnie skompilowany.

1. Dodaj następujący kod do randomNum.py pliku. Spowoduje to otwarcie pliku tekstowego i zapisanie skompilowanego programu w odpowiednim formacie.

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

2. Aby przesłać zadanie do usługi Azure Quantum, zaloguj się przy użyciu interfejsu wiersza polecenia platformy Azure:

   az login
   

3. Upewnij się, że korzystasz z najnowszej wersji rozszerzenia interfejsu wiersza polecenia quantum platformy Azure:

   az extension add --upgrade --name quantum
   

4. Określ subskrypcję, której chcesz użyć z tych skojarzonych z kontem platformy Azure. Identyfikator subskrypcji można również znaleźć w przeglądzie obszaru roboczego w Azure Portal.

   az account set -s <MySubscriptionID>
   

5. Wyświetl dostępne obszary robocze za pomocą:

   az quantum workspace list
   

6. Możesz użyć quantum workspace set polecenia , aby wybrać domyślny obszar roboczy, którego chcesz użyć do wyświetlania listy i przesyłania zadań.

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

7. Wyświetl dostępne w obszarze roboczym następujące targets elementy:

   az quantum target list -o table
   

8. Prześlij zadanie przy użyciu job submit polecenia .

   • --target-id może być dowolnym target. W tym przykładzie użyj polecenia rigetti.sim.qvmtarget.
   • --job-name może być dowolnym ciągiem.
   • --job-input-format jest zawsze qir.v1.
   • --job-input-file to nazwa pliku tekstowego utworzonego w kroku 1.
   • --entry-point jest zawsze 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. Aby sprawdzić stan zadania, skopiuj identyfikator z danych wyjściowych ostatniego kroku i użyj job show polecenia :

   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. Aby wyświetlić dane wyjściowe zadania, użyj job output polecenia :

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

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

Następne kroki

• Praca z zadaniami usługi Azure Quantum
• Dostawcy obliczeń kwantowych