def test_probability_balanced(self): """Test if p=0.5 is returned when counts are balanced and prior is flat.""" node = Probability(outcome="1") # balanced counts with a flat prior will yield p = 0.5 data = {"1": 512, "0": 512} processed_data = node(data=np.asarray([data])) self.assertAlmostEqual(unp.nominal_values(processed_data), 0.5)
def test_validation(self): """Test the validation mechanism.""" for validate, error in [(False, AttributeError), (True, DataProcessorError)]: processor = DataProcessor("counts") processor.append(Probability("00", validate=validate)) with self.assertRaises(error): processor({"counts": [0, 1, 2]})
def test_populations(self): """Test that counts are properly converted to a population.""" processor = DataProcessor("counts") processor.append(Probability("00")) new_data = processor(self.exp_data_lvl2.data[0]) self.assertEqual(new_data[0], 0.4) self.assertEqual(new_data[1], 0.4 * (1 - 0.4) / 10)
def test_variance_not_zero(self): """Test if finite variance is computed at max or min probability.""" node = Probability(outcome="1") data = {"1": 1024, "0": 0} processed_data = node(data=np.asarray([data])) self.assertGreater(unp.std_devs(processed_data), 0.0) self.assertLessEqual(unp.nominal_values(processed_data), 1.0) data = {"1": 0, "0": 1024} processed_data = node(data=np.asarray([data])) self.assertGreater(unp.std_devs(processed_data), 0.0) self.assertGreater(unp.nominal_values(processed_data), 0.0)
def test_populations(self): """Test that counts are properly converted to a population.""" processor = DataProcessor("counts") processor.append(Probability("00")) # Test on a single datum. new_data, error = processor(self.exp_data_lvl2.data(0)) self.assertEqual(new_data, 0.4) self.assertEqual(error, np.sqrt(0.4 * (1 - 0.4) / 10)) # Test on all the data new_data, error = processor(self.exp_data_lvl2.data()) self.assertTrue(np.allclose(new_data, np.array([0.4, 0.2])))
def test_bad_analysis(self): """Test the Rabi analysis.""" experiment_data = ExperimentData() thetas = np.linspace(0.0, np.pi / 4, 31) amplitudes = np.linspace(0.0, 0.95, 31) experiment_data.add_data( self.simulate_experiment_data(thetas, amplitudes, shots=200)) data_processor = DataProcessor("counts", [Probability(outcome="1")]) experiment_data = OscillationAnalysis().run( experiment_data, data_processor=data_processor, plot=False) result = experiment_data.analysis_results() self.assertEqual(result[0].quality, "bad")
def test_good_analysis(self): """Test the Rabi analysis.""" experiment_data = ExperimentData() thetas = np.linspace(-np.pi, np.pi, 31) amplitudes = np.linspace(-0.25, 0.25, 31) expected_rate, test_tol = 2.0, 0.2 experiment_data.add_data( self.simulate_experiment_data(thetas, amplitudes, shots=400)) data_processor = DataProcessor("counts", [Probability(outcome="1")]) experiment_data = OscillationAnalysis().run( experiment_data, data_processor=data_processor, plot=False) result = experiment_data.analysis_results(0) self.assertEqual(result.quality, "good") self.assertAlmostEqual(result.value[1], expected_rate, delta=test_tol)
def test_populations(self): """Test that counts are properly converted to a population.""" processor = DataProcessor("counts") processor.append(Probability("00", alpha_prior=1.0)) # Test on a single datum. new_data = processor(self.exp_data_lvl2.data(0)) self.assertAlmostEqual(float(unp.nominal_values(new_data)), 0.41666667) self.assertAlmostEqual(float(unp.std_devs(new_data)), 0.13673544235706114) # Test on all the data new_data = processor(self.exp_data_lvl2.data()) np.testing.assert_array_almost_equal( unp.nominal_values(new_data), np.array([0.41666667, 0.25]), )
def test_end_to_end_restless_standard_processor(self, pi_ratio): """Test the restless experiment with a standard processor end to end.""" error = -np.pi * pi_ratio backend = MockRestlessFineAmp(error, np.pi, "x") amp_exp = FineXAmplitude(0, backend) # standard data processor. standard_processor = DataProcessor("counts", [Probability("01")]) amp_exp.analysis.set_options(data_processor=standard_processor) # enable a restless measurement setting. amp_exp.enable_restless(rep_delay=1e-6, override_processor_by_restless=False) expdata = amp_exp.run(backend) self.assertExperimentDone(expdata) result = expdata.analysis_results(1) d_theta = result.value.n self.assertTrue(abs(d_theta - error) > 0.01) # check that the fit amplitude is much smaller than 1. amp_fit = expdata.analysis_results(0).value[0] self.assertTrue(amp_fit < 0.05)
def test_json(self): """Check if the node is serializable.""" node = Probability(outcome="00", alpha_prior=0.2) self.assertRoundTripSerializable(node, check_func=self.json_equiv)