Merge pull request #450 from qiboteam/results

fix

src/qibolab/instruments/rfsoc.py

@@ -240,7 +240,7 @@ def play(
                 if execution_parameters.acquisition_type is AcquisitionType.DISCRIMINATION:
                     discriminated_shots = self.classify_shots(i_pulse, q_pulse, qubits[ro_pulse.qubit])
                     if execution_parameters.averaging_mode is AveragingMode.CYCLIC:
-                        discriminated_shots = np.mean(discriminated_shots, keepdims=True)
+                        discriminated_shots = np.mean(discriminated_shots, axis=0)
                     result = execution_parameters.results_type(discriminated_shots)
                 else:
                     result = execution_parameters.results_type(i_pulse + 1j * q_pulse)
@@ -464,15 +464,15 @@ def convert_sweep_results(
 
                 if not average:
                     shape = i_vals.shape
-                    np.reshape(i_vals, (execution_parameters.nshots, *shape[:-1]))
-                    np.reshape(q_vals, (execution_parameters.nshots, *shape[:-1]))
+                    i_vals = np.reshape(i_vals, (self.cfg.reps, *shape[:-1]))
+                    q_vals = np.reshape(q_vals, (self.cfg.reps, *shape[:-1]))
 
                 if execution_parameters.acquisition_type is AcquisitionType.DISCRIMINATION:
                     qubit = qubits[sequence.ro_pulses[i].qubit]
-                    discrimated_shots = self.classify_shots(i_vals, q_vals, qubit)
+                    discriminated_shots = self.classify_shots(i_vals, q_vals, qubit)
                     if execution_parameters.averaging_mode is AveragingMode.CYCLIC:
-                        discriminated_shots = np.mean(discriminated_shots, keepdims=True)
-                    result = execution_parameters.results_type(discrimated_shots)
+                        discriminated_shots = np.mean(discriminated_shots, axis=0)
+                    result = execution_parameters.results_type(discriminated_shots)
                 else:
                     result = execution_parameters.results_type(i_vals + 1j * q_vals)
 

src/qibolab/result.py

@@ -160,3 +160,8 @@ def __add__(self, data):
         new_res.statistical_frequency = np.append(self.statistical_frequency, data.statistical_frequency)
         new_res.std = np.append(self.std, data.std)
         return new_res
+
+    @lru_cache
+    def probability(self, state=0):
+        """Returns the statistical frequency of the specified state (0 or 1)."""
+        return abs(1 - state - self.statistical_frequency)

tests/test_instruments_rfsoc.py

@@ -7,7 +7,12 @@
 from qibolab.platform import create_tii_rfsoc4x2
 from qibolab.platforms.abstract import Qubit
 from qibolab.pulses import PulseSequence
-from qibolab.result import AveragedIntegratedResults, IntegratedResults, SampleResults
+from qibolab.result import (
+    AveragedIntegratedResults,
+    AveragedSampleResults,
+    IntegratedResults,
+    SampleResults,
+)
 from qibolab.sweeper import Parameter, Sweeper
 
 RUNCARD = qibolab_folder / "runcards" / "tii1q_b1.yml"
@@ -238,11 +243,13 @@ def test_play():
     sequence.add(platform.create_RX_pulse(qubit=0, start=0))
     sequence.add(platform.create_MZ_pulse(qubit=0, start=100))
 
-    out_dict = instrument.play(platform.qubits, sequence)
+    out_dict = instrument.play(
+        platform.qubits, sequence, ExecutionParameters(acquisition_type=AcquisitionType.INTEGRATION)
+    )
 
     assert sequence[1].serial in out_dict
-    assert isinstance(out_dict[sequence[1].serial], ExecutionResults)
-    assert np.shape(out_dict[sequence[1].serial].i) == (1000,)
+    assert isinstance(out_dict[sequence[1].serial], IntegratedResults)
+    assert np.shape(out_dict[sequence[1].serial].voltage_i) == (1000,)
 
 
 @pytest.mark.qpu
@@ -256,15 +263,29 @@ def test_sweep():
     sequence.add(platform.create_MZ_pulse(qubit=0, start=100))
     sweep = Sweeper(parameter=Parameter.frequency, values=np.arange(10, 35, 10), pulses=[sequence[0]])
 
-    out_dict1 = instrument.sweep(platform.qubits, sequence, sweep, average=True, relaxation_time=100_000)
-    out_dict2 = instrument.sweep(platform.qubits, sequence, sweep, average=False, relaxation_time=100_000)
+    out_dict1 = instrument.sweep(
+        platform.qubits,
+        sequence,
+        ExecutionParameters(relaxation_time=100_000, averaging_mode=AveragingMode.CYCLIC),
+        sweep,
+    )
+    out_dict2 = instrument.sweep(
+        platform.qubits,
+        sequence,
+        ExecutionParameters(
+            relaxation_time=100_000,
+            acquisition_type=AcquisitionType.INTEGRATION,
+            averaging_mode=AveragingMode.SINGLESHOT,
+        ),
+        sweep,
+    )
 
     assert sequence[1].serial in out_dict1
     assert sequence[1].serial in out_dict2
-    assert isinstance(out_dict1[sequence[1].serial], AveragedResults)
-    assert isinstance(out_dict2[sequence[1].serial], ExecutionResults)
-    assert np.shape(out_dict1[sequence[1].serial].i) == (len(sweep.values),)
-    assert np.shape(out_dict2[sequence[1].serial].i) == (len(sweep.values) * 1000,)
+    assert isinstance(out_dict1[sequence[1].serial], AveragedSampleResults)
+    assert isinstance(out_dict2[sequence[1].serial], IntegratedResults)
+    assert np.shape(out_dict2[sequence[1].serial].voltage_i) == (1000, len(sweep.values))
+    assert np.shape(out_dict1[sequence[1].serial].statistical_frequency) == (len(sweep.values),)
 
 
 @pytest.mark.qpu
@@ -279,6 +300,12 @@ def test_python_reqursive_sweep():
     sweep1 = Sweeper(parameter=Parameter.amplitude, values=np.arange(0.01, 0.03, 10), pulses=[sequence[0]])
     sweep2 = Sweeper(parameter=Parameter.frequency, values=np.arange(10, 35, 10), pulses=[sequence[0]])
 
-    out_dict = instrument.sweep(platform.qubits, sequence, sweep1, sweep2, average=True, relaxation_time=100_000)
+    out_dict = instrument.sweep(
+        platform.qubits,
+        sequence,
+        ExecutionParameters(relaxation_time=100_000, averaging_mode=AveragingMode.CYCLIC),
+        sweep1,
+        sweep2,
+    )
 
     assert sequence[1].serial in out_dict

tests/test_platforms_abstract.py

@@ -13,7 +13,7 @@
 from qibo.models import Circuit
 from qibo.states import CircuitResult
 
-from qibolab import Platform
+from qibolab import ExecutionParameters, Platform
 from qibolab.backends import QibolabBackend
 from qibolab.paths import qibolab_folder
 from qibolab.platforms.abstract import AbstractPlatform
@@ -158,15 +158,15 @@ def test_platform_bias(platform):
 def test_multiqubitplatform_execute_empty(platform):
     # an empty pulse sequence
     sequence = PulseSequence()
-    platform.execute_pulse_sequence(sequence, nshots)
+    platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
 def test_multiqubitplatform_execute_one_drive_pulse(platform):
     # One drive pulse
     sequence = PulseSequence()
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=200))
-    platform.execute_pulse_sequence(sequence, nshots)
+    platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -177,7 +177,7 @@ def test_multiqubitplatform_execute_one_long_drive_pulse(platform):
     sequence = PulseSequence()
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=8192 + 200))
     with pytest.raises(NotImplementedError):
-        platform.execute_pulse_sequence(sequence, nshots)
+        platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -188,7 +188,7 @@ def test_multiqubitplatform_execute_one_extralong_drive_pulse(platform):
     sequence = PulseSequence()
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=2 * 8192 + 200))
     with pytest.raises(NotImplementedError):
-        platform.execute_pulse_sequence(sequence, nshots)
+        platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -197,7 +197,7 @@ def test_multiqubitplatform_execute_one_drive_one_readout(platform):
     sequence = PulseSequence()
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=200))
     sequence.add(platform.create_qubit_readout_pulse(qubit, start=200))
-    platform.execute_pulse_sequence(sequence, nshots)
+    platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -208,7 +208,7 @@ def test_multiqubitplatform_execute_multiple_drive_pulses_one_readout(platform):
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=204, duration=200))
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=408, duration=400))
     sequence.add(platform.create_qubit_readout_pulse(qubit, start=808))
-    platform.execute_pulse_sequence(sequence, nshots)
+    platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -221,7 +221,7 @@ def test_multiqubitplatform_execute_multiple_drive_pulses_one_readout_no_spacing
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=200, duration=200))
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=400, duration=400))
     sequence.add(platform.create_qubit_readout_pulse(qubit, start=800))
-    platform.execute_pulse_sequence(sequence, nshots)
+    platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -234,7 +234,7 @@ def test_multiqubitplatform_execute_multiple_overlaping_drive_pulses_one_readout
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=200, duration=200))
     sequence.add(platform.create_qubit_drive_pulse(qubit, start=50, duration=400))
     sequence.add(platform.create_qubit_readout_pulse(qubit, start=800))
-    platform.execute_pulse_sequence(sequence, nshots)
+    platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -249,7 +249,7 @@ def test_multiqubitplatform_execute_multiple_readout_pulses(platform):
     sequence.add(ro_pulse1)
     sequence.add(qd_pulse2)
     sequence.add(ro_pulse2)
-    platform.execute_pulse_sequence(sequence, nshots)
+    platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots))
 
 
 @pytest.mark.qpu
@@ -261,7 +261,7 @@ def test_excited_state_probabilities_pulses(platform, qubit):
     sequence = PulseSequence()
     sequence.add(qd_pulse)
     sequence.add(ro_pulse)
-    result = platform.execute_pulse_sequence(sequence, nshots=5000)
+    result = platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=5000))
 
     cr = CircuitResult(backend, Circuit(platform.nqubits), result, nshots=5000)
     probs = backend.circuit_result_probabilities(cr, qubits=[qubit])
@@ -281,7 +281,7 @@ def test_ground_state_probabilities_pulses(platform, qubit, start_zero):
         ro_pulse = platform.create_MZ_pulse(qubit, start=qd_pulse.duration)
     sequence = PulseSequence()
     sequence.add(ro_pulse)
-    result = platform.execute_pulse_sequence(sequence, nshots=5000)
+    result = platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=5000))
 
     cr = CircuitResult(backend, Circuit(platform.nqubits), result, nshots=5000)
     probs = backend.circuit_result_probabilities(cr, qubits=[qubit])

tests/test_result.py

@@ -43,19 +43,19 @@ def generate_random_avg_state_result(length=5):
 
 
 def test_iq_constructor():
-    """Testing IntegratedResults constructor"""
+    """Testing ExecutionResults constructor"""
     test = np.array([(1, 2), (1, 2)])
     IntegratedResults(test)
 
 
 def test_raw_constructor():
-    """Testing RawWaveformResults constructor"""
+    """Testing ExecutionResults constructor"""
     test = np.array([(1, 2), (1, 2)])
     RawWaveformResults(test)
 
 
 def test_state_constructor():
-    """Testing SampleResults constructor"""
+    """Testing ExecutionResults constructor"""
     test = np.array([1, 1, 0])
     SampleResults(test)
 
@@ -134,14 +134,7 @@ def test_serialize_state(average):
             np.testing.assert_equal(output[key], target_dict[key].flatten())
     else:
         results = generate_random_avg_state_result(5)
-        output = results.serialize
-        avg = results
-        target_dict = {
-            "0": abs(1 - np.mean(results.samples, axis=0)),
-        }
-        assert avg.serialize.keys() == target_dict.keys()
-        for key in output:
-            np.testing.assert_equal(avg.serialize[key], target_dict[key].flatten())
+        assert len(results.serialize["0"]) == 125
 
 
 @pytest.mark.parametrize("result", ["iq", "raw"])
@@ -161,15 +154,3 @@ def test_serialize_averaged_iq_results(result):
     assert output.keys() == target_dict.keys()
     for key in output:
         np.testing.assert_equal(output[key], target_dict[key].flatten())
-
-
-def test_serialize_averaged_state_results():
-    """Testing to_dict method"""
-    results = generate_random_avg_state_result(5)
-    output = results.serialize
-    target_dict = {
-        "0": abs(1 - np.mean(results.samples, axis=0)),
-    }
-    assert output.keys() == target_dict.keys()
-    for key in output:
-        np.testing.assert_equal(output[key], target_dict[key].flatten())