def test_univ_uniform_range(self):
"""
Distributions: Checks that the univariate uniform dist obeys limits.
"""
for lower, upper in [(0, 1), (-1, 1), (-1, 5)]:
dist = UniformDistribution([lower, upper])
samples = dist.sample(1000)
assert np.all(samples >= lower)
assert np.all(samples <= upper)
def test_univ_uniform_range(self):
"""
Distributions: Checks that the univariate uniform dist obeys limits.
"""
for lower, upper in [(0, 1), (-1, 1), (-1, 5)]:
dist = UniformDistribution([lower, upper])
samples = dist.sample(1000)
assert np.all(samples >= lower)
assert np.all(samples <= upper)
def test_univ_uniform_moments(self):
"""
Distributions: Checks that the univ. uniform dist. has the right moments.
"""
dist = UniformDistribution([[0, 1]])
samples = dist.sample(10000)
# We use low-precision checks here, since the error goes as 1/sqrt{N}.
# Determinism helps us be sure that once we pass, we'll keep passing,
# but it does nothing to make the moments accurate.
assert_almost_equal(1 / 12, samples.var(), 2)
assert_almost_equal(1 / 2, samples.mean(), 2)
def test_univ_uniform_moments(self):
"""
Distributions: Checks that the univ. uniform dist. has the right moments.
"""
dist = UniformDistribution([[0, 1]])
samples = dist.sample(10000)
# We use low-precision checks here, since the error goes as 1/sqrt{N}.
# Determinism helps us be sure that once we pass, we'll keep passing,
# but it does nothing to make the moments accurate.
assert_almost_equal(1 / 12, samples.var(), 2)
assert_almost_equal(1 / 2, samples.mean(), 2)
def simple_est_rb(data,
interleaved=False,
p_min=0.0,
p_max=1.0,
n_particles=8000,
return_all=False):
r"""
Estimates the fidelity of a gateset from a standard or interleaved randomized benchmarking
experiment.
:param data: Data to be used in estimating the gateset fidelity.
:type data: see :ref:`simple_est_data_arg`
:param float p_min: Minimum value of the parameter :math:`p`
to consider feasible.
:param float p_max: Minimum value of the parameter :math:`p`
to consider feasible.
:param int n_particles: The number of particles to be used in estimating
the randomized benchmarking model.
:param bool return_all: Controls whether additional return
values are provided, such as the updater.
:column counts (int): How many sequences of length :math:`m` were observed to
survive.
:column m (int): How many gates were used for sequences in this row of the data.
:column n_shots (int): How many different sequences of length :math:`m`
were measured.
:column reference (bool): `True` if this row represents reference sequences, or
`False` if the gate of interest is interleaved. Note that this column is omitted
if ``interleaved`` is `False`.
:return mean: Bayesian mean estimator for the model vector
:math:`(p, A, B)`, or :math:`(\tilde{p}, p_{\text{ref}}, A, B)`
for the interleaved case.
:return var: Variance of the final posterior over RB model vectors.
:return extra: See :ref:`simple_est_extra_return`. Only returned
if ``return_all`` is `True`.
"""
model = BinomialModel(RandomizedBenchmarkingModel(interleaved=interleaved))
prior = PostselectedDistribution(
UniformDistribution(
[[p_min, p_max], [0, 1], [0, 1]] if not interleaved else
[[p_min, p_max], [p_min, p_max], [0, 1], [0, 1]]), model)
data = load_data_or_txt(data, [('counts', 'uint'), ('m', 'uint'),
('n_shots', 'uint')] +
([('reference', 'uint')] if interleaved else []))
cols_expparams = {'m': (1, 'm'), 'n_meas': (2, 'n_shots')}
if interleaved:
cols_expparams['reference'] = (3, 'reference')
outcomes, expparams = data_to_params(data,
model.expparams_dtype,
cols_expparams=cols_expparams)
return do_update(model, n_particles, prior, outcomes, expparams,
return_all)
def simple_est_prec(data, freq_min=0.0, freq_max=1.0, n_particles=6000, return_all=False):
"""
Estimates a simple precession (cos²) from experimental data.
Note that this model is mainly for testing purposes, as it does not
consider the phase or amplitude of precession, leaving only the frequency.
:param data: Data to be used in estimating the precession frequency.
:type data: see :ref:`simple_est_data_arg`
:param float freq_min: The minimum feasible frequency to consider.
:param float freq_max: The maximum feasible frequency to consider.
:param int n_particles: The number of particles to be used in estimating
the precession frequency.
:param bool return_all: Controls whether additional return
values are provided, such as the updater.
:column counts (int): How many counts were observed at the sampled
time.
:column t (float): The evolutions time at which the samples
were collected.
:column n_shots (int): How many samples were collected at the
given evolution time.
:return mean: Bayesian mean estimator for the precession frequency.
:return var: Variance of the final posterior over frequency.
:return extra: See :ref:`simple_est_extra_return`. Only returned
if ``return_all`` is `True`.
"""
model = BinomialModel(SimplePrecessionModel(freq_min))
prior = UniformDistribution([0, freq_max])
data = load_data_or_txt(data, [
('counts', 'uint'),
('t', float),
('n_shots', 'uint')
])
outcomes, expparams = data_to_params(data,
model.expparams_dtype,
cols_expparams={
'x': (1, 't'),
'n_meas': (2, 'n_shots')
}
)
return do_update(
model, n_particles, prior, outcomes, expparams,
return_all
)
def run_estimate(data, freq,
n_particles=10000, return_all=False):
"""this is a copy of qinfer.simple_
Args:
data:
n_particles:
return_all:
Returns:
"""
model = BinomialModel(AmplitudeEstimator(freq))
prior = PostselectedDistribution(
UniformDistribution(
[
[0.30, 0.5],
[0.30, 0.5]
]),
model,
maxiters=10000
)
# prior = MyDistribution()
data = load_data_or_txt(data, [
('counts', 'uint'),
('t', float),
('n_shots', 'uint')
])
outcomes, expparams = data_to_params(data,
model.expparams_dtype,
cols_expparams={
't': (1, 't'),
'n_meas': (2, 'n_shots')
}
)
return do_update(
model, n_particles, prior, outcomes, expparams,
return_all
)
def _mk_updater(self, n_particles, **kwargs):
return SMCUpdater(self.model, n_particles, UniformDistribution([0, 1]), **kwargs)
mps_buf.release()
eps_buf.release()
dest_buf.release()
# Now we concatenate over outcomes.
return FiniteOutcomeModel.pr0_to_likelihood_array(outcomes, pr0)
## SCRIPT ######################################################################
if __name__ == "__main__":
# NOTE: This is now redundant with the perf_testing module.
simple_model = SimplePrecessionModel()
for model in [AcceleratedPrecessionModel(), SimplePrecessionModel()]:
true = np.random.random(1)
updater = SMCUpdater(model, 100000, UniformDistribution([0, 1]))
tic = time.time()
for idx_exp in range(200):
if not (idx_exp % 20):
print(idx_exp)
expparams = np.array([(9 / 8)**idx_exp])
updater.update(simple_model.simulate_experiment(true, expparams),
expparams)
print(model, updater.est_mean(), true, time.time() - tic)
"""
from __future__ import division
from t1_model import T1Model
from qinfer.distributions import UniformDistribution
from qinfer.smc import SMCUpdater
from qinfer.resamplers import LiuWestResampler
import numpy as np
import matplotlib.pyplot as plt
from qinfer.expdesign import ExperimentDesigner
import logging
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
model = T1Model()
prior = UniformDistribution(np.array([0, 10]))
N_particles = 1000000
updater = SMCUpdater(
model, N_particles, prior, resampler=LiuWestResampler(),
zero_weight_policy='reset'
)
designer = ExperimentDesigner(updater, opt_algo=1)
# Set the value of T1 to Learn, pick 1 value from prior
true_model = prior.sample()
# true_model=np.array([11.032], dtype=model.expparams_dtype)
performance_dtype = [
('expparams', 'float'),
('sim_outcome', 'float'),
('est_mean', 'float'),
def test_uniform_shape(self):
"""
Distributions: Checks that the multivar. uni. dist has the right shape.
"""
dist = UniformDistribution([[0, 1], [0, 2], [0, 3]])
assert dist.sample(100).shape == (100, 3)
def test_uniform_shape(self):
"""
Distributions: Checks that the multivar. uni. dist has the right shape.
"""
dist = UniformDistribution([[0, 1], [0, 2], [0, 3]])
assert dist.sample(100).shape == (100, 3)