def _get_projection_quadratic(
cfg):
"""Get a projection quadratic problem from the given config."""
return (problem_spec.Spec(pg.ProjectionQuadratic, (cfg["dim"],), {}),
losg_datasets.random_symmetric(cfg["dim"],
int(cfg["n_samples"] // 2) * 2),
cfg["bs"])
def _get_sum_of_quadratics(cfg):
"""Get a sum of quadratics problem from the given config."""
return (
problem_spec.Spec(pg.SumOfQuadratics, (cfg["dim"], ), {}),
# dataset size must be divisible by 2.
losg_datasets.random_symmetric(cfg["dim"],
int(cfg["n_samples"] // 2) * 2),
cfg["bs"])
def _get_fully_connected(cfg):
"""Get a fully connected problem from the given config."""
return (problem_spec.Spec(
pg.FullyConnected, (cfg["n_features"], cfg["n_classes"]), {
"hidden_sizes": tuple(cfg["hidden_sizes"]),
"activation": utils.get_activation(cfg["activation"]),
}), losg_datasets.random_mlp(cfg["n_features"],
cfg["n_samples"]), cfg["bs"])
def _get_sparse_softmax_regression(cfg):
"""Get a sparse softmax regression problem."""
return (problem_spec.Spec(pg.SparseSoftmaxRegression,
(cfg["n_features"], cfg["n_classes"]),
{"noise_stdev": cfg["noise_stdev"]}),
losg_datasets.noisy_parity_class(cfg["n_samples"],
n_classes=cfg["n_classes"]),
cfg["bs"])
def _get_sparse_problem(cfg):
"""Get a sparse problem from the given config."""
name, cc = cfg["base"]
base_spec, dataset, bs = _problem_sample_get[name][1](cc)
return (problem_spec.Spec(
pg.SparseProblem, [base_spec], {
"zero_probability": cfg["zero_probability"],
"noise_stdev": cfg["noise_stdev"]
}), dataset, bs)
def testSparseProblem_alwaysZero(self):
zero_prob = 1.0
problem = pg.SparseProblem(problem_spec.Spec(pg.Quadratic, (5, ), {}),
zero_prob)
self.assertEqual(zero_prob, problem.zero_prob)
parameters = problem.init_tensors(seed=1234)
objective = problem.objective(parameters)
gradients = problem.gradients(objective, parameters)
self.assertLen(gradients, 1)
with self.test_session() as sess:
self.assertFalse(any(sess.run(gradients[0])))
def testSparseProblem_someProbability(self):
tf.set_random_seed(1234)
zero_prob = 0.5
problem = pg.SparseProblem(problem_spec.Spec(pg.Quadratic, (5, ), {}),
zero_prob)
self.assertEqual(zero_prob, problem.zero_prob)
parameters = problem.init_tensors(seed=1234)
objective = problem.objective(parameters)
gradients = problem.gradients(objective, parameters)
self.assertLen(gradients, 1)
with self.test_session() as sess:
self.assertTrue(any(sess.run(gradients[0])))
self.assertFalse(all(sess.run(gradients[0])))
def _get_log_objective(cfg):
"""Get a log objective problem fromt he given config."""
name, cc = cfg["base"]
base_spec, dataset, bs = _problem_sample_get[name][1](cc)
return (problem_spec.Spec(pg.LogObjective, [base_spec], {}), dataset, bs)
def _get_rescale_problem(cfg):
"""Get a rescale problem from the given config."""
name, cc = cfg["base"]
base_spec, dataset, bs = _problem_sample_get[name][1](cc)
return (problem_spec.Spec(pg.Rescale, [base_spec],
{"scale": cfg["scale"]}), dataset, bs)
def _get_min_max_well(cfg):
"""Get a min max well problem from the given config."""
return problem_spec.Spec(pg.MinMaxWell, (cfg["dim"], ),
{"noise_stdev": cfg["noise_stdev"]}), None, None
def _get_quadratic_problem(cfg):
"""Get a quadratic problem from the given config."""
return problem_spec.Spec(pg.Quadratic, (cfg["dim"], ),
{"noise_stdev": cfg["noise_stdev"]}), None, None
def _get_dependency_chain(cfg):
"""Get a dependency chain problem from the given config."""
return (problem_spec.Spec(pg.DependencyChain, (cfg["dim"], ), {}),
losg_datasets.random_mlp(cfg["dim"], cfg["n_samples"]), cfg["bs"])
def _get_norm(cfg):
"""Get a norm problem from the given config."""
return (problem_spec.Spec(pg.Norm, (cfg["dim"], ),
{"norm_power": cfg["norm_power"]}), None, None)
def _get_optimization_test_problems(cfg):
"""Get an optimization test function problem form the given config."""
return problem_spec.Spec(_opt_test_problems[cfg["problem"]], (),
{"noise_stdev": cfg["noise_stdev"]}), None, None
def _get_bowl_problem(cfg):
"""Get a bowl problem from the given config."""
return problem_spec.Spec(pg.Bowl, (cfg["cond"], ), {
"noise_stdev": cfg["noise_stdev"],
"angle": cfg["angle"]
}), None, None
def problem_fn_to_problem_definition(problem_fn):
return lambda: (problem_spec.Spec(problem_fn, (), {}), None, None)
def _get_outward_snake(cfg):
"""Get an outward snake problem from the given config."""
return (problem_spec.Spec(pg.OutwardSnake, (cfg["dim"], ), {}),
losg_datasets.random_mlp(cfg["dim"], cfg["n_samples"]), cfg["bs"])
