Wprowadzenie do sesji

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

1. W programie VS Code wybierz pozycję Wyświetl paletę poleceń i wybierz pozycję Utwórz: nowy notes Jupyter.>

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 środowisko nie zostało wykryte, zobacz Jupyter Notebooks in VS Code (Notesy Jupyter Notebooks w programie VS Code ), aby uzyskać informacje o konfiguracji.

3. W pierwszej komórce notesu uruchom polecenie

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

4. Kliknij pozycję + Kod , aby dodać nową komórkę w notesie i zaimportować qsharp zestaw SDK języka Python.

   import qsharp
   

5. Wybierz wybrany kwanttarget. W tym przykładzie używasz symulatora IonQ jako target.

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

6. Wybierz konfiguracje target profilu , Baselub Adaptive_RIUnrestricted.

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

   Uwaga

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

7. 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;
   }
   

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

   Podczas przekazywania argumentów jako parametrów do zadania są one formatowane w wyrażeniu Q# podczas wywoływania elementu qsharp.compile. Oznacza to, że należy zachować ostrożność, aby sformatować argumenty jako Q# obiekty. W tym przykładzie, ponieważ tablice w języku Python są już drukowane jako [item0, item1, ...], argumenty wejściowe są zgodne z formatowaniem Q# . W przypadku innych struktur danych języka Python może być potrzebna większa obsługa, aby uzyskać wartości ciągów wstawione w Q# zgodny sposób.

9. 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. Najpierw należy zaimportować dodatkowe moduły z azure-quantum i qiskit. Następnie utwórz provider obiekt przy użyciu informacji o obszarze roboczym quantum.

   from qiskit import QuantumCircuit
   from azure.quantum import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   
   workspace = Workspace(
               resource_id = "", # add your resource ID
               location = "") # add your location
   
   provider = AzureQuantumProvider(workspace)
   

2. 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()
   

3. Następnie utwórz wystąpienie zaplecza z wybranym kwantem target . W tym przykładzie targetustaw symulator IonQ jako .

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

4. Następnie utwórz sesję. Załóżmy, że chcesz uruchomić obwód kwantowy trzy razy, więc użyjesz backend.run metody do przesłania obwodu Qiskit i powtórzysz kod 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. Najpierw 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. Następnie utwórz service obiekt 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 wybrany kwanttarget. W tym przykładzie używasz symulatora IonQ jako target.

   Uwaga

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

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

4. Następnie utworzysz sesję. Załóżmy, że chcesz uruchomić obwód kwantowy trzy razy, więc użyjesz target.submit metody do przesłania obwodu Cirq i powtórzysz kod 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]