Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

collection of small fixes, features, and random pieces of code #993

Merged
merged 23 commits into from
Oct 25, 2024

Conversation

hay-k
Copy link
Contributor

@hay-k hay-k commented Aug 19, 2024

This PR brings the following:

  • some cherry picked commits from branch alvaro/latest_20231215 that collectively
    1. introduce support for couplers in the qblox driver.
    2. expose offset_i and offset_q mixer calibration parameters for qblox RF modules.
  • cleanup of the said commits to
    1. align the code with main (the commits were based on older version of qibolab)
    2. make the code more pythonic and more readable
    3. remove things that were done from a perspective of a user that uses qblox alone (i.e. from a perspective where qibolab==qblox driver), but should not be part of things qibolab does.
  • fix "deserialization" of Custom pulse shape:
    • as a side effect fixes deserialization of IIR, and SNR as well.

This is intended to cover the discussions in #919 and #921

Copy link

codecov bot commented Aug 19, 2024

Codecov Report

Attention: Patch coverage is 57.71812% with 63 lines in your changes missing coverage. Please review.

Project coverage is 69.82%. Comparing base (32187d4) to head (f85447a).
Report is 24 commits behind head on 0.1.

Files with missing lines Patch % Lines
src/qibolab/instruments/qblox/cluster_qcm_bb.py 4.76% 20 Missing ⚠️
src/qibolab/instruments/qblox/controller.py 24.00% 19 Missing ⚠️
src/qibolab/instruments/qblox/port.py 41.17% 10 Missing ⚠️
src/qibolab/instruments/qblox/cluster_qrm_rf.py 0.00% 4 Missing ⚠️
src/qibolab/instruments/qblox/sequencer.py 20.00% 4 Missing ⚠️
src/qibolab/instruments/qblox/cluster_qcm_rf.py 0.00% 3 Missing ⚠️
src/qibolab/pulses.py 96.61% 2 Missing ⚠️
src/qibolab/platform/platform.py 92.30% 1 Missing ⚠️
Additional details and impacted files
@@            Coverage Diff             @@
##              0.1     #993      +/-   ##
==========================================
- Coverage   70.07%   69.82%   -0.26%     
==========================================
  Files          64       64              
  Lines        6771     6859      +88     
==========================================
+ Hits         4745     4789      +44     
- Misses       2026     2070      +44     
Flag Coverage Δ
unittests 69.82% <57.71%> (-0.26%) ⬇️

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

@hay-k hay-k marked this pull request as ready for review August 21, 2024 06:08
@alecandido alecandido changed the base branch from main to 0.1 August 21, 2024 09:29
@hay-k hay-k requested a review from DavidSarlle August 22, 2024 06:25
@DavidSarlle
Copy link
Contributor

@hay-k I am still reviewing the PR. Sorry, but after the last warm up I had to re calibrate the chip using the old driver in order to compare the results with your version of the qblox driver. I am finishing the 2q gates so, I will report what I see at the end of the week.

@DavidSarlle
Copy link
Contributor

Hi @hay-k I am trying to reproduce the same results that we are getting with the old version for the driver and your PR.

I am trying to reproduce the same results for the 2q gates running the iSWAP and CZ chevron. This routines are working perfectly with the old version of the driver:

Classify q1 q2


  • id: single shot classification
    priority: 0
    next: chevron signal
    operation: single_shot_classification
    targets: [1,2]
    parameters:
    nshots: 5_000
    relaxation_time: 100_000

  • id: chevron signal iSWAP
    operation: chevron_signal
    targets: [[1, 2]]
    parameters:
    amplitude_max_factor: 1.145 #0.23
    amplitude_min_factor: 0.9 #0.18
    amplitude_step_factor: 0.001
    duration_max: 180
    duration_min: 1
    duration_step: 1
    native: iSWAP
    nshots: 100
    relaxation_time: 100000


With the latest version of the runcard (same used in the old driver):
qiboteam/qibolab_platforms_qrc#161

And it is throwing the error:

Traceback (most recent call last):
File "/nfs/users/david.fuentes/main/bin/qq", line 8, in
sys.exit(command())
File "/nfs/users/david.fuentes/main/lib/python3.10/site-packages/click/core.py", line 1157, in call
return self.main(*args, **kwargs)
File "/nfs/users/david.fuentes/main/lib/python3.10/site-packages/click/core.py", line 1078, in main
rv = self.invoke(ctx)
File "/nfs/users/david.fuentes/main/lib/python3.10/site-packages/click/core.py", line 1688, in invoke
return _process_result(sub_ctx.command.invoke(sub_ctx))
File "/nfs/users/david.fuentes/main/lib/python3.10/site-packages/click/core.py", line 1434, in invoke
return ctx.invoke(self.callback, **ctx.params)
File "/nfs/users/david.fuentes/main/lib/python3.10/site-packages/click/core.py", line 783, in invoke
return __callback(*args, **kwargs)
File "/nfs/users/david.fuentes/qibocal/src/qibocal/cli/_base.py", line 75, in auto
autocalibrate(runcard, folder, force, update)
File "/nfs/users/david.fuentes/qibocal/src/qibocal/cli/autocalibration.py", line 42, in autocalibrate
history = runcard.run(
File "/nfs/users/david.fuentes/qibocal/src/qibocal/auto/runcard.py", line 63, in run
instance.run_protocol(
File "/nfs/users/david.fuentes/qibocal/src/qibocal/auto/execute.py", line 131, in run_protocol
completed = task.run(platform=self.platform, targets=self.targets, mode=mode)
File "/nfs/users/david.fuentes/qibocal/src/qibocal/auto/task.py", line 149, in run
completed.data, completed.data_time = operation.acquisition(
File "/nfs/users/david.fuentes/qibocal/src/qibocal/auto/operation.py", line 42, in wrapper
out = func(*args, **kwds)
File "/nfs/users/david.fuentes/qibocal/src/qibocal/protocols/two_qubit_interaction/chevron/chevron_signal.py", line 123, in _aquisition
results = platform.sweep(
File "/nfs/users/david.fuentes/qibolab/src/qibolab/platform/platform.py", line 308, in sweep
new_result = instrument.sweep(
File "/nfs/users/david.fuentes/qibolab/src/qibolab/instruments/qblox/controller.py", line 300, in sweep
self._sweep_recursion(
File "/nfs/users/david.fuentes/qibolab/src/qibolab/instruments/qblox/controller.py", line 503, in _sweep_recursion
result = self._execute_pulse_sequence(
File "/nfs/users/david.fuentes/qibolab/src/qibolab/instruments/qblox/controller.py", line 184, in _execute_pulse_sequence
module.process_pulse_sequence(
File "/nfs/users/david.fuentes/qibolab/src/qibolab/instruments/qblox/cluster_qcm_bb.py", line 394, in process_pulse_sequence
sequencer.waveforms_buffer.add_waveforms(
File "/nfs/users/david.fuentes/qibolab/src/qibolab/instruments/qblox/sequencer.py", line 94, in add_waveforms
pulse.idx_range = self.bake_pulse_waveforms(
File "/nfs/users/david.fuentes/qibolab/src/qibolab/instruments/qblox/sequencer.py", line 140, in bake_pulse_waveforms
waveform = pulse_copy.envelope_waveform_i(SAMPLING_RATE)
File "/nfs/users/david.fuentes/qibolab/src/qibolab/pulses.py", line 868, in envelope_waveform_i
return self.shape.envelope_waveform_i(sampling_rate)
File "/nfs/users/david.fuentes/qibolab/src/qibolab/pulses.py", line 752, in envelope_waveform_i
raise ValueError(
ValueError: Length of envelope_i must be equal to pulse duration in samples

I have tried setting the qf and coupler pulse to 200ns, that is the same number of samples of the custom shape used during this routine, but same error is raised.

It would be nice to check this routine, because it involves many of the fixes that you have introduced.

Any idea what is the problem?

@hay-k
Copy link
Contributor Author

hay-k commented Sep 18, 2024

@DavidSarlle is this experiment sweeping the duration of the custom pulse?

@DavidSarlle
Copy link
Contributor

@DavidSarlle is this experiment sweeping the duration of the custom pulse?

Yes, it is. The flux pulse is using custom shape, needed to get good chevrons. I know that the error is raised because the number of samples is changing during the sweeping. But this is something necessary and was fixed long time ago in Alvaro's branch because qblox does not support predistorted pulses yet.

By the way, I will write today a detailed report with the differences observed between branches.

@hay-k
Copy link
Contributor Author

hay-k commented Sep 18, 2024

How is this type of sweep supposed to be interpreted? How does one sweep the duration of a pulse that is specified sample by sample and has fixed duration?

I have checked what Alvaro has done in his branch. It pretty much boils down to this line. The variable num_samples is the number of samples in the pulse duration. While self.envelope_i always has 180 samples in it, the num_samples changes its value during the sweep. As long as num_samples is less than 180, this line of code takes only the first num_samples samples of the custom pulse. Thus, in one sweep iteration the custom pulse is the first 60 samples of the pulse definition, in another iteration it is the first 70 samples, etc. I am not sure if this is the correct way of sweeping custom pulse duration.

@DavidSarlle
Copy link
Contributor

All results has been made with iqm5q qubit q1/q4 trying to minimizze the tiome between execution of the same routine.
The platform config and action runcard can be obtained from the qibo server using the report URL.
PRs used:

(Old driver)

qibocal -> alvaro/latest_20231215
qibolab -> alvaro/latest_20231215
qibolab_platforms_qrc -> david/alvaro_latest

New driver:

qibocal -> main
qibolab -> qblox-ad-hox-features
qibolab_platforms_qrc -> david/iqm5q_CZs_iSWAPS_refined

classify

alvaro: http://login.qrccluster.com:9000/W4Bb2lEmRmSm1_BPuZLAaA==
hayk: http://login.qrccluster.com:9000/t7SaAt8IRU6wYP5qgQmRYQ==

COMMENTS: All results matching

qubit spec flux

alvaro: http://login.qrccluster.com:9000/EYdEAkTgRk2PWPA72WjohQ==
hayk: http://login.qrccluster.com:9000/PRWf2yC9R9mcZI1Iu-KJIw==

COMMENTS: Phase results not matching

qubit spec

alvaro: http://login.qrccluster.com:9000/eMJF7vRlQwKpH5heYWckHw==
hayk: http://login.qrccluster.com:9000/4BkgKYPCT72PXwD9LieYig==

COMMENTS: Phase results not matching

rabi amplitude

alvaro: http://login.qrccluster.com:9000/_kpHtQ08ReyxxRc_VpjAKg==
hayk: http://login.qrccluster.com:9000/egSiv8AVRzy3riUylYl4YA==

COMMENTS: Phase results not matching

rabi length

alvaro: http://login.qrccluster.com:9000/hHC9WWizS8a4TxmUDlwmzA==
hayk: http://login.qrccluster.com:9000/iMDueMb_SRSXsrDXmc1JCw==

COMMENTS: Probably RO pulse not well allocated during sweep and pulse sequence duration changed, as we pointed out long time ago.

ramsey

alvaro: http://login.qrccluster.com:9000/txpGzRxwRzG2dDG1H9gxRA==
hayk: http://login.qrccluster.com:9000/eOySVLI5RGCyzUl_IsgDmQ==

COMMENTS: Signal results not matching. Probably RO pulse not well allocated during sweep and pulse sequence duration changed, as we pointed out long time ago.

T1

alvaro: http://login.qrccluster.com:9000/A3ebtszyTmKpRrC9-BEu-A==
hayk: http://login.qrccluster.com:9000/Cl-y4DeiTP6_MBRlWBGt9Q==

COMMENTS: Signal results not matching. Probably RO pulse not well allocated during sweep and pulse sequence duration changed, as we pointed out long time ago.

T2

alvaro: http://login.qrccluster.com:9000/I8j2GDt6SMWqGwNplVkz2Q==
hayk: http://login.qrccluster.com:9000/a5IiAhEAQvez_GEHmBJsbQ==

COMMENTS: Signal results not matching. Probably RO pulse not well allocated during sweep and pulse sequence duration changed, as we pointed out long time ago.

OTHER PROBLEMS:

  • Custom pulse shape not working when sweeping duration and modify the duration/samples.

@DavidSarlle
Copy link
Contributor

How is this type of sweep supposed to be interpreted? How does one sweep the duration of a pulse that is specified sample by sample and has fixed duration?

I have checked what Alvaro has done in his branch. It pretty much boils down to this line. The variable num_samples is the number of samples in the pulse duration. While self.envelope_i always has 180 samples in it, the num_samples changes its value during the sweep. As long as num_samples is less than 180, this line of code takes only the first num_samples samples of the custom pulse. Thus, in one sweep iteration the custom pulse is the first 60 samples of the pulse definition, in another iteration it is the first 70 samples, etc. I am not sure if this is the correct way of sweeping custom pulse duration.

@aorgazf can give you more details. But that was the idea that we had to fix the problem. It works. as soon as we implemented, we were able to characterize the couplers and 2q gates. Before, the flux pulses were far away of being perfect and we needed to pre-distort them. As soon as we did it, we started to see the chevrons. @hay-k if you have any othe better solutions, feel free to introduce it and test it.

@alecandido
Copy link
Member

alecandido commented Sep 18, 2024

Thus, in one sweep iteration the custom pulse is the first 60 samples of the pulse definition, in another iteration it is the first 70 samples, etc. I am not sure if this is the correct way of sweeping custom pulse duration.

It is not: you should either compute the samples from a function, or interpolate the given ones.

SciPy has easy-to-use interpolators that you could use for that
https://docs.scipy.org/doc/scipy/tutorial/interpolate.html

@aorgazf
Copy link
Member

aorgazf commented Sep 18, 2024

Hi,
I understand that sweeping the duration of a pulse with an arbitrary waveform could be done in multiple ways (including the interpolation that @alecandido mentioned). But for the 2q gate characterization protocols, I needed to play the first i samples of its waveform on each iteration. Iterating from 1 to the max number of samples of the waveform.

@alecandido
Copy link
Member

Hi @aorgazf, this is more or less becoming a performance optimization issue.

Indeed, I see that what you say could be used (though I won't enter the details of the specific protocols, as I'm not experienced enough with that), but it's also not the general expected behavior.

We had a similar problem with QM, that has the option to interpolate the waveform in real time.

The solution we're proposing with @stavros11 in 0.2 is to split the sweeper in two:

  • there will be QM-specific sweeper kind (i.e. Parameter) not branded as QM: it will be an interpolated duration sweeper, supposed to interpolate on hardware; in practice, this would only be possible for QM (and that's what we implemented), but we were thinking to allow for automated fallback on the more general duration sweeper
  • the basic duration sweeper instead is a very plain one, with no surprise and great waste: upload all the distinct waveforms you want to sweep; in this way there are no additional limitations/constraints (as increment by one sample, linearly, or whatever), but it will consume a lot of memory

So, if this kind of sweeper you're proposing is relevant (as said, for the sake of the current discussion I consider it relevant), it could be implemented in the same way, as a duration cut sweeper.
We could also have an automated fallback as well, in such a way that routines could be implemented with the duration cut sweeper, without checking whether the electronics in the platform is explicitly supporting that.
Instead, I would ask you to keep the simpler behavior for the basic duration sweeper.

I'm mostly talking about the long-run development of Qibolab (i.e. 0.2+), since I'd like to support more and more features, but improving the standardization and compatibility at the same time.
If you need a quick-fix for 0.1, to avoid the branching issue, and this is already the status quo for Qblox, I'm fine with the duration cut sweeper being implemented as the default duration sweeper (the only one Qibocal is currently aware of), transitionally.

@DavidSarlle
Copy link
Contributor

DavidSarlle commented Sep 19, 2024

another example of results mismatching:

Landscape

alvaro: http://login.qrccluster.com:9000/x0Wj_DoPTWCL_8ob5hAehw==
hayk: http://login.qrccluster.com:9000/ugKLctRESUaccZpzn_c70w==

COMMENTS: Signal and/or phase results not matching. Probably RO pulse not well allocated during sweep and pulse sequence duration changed, as we pointed out long time ago.

We need to be able to run the landscape to fine tuning the CZs

@hay-k
Copy link
Contributor Author

hay-k commented Sep 19, 2024

@DavidSarlle

Phase results not matching

I believe this is not an issue in the driver, it is because of some difference in data processing between the two versions of software.

Probably RO pulse not well allocated

This was thoroughly discussed in #919 and in a few meetings with @aorgazf. The short summary is that this cannot be consistently fixed in qibolab until qibolab 0.2 is released. Why? The current qibolab API is limited and does not allow user to specify whether they want to move RO when the start or duration of other pulses is changed, or they want to keep RO in the same place always. Drivers cannot be implemented so that they handle both cases correctly - they always do the same thing regardless of what user requests (e.g. ZI driver always pushes the RO to the end, and the qblox driver always plays RO in a fixed place). It was concluded that for now it is a good consensus to implement all new features (e.g. couplers, mixer calibration, fix deserialization of Custom pulse, etc.), but don't fix the RO pulse start time sweep problems.

@hay-k
Copy link
Contributor Author

hay-k commented Sep 19, 2024

Anyways,

The original idea behind this PR was to implement things nicely, in a way that makes sense in general and not in the context of specific experiments and platforms only. Thus the PR could be merged and a new version of qibolab released. Given the fact that so far not all discussions/conclusions have been kept by all parties, and my opinion that there is no point in further discussions attempting to do things the proper way, I propose the following:

  • Drop the idea that this branch should be merged into main, and released. I hope this is fine by you, @scarrazza
  • Shoehorn whatever piece of code makes the most needed things work for setups with qblox driver, at the cost of making less important things broken (e.g. proper sweep of custom pulse duration, or experiments with duration/start sweeps that need RO in fixed location).
  • Keep this branch updated with any changes in main as long as required.
  • 0.2 release should have proper solutions to all problems that are the topic of this PR to be considered having feature parity with 0.1*.

This means:

  • Shoehorn some workaround code into the driver so that experiments like T2 and Ramsey work.
  • Shoehorn some workaround code into the driver so that experiments like Rabi length work.
  • Change the custom pulse envelope waveform to cut when the pulse duration is shorter than number of samples in the shape, pretending that this is a custom pulse duration sweep.

@scarrazza
Copy link
Member

@hay-k at this stage please go ahead with this proposal. Qibolab 0.1 should contain the required patches until 0.2 takes over.

@hay-k hay-k marked this pull request as draft September 20, 2024 07:33
@hay-k hay-k changed the title collection of small fixes and features [DO NOT MERGE] collection of small fixes, features, and random pieces of code Sep 20, 2024
@hay-k
Copy link
Contributor Author

hay-k commented Sep 20, 2024

@DavidSarlle

In line with the proposal above, I have now pushed two commits to this branch:

  1. for experiments where the start of a non-RO pulse is swept, the RO pulse will be pushed as well, which means experiments like T2 and Ramsey should produce expected results.
image 2. added the functionality to cut custom pulses to their first samples when their duration is swept, as discussed above.

Only remaining thing is the case where the RO needs to be pushed when the duration of a drive pulse is swept (e.g. Rabi length experiment). Turns out I didn't have a ready workaround for this one, so I will try to figure out something a bit later, and push a new commit.

@DavidSarlle
Copy link
Contributor

Thanks @hay-k . Please try to reproduce the reports uploaded to be sure that the fixes introduced are working.

Also remember the problems with displaying/manipulating the phase data in many routines. Try to reproduce yourself the landscape report and other reports like qubit spec where this issue can be observed.

@hay-k
Copy link
Contributor Author

hay-k commented Sep 20, 2024

Now I have a workaround for the case of duration sweeper as well, and Rabi length experiment works fine:

image

@DavidSarlle I didn't try the chevron experiment, can you test that one?

Also remember the problems with displaying/manipulating the phase data in many routines.

Is this really a problem?

@hay-k
Copy link
Contributor Author

hay-k commented Sep 20, 2024

Is this really a problem?

Nevermind. I found where this difference is coming from. It should not cause any problems because this phase calculations are done only for the plots in the signal experiments, but anyways I changed it so that it looks like as it did in the past.
image

@DavidSarlle
Copy link
Contributor

DavidSarlle commented Sep 20, 2024

Thanks @hay-k . I have tested right now the landscape and it is still not working. Thanks for fixing the phase problem, but maybe there is still something else that is not working as expected as you can see in the landscape. This is the reason why I said that the phase manipulation was a problem.

http://login.qrccluster.com:9000/FzsNOANnT3W6LeXULiOxew==

Also all the drivers supported by qibo are displaying the phase in that way.

@DavidSarlle
Copy link
Contributor

@hay-k I tested the chevrons, and now is not raising any bug, but the results are not good:

alvaro: http://login.qrccluster.com:9000/jyjXrMv6Q0qCFz8WbYKlKg==
hayk: http://login.qrccluster.com:9000/1JShL92OSn2uRgtahTywyQ==

Please note that the chevron routine is using all the fixes introduced.

@hay-k
Copy link
Contributor Author

hay-k commented Sep 23, 2024

@DavidSarlle This is because your platform definition for the new version of software is incomplete - the platform does not know that it has couplers, which results into the coupler pulse not being applied. To fix this you need to do the following change:

     return Platform(
-        str(FOLDER), qubits, pairs, instruments, settings, resonator_type="2D"
+        str(FOLDER), qubits, pairs, instruments, settings, resonator_type="2D", couplers=couplers
     )

With this change I can see nice chevron similar to what you get from the old versions:
image

@hay-k hay-k force-pushed the qblox-ad-hoc-features branch 2 times, most recently from add0158 to 21e795b Compare October 23, 2024 07:09
@alecandido
Copy link
Member

@hay-k I'm not sure if you already encountered, but do not worry about pre-commit. There is a known issue, and for the time being we're just ignoring it (if nothing happens before, next week I'll take action...).

@hay-k hay-k linked an issue Oct 23, 2024 that may be closed by this pull request
Copy link
Member

@alecandido alecandido left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This PR is mostly affecting just Qblox, and that was confirmed to work by @DavidSarlle.

I checked the changes, and those beyond the scope of the driver itself are very limited. I'm reporting a sign in the phases below (to be discussed there), while platform/platform.py is affected only to tune flux pulses, in a backward compatible way.
pulses.py is more heavily changed, but mostly just for the (de)serialization and waveforms (which are only used by Qblox itself), as well as a method of the PulseSequence, which I also confirmed is only used by Qblox.

It should be ready to be merged, but I will wait just one more day for some final tests (just to be completely sure).

Thanks @hay-k for these fixes!
(btw, you didn't mark as ready for review, but I will leave you to merge in any case)

@@ -38,7 +38,7 @@ def magnitude(self):
@cached_property
def phase(self):
"""Signal phase in radians."""
return np.unwrap(np.arctan2(self.voltage_i, self.voltage_q))
return np.unwrap(np.arctan2(self.voltage_q, self.voltage_i))
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

So, I'm not sure why you are reversing the two arguments, but this seems to be different from what we used until now.

Even in 0.2, we were computing the phase as
https://github.com/qiboteam/qibocal/blob/d35ab6b2d707031520927a9325b62b9b95a60c62/src/qibocal/result.py#L78
i.e.

$$ \arctan\left(\frac{I}{Q}\right) $$

while you're using:

$$ \arctan\left(\frac{Q}{I}\right) $$

This is mostly a sign, since

$$ \arctan\left(\frac{1}{x}\right) = \frac{\pi}{2} - \arctan(x) $$

(i.e. a sign and an offset, which should be taken away from the unwrapping and cable delay removal).

It's not extremely relevant, and I don't have any special reason to push for one sign or the other. I'm just trying to track the changes.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@alecandido The reason is the numpy's definition of the arctan2 function. The phase (or angle as in np.angle) of a complex number a+jb is np.arctan2(b, a) and not np.arctan2(a, b).

@scarrazza
Copy link
Member

@hay-k can we merge this today?

@alecandido alecandido added this to the Qibolab 0.1.10 milestone Oct 25, 2024
@hay-k hay-k merged commit 4892a5f into 0.1 Oct 25, 2024
23 of 26 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

Successfully merging this pull request may close these issues.

Sequences with different frequencies are not separated Qblox results not matching between qibo versions
6 participants