{ "cells": [ { "cell_type": "markdown", "id": "65ddb2a6", "metadata": {}, "source": [ "(sec-tutorial-schedulegettable)=\n", "\n", "# Tutorial: ScheduleGettable\n", "\n", "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`ScheduleGettable.ipynb`\n", "```\n", "\n", "This tutorial covers the {class}`~quantify_scheduler.gettables.ScheduleGettable` in-depth. If you're looking for more information on how to set up an experiment in general, please see {ref}`sec-tutorial-experiment`.\n", "\n", "The {class}`~quantify_scheduler.gettables.ScheduleGettable` forms the top-level interface to {mod}`quantify_scheduler`. Under the hood, it uses `quantify-scheduler` modules to compile {ref}`Schedules `, run them on your hardware and retrieve measurement data from the hardware. As the {class}`~quantify_scheduler.gettables.ScheduleGettable` uses functions that return {class}`~quantify_scheduler.schedules.schedule.Schedule`s, you can dynamically set function parameters during experiments.\n", "\n", "For those familiar with [quantify-core](https://quantify-os.org/docs/quantify-core), the interface of the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also designed to be used as a [gettable](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#settables-and-gettables) for [MeasurementControl](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#measurement-control). This is convenient for large, possibly multi-dimensional measurement loops, as is demonstrated in {ref}`2D (and ND) measurement loops`.\n", "\n", "Two things are always required when using a {class}`~quantify_scheduler.gettables.ScheduleGettable`: a {ref}`QuantumDevice ` and a function that returns a {class}`~quantify_scheduler.schedules.schedule.Schedule`. We will set these up in a few example scenarios below and show how to use the {class}`~quantify_scheduler.gettables.ScheduleGettable`. More commonly used schedule functions are also included in `quantify-scheduler` out of the box. You can find them in {mod}`~.quantify_scheduler.schedules.spectroscopy_schedules`, {mod}`~.quantify_scheduler.schedules.timedomain_schedules` and {mod}`~.quantify_scheduler.schedules.trace_schedules`.\n", "\n", "(sec-schedulegettable-1dsweep-usage)=\n", "\n", "## 1D iterative measurement loop\n", "\n", "\n", "```{admonition} Setup and hardware configuration\n", "The device setup and hardware configuration for this tutorial can be viewed in the collapsed code cells. In places where you would communicate with actual hardware, dummy objects have been used. If you want to learn more about how to set up the {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` and hardware configuration, please see our other tutorials, in particular {ref}`sec-tutorial-experiment` and {ref}`sec-tutorial-compiling`.\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "id": "cf8e7c7f", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data will be saved in:\n", "/root/quantify-data\n" ] } ], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "from quantify_core.data import handling as dh\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "from quantify_scheduler.helpers.qblox_dummy_instrument import start_dummy_cluster_armed_sequencers\n", "\n", "\n", "# First, don't forget to set the data directory!\n", "dh.set_datadir() # change me!\n", "\n", "# We define a single transmon qubit as an element (BasicTransmonElement) of the\n", "# QuantumDevice, and populate the parameters with some reasonable values.\n", "\n", "# Device parameters\n", "ACQ_DELAY = 100e-9\n", "FREQ_01 = 4e9\n", "READOUT_AMP = 0.1\n", "READOUT_FREQ = 4.3e9\n", "PI_PULSE_AMP = 0.15\n", "LO_FREQ_QUBIT = 3.9e9\n", "LO_FREQ_READOUT = 4.5e9\n", "\n", "single_qubit_device = QuantumDevice(\"single_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "single_qubit_device.add_element(q0)\n", "\n", "# Assign device parameters to transmon element\n", "q0.measure.pulse_amp(READOUT_AMP)\n", "q0.clock_freqs.readout(READOUT_FREQ)\n", "q0.clock_freqs.f01(FREQ_01)\n", "q0.measure.acq_delay(ACQ_DELAY)\n", "q0.rxy.amp180(PI_PULSE_AMP)\n", "\n", "# For this example, we will set up a Qblox cluster hardware setup with two modules: a\n", "# QRM-RF and a QCM-RF.\n", "\n", "# Note: if you are connecting to an actual cluster, you would provide the\n", "# 'identifier' argument (the ip address, device name or serial number) instead\n", "# of the 'dummy_cfg' argument.\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "# We create an InstrumentCoordinator to control the cluster and add it to the\n", "# QuantumDevice.\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "# A basic hardware configuration will be used for the two cluster modules.\n", "\n", "hardware_cfg = {\n", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\",\n", " f\"{cluster.name}\": {\n", " \"ref\": \"internal\",\n", " \"instrument_type\": \"Cluster\",\n", " f\"{cluster.module1.name}\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": LO_FREQ_READOUT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:res\",\n", " \"clock\": \"q0.ro\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module2.name}\": {\n", " \"instrument_type\": \"QCM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": LO_FREQ_QUBIT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:mw\",\n", " \"clock\": \"q0.01\",\n", " }\n", " ],\n", " },\n", " },\n", " },\n", "}\n", "\n", "# This hardware configuration should also be added to the quantum device.\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "91c7b9b3", "metadata": {}, "source": [ "For this experiment, we have set up a basic {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` called `single_qubit_device`, representing a single transmon qubit.\n", "\n", "We'll now define the schedule function. A valid schedule function must contain a `repetitions` (integer) parameter (see {ref}`Repetitions`), and can contain any number of additional parameters. It must return a {class}`~quantify_scheduler.schedules.schedule.Schedule` object.\n", "\n", "The schedule function can be parameterized to loop over different values. The parameters can be scalars or arrays. For example, the schedule function defined below takes an array of values for the parameter `times`. This is called a _batched_ measurement, as will be explained further in this tutorial." ] }, { "cell_type": "code", "execution_count": 2, "id": "e05636d5", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library import Measure, Reset, X\n", "\n", "def t1_sched(times, repetitions=1):\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(\"q0\"), label=f\"Reset {i}\")\n", " schedule.add(X(\"q0\"), label=f\"pi {i}\")\n", " # Measure tau seconds after the start of the X gate\n", " schedule.add(\n", " Measure(\"q0\", acq_index=i),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "f56074b1", "metadata": {}, "source": [ "Now, let's create the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_scheduler.gettables.ScheduleGettable` provides a convenient way to compile and execute schedules in just a few lines of code. The parameters can be set directly, with arrays and scalars, or through QCoDeS parameters, as shown below." ] }, { "cell_type": "code", "execution_count": 3, "id": "2164131f", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from qcodes.instrument.parameter import ManualParameter\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "\n", "# The points we want to measure.\n", "times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)\n", "\n", "# As QCoDeS parameter:\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "# Set the parameter. This can be done even after defining the gettable!\n", "time(times)\n", "\n", "# Or as array:\n", "time = times\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"times\": time},\n", " batched=True\n", ")" ] }, { "cell_type": "markdown", "id": "73b64180", "metadata": {}, "source": [ "Note that `batched=True` here. This means we are doing a _batched_ measurement, which simply means that we tell the {class}`~quantify_scheduler.gettables.ScheduleGettable` to expect an array of values in the acquisition result. In this case, our schedule function creates one schedule for an array of times, and it includes an acquisition (the {class}`~quantify_scheduler.operations.gate_library.Measure` operation) for each point." ] }, { "cell_type": "code", "execution_count": 4, "id": "02436503", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "import xarray\n", "\n", "from quantify_scheduler.waveforms import soft_square\n", "\n", "from qblox_instruments import DummyScopeAcquisitionData, DummyBinnedAcquisitionData\n", "\n", "\n", "soft_sq_samples = round(q0.measure.integration_time() * 1e9)\n", "soft_sq_times = np.arange(soft_sq_samples)\n", "soft_sq = soft_square(t=soft_sq_times, amp=0.5)\n", "scope_data_real = np.zeros(16384) # Scope trace acquires 16384 points\n", "scope_data_real[:soft_sq_samples] = soft_sq\n", "scope_data_real += np.random.randn(16384) / 500 # add some \"noise\"\n", "\n", "# Create dummy scope data with the soft square pulse on the I path and noise on\n", "# the Q path\n", "scope_data = list(zip(scope_data_real, np.random.randn(16384) / 500))\n", "\n", "dummy_scope_acquisition_data = DummyScopeAcquisitionData(\n", " data=scope_data, out_of_range=(False, False), avg_cnt=(0, 0)\n", " )\n", "\n", "ic_cluster.instrument.set_dummy_scope_acquisition_data(\n", " slot_idx=1, sequencer=None, data=dummy_scope_acquisition_data\n", ")\n", "\n", "\n", "# Dataset with T1 experiment data\n", "example_dataset = xarray.open_dataset(\"../examples/dataset.hdf5\")\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re) * 1024, float(im) * 1024)\n", " for re, im in zip(example_dataset[\"y0\"], example_dataset[\"y1\"])\n", " ],\n", ")" ] }, { "cell_type": "markdown", "id": "8a8b4cc7", "metadata": {}, "source": [ "Let's now run the experiment and retrieve the acquisitions using the {meth}`~quantify_scheduler.gettables.ScheduleGettable.get` method." ] }, { "cell_type": "code", "execution_count": 5, "id": "1d3af341", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(times, data[0], '.', label=\"real\")\n", "plt.plot(times, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Idle time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "7f434512", "metadata": {}, "source": [ "Note that the data used here is the same as in {ref}`sec-tutorial-experiment`. The example dataset can be downloaded {download}`here <../examples/dataset.hdf5>`.\n", "\n", "As we defined 125 points in our `times` array which were measured in 125 different `acq_index`es, the acquisition result also contains 125 _I_ values (in `data[0][:]`) and 125 _Q_ values (in `data[1][:]`). The general format of the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also explained in the {ref}`user guide `.\n", "\n", "## Trace measurement\n", "\n", "The previous experiment's acquisition results had one data point for each acquisition in the schedule. For a trace measurement, the data format is slightly different. To illustrate this, let us set up an experiment with a trace measurement." ] }, { "cell_type": "code", "execution_count": 6, "id": "b082029d", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations.pulse_library import IdlePulse, SoftSquarePulse\n", "\n", "\n", "def trace_schedule(pulse_amp, acq_delay, port=\"q0:res\", clock=\"q0.ro\", repetitions=1):\n", " schedule = Schedule(\"Trace a pulse\", repetitions=repetitions)\n", "\n", " schedule.add(\n", " SoftSquarePulse(\n", " duration=q0.measure.integration_time(),\n", " amp=pulse_amp,\n", " port=port,\n", " clock=clock,\n", " ),\n", " label=\"trace_pulse\",\n", " )\n", "\n", " # Add acq_delay to compensate for time-of-flight of the pulse\n", " schedule.add(\n", " Measure(q0.name, acq_protocol=\"Trace\"),\n", " ref_pt=\"start\",\n", " rel_time=acq_delay,\n", " label=\"acquisition\"\n", " )\n", "\n", " return schedule" ] }, { "cell_type": "markdown", "id": "658f3e74", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "64436c51", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:757: RuntimeWarning: Operation is interrupting previous Pulse because it starts before the previous ends, offending operation: Pulse \"Measure q0\" (t0=1e-07, duration=3e-07)\n", " warnings.warn(\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=trace_schedule,\n", " schedule_kwargs={\n", " \"pulse_amp\": 0.5,\n", " \"acq_delay\": 100e-9,\n", " },\n", " batched=True,\n", ")\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(np.arange(1000)/1e9, data[0], '.', label=\"real\")\n", "plt.plot(np.arange(1000)/1e9, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "965e769b", "metadata": {}, "source": [ "This time, there is only one acquisition operation in the schedule. The measurement result contains two arrays: one for the _I_ values (`data[0][:]`), and one for the _Q_ values (`data[1][:]`) of the acquired trace.\n", "\n", "## MeasurementControl\n", "\n", "Iterating through different parameters can be done with some help from `quantify-core` as well, through the {class}`~quantify_core.measurement.control.MeasurementControl` class. The {class}`~quantify_core.measurement.control.MeasurementControl` uses settables (parameters to vary in an experiment) and gettables (in this case, our {class}`~quantify_scheduler.gettables.ScheduleGettable`). The settable must be a class that implements `set()`, such as a QCoDeS {class}`~qcodes.parameters.ManualParameter`.\n", "\n", "In this example, the settable is the `time` object, and the setpoints are a numpy array of values (`times`). These are added to the {class}`~quantify_core.measurement.control.MeasurementControl` as shown, together with the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_core.measurement.control.MeasurementControl` object will be in charge of setting the setpoints, and retrieving the measurement results through the gettable." ] }, { "cell_type": "code", "execution_count": 8, "id": "81802baf", "metadata": {}, "outputs": [], "source": [ "from quantify_core.measurement.control import MeasurementControl\n", "\n", "\n", "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settable\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "time.batched = True\n", "\n", "times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"times\": time},\n", " batched=True\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables(time)\n", "measurement_control.setpoints(times)\n", "measurement_control.gettables(gettable)" ] }, { "cell_type": "markdown", "id": "9d587800", "metadata": {}, "source": [ "The experiment is set to run fully in _batched_ mode. When using {class}`~quantify_core.measurement.control.MeasurementControl`, settables and gettables can be either batched (an array of points is set for each measurement iteration) or iterative (only one point is set per iteration). Combinations of batched and iterative settables are possible, as explained in detail in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#mixing-iterative-and-batched-settables).\n", "\n", "Settables and gettables are batched if they have the attribute `batched=True`. In {class}`~quantify_scheduler.gettables.ScheduleGettable`, this can be controlled through the `batched` argument when creating the class. For other classes, the attribute can be added dynamically if needed, as shown above for the `time` parameter.\n", "\n", "With both the gettable and the settable having `batched=True`, the {class}`~quantify_core.measurement.control.MeasurementControl` knows that it should set the entire `times` array as the settable's value (instead of repeating the experiment for each value in the array). All data points are measured without interruption and all measurement results are returned in one go. Now, let's run the experiment and retrieve the data." ] }, { "cell_type": "code", "execution_count": 9, "id": "bfd77167", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t --- (None) --- \n", "Batched settable(s):\n", "\t sample \n", "Batch size limit: 125\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c67c8125cd6340e39987a0d5cbd19a2d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dataset = measurement_control.run()" ] }, { "cell_type": "markdown", "id": "1f3966d1", "metadata": {}, "source": [ "The {class}`~quantify_core.measurement.control.MeasurementControl` class processes the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable`, and turns it into a {class}`~xarray.Dataset`. More information on the format of this dataset can be found in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#dataset)." ] }, { "cell_type": "code", "execution_count": 10, "id": "eed4c989", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 3kB\n",
       "Dimensions:  (dim_0: 125)\n",
       "Coordinates:\n",
       "    x0       (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n",
       "    y1       (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n",
       "Attributes:\n",
       "    tuid:                             20240502-150615-936-da8a59\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         False\n",
       "    1d_2_settables_uniformly_spaced:  False
" ], "text/plain": [ " Size: 3kB\n", "Dimensions: (dim_0: 125)\n", "Coordinates:\n", " x0 (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n", "Dimensions without coordinates: dim_0\n", "Data variables:\n", " y0 (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n", " y1 (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n", "Attributes:\n", " tuid: 20240502-150615-936-da8a59\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dataset" ] }, { "cell_type": "markdown", "id": "739fd2bc", "metadata": {}, "source": [ "The dataset coordinates and data variables are named as generic `x` and `y` parameters. You can click on the 'Show/Hide attributes' button next to the coordinates and variables to see what they refer to.\n", "\n", "(sec-tutorial-schedulegettable-repetitions)=\n", "## Repetitions\n", "\n", "Repetition defines how many times the defined schedule will run on the hardware. Running the schedule multiple times can be useful for example if the user would like to reduce errors of acquisitions by averaging the result of multiple measurements.\n", "\n", "There are multiple ways the repetitions can be set. They are not completely independent of each other, and which setting will be taken into account depends on how you create and use the schedule.\n", "\n", "1. {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`: via `cfg_sched_repetitions` (by default it is `1024`),\n", "2. schedule function: via the `repetitions` function argument,\n", "3. {class}`~quantify_scheduler.schedules.schedule.Schedule` object: via the `repetitions` function argument of its constructor, or via its `repetitions` attribute directly,\n", "4. ({class}`~quantify_scheduler.gettables.ScheduleGettable`: currently, it is not possible to supply `repetitions` via `schedule_kwargs`).\n", "\n", "Ultimately, the {class}`~quantify_scheduler.schedules.schedule.Schedule` object is what governs the repetitions, via its `repetitions` attribute.\n", "\n", "When using a schedule function, the `repetitions` function argument sets the repetitions, provided that the schedule function passes it to the `Schedule` object. This is true for the pre-defined schedules, see {mod}`!quantify_scheduler.schedules`.\n", "\n", "However, if the experiment is run using `ScheduleGettable`, this `repetitions` function argument is set to `QuantumDevice.cfg_sched_repetitions`. Hence, typically, the schedule will run `QuantumDevice.cfg_sched_repetitions` times.\n", "\n", "### Possible mistake: ignoring `repetitions` argument\n", "\n", "Keep in mind that the schedule function should pass the `repetitions` argument to the `Schedule` initializer, otherwise both `QuantumDevice.cfg_sched_repetitions` and the `repetitions` argument of the schedule function will be ignored. For example, in the following setup, the `repetitions` will always be `1` (default for the `Schedule` object), even if `cfg_sched_repetitions` is set to `2`." ] }, { "cell_type": "code", "execution_count": 11, "id": "0e7c9631", "metadata": {}, "outputs": [], "source": [ "def schedule_function(q0: str, repetitions: int):\n", " schedule = Schedule(\"Example schedule\")\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "quantum_device.cfg_sched_repetitions(2)\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "97359847", "metadata": {}, "source": [ "### Possible mistake: ignoring `cfg_sched_repetitions` default value\n", "\n", "Also note, that the default value of the `repetitions` argument of the schedule function will be ignored if `ScheduleGettable` is used, and it will be set to `QuantumDevice.cfg_sched_repetitions`. For example, in the following setup, `repetitions` will be `1024` (default for `QuantumDevice`), even if the default argument for `repetitions` is `2`." ] }, { "cell_type": "code", "execution_count": 12, "id": "5a46056f", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "91bde55f", "metadata": {}, "outputs": [], "source": [ "def schedule_function(q0: str, repetitions: int = 2):\n", " schedule = Schedule(\"Example schedule\", repetitions=repetitions)\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "31063366", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "7deead1b", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import Cluster, ClusterType, DummyBinnedAcquisitionData\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "\n", "\n", "single_qubit_device.close_all()\n", "\n", "# Device parameters\n", "Q0_ACQ_DELAY = 100e-9\n", "Q0_FREQ_01 = 4e9\n", "Q0_READOUT_AMP = 0.1\n", "Q0_READOUT_FREQ = 4.3e9\n", "Q0_PI_PULSE_AMP = 0.15\n", "Q0_LO_FREQ_QUBIT = 3.9e9\n", "Q0_LO_FREQ_READOUT = 4.5e9\n", "\n", "Q1_ACQ_DELAY = 120e-9\n", "Q1_FREQ_01 = 4.1e9\n", "Q1_READOUT_AMP = 0.1\n", "Q1_READOUT_FREQ = 3.8e9\n", "Q1_PI_PULSE_AMP = 0.15\n", "Q1_LO_FREQ_QUBIT = 4.1e9\n", "Q1_LO_FREQ_READOUT = 3.8e9\n", "\n", "two_qubit_device = QuantumDevice(\"two_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "q0.measure.acq_channel(0)\n", "q0.measure.pulse_amp(Q0_READOUT_AMP)\n", "q0.clock_freqs.readout(Q0_READOUT_FREQ)\n", "q0.clock_freqs.f01(Q0_FREQ_01)\n", "q0.measure.acq_delay(Q0_ACQ_DELAY)\n", "q0.rxy.amp180(Q0_PI_PULSE_AMP)\n", "\n", "q1 = BasicTransmonElement(\"q1\")\n", "q1.measure.acq_channel(1) # Note that we're specifying that measurements on q1 should use a different measurement channel\n", "q1.measure.pulse_amp(Q1_READOUT_AMP)\n", "q1.clock_freqs.readout(Q1_READOUT_FREQ)\n", "q1.clock_freqs.f01(Q1_FREQ_01)\n", "q1.measure.acq_delay(Q1_ACQ_DELAY)\n", "q1.rxy.amp180(Q1_PI_PULSE_AMP)\n", "\n", "two_qubit_device.add_element(q0)\n", "two_qubit_device.add_element(q1)\n", "\n", "# We will need to adjust the hardware configuration.\n", "\n", "# Note: if you are connecting to an actual cluster, you would provide the\n", "# 'identifier' argument (the ip address, device name or serial number) instead\n", "# of the 'dummy_cfg' argument.\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " 3: ClusterType.CLUSTER_QRM_RF,\n", " 4: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "two_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "hardware_cfg = {\n", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\",\n", " f\"{cluster.name}\": {\n", " \"ref\": \"internal\",\n", " \"instrument_type\": \"Cluster\",\n", " f\"{cluster.module1.name}\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q0_LO_FREQ_READOUT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:res\",\n", " \"clock\": \"q0.ro\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module2.name}\": {\n", " \"instrument_type\": \"QCM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q0_LO_FREQ_QUBIT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:mw\",\n", " \"clock\": \"q0.01\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module3.name}\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q1_LO_FREQ_READOUT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q1:res\",\n", " \"clock\": \"q1.ro\",\n", " }\n", " ],\n", " },\n", " },\n", " f\"{cluster.module4.name}\": {\n", " \"instrument_type\": \"QCM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": Q1_LO_FREQ_QUBIT,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q1:mw\",\n", " \"clock\": \"q1.01\",\n", " }\n", " ],\n", " },\n", " },\n", " },\n", "}\n", "\n", "two_qubit_device.hardware_config(hardware_cfg)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")" ] }, { "cell_type": "markdown", "id": "70fba487", "metadata": {}, "source": [ "2D and higher-dimensional measurement loops are easy to realize. Below we show an example Chevron experiment, which is a type of two-qubit experiment often performed on transmon qubits. The experiment includes a square pulse, and we want to vary both its amplitude and duration in a 2D grid. We have already set up a two-qubit {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` under the variable name `two_qubit_device`.\n", "\n", "We define simple schedule below with a parameterized amplitude and duration of the square pulse. `duration` and `amp` are scalars, so for each measurement point the schedule will be recompiled." ] }, { "cell_type": "code", "execution_count": 15, "id": "ae7d1dd7", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library import Measure, Reset, X, X90\n", "from quantify_scheduler.operations.pulse_library import SquarePulse\n", "\n", "def chevron_schedule_not_batched(duration, amp, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\") # Start at the end of the reset\n", " # We specify a clock for tutorial purposes, Chevron experiments do not necessarily use modulated square pulses\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square) # Start at the end of the square pulse\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\", # Start at the same time as the other measure\n", " )\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "eaf3d3c2", "metadata": {}, "source": [ "We set up a non-batched measurement with {class}`~quantify_core.measurement.control.MeasurementControl` and a {class}`~quantify_scheduler.gettables.ScheduleGettable`. For this {class}`~quantify_scheduler.gettables.ScheduleGettable`, notice the keyword argument `num_channels=2`, which is needed since we specified in the quantum device elements that the measurements on `\"q0\"` and `\"q1\"` should end up in two different channels.\n", "\n", "In addition, we used another new argument in the {class}`~quantify_scheduler.gettables.ScheduleGettable`: `real_imag=False`. `real_imag` can be used to transform the acquisition data. If it is `True` (the default), the I and Q values will be returned, and if it is `False`, the data will be transformed to the absolute value and the phase (in degrees, in the interval `(-180, 180]`)." ] }, { "cell_type": "code", "execution_count": 16, "id": "32f6af5d", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5b8ddfe3795a495594bd27d4ffabb5f5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = False\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_not_batched,\n", " schedule_kwargs={\"duration\": duration, \"amp\": amplitude},\n", " batched=False,\n", " real_imag=False,\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes]) # note: setpoints_grid instead of setpoints\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 17, "id": "e5778719", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y1       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y2       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y3       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "Attributes:\n",
       "    tuid:                             20240502-150617-038-0178f8\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y1 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y2 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y3 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", "Attributes:\n", " tuid: 20240502-150617-038-0178f8\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "4ebc47c0", "metadata": {}, "source": [ "As expected, this dataset contains double the amount of coordinates and data variables (note that the actual data has been mocked and set to 0.0). The two coordinates refer to the settables, `duration` and `amplitude`. With `real_imag` now set to `False`, the data variables contain the magnitude and phase (as opposed to the I and Q voltages) for measurements on `\"q0\"` and `\"q1\"`.\n", "\n", "### Batched 2D experiment\n", "\n", "Since this measurement is not batched, it's rather slow. Let's make this faster with (partial) batching.\n", "\n", "We will batch the amplitudes together, so we change the amplitudes parameter in the schedule function to an array." ] }, { "cell_type": "code", "execution_count": 18, "id": "53a3fe0b", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import DummyBinnedAcquisitionData\n", "\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")" ] }, { "cell_type": "code", "execution_count": 19, "id": "c3b0b874", "metadata": {}, "outputs": [], "source": [ "def chevron_schedule_batched(duration, amps, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " for amp in amps:\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\")\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square)\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\",\n", " )\n", "\n", " acq_idx += 1\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "6a52fd9c", "metadata": {}, "source": [ "We specify that we want to batch the amplitudes by setting ``amplitude.batched = True`` and ``batched=True``as keyword argument for the gettable. Finally, we run this experiment just as before." ] }, { "cell_type": "code", "execution_count": 20, "id": "bbf3976b", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t duration \n", "Batched settable(s):\n", "\t amplitude \n", "Batch size limit: 60\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "65672b7ba65846ffb7bd99367d3afd23", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = True\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_batched,\n", " schedule_kwargs={\"duration\": duration, \"amps\": amplitude},\n", " batched=True,\n", " real_imag=False,\n", " data_labels=[\"Magnitude Q0\", \"Phase Q0\", \"Magnitude Q1\", \"Phase Q1\"],\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes])\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 21, "id": "8dbe6678", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y1       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "    y2       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y3       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "Attributes:\n",
       "    tuid:                             20240502-150621-671-187689\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y1 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", " y2 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y3 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", "Attributes:\n", " tuid: 20240502-150621-671-187689\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "30435c3a", "metadata": {}, "source": [ "The shape of the dataset is no different from the previous (non-batched) experiment, but the metadata is a little different. Some coordinates and data variables now have the `batched=True` attribute. We also introduced another keyword argument: the `data_labels`. These `data_labels` are picked up by the {class}`~quantify_core.measurement.control.MeasurementControl`and end up in the {class}`xarray.Dataset` as the \"long_name\" of attributes. For example, `\"y0\"`s label can be accessed through `dataset[\"y0\"].attrs[\"long_name\"]`. The various plotting features of `quantify-core` will use this name to get labels for the figure axes." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.19" }, "source_map": [ 6, 34, 140, 148, 165, 169, 194, 198, 246, 250, 262, 272, 298, 302, 321, 331, 355, 363, 368, 372, 374, 400, 416, 422, 429, 444, 450, 593, 599, 623, 629, 666, 668, 678, 698, 720, 724, 760, 762 ], "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "1ea8ea1ca0f84e84bdc461d8d49c371c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "3240ae2b8bef45e4b286347856b641b6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "3c4094dd60964dd9a9beedfd211be83f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "3ec63f526f51429da8933982bd63f9a1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "46632a7f919249ffb8de012e9e509717": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_af6b8c54b3164afc89bc06587025c21c", "placeholder": "​", "style": "IPY_MODEL_3ec63f526f51429da8933982bd63f9a1", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "51a50ef6a9bc4c64bb6346869acb2711": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "5b8ddfe3795a495594bd27d4ffabb5f5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_ae64aa4ff79346d5a2376964f27e0dc6", "IPY_MODEL_d8db460398bd4f63ade14b285118a7eb", "IPY_MODEL_cfcdac24161347de8385d445cb5e4987" ], "layout": "IPY_MODEL_f95f82747a8143b097f1db2978a2d23a", "tabbable": null, "tooltip": null } }, "5d080b8ebd484c37a80988a0e08b8c16": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "65672b7ba65846ffb7bd99367d3afd23": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_46632a7f919249ffb8de012e9e509717", "IPY_MODEL_c09758e12f3245f88c11f2e9b2f8e2a6", "IPY_MODEL_8140006c2a774663aae07580e91e40a0" ], "layout": "IPY_MODEL_9180b111305d4871873b6cbec5f0742f", "tabbable": null, "tooltip": null } }, "6b099b59851648ec8d4263f64bd77369": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8140006c2a774663aae07580e91e40a0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_a1a4eb0a90b04e559f2863b78b8c42c1", "placeholder": "​", "style": "IPY_MODEL_51a50ef6a9bc4c64bb6346869acb2711", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "8bc3cdb0b76a40768e3b48b654e513a3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8f015551e4f64a0ba50b09941cd4858d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "9180b111305d4871873b6cbec5f0742f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "93f09720627d4328913b6cd50d5dc1f9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_6b099b59851648ec8d4263f64bd77369", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_dfed7e022f05471fbc9453427fb78fad", "tabbable": null, "tooltip": null, "value": 100.0 } }, "9d0616cde3b44a4fbf84ec8dd5896b73": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_f92ce9cce6874536b3f5d1077b365683", "placeholder": "​", "style": "IPY_MODEL_b022520b314346138b8b48efb0d2f309", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "a0e67cde5a3043d1abae0eff42af2ad8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "a1a4eb0a90b04e559f2863b78b8c42c1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "ad3c0817ac014e05818d21e5a524fa85": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "ae64aa4ff79346d5a2376964f27e0dc6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_8bc3cdb0b76a40768e3b48b654e513a3", "placeholder": "​", "style": "IPY_MODEL_d26047bcd2d442048beac39f09db61ec", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "af6b8c54b3164afc89bc06587025c21c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "b022520b314346138b8b48efb0d2f309": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "c09758e12f3245f88c11f2e9b2f8e2a6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_3240ae2b8bef45e4b286347856b641b6", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_ad3c0817ac014e05818d21e5a524fa85", "tabbable": null, "tooltip": null, "value": 100.0 } }, "c2c28189919f46e7a122995e944ae2c0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "c67c8125cd6340e39987a0d5cbd19a2d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_9d0616cde3b44a4fbf84ec8dd5896b73", "IPY_MODEL_93f09720627d4328913b6cd50d5dc1f9", "IPY_MODEL_ff9365aaebb54c10b903010b228ffe64" ], "layout": "IPY_MODEL_a0e67cde5a3043d1abae0eff42af2ad8", "tabbable": null, "tooltip": null } }, "cfcdac24161347de8385d445cb5e4987": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_1ea8ea1ca0f84e84bdc461d8d49c371c", "placeholder": "​", "style": "IPY_MODEL_d517b8f3094441dfa9e11e21e69a7b9a", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:04 | time left: 00:00 ] " } }, "d26047bcd2d442048beac39f09db61ec": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "d517b8f3094441dfa9e11e21e69a7b9a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "d8db460398bd4f63ade14b285118a7eb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_3c4094dd60964dd9a9beedfd211be83f", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_c2c28189919f46e7a122995e944ae2c0", "tabbable": null, "tooltip": null, "value": 100.0 } }, "dfed7e022f05471fbc9453427fb78fad": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "f92ce9cce6874536b3f5d1077b365683": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "f95f82747a8143b097f1db2978a2d23a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "ff9365aaebb54c10b903010b228ffe64": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_8f015551e4f64a0ba50b09941cd4858d", "placeholder": "​", "style": "IPY_MODEL_5d080b8ebd484c37a80988a0e08b8c16", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }