Wprowadzenie do sesji

W tym przykładzie pokazano, jak utworzyć sesję z Q# kodem wbudowanym przy użyciu Jupyter Notebook w Visual Studio Code (VS Code). Sesje można również tworzyć przy użyciu Python programu , który wywołuje sąsiadujący Q# program.

1. W VS Codeprogramie otwórz menu Widok i wybierz pozycję Paleta poleceń.

2. Wprowadź i wybierz pozycję Utwórz: Nowy Jupyter Notebook.

3. W prawym górnym rogu VS Code zostanie wykryta i wyświetlona wersja Python oraz środowisko wirtualne Python, które zostały wybrane dla notatnika. Jeśli masz wiele Python środowisk, może być konieczne wybranie jądra przy użyciu selektora jądra w prawym górnym rogu. Jeśli środowisko nie zostało wykryte, zobacz Jupyter Notebookw dokumentacji VS Code aby uzyskać informacje o konfiguracji.

4. W pierwszej komórce notesu uruchom następujący kod:

   from qdk.azure import Workspace
   
   workspace = Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

5. Dodaj nową komórkę w notebooku i zaimportuj pakiet qsharpPython.

   from qdk import qsharp
   

6. Wybierz swój kwantowy target. W tym przykładzie target jest to symulator IonQ.

   target = workspace.get_targets("ionq.simulator")
   

7. Wybierz konfiguracje target profilu , Baselub Adaptive_RIUnrestricted.

   qsharp.init(target_profile=qsharp.TargetProfile.Base) # or qsharp.TargetProfile.Adaptive_RI, qsharp.TargetProfile.Unrestricted
   

   Uwaga

   Adaptive_RI target Zadania profilu są obecnie obsługiwane w aplikacji Quantinuum targets. Aby uzyskać więcej informacji, zobacz Zintegrowane hybrydowe obliczenia kwantowe.

8. Napisz swój Q# program. Na przykład następujący Q# program generuje losowy bit. Aby zilustrować użycie argumentów wejściowych, ten program przyjmuje liczbę całkowitą, ni tablicę kątów, angle, jako dane wejściowe.

   %%qsharp
   import Std.Measurement.*;
   import Std.Arrays.*;
   
   operation GenerateRandomBits(n: Int, angle: Double[]) : Result[] {
      use qubits = Qubit[n]; // n parameter as the size of the qubit array
      for q in qubits {
          H(q);
      }
      R(PauliZ, angle[0], qubits[0]); // arrays as entry-points parameters
      R(PauliZ, angle[1], qubits[1]);
      let results = MeasureEachZ(qubits);
      ResetAll(qubits);
      return results;
   }
   

9. Następnie utworzysz sesję. Załóżmy, że chcesz uruchomić GenerateRandomBit operację trzy razy, dlatego użyjesz target.submit polecenia , aby przesłać Q# operację z target danymi i powtórzyć kod trzy razy — w rzeczywistym scenariuszu możesz przesłać różne programy zamiast tego samego kodu.

   angle = [0.0, 0.0]
   with target.open_session(name="Q# session of three jobs") as session:
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 1", shots=100) # First job submission
       angle[0] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 2", shots=100) # Second job submission
       angle[1] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 3", shots=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

   Ważne

   Po przekazaniu argumentów jako parametrów do zadania, są one formatowane do wyrażenia Q# w momencie, gdy qsharp.compile jest wywoływany. Oznacza to, że należy sformatować argumenty jako Q# obiekty. W tym przykładzie, ponieważ tablice w pliku Python są już drukowane jako [item0, item1, ...], argumenty wejściowe są zgodne z formatowaniem Q# . W przypadku innych Python struktur danych może być potrzebne dodatkowe przetwarzanie, aby wstawione wartości ciągów pasowały w Q# w sposób zgodny.

10. Po utworzeniu sesji można pobrać workspace.list_session_jobs listę wszystkich zadań w sesji. Aby uzyskać więcej informacji, zobacz Jak zarządzać sesjami.

1. Zaimportuj dodatkowe moduły z azure-quantum i qiskit.

   from qdk.qiskit import QuantumCircuit
   from qdk.azure import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   

2. Utwórz obiekt provider przy użyciu informacji o obszarze roboczym Quantum.

   workspace = Workspace(
               resource_id = "", # add your resource ID
               location = "") # add your location
   
   provider = AzureQuantumProvider(workspace)
   

3. Napisz obwód kwantowy. Na przykład poniższy obwód generuje losowy bit.

   circuit = QuantumCircuit(2, 2)
   circuit.name = "GenerateRandomBit"
   circuit.h(0)
   circuit.cx(0,1)
   circuit.measure([0,1], [0,1])
   circuit.draw()
   

4. Utwórz instancję backendu z wybranym kwantem target. W tym przykładzie skonfiguruj element target na symulator IonQ.

   backend = provider.get_backend("ionq.simulator")
   

5. Utwórz sesję. Załóżmy, że chcesz uruchomić obwód kwantowy trzy razy, więc użyjesz backend.run do przesłania obwodu Qiskit i powtórzysz to trzy razy. W rzeczywistym scenariuszu możesz przesłać różne programy zamiast tego samego kodu. Możesz użyć workspace.list_session_jobs polecenia , aby pobrać listę wszystkich zadań w sesji. Aby uzyskać więcej informacji, zobacz Jak zarządzać sesjami.

   with backend.open_session(name="Qiskit Session") as session:
       job1 = backend.run(circuit=circuit, shots=100, job_name="Job 1") # First job submission
       job1.wait_for_final_state()
       job2 = backend.run(circuit=circuit, shots=100, job_name="Job 2") # Second job submission
       job2.wait_for_final_state()
       job3 = backend.run(circuit=circuit, shots=100, job_name="Job 3") # Third job submission
       job3.wait_for_final_state()
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

1. Napisz obwód kwantowy. Na przykład poniższy obwód generuje losowy bit.

   import cirq
   
   q0 = cirq.LineQubit(0)
   q1 = cirq.LineQubit(1)
   circuit = cirq.Circuit(
       cirq.H(q0),  # H gate
       cirq.CNOT(q0, q1),
       cirq.measure(q0, key='q0'),
       cirq.measure(q1, key='q1')
   )
   print(circuit)
   

2. Utwórz obiekt service przy użyciu informacji o obszarze roboczym Quantum.

   from azure.quantum.cirq import AzureQuantumService
   
   service = AzureQuantumService(
               resource_id = "", # add your resource ID
               location = "") # add your location
   

3. Wybierz swój kwantowy target. W tym przykładzie target jest to symulator IonQ.

   Uwaga

   Cirq obwody mogą używać tylko IonQ lub Quantinuum targets.

   target = service.get_target("ionq.simulator")
   

4. Utwórz sesję. Załóżmy, że chcesz uruchomić obwód kwantowy trzy razy, więc użyjesz target.submit do przesłania obwodu Cirq i powtórzysz to trzy razy. W rzeczywistym scenariuszu możesz przesłać różne programy zamiast tego samego kodu. Możesz użyć workspace.list_session_jobs polecenia , aby pobrać listę wszystkich zadań w sesji. Aby uzyskać więcej informacji, zobacz Jak zarządzać sesjami.

   with target.open_session(name="Cirq Session") as session:
       target.submit(program=circuit, name="Job 1", repetitions=100) # First job submission
       target.submit(program=circuit, name="Job 2", repetitions=100) # Second job submission
       target.submit(program=circuit, name="Job 3", repetitions=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]