{ "cells": [ { "cell_type": "markdown", "id": "ba3c7f30", "metadata": { "lines_to_next_cell": 0 }, "source": [] }, { "cell_type": "markdown", "id": "40372221", "metadata": { "tags": [ "header_banner" ] }, "source": [ "\n", " \"image0\"\n", "" ] }, { "cell_type": "code", "execution_count": 1, "id": "bf644215", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:18.662099Z", "iopub.status.busy": "2025-03-12T18:00:18.660574Z", "iopub.status.idle": "2025-03-12T18:00:20.784002Z", "shell.execute_reply": "2025-03-12T18:00:20.783033Z" }, "tags": [ "imports", "header_0" ] }, "outputs": [], "source": [ "from copy import deepcopy\n", "from typing import Callable\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import rich # noqa:F401\n", "from qcodes import ManualParameter\n", "from scipy.optimize import least_squares\n", "from scipy.signal import savgol_filter\n", "from xarray.core.dataset import Dataset\n", "\n", "import quantify_core.data.handling as dh\n", "from qblox_instruments.simulations import exponential_overshoot_correction\n", "from quantify_core.analysis.single_qubit_timedomain import SingleQubitTimedomainAnalysis\n", "from quantify_core.visualization.mpl_plotting import (\n", " set_suptitle_from_dataset,\n", " set_xlabel,\n", " set_ylabel,\n", ")\n", "from quantify_scheduler import QuantumDevice, Schedule, ScheduleGettable\n", "from quantify_scheduler.backends.qblox import constants\n", "from quantify_scheduler.backends.types.qblox import QbloxHardwareDistortionCorrection\n", "from quantify_scheduler.device_under_test.quantum_device import DeviceElement\n", "from quantify_scheduler.operations import (\n", " X90,\n", " Y90,\n", " IdlePulse,\n", " Measure,\n", " Reset,\n", " SquarePulse,\n", " X,\n", ")\n", "\n", "from utils import display_dict, initialize_hardware, run_schedule, show_connectivity # noqa:F401" ] }, { "cell_type": "code", "execution_count": 2, "id": "05b1658e", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:20.788305Z", "iopub.status.busy": "2025-03-12T18:00:20.787351Z", "iopub.status.idle": "2025-03-12T18:00:20.792788Z", "shell.execute_reply": "2025-03-12T18:00:20.792125Z" }, "tags": [ "config", "header_1" ] }, "outputs": [], "source": [ "hw_config_path = \"configs/tuning_transmon_coupled_pair_hardware_config.json\"\n", "device_path = \"devices/transmon_device_2q.json\"" ] }, { "cell_type": "code", "execution_count": 3, "id": "5488e4f2", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:20.796747Z", "iopub.status.busy": "2025-03-12T18:00:20.795115Z", "iopub.status.idle": "2025-03-12T18:00:20.801863Z", "shell.execute_reply": "2025-03-12T18:00:20.801077Z" }, "tags": [ "header_2" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data will be saved in:\n", "/root/quantify-data\n" ] } ], "source": [ "# Enter your own dataset directory here!\n", "dh.set_datadir(dh.default_datadir())" ] }, { "cell_type": "code", "execution_count": 4, "id": "8e55ffa6", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:20.809003Z", "iopub.status.busy": "2025-03-12T18:00:20.806444Z", "iopub.status.idle": "2025-03-12T18:00:21.547041Z", "shell.execute_reply": "2025-03-12T18:00:21.545997Z" }, "tags": [ "header_3" ] }, "outputs": [], "source": [ "quantum_device = QuantumDevice.from_json_file(device_path)\n", "qubit = quantum_device.get_element(\"q0\")\n", "quantum_device.hardware_config.load_from_json_file(hw_config_path)\n", "cluster_ip = None\n", "meas_ctrl, inst_coord, cluster = initialize_hardware(quantum_device, ip=cluster_ip)" ] }, { "cell_type": "markdown", "id": "ac757c80", "metadata": {}, "source": [ "# Cryoscope\n", "\n", "This notebook replicates the Cryoscope protocol in [this paper](https://doi.org/10.1063/1.5133894). Here's the [arxiv link](https://arxiv.org/abs/1907.04818).\n", "\n", "Cryoscope is short for cryogenic oscilloscope, and is used to sample baseband pulses. This can then be used to correct the pulse distortions.\n", "\n", "The experiment in this tutorial is meant to be executed with a Qblox Cluster controlling a flux-tunable transmon system.\n", "\n", "The experiments can also be executed using a dummy Qblox device that is created via an instance of the `Cluster` class, and is initialized with a dummy configuration. However, when using a dummy device, simulated data will be generated and analyzed." ] }, { "cell_type": "markdown", "id": "3353210f", "metadata": {}, "source": [ "## Hardware setup\n", "In this section we configure the hardware configuration which specifies the connectivity of our system." ] }, { "cell_type": "markdown", "id": "b7ee2e41", "metadata": {}, "source": [ "### Configuration file\n", "\n", "This is a template hardware configuration file for a single qubit system (we name the qubit `q0`), with a dedicated flux-control line.\n", "\n", "The hardware setup is as follows, by cluster slot:\n", "- **QCM-RF** (Slot 6)\n", " - Drive line for `q0` using fixed 80 MHz IF.\n", "- **QCM** (Slot 2)\n", " - Flux line for `q0`.\n", "- **QRM-RF** (Slot 8)\n", " - Shared readout line for `q0` using a fixed LO set at 7.5 GHz.\n", "\n", "Note that in the hardware configuration below the mixers are uncorrected, but for high fidelity experiments this should also be done for all the modules." ] }, { "cell_type": "markdown", "id": "02290295", "metadata": { "tags": [ "no_demo" ] }, "source": [ "## Setup\n", "In this section we configure the hardware configuration which specifies the connectivity of our system.\n", "\n", "The experiments of this tutorial are meant to be executed with a Qblox Cluster controlling a transmon system.\n", "The experiments can also be executed using a dummy Qblox device that is created via an instance of the `Cluster` class, and is initialized with a dummy configuration.\n", "When using a dummy device, the analysis will not work because the experiments will return `np.nan` values.\n", "\n", "### Configuration file\n", "\n", "This is a template hardware configuration file for a 2-qubit system with a flux-control line which can be used to tune the qubit frequency. We will only work with qubit 0.\n", "\n", "The hardware connectivity is as follows, by cluster slot:\n", "\n", "- **QCM** (Slot 2)\n", " - $\\text{O}^{1}$: Flux line for `q0`.\n", " - $\\text{O}^{2}$: Flux line for `q1`.\n", "\n", "- **QCM-RF** (Slot 6)\n", " - $\\text{O}^{1}$: Drive line for `q0` using fixed 80 MHz IF.\n", " - $\\text{O}^{2}$: Drive line for `q1` using fixed 80 MHz IF.\n", "\n", "- **QRM-RF** (Slot 8)\n", " - $\\text{O}^{1}$ and $\\text{I}^{1}$: Shared readout line for `q0`/`q1` using a fixed LO set at 7.5 GHz.\n", "\n", "Note that in the hardware configuration below the mixers are uncorrected, but for high fidelity experiments this should also be done for all the modules." ] }, { "cell_type": "markdown", "id": "0fcbf9c1", "metadata": { "tags": [ "no_demo" ] }, "source": [ "### Quantum device settings\n", "Here we initialize our `QuantumDevice` and our qubit parameters, checkout this [tutorial](https://quantify-os.org/docs/quantify-scheduler/tutorials/Operations%20and%20Qubits.html) for further details.\n", "\n", "In short, a `QuantumDevice` contains device elements where we save our found parameters. Here we are loading a template for 2 qubits, but we will only use qubit 0." ] }, { "cell_type": "markdown", "id": "330ca565", "metadata": {}, "source": [ "Select the appropriate modules for this experiment:\n", "- A QCM baseband module for the flux line\n", "- A QCM-RF module for the XY drive line\n", "- A QRM-RF module for the readout" ] }, { "cell_type": "code", "execution_count": 5, "id": "c6f94168", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.550377Z", "iopub.status.busy": "2025-03-12T18:00:21.550095Z", "iopub.status.idle": "2025-03-12T18:00:21.553552Z", "shell.execute_reply": "2025-03-12T18:00:21.552857Z" } }, "outputs": [], "source": [ "cluster0 = cluster" ] }, { "cell_type": "markdown", "id": "53447bad", "metadata": {}, "source": [ "## Experiment setup" ] }, { "cell_type": "markdown", "id": "474dafc4", "metadata": { "lines_to_next_cell": 2 }, "source": [ "### Quantum device settings\n", "Here we use the `quantum_device` that has our qubit parameters, check out this [tutorial](https://quantify-os.org/docs/quantify-scheduler/dev/tutorials/Operations%20and%20Qubits.html) for further details.\n", "\n", "In short, a `quantum_device` contains device elements where we save our found parameters.\n", "If reinitialization is required, call `quantum_device.close()` to avoid restarting the kernel." ] }, { "cell_type": "code", "execution_count": 6, "id": "372ff67a", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.555946Z", "iopub.status.busy": "2025-03-12T18:00:21.555675Z", "iopub.status.idle": "2025-03-12T18:00:21.559186Z", "shell.execute_reply": "2025-03-12T18:00:21.558493Z" } }, "outputs": [], "source": [ "q0 = quantum_device.get_element(\"q0\")\n", "q1 = quantum_device.get_element(\"q1\")" ] }, { "cell_type": "markdown", "id": "7d813c23", "metadata": {}, "source": [ "### Configure external flux control\n", "We need to have some way of controlling the external flux.\n", "\n", "This can be done by setting an output bias on a QCM baseband module of the cluster which is then connected to the flux-control line.\n", "\n", "Here we are nullifying the external flux on the qubit." ] }, { "cell_type": "code", "execution_count": 7, "id": "92e3df0b", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.561746Z", "iopub.status.busy": "2025-03-12T18:00:21.561338Z", "iopub.status.idle": "2025-03-12T18:00:21.569617Z", "shell.execute_reply": "2025-03-12T18:00:21.568915Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "# hardware_cfg[\"connectivity\"][\"graph\"] contains a graph of how each physical output port\n", "# connects to the device.\n", "# Here we select the outputs that correspond to the flux, and then create a dict with\n", "# a key:value pair `q*`:`cluster*.module*.out*_offset`\n", "hardware_cfg = quantum_device.hardware_config()\n", "\n", "flux_settables = {\n", " element[1].split(\":\")[0]: eval(\n", " \".\".join(element[0].split(\".\")[:2]) + f\".out{element[0][-1]}_offset\"\n", " )\n", " for element in hardware_cfg[\"connectivity\"][\"graph\"]\n", " if element[1][-3:] == \":fl\"\n", "}\n", "\n", "for flux_settable in flux_settables.values():\n", " flux_settable.inter_delay = 100e-9 # Delay time in seconds between consecutive set operations.\n", " flux_settable.step = 0.3e-3 # Stepsize in V that this Parameter uses during set operation.\n", " flux_settable() # get before set to avoid jumps\n", " flux_settable(0.0)" ] }, { "cell_type": "markdown", "id": "41e0461e", "metadata": { "lines_to_next_cell": 2 }, "source": [ "## Experiment\n", "\n", "As in the single qubit tuneup tutorial, the sweep setpoints for all experiments in this section are only examples. The sweep setpoints should be changed to match your own system.\n", "In this section we assume that each individual qubit has already been characterized, and that they have been biased to their sweetspots.\n", "\n", "The Cryoscope method allows us to \"capture\" the flux pulse similar to an oscilloscope. It does this by first setting up two Ramsey-style experiments in which the gap between the two pi pulses is fixed: one where the second pi half pulse has the same phase, and another where the second pi half pulse is 90 degrees phase shifted. This allows us to measure the phase of the qubit on the equator of the Bloch sphere. In between the two pi half pulses, a flux pulse of small incremental duration is played in each iteration of the Ramsey style experiment, while the rest of the time between the pip half pulses is just idle time.\n", "\n", "The flux pulse changes the qubit frequency while it is played, and the time integral of this frequency change gives the total phase accrued by the qubit. If we measure this cumulative phase for small incremental changes in the duration of the flux pulse, then we can effectively work out the frequency change in the qubit over time as the flux pulse is played by taking the derivative of the phase accrued vs time. Then using an already measured flux arc (qubit frequency vs flux), we can convert this frequency change over time to the actual flux seen by the qubit over time." ] }, { "cell_type": "code", "execution_count": 8, "id": "7df54eba", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.572218Z", "iopub.status.busy": "2025-03-12T18:00:21.571679Z", "iopub.status.idle": "2025-03-12T18:00:21.581385Z", "shell.execute_reply": "2025-03-12T18:00:21.580781Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "def cryoscope_sched(\n", " qubit: DeviceElement,\n", " time_axis: np.ndarray,\n", " x_or_y_axis: np.ndarray,\n", " amplitude: float = 0.1,\n", " start_pad: float = 40e-9,\n", " end_pad: float = 100e-9,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", " \"\"\"\n", " Generate a schedule for performing a Cryoscope experiment.\n", "\n", " Parameters\n", " ----------\n", " qubit\n", " The name of the qubit e.g., :code:`\"q0\"` to perform the experiment on.\n", " time_axis\n", " The time axis for which the cryoscope experiment is run.\n", " x_or_y_axis\n", " Defines the pi half pulse after the wait time as an X90 or Y90.\n", " amplitude\n", " The amplitude of the flux pulse.\n", " start_pad\n", " The starting pad time of the flux pulse.\n", " end_pad\n", " The ending pad time of the flux pulse.\n", " repetitions\n", " The amount of times the Schedule will be repeated.\n", "\n", " Returns\n", " -------\n", " :\n", " An experiment schedule.\n", "\n", " \"\"\"\n", " schedule = Schedule(\"Cryoscope\", repetitions)\n", "\n", " # Calculate the additional time required to make\n", " # one iteration take a multiple of 4 ns to complete.\n", " idle_pulse_time = (\n", " 4e-9\n", " - (\n", " qubit.reset.duration()\n", " + start_pad\n", " + time_axis[-1] # Gap between pi half pulses excluding padding.\n", " + end_pad\n", " + 2 * qubit.rxy.duration()\n", " + qubit.measure.pulse_duration()\n", " )\n", " % 4e-9\n", " )\n", "\n", " # Create a dict x_or_y_op that assigns an X or Y gate to the binary keys\n", " x_or_y_op = {0: X90(qubit.name), 1: Y90(qubit.name)}\n", "\n", " # This IdlePulse is needed to have a starting point relative\n", " # to which a relative time can be assigned to the Reset pulse.\n", " schedule.add(IdlePulse(4e-9))\n", " # Loop through the time axis. The last point is not used because\n", " # it is used for the calibration points later.\n", " for i, (time, x_or_y) in enumerate(zip(time_axis[:-2], x_or_y_axis[:-2])):\n", " # Wait for additional time calculated above and then Reset the qubit.\n", " schedule.add(Reset(qubit.name), label=f\"Reset {i}\", rel_time=idle_pulse_time)\n", " # Move the qubit to the equator on the bloch sphere.\n", " pi_half = schedule.add(X90(qubit.name))\n", " if time > 0:\n", " # Add the flux pulse of time t to the schedule\n", " schedule.add(\n", " SquarePulse(\n", " amp=amplitude, duration=time, port=qubit.ports.flux(), clock=\"cl0.baseband\"\n", " ),\n", " ref_op=pi_half,\n", " rel_time=start_pad,\n", " )\n", " # Wait for the gap time and play the second pi half pulse.\n", " # This pi half pulse is either an X90 or Y90.\n", " schedule.add(\n", " x_or_y_op[x_or_y], ref_op=pi_half, rel_time=start_pad + time_axis[-1] + end_pad\n", " )\n", " # Measure the qubit.\n", " schedule.add(Measure(qubit.name, acq_index=i), label=f\"Measurement {i}\")\n", "\n", " # Calibration points measured by preparing ground and excited states.\n", " schedule.add(Reset(qubit.name), label=\"Reset Cal 0\")\n", " schedule.add(Measure(qubit.name, acq_index=i + 1), label=\"Calibration 0\")\n", " schedule.add(Reset(qubit.name), label=\"Reset Cal 1\")\n", " schedule.add(X(qubit.name))\n", " schedule.add(Measure(qubit.name, acq_index=i + 2), label=\"Calibration 1\")\n", "\n", " return schedule" ] }, { "cell_type": "markdown", "id": "b59dd004", "metadata": { "lines_to_next_cell": 2 }, "source": [ "### Create a CryoscopeAnalysis class\n", "This class extends the class `SingleQubitTimedomainAnalysis` from `quantify_core.analysis.single_qubit_timedomain`:\n", "- Specify that the `run()` method uses calibration points\n", "- Extend the `process_data()` method to populate `self.dataset_processed` with an `xarray` dataset:\n", " - coords: `\"Time (ns)\"`\n", " - axis: `\"frequency_change\"`\n", " - axis: `\"reconstructed_phi\"`\n", "- Add method `create_figures()`" ] }, { "cell_type": "code", "execution_count": 9, "id": "df57bf89", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.583565Z", "iopub.status.busy": "2025-03-12T18:00:21.583258Z", "iopub.status.idle": "2025-03-12T18:00:21.593226Z", "shell.execute_reply": "2025-03-12T18:00:21.592618Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "class CryoscopeAnalysis(SingleQubitTimedomainAnalysis):\n", " \"\"\"\n", " Analysis class for the Cryoscope experiment.\n", "\n", " This class extends the SingleQubitTimedomainAnalysis class, which in turn extends the\n", " BaseAnalysis class:\n", " - BaseAnalysis.run() runs all steps in the AnalysisSteps class:\n", " 1. process_data # Empty\n", " 2. run_fitting # Empty\n", " 3. analyze_fit_results # Empty\n", " 4. create_figures # Empty\n", " 5. adjust_figures # Defined\n", " 6. save_figures # Defined\n", " 7. save_quantities_of_interest # Defined\n", " 8. save_processed_dataset # Defined\n", " 9. save_fit_results # Defined\n", " - SingleQubitTimedomainAnalysis extends BaseAnalysis:\n", " - run() defines self.calibration_points\n", " - process_data() populates dataset_processed.S21 and dataset_processed.pop_exc\n", " - CryoscopeAnalysis extends SingleQubitTimedomainAnalysis:\n", " - process_data() is extended by calculating:\n", " - x_vals, y_vals\n", " - unfiltered_phase\n", " - filtered_phase\n", " - unwrapped_phase\n", " - phase_derivative\n", " - frequency_change\n", " - reconstructed_phi\n", " - create_figures() is defined\n", " \"\"\"\n", "\n", " def __init__( # noqa: D107\n", " self,\n", " dataset: Dataset = None,\n", " tuid: str = None,\n", " label: str = \"\",\n", " settings_overwrite: dict = None,\n", " plot_figures: bool = True,\n", " frequency_change_to_flux: Callable = None,\n", " savgol_filter_params: dict = {\"window_length\": 2, \"polyorder\": 1},\n", " ) -> None:\n", " super().__init__(dataset, tuid, label, settings_overwrite, plot_figures)\n", " self.frequency_change_to_flux = frequency_change_to_flux\n", " self.savgol_filter_params = savgol_filter_params\n", "\n", " def run(self):\n", " \"\"\"\n", " Run the SingleQubitTimedomainAnalysis with calibration_points.\n", "\n", " This removes the calibration points (last two) and converts\n", " the rest of the IQ values to a population (pop_exc).\n", " \"\"\"\n", " return super().run(calibration_points=True)\n", "\n", " def process_data(self): # noqa: D102\n", " super().process_data()\n", "\n", " # Translate and scale the populations from X and Y measurements\n", " # from the range [0,1] to [-1,1]\n", " x_vals = 2 * (self.dataset_processed[\"pop_exc\"].values[:-2:2] - 0.5)\n", " y_vals = 2 * (self.dataset_processed[\"pop_exc\"].values[1:-2:2] - 0.5)\n", "\n", " # Find phase from the X,Y coordinates\n", " unfiltered_phase = np.angle(x_vals + 1j * y_vals)\n", " # Store the unfiltered phase for debugging purposes\n", " self.dataset_processed[\"unfiltered_phase\"] = ([\"t\"], unfiltered_phase)\n", "\n", " # First unwrap the phase\n", " unwrapped_phase = np.unwrap(unfiltered_phase)\n", " # Store the unwrapped phase for debugging purposes\n", " self.dataset_processed[\"unwrapped_phase\"] = ([\"t\"], unwrapped_phase)\n", "\n", " # Use the savgol_filter to both filter and take the derivative of the unwrapped phase.\n", " # The parameters of the savgol_filter may need to be changed after this is run on an\n", " # actual device.\n", " filtered_phase_derivative = savgol_filter(\n", " unwrapped_phase,\n", " window_length=self.savgol_filter_params[\"window_length\"],\n", " polyorder=self.savgol_filter_params[\"polyorder\"],\n", " deriv=1,\n", " )\n", "\n", " # Store the filtered phase derivative for debugging purposes\n", " self.dataset_processed[\"filtered_phase_derivative\"] = ([\"t\"], filtered_phase_derivative)\n", "\n", " # Rescale the filtered phase derivative to units of frequency change\n", " frequency_change = filtered_phase_derivative / (\n", " self.dataset_processed.x1[2].values - self.dataset_processed.x1[0].values\n", " )\n", " # Store the frequency change\n", " self.dataset_processed[\"frequency_change\"] = ([\"t\"], frequency_change)\n", "\n", " # if frequency_change_to_flux is provided, convert the frequency to flux (reconstructed_phi) and plot this.\n", " if self.frequency_change_to_flux is not None:\n", " reconstructed_phi = self.frequency_change_to_flux(frequency_change)\n", " self.dataset_processed[\"reconstructed_phi\"] = ([\"t\"], reconstructed_phi)\n", " else:\n", " print(\n", " \"frequency_change_to_flux was not provided, reconstructed_phi has not been calculated.\"\n", " )\n", "\n", " def create_figures(self): # noqa: D102\n", " fig, ax = plt.subplots()\n", " fig_id = \"Cryoscope\"\n", " self.figs_mpl[fig_id] = fig\n", " self.axs_mpl[fig_id] = ax\n", "\n", " # if frequency_change_to_flux is provided, plot it.\n", " if self.frequency_change_to_flux is not None:\n", " ax.plot(\n", " 1e9 * self.dataset_processed[\"reconstructed_phi\"].coords[\"t\"],\n", " self.dataset_processed[\"reconstructed_phi\"],\n", " label=\"Measured\",\n", " )\n", " set_ylabel(r\"Reconstructed $\\Phi/\\Phi_0$\")\n", " # if frequency_change_to_flux is not provided, plot the frequency change.\n", " else:\n", " ax.plot(\n", " 1e9 * self.dataset_processed[\"frequency_change\"].coords[\"t\"],\n", " self.dataset_processed[\"frequency_change\"] / 1e6,\n", " label=\"Measured\",\n", " )\n", " set_ylabel(\"Frequency change (MHz)\")\n", " set_xlabel(\"Time (ns)\")\n", " set_suptitle_from_dataset(fig, self.dataset)" ] }, { "cell_type": "markdown", "id": "dde234ba", "metadata": { "lines_to_next_cell": 2 }, "source": [ "### Define the flux dependence of the qubit frequency\n", "This is qubit specific, and assumes that the qubit has already been characterized. In the simplest case of a symmetric qubit (i.e. one with identical JJs in the SQUID), only $E_\\text{J}$ and $E_\\text{C}$ need to be provided." ] }, { "cell_type": "code", "execution_count": 10, "id": "80f99cd4", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.595152Z", "iopub.status.busy": "2025-03-12T18:00:21.594987Z", "iopub.status.idle": "2025-03-12T18:00:21.599941Z", "shell.execute_reply": "2025-03-12T18:00:21.599347Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "def flux_to_frequency_change(flux: np.ndarray):\n", " \"\"\"\n", " Convert frequency to flux.\n", "\n", " Currently this assumes a symmetric qubit and fixed parameters.\n", "\n", " Args:\n", " ----\n", " flux (np.ndarray): an array of flux values, in units of flux quantum\n", "\n", " \"\"\"\n", " h = 1 / (2 * np.pi)\n", " e_c = h * 300e6\n", " e_j = (h * q0.clock_freqs.f01() + e_c) ** 2 / (8 * e_c)\n", " return (1 / h) * (\n", " np.sqrt(8 * e_j * e_c * np.abs(np.cos(np.pi * flux))) - e_c\n", " ) - q0.clock_freqs.f01()\n", "\n", "\n", "def frequency_change_to_flux(freq_change: np.ndarray):\n", " r\"\"\"\n", " Convert flux to frequency.\n", "\n", " \\Phi(\\tau) = \\pm \\Phi_0/\\pi \\arccos((Ec+h*freq_change)**2/(8*Ej*Ec)),\n", " or in units of flux quantum:\n", " |\\Phi(\\tau)/\\Phi_0| = arccos((Ec+h*freq_change)**2/(8*Ej*Ec))/pi.\n", " \"\"\"\n", " # Assuming the qubit is parked at the maximum frequency, we can clip positive frequency changes to zero\n", " freq_change = np.clip(freq_change, None, 0)\n", " h = 1 / (2 * np.pi)\n", " e_c = h * 300e6\n", " e_j = (h * q0.clock_freqs.f01() + e_c) ** 2 / (8 * e_c)\n", " return (\n", " np.arccos((h * (q0.clock_freqs.f01() + freq_change) + e_c) ** 2 / (8 * e_j * e_c)) / np.pi\n", " )" ] }, { "cell_type": "markdown", "id": "58cf086f", "metadata": { "lines_to_next_cell": 2 }, "source": [ "### Define the shape of the flux pulse\n", "- When testing with a dummy cluster, this should mimic the distortions of the cables.\n", "- When running on a real device, this should be a true step function." ] }, { "cell_type": "code", "execution_count": 11, "id": "95e44b56", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.602169Z", "iopub.status.busy": "2025-03-12T18:00:21.601730Z", "iopub.status.idle": "2025-03-12T18:00:21.605394Z", "shell.execute_reply": "2025-03-12T18:00:21.604783Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "def flux_pulse_shape(t: np.ndarray):\n", " \"\"\"\n", " Shape of the flux pulse send to the qubit.\n", "\n", " Predistortion calculated using the Qblox simulator for the exponential overshoot correction\n", " using values in the cluster to simulate the real time predistortions,\n", " and an exponential overshoot distortion is added to the signal\n", " that is fixed to simulate a real distortion.\n", " \"\"\"\n", " signal = 0.1 * (1 + 0.05 * np.exp(-t / 72e-9))\n", " signal[np.where(t <= 0)] = 0.0\n", " return exponential_overshoot_correction(\n", " signal,\n", " cluster0.module2.out0_exp0_amplitude(),\n", " max(cluster0.module2.out0_exp0_time_constant(), 6),\n", " )" ] }, { "cell_type": "markdown", "id": "c55ae396", "metadata": { "lines_to_next_cell": 2 }, "source": [ "### Define simulated data when running on a dummy cluster" ] }, { "cell_type": "code", "execution_count": 12, "id": "ffad356b", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.607176Z", "iopub.status.busy": "2025-03-12T18:00:21.607020Z", "iopub.status.idle": "2025-03-12T18:00:21.611836Z", "shell.execute_reply": "2025-03-12T18:00:21.611273Z" } }, "outputs": [], "source": [ "def get_simulated_cryoscope_data():\n", " \"\"\"Convert the flux pulse shape to cryoscope data.\"\"\"\n", " # Convert the flux pulse shape to frequency change.\n", " freq_change = flux_to_frequency_change(flux_pulse_shape(time_axis()[::2]))\n", " freq_change -= freq_change[0]\n", " cumulative_phase_change = np.cumsum(2 * np.pi * freq_change) * np.diff(time_axis()[:4:2])[0]\n", " # Define IQ values for ground state and excited state\n", " ground_state = 0\n", " excited_state = 1 + 5.0j\n", " # compute the IQ values for the X measurements\n", " x_measurements = (np.cos(cumulative_phase_change) * 0.5 + 0.5) * excited_state\n", " # compute the IQ values for the Y measurements\n", " y_measurements = (np.sin(cumulative_phase_change) * 0.5 + 0.5) * excited_state\n", "\n", " # Assign the last of the x and y measurements\n", " # to ground and excited state IQ values\n", " x_measurements[-1] = ground_state\n", " y_measurements[-1] = excited_state\n", "\n", " # reshape to the way that an actual measurement would look like\n", " result = np.concatenate((x_measurements, y_measurements)).reshape(2, -1).T.flatten()\n", "\n", " return [np.real(result), np.imag(result)]\n", "\n", "\n", "def simulated_get():\n", " \"\"\"Run the previous get function but only return simulated data.\"\"\"\n", " gettable.old_get()\n", " return get_simulated_cryoscope_data()" ] }, { "cell_type": "markdown", "id": "33b26a3b", "metadata": {}, "source": [ "### Define the schedule gettables for the measurement" ] }, { "cell_type": "code", "execution_count": 13, "id": "2eb5c01c", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.613805Z", "iopub.status.busy": "2025-03-12T18:00:21.613509Z", "iopub.status.idle": "2025-03-12T18:00:21.618076Z", "shell.execute_reply": "2025-03-12T18:00:21.617494Z" } }, "outputs": [], "source": [ "time_axis = ManualParameter(name=\"time_axis\", unit=\"(ns)\", label=\"Time\")\n", "time_axis.batched = True\n", "\n", "x_or_y = ManualParameter(name=\"x_or_y\", unit=\"\", label=\"axis\")\n", "x_or_y.batched = True\n", "\n", "cryoscope_kwargs = {\n", " \"time_axis\": time_axis,\n", " \"x_or_y_axis\": x_or_y,\n", " \"amplitude\": 0.156,\n", " \"qubit\": quantum_device.get_element(\"q0\"),\n", "}\n", "\n", "gettable = ScheduleGettable(\n", " quantum_device,\n", " schedule_function=cryoscope_sched,\n", " schedule_kwargs=cryoscope_kwargs,\n", " real_imag=True,\n", " batched=True,\n", ")\n", "\n", "# replace the get method for the gettable in case the cluster is a dummy\n", "if cluster_ip is None:\n", " gettable.old_get = gettable.get\n", " gettable.get = simulated_get\n", "\n", "# Set the number of repetitions (or averages)\n", "quantum_device.cfg_sched_repetitions(1)" ] }, { "cell_type": "markdown", "id": "8d182f41", "metadata": {}, "source": [ "### Define the time spacing between pulses\n", "\n", "This allows for transients to decay." ] }, { "cell_type": "code", "execution_count": 14, "id": "da375203", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.620007Z", "iopub.status.busy": "2025-03-12T18:00:21.619850Z", "iopub.status.idle": "2025-03-12T18:00:21.622408Z", "shell.execute_reply": "2025-03-12T18:00:21.621850Z" } }, "outputs": [], "source": [ "constants.PULSE_STITCHING_DURATION = 16e-9" ] }, { "cell_type": "markdown", "id": "9e0e5833", "metadata": {}, "source": [ "### Measure the phase vs the duration of the detuning flux pulse" ] }, { "cell_type": "code", "execution_count": 15, "id": "09e26e6d", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.624313Z", "iopub.status.busy": "2025-03-12T18:00:21.624158Z", "iopub.status.idle": "2025-03-12T18:00:21.628941Z", "shell.execute_reply": "2025-03-12T18:00:21.628373Z" } }, "outputs": [], "source": [ "time_axis_setpoints = np.arange(-5e-9, 200e-9, 1e-9)\n", "x_or_y_setpoints = [0, 1]\n", "meas_ctrl.settables([x_or_y, time_axis])\n", "meas_ctrl.setpoints_grid([x_or_y_setpoints, time_axis_setpoints])\n", "# Pass the ScheduleGettable class with schedule_function=cryoscope_sched on to the measurement control\n", "meas_ctrl.gettables(gettable)\n", "hw_cfg = quantum_device.hardware_config()" ] }, { "cell_type": "code", "execution_count": 16, "id": "1cbf9d13", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:21.630779Z", "iopub.status.busy": "2025-03-12T18:00:21.630626Z", "iopub.status.idle": "2025-03-12T18:00:23.896709Z", "shell.execute_reply": "2025-03-12T18:00:23.896125Z" } }, "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 x_or_y, time_axis \n", "Batch size limit: 410\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "153314739be44fb890b9a4d49c987cb3", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "if hw_cfg.get(\"hardware_options\", {}).get(\"distortion_corrections\") is not None:\n", " # In case the cells below have already been run, we need to reset the distortion_corrections hardware option again.\n", " print(\n", " f\"Predistortion filter removed. Previous value: {hw_cfg['hardware_options'].pop('distortion_corrections', None)}\"\n", " )\n", "# Run the measurement control loop\n", "cryoscope_ds = meas_ctrl.run(f\"Cryoscope Experiment A {cryoscope_kwargs['amplitude']}\")\n", "# Analyze the date from the measurement\n", "if cluster_ip is None:\n", " savgol_filter_params = {\"window_length\": 2, \"polyorder\": 1}\n", "else:\n", " savgol_filter_params = {\"window_length\": 10, \"polyorder\": 1}\n", "cryoscope_result = CryoscopeAnalysis(\n", " dataset=cryoscope_ds,\n", " label=\"Cryoscope\",\n", " settings_overwrite={\"mpl_transparent_background\": False},\n", " frequency_change_to_flux=frequency_change_to_flux,\n", " savgol_filter_params=savgol_filter_params,\n", ").run()\n", "cryoscope_result.display_figs_mpl()" ] }, { "cell_type": "markdown", "id": "de5e3234", "metadata": { "lines_to_next_cell": 2 }, "source": [ "### Calculate the predistortion needed to send a square pulse\n", "\n", "In order to find the optimal parameters for the overshoot correction, we define the residual as the difference between exponential_overshoot_correction() applied to the measured $\\Phi/\\Phi_0$, and the ideal pulse shape." ] }, { "cell_type": "code", "execution_count": 17, "id": "146292ea", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:23.899530Z", "iopub.status.busy": "2025-03-12T18:00:23.899221Z", "iopub.status.idle": "2025-03-12T18:00:23.903048Z", "shell.execute_reply": "2025-03-12T18:00:23.902590Z" } }, "outputs": [], "source": [ "# Define the residual for the fitting function\n", "def residual(params: list, distorted_data: np.ndarray):\n", " # Params are [amp,tau,scale]\n", " distorted_data = deepcopy(distorted_data.values)\n", " # Remove the offset: subtract the value of the first data point from the data array\n", " distorted_data -= distorted_data[0]\n", " # Scale the data by scaling parameter\n", " distorted_data /= 2 * params[2]\n", " # Define the ideal pulse as a step function with height 0.5 starting at t=0\n", " ideal = 0.5 * np.ones(len(distorted_data))\n", " ideal[:5] = 0\n", "\n", " return exponential_overshoot_correction(distorted_data, params[0], params[1]) - ideal" ] }, { "cell_type": "markdown", "id": "38434de1", "metadata": {}, "source": [ "Find a best fit for the predistortion filter that would result in a clean pulse at the qubit using the least squares method." ] }, { "cell_type": "code", "execution_count": 18, "id": "6d2049ea", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:23.905320Z", "iopub.status.busy": "2025-03-12T18:00:23.905172Z", "iopub.status.idle": "2025-03-12T18:00:23.911839Z", "shell.execute_reply": "2025-03-12T18:00:23.911373Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/builds/qblox/packages/software/qblox_instruments_docs/.venv/lib/python3.9/site-packages/qblox_instruments/simulations/predistortions.py:80: UserWarning: Qblox simulator plugin WARNING: Output will be clipped.The result of the simulation cannot be trusted.\n", " warnings.warn(\n" ] } ], "source": [ "time = cryoscope_result.dataset_processed.t\n", "# Convert xarray.DataArray to np.array, store the results separately in memory\n", "distorted_data = cryoscope_result.dataset_processed.reconstructed_phi\n", "# Find the overshoot correction parameters that best approximate the ideal pulse shape\n", "res = least_squares(residual, x0=(0.33, 73, 0.1), args=(distorted_data,))" ] }, { "cell_type": "markdown", "id": "19b104d0", "metadata": {}, "source": [ "Plot the measured pulse shape versus the corrected and predistorted pulse shapes" ] }, { "cell_type": "code", "execution_count": 19, "id": "db194318", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:23.913757Z", "iopub.status.busy": "2025-03-12T18:00:23.913608Z", "iopub.status.idle": "2025-03-12T18:00:24.081798Z", "shell.execute_reply": "2025-03-12T18:00:24.081343Z" }, "tags": [ "nbsphinx-thumbnail" ] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ideal = res.x[2] * np.ones(len(distorted_data))\n", "ideal[:5] = 0\n", "\n", "fig, ax = plt.subplots()\n", "ax.plot(time, distorted_data, label=\"measured\")\n", "ax.plot(\n", " time, exponential_overshoot_correction(distorted_data, res.x[0], res.x[1]), label=\"corrected\"\n", ")\n", "ax.plot(time, exponential_overshoot_correction(ideal, res.x[0], res.x[1]), label=\"predistorted\")\n", "if cluster_ip is None:\n", " ax.set_ylim(0.9 * res.x[2], 1.1 * res.x[2])\n", "ax.set_xlabel(\"Time (ns)\")\n", "ax.set_ylabel(r\"Reconstructed $\\Phi$\")\n", "ax.legend()\n", "ax.grid()" ] }, { "cell_type": "markdown", "id": "d469e57e", "metadata": {}, "source": [ "### Repeat the measurement of the phase vs the duration of the detuning flux pulse\n", "\n", "This time with the predistortion filter applied." ] }, { "cell_type": "code", "execution_count": 20, "id": "aad86d8a", "metadata": { "execution": { "iopub.execute_input": "2025-03-12T18:00:24.084004Z", "iopub.status.busy": "2025-03-12T18:00:24.083851Z", "iopub.status.idle": "2025-03-12T18:00:25.976881Z", "shell.execute_reply": "2025-03-12T18:00:25.976360Z" } }, "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 x_or_y, time_axis \n", "Batch size limit: 410\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "af810338ba184d188f5c24e4e9329daa", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Set the hardware distortions for the relevant flux line.\n", "hw_cfg[\"hardware_options\"][\"distortion_corrections\"] = {\n", " \"q0:fl-cl0.baseband\": QbloxHardwareDistortionCorrection(exp0_coeffs=[res.x[1], res.x[0]])\n", "}\n", "\n", "quantum_device.hardware_config(hw_cfg)\n", "\n", "cryoscope_ds = meas_ctrl.run(f\"Cryoscope Experiment A {cryoscope_kwargs['amplitude']}\")\n", "\n", "cryoscope_result = CryoscopeAnalysis(\n", " dataset=cryoscope_ds,\n", " label=\"Cryoscope\",\n", " settings_overwrite={\"mpl_transparent_background\": False},\n", " frequency_change_to_flux=frequency_change_to_flux,\n", ").run()\n", "cryoscope_result.display_figs_mpl()" ] } ], "metadata": { "files_to_bundle_in_zip_file": [ "figures/Banner.jpeg", "configs/tuning_transmon_coupled_pair_hardware_config.json", "devices/transmon_device_2q.json", "utils.py" ], "jupytext": { "cell_metadata_filter": "all", "notebook_metadata_filter": "files_to_bundle_in_zip_file,is_demo,execute" }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "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.20" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "153314739be44fb890b9a4d49c987cb3": { "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_5c8c2f6120734da4be623e204581ce97", "IPY_MODEL_f0d9875fa761486ba3a63e1440a1d42e", "IPY_MODEL_818adfcebd6447c68ce1b3e1d5f249b7" ], "layout": "IPY_MODEL_dfe3c8388ad342349f1c5b6c932cef3b", "tabbable": null, "tooltip": null } }, "1670d39f403c4dcc913257d39291e9ad": { "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 } }, "2a14aeb865a04cfb8ae28b245eba37c9": { "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 } }, "30ff5d246fe9469d9fd8d53ac813888b": { "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 } }, "50a0dd2c20594a9187d62b0a45bd2806": { "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_30ff5d246fe9469d9fd8d53ac813888b", "placeholder": "​", "style": "IPY_MODEL_703df09ce68047bfb674fda4ac993f50", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "5c8c2f6120734da4be623e204581ce97": { "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_f01c3d8eb9a34c39aed6a1da074cf352", "placeholder": "​", "style": "IPY_MODEL_7bb53fe71a4f42dba21eac28be8b0758", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "703df09ce68047bfb674fda4ac993f50": { "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 } }, "7bb53fe71a4f42dba21eac28be8b0758": { "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 } }, "818adfcebd6447c68ce1b3e1d5f249b7": { "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_9c411d3856a54fb58240cb8f5f04d7c2", "placeholder": "​", "style": "IPY_MODEL_948e861859934f9d89948d03eaa3814e", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 410" } }, "948e861859934f9d89948d03eaa3814e": { "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 } }, "9c411d3856a54fb58240cb8f5f04d7c2": { "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 } }, "ac2b19cb2af848f6a2b6e9033ebdc405": { "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 } }, "af810338ba184d188f5c24e4e9329daa": { "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_50a0dd2c20594a9187d62b0a45bd2806", "IPY_MODEL_df5a797c707b4654beebd031f69ed097", "IPY_MODEL_eed726e00821422bb15a5faa14647d85" ], "layout": "IPY_MODEL_2a14aeb865a04cfb8ae28b245eba37c9", "tabbable": null, "tooltip": null } }, "c13821e2f1a2434eae816ccf360626ca": { "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": "" } }, "c14854401c474190889515274faafde1": { "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 } }, "df5a797c707b4654beebd031f69ed097": { "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_ac2b19cb2af848f6a2b6e9033ebdc405", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_c13821e2f1a2434eae816ccf360626ca", "tabbable": null, "tooltip": null, "value": 100.0 } }, "dfe3c8388ad342349f1c5b6c932cef3b": { "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 } }, "e3950253da46413ca6931a4469985241": { "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 } }, "eed726e00821422bb15a5faa14647d85": { "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_1670d39f403c4dcc913257d39291e9ad", "placeholder": "​", "style": "IPY_MODEL_e3950253da46413ca6931a4469985241", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 410" } }, "efe4cc0316564e5f9b4455a4d4177699": { "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": "" } }, "f01c3d8eb9a34c39aed6a1da074cf352": { "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 } }, "f0d9875fa761486ba3a63e1440a1d42e": { "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_c14854401c474190889515274faafde1", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_efe4cc0316564e5f9b4455a4d4177699", "tabbable": null, "tooltip": null, "value": 100.0 } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }