def setUp(self):
A = uniform.uniform_noisy_engine()
X = dataset.DatasetSampledFromFile(nickname='BIDS-ALL',
sample_to_scale=1E4,
reduce_to_dom_shape=1024,
seed=0)
W = workload.Prefix1D(domain_shape_int=1024)
E1 = experiment.Single(X, W, A, 0.1, 0)
E2 = experiment.Single(X, W, A, 0.1, 1)
self.metric_group = [metric.SampleError(E1), metric.SampleError(E2)]
def error(self, data, reps=10):
tot = 0
for x in range(0, reps):
M = metric.SampleError(experiment.Single(data.x, data.Q, self._alg,
data.epsilon, next(self.S)))
err = M.compute().error_payload
tot += err['TypeI.L2']
return tot / reps
def test_experiment_can_run(self):
E = experiment.Single(self.X1,
self.W1,
self.A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_MWEM_ADP_2D(self):
A = mwemND.mwemND_adaptive_engine(index='DEFALUT2D')
E = experiment.Single(self.X2,
self.W2,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_AHP_ADP_1D(self):
A = ahp.ahpND_adaptive_engine(index='DEFALUT1D')
E = experiment.Single(self.X1,
self.W1,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_PHP(self):
A = thirdparty.php_engine()
E = experiment.Single(self.X1,
self.W1,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_AG(self):
A = AG.AG_engine()
E = experiment.Single(self.X2,
self.W2,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_identity(self):
A = identity.identity_engine()
E = experiment.Single(self.X1,
self.W1,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_uniform_noisy_2D(self):
A = uniform.uniform_noisy_engine()
E = experiment.Single(self.X2,
self.W2,
A,
self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_greedyH(self):
A = dawa.greedyH_only_engine()
E = experiment.Single(self.X1,
self.W1,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_mwemND_1D(self):
A = mwemND.mwemND_engine()
E = experiment.Single(self.X1,
self.W1,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def test_privelet(self):
A = privelet.privelet_engine()
E = experiment.Single(self.X1,
self.W1,
A,
epsilon=self.expr_eps,
seed=self.expr_seed).run()
E_dict = E.asDict()
self.assertEqual(self.expr_seed, E_dict['seed'])
self.assertEqual(self.expr_eps, E_dict['epsilon'])
def setUp(self):
super(TestExecution, self).setUp()
domain1 = 1024
sample = 1E4
domain2 = (32, 32)
self.expr_seed = 12345
self.expr_eps = 0.1
self.X1 = dataset.DatasetSampledFromFile(nickname='HEPTH',
sample_to_scale=sample,
reduce_to_dom_shape=domain1,
seed=111)
self.W1 = workload.Prefix1D(domain_shape_int=domain1)
self.X2 = dataset.DatasetSampledFromFile(nickname='SF-CABS-S',
sample_to_scale=sample,
reduce_to_dom_shape=domain2,
seed=111)
self.W2 = workload.RandomRange(shape_list=[(5, 5), (10, 10)],
domain_shape=domain2,
size=1000,
seed=9001)
self.A1 = uniform.uniform_noisy_engine()
self.A2 = AG.AG_engine(c=10, c2=5, alpha=.4)
self.E1 = experiment.Single(self.X1,
self.W1,
self.A1,
epsilon=self.expr_eps,
seed=self.expr_seed)
self.E2 = experiment.Single(self.X2,
self.W2,
self.A2,
epsilon=self.expr_eps,
seed=self.expr_seed)
self.M1 = metric.SampleError(self.E1)
self.M2 = metric.PopulationError(self.E2)
def test_ancillary_payload(self):
ancillary_payload = {'foo': 'bar'}
class Operator(BaseAlgorithm):
def __init__(self, short_name='operator'):
self.init_params = util.init_params_from_locals(locals())
self.short_name = short_name
def Run(self, Q, x, epsilon, seed=None):
return x, ancillary_payload
A = Operator()
E = experiment.Single(self.X1,
self.W1,
A,
epsilon=self.expr_eps,
seed=self.expr_seed)
M = metric.SampleError(E)
M.compute()
self.assertDictEqual(E.analysis_payload()['ancillary_output'],
ancillary_payload)
def E(d, w, a, epsilon, seed):
return experiment.Single(d, w, a, epsilon, seed=seed)
