Show pulses and registers, hide sequences

For pedagogical reasons, we want to show pulses and registers (which will teach our users
something about our architecture) but not pulser.Sequence (which is more of an API detail),
so this reworks the API and tutorial to make it possible.

Author: Yoric

examples/tutorial 1 - Using a Quantum Device to Extract Machine-Learning Features.ipynb

@@ -232,7 +232,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can check the sequence for one of the samples:"
+    "We can check the geometry for one of the samples:"
    ]
   },
   {
@@ -242,7 +242,7 @@
    "outputs": [],
    "source": [
     "dataset_example = processed_dataset[64]\n",
-    "dataset_example.draw_sequence()"
+    "dataset_example.draw_register()"
    ]
   },
   {
@@ -251,7 +251,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dataset_example.draw_register()"
+    "dataset_example.draw_pulse()"
    ]
   },
   {

examples/tutorial 1a - Using a Quantum Device to Extract Machine-Learning Features - low-level.ipynb

@@ -84,11 +84,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Create a Pulser sequence\n",
+    "## Compile a Register and a Pulse\n",
     "\n",
-    "Once the embedding is found, we create a Pulser Sequence that can be interpreted by a Quantum Device.\n",
+    "Once the embedding is found, we compile a Register (the position of atoms on the Quantum Device) and a Pulse (the lasers applied to these atoms).\n",
     "\n",
-    "Not all graphs can be embedded on a given device. In this notebook, for the sake of simplicity, we simply discard graphs that cannot be trivially embedded. Future versions of this library may succeed at embedding more graphs."
+    "Note that not all graphs can be embedded on a given device. In this notebook, for the sake of simplicity, we simply discard graphs that cannot be trivially embedded. Future versions of this library may succeed at embedding more graphs."
    ]
   },
   {
@@ -97,26 +97,27 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from qek.shared.error import CompilationError\n",
+    "\n",
     "compiled = [] \n",
     "\n",
     "for graph in tqdm(graphs_to_compile):\n",
-    "    sequence = None\n",
     "    try:\n",
-    "        sequence = graph.compute_sequence()\n",
-    "    except ValueError:\n",
+    "        register = graph.compile_register()\n",
+    "        pulse = graph.compile_pulse()\n",
+    "    except CompilationError:\n",
     "        # Let's just skip graphs that cannot be computed.\n",
-    "        print(\"Sequence %s cannot be compiled for this device\" % (graph.id, ))\n",
+    "        print(\"Graph %s cannot be compiled for this device\" % (graph.id, ))\n",
     "        continue\n",
-    "    if sequence is not None:\n",
-    "        compiled.append((graph, sequence))\n",
-    "print(\"Compiled %s sequences\" % (len(compiled, )))"
+    "    compiled.append((graph, register, pulse))\n",
+    "print(\"Compiled %s graphs into registers/pulses\" % (len(compiled, )))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's take a look at some of these sequences."
+    "Let's take a look at some of these registers and pulses."
    ]
   },
   {
@@ -125,13 +126,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "example_graph, example_sequence = compiled[64]\n",
+    "example_graph, example_register, example_pulse = compiled[64]\n",
     "\n",
     "# The molecule, as laid out on the Quantum Device.\n",
-    "example_sequence.register.draw(blockade_radius=pl.AnalogDevice.min_atom_distance + 0.01)\n",
+    "example_register.draw(blockade_radius=pl.AnalogDevice.min_atom_distance + 0.01)\n",
     "\n",
     "# The laser pulse used to control its state evolution.\n",
-    "example_sequence.draw()"
+    "example_pulse.draw()"
    ]
   },
   {
@@ -151,10 +152,15 @@
    "source": [
     "import pulser\n",
     "\n",
-    "alternative_sequence = pulser.Sequence(              # A sequence of 0 pulses.\n",
-    "    pulser.Register({\"q0\": (0, 0)}), # A single atom, called q0, at the center of the device.\n",
-    "    pulser.AnalogDevice                       # A generic analog quantum computer.\n",
-    ")\n"
+    "example_register = pulser.Register({\"q0\": (0, 0)})\n",
+    "example_pulse = pulser.Pulse.ArbitraryPhase(\n",
+    "    amplitude=pulser.waveforms.RampWaveform(duration=150, start=100, stop=300),\n",
+    "    phase=pulser.waveforms.ConstantWaveform(duration=150, value=15),\n",
+    "    post_phase_shift=5\n",
+    ")\n",
+    "\n",
+    "example_register.draw()\n",
+    "example_pulse.draw()"
    ]
   },
   {
@@ -180,8 +186,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from pulser_simulation import QutipEmulator\n",
     "from qek.data.dataset import ProcessedData\n",
+    "from qek.backends import QutipBackend\n",
     "\n",
     "# In this tutorial, to make things faster, we'll only run the sequences that require 5 qubits or less.\n",
     "# If you wish to run more entries, feel free to increase this value.\n",
@@ -193,12 +199,12 @@
     "MAX_QUBITS = 5\n",
     "\n",
     "processed_dataset = []\n",
-    "for graph, sequence in tqdm(compiled):\n",
-    "    if len(sequence.qubit_info) > MAX_QUBITS:\n",
+    "executor = QutipBackend(device=pl.AnalogDevice)\n",
+    "for graph, register, pulse in tqdm(compiled):\n",
+    "    if len(register.qubits) > MAX_QUBITS:\n",
     "        continue\n",
-    "    simulator = QutipEmulator.from_sequence(sequence=sequence)\n",
-    "    states = simulator.run().sample_final_state()\n",
-    "    processed_dataset.append(ProcessedData(sequence=sequence, state_dict=states, target=graph.target))"
+    "    states = await executor.run(register=register, pulse=pulse)\n",
+    "    processed_dataset.append(ProcessedData.from_register(register=register, pulse=pulse, device=pl.AnalogDevice, state_dict=states, target=graph.target))"
    ]
   },
   {
@@ -233,11 +239,10 @@
     "HAVE_PASQAL_ACCOUNT = False # If you have a PASQAL Cloud account, fill in the details and set this to `True`.\n",
     "\n",
     "if HAVE_PASQAL_ACCOUNT: \n",
+    "    from qek.backends import RemoteQPUBackend\n",
     "    processed_dataset = []\n",
     "\n",
     "    # Initialize connection\n",
-    "    from pulser.json.abstract_repr.deserializer import deserialize_device\n",
-    "    from pasqal_cloud import SDK\n",
     "\n",
     "    my_project_id = \"your_project_id\"# Replace this value with your project_id on the PASQAL platform.\n",
     "    my_username   = \"your_username\"  # Replace this value with your username or email on the PASQAL platform.\n",
@@ -246,62 +251,36 @@
     "        # See the documentation of PASQAL Cloud for other ways to provide your password.\n",
     "\n",
     "    # Initialize the cloud client\n",
-    "    sdk = SDK(username=my_username, project_id=my_project_id, password=my_password)\n",
+    "    executor = RemoteQPUBackend(username=my_username, project_id=my_project_id, password=my_password)\n",
     "\n",
-    "    # Fetch the latest lists of QPUs\n",
-    "    specs = sdk.get_device_specs_dict()\n",
-    "    # We'll use \"Fresnel\", generally the recommended QPU on PASQAL Cloud as of this writing.\n",
-    "    device = deserialize_device(specs[\"FRESNEL\"])\n",
+    "    # Fetch the specification of our QPU\n",
+    "    device = await executor.device()\n",
     "\n",
     "    # As previously, create the list of graphs and embed them.\n",
     "    graphs_to_compile = []\n",
     "    for i, data in enumerate(tqdm(og_ptcfm)):\n",
-    "        graph = qek_graphs.MoleculeGraph(data=data, device=device, id=i)\n",
+    "        graph = qek_graphs.PTCFMGraph(data=data, device=device, id=i)\n",
     "        graphs_to_compile.append(graph)\n",
     "\n",
     "    compiled = []\n",
     "    for graph in tqdm(graphs_to_compile):\n",
     "        sequence = None\n",
     "        try:\n",
-    "            sequence = graph.compute_sequence()\n",
-    "        except ValueError:\n",
+    "            register = graph.compile_register()\n",
+    "            pulse = graph.compile_pulse()\n",
+    "        except CompilationError:\n",
     "            # Let's just skip graphs that cannot be computed.\n",
     "            print(\"Sequence %s cannot be compiled for this device\" % (graph.id, ))\n",
     "            continue\n",
-    "        if sequence is not None:\n",
-    "            compiled.append((graph, sequence))\n",
+    "    compiled.append((graph, register, pulse))\n",
     "\n",
     "    # Now that the connection is initialized, we just have to send the work\n",
     "    # to the QPU and wait for the results.\n",
-    "    for graph, sequence in tqdm(compiled):\n",
-    "\n",
-    "        # Send the work to the QPU.\n",
-    "        batch = sdk.create_batch(\n",
-    "            # The sequence.\n",
-    "            sequence.to_abstract_repr(),\n",
-    "\n",
-    "            # Run each sequence 1000 times to refine results. Recall that quantum computations\n",
-    "            # are probabilistic, so you need to run each sequence many times to progressively\n",
-    "            # refine your probability distribution.\n",
-    "            jobs=[{\"runs\": 1000}],\n",
-    "\n",
-    "            # And wait for the results.\n",
-    "            #\n",
-    "            # WARNING\n",
-    "            #\n",
-    "            # # Wait lines\n",
-    "            #\n",
-    "            # As of this writing, the waiting line to access a QPU can be very long (typically\n",
-    "            # several hours). Argument `wait=True` will stop your program until the batch has\n",
-    "            # completed. You will have to determine whether that's what you want.\n",
-    "            wait=True,\n",
-    "        )\n",
-    "\n",
-    "        # The sdk returns a single job.\n",
-    "        job = batch.jobs[0]\n",
-    "        assert job.status == \"DONE\"\n",
-    "        states = job.result\n",
-    "        processed_dataset.append(ProcessedData(sequence=sequence, state_dict=states, target=graph.target))"
+    "    for graph, register, pulse in tqdm(compiled):\n",
+    "\n",
+    "        # Send the work to the QPU and await the result\n",
+    "        states = await executor.run(register=register, pulse=pulse)\n",
+    "        processed_dataset.append(ProcessedData.from_register(register=register, pulse=pulse, device=device, state_dict=states, target=graph.target))"
    ]
   },
   {
@@ -345,7 +324,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can check the sequence for one of the samples:"
+    "Let's take a look at one of our samples:"
    ]
   },
   {
@@ -354,8 +333,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dataset_example = processed_dataset[64]\n",
-    "dataset_example.draw_sequence()"
+    "from qek.data.dataset import ProcessedData\n",
+    "\n",
+    "# The geometry we compiled from this graph for execution on the Quantum Device.\n",
+    "dataset_example: ProcessedData = processed_dataset[64]\n",
+    "dataset_example.draw_register()"
    ]
   },
   {
@@ -364,7 +346,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dataset_example.draw_register()"
+    "# The laser pulses we used to drive the execution on the Quantum Device.\n",
+    "dataset_example.draw_pulse()"
    ]
   },
   {

pyproject.toml

@@ -38,6 +38,7 @@ dependencies = [
   "torch_geometric",
   "matplotlib",
   "emu-mps~=1.2.0",
+  "pasqal-cloud",
 ]
 
 [tool.hatch.metadata]