class TestEIF2D(unittest.TestCase):
def setUp(self):
self.graph2d = graph2d
print(self.graph2d.Y)
lids2d = np.random.choice(graph2d.X.shape[0], 10, replace=False)
uids = np.delete(np.arange(self.graph2d.Y.shape[0]), lids2d)
self.ym = np.argmax(self.graph2d.Y[uids])
Yl2d = graph2d.Y[lids2d]
graph2d.Y = np.zeros((graph2d.Y.shape[0]))
graph2d.update(lids2d, Yl2d)
self.lp = HMN(self.graph2d)
def test_compute(self):
self.lp.label_propagate(self.graph2d)
print(self.graph2d.Y)
eif = EIF(self.graph2d, self.lp)
uids = np.delete(np.arange(self.graph2d.Y.shape[0]), self.graph2d.lids)
a = []
for id_test in uids:
a.append(eif.compute(int(id_test)))
print("a:", a)
ympred = a[self.ym]
print("max y prediction", ympred)
rank = sorted(a, reverse=True).index(ympred)
print("rank:", rank)
assert len(a) == uids.shape[0]
def setUp(self):
self.graph1d = graph1d
lids1d = np.random.choice(graph1d.X.shape[0], 10, replace=False)
uids = np.delete(np.arange(self.graph1d.Y.shape[0]), lids1d)
self.ym = np.argmax(self.graph1d.Y[uids])
Yl1d = graph1d.Y[lids1d]
graph1d.Y = np.zeros((graph1d.Y.shape[0]))
graph1d.update(lids1d, Yl1d)
self.lp = HMN(self.graph1d)
def test_hmn_2d(self):
hmn = HMN(self.graph2d)
YL = self.graph2d.Y[self.graph2d.lids]
hmn.label_propagate(self.graph2d)
assert np.array_equal(self.graph2d.Y[self.graph2d.lids], YL)
#print("True 2d: ", self.trueY2d[:20])
#print("Label propagation: ", self.graph2d.Y[:20])
print("hmn mse", sum((self.trueY2d - self.graph2d.Y)**2))
def setUp(self):
self.true1dY = graph1d.Y
self.true2dY = graph2d.Y
graph1d.Y = np.zeros((graph1d.Y.shape[0])).reshape(graph1d.Y.shape[0], -1)
graph2d.Y = np.zeros((graph2d.Y.shape[0])).reshape(graph2d.Y.shape[0], -1)
lp1 = HMN(graph1d)
lp2 = HMN(graph2d)
af1d = EIF(graph1d, lp1)
af2d = EIF(graph2d, lp2)
maximizer1d = RandomSampling(af1d)
maximizer2d = RandomSampling(af2d)
self.graph1d = graph1d
self.graph2d = graph2d
self.solver1d = GBOPT(self.graph1d, objective_function1d, lp1,
af1d, maximizer1d,
init_random_choice)
self.solver2d = GBOPT(self.graph2d, objective_function2d, lp2,
af2d, maximizer2d,
init_random_choice)
def gb_opt(graph,
objective_function,
label_prop_alg="hmn",
acquisition_func="eif",
maximize_func="random",
n_samples=-1,
num_iterations=1000,
initial_design="random",
n_init=10,
lids_init=None,
Y_init=None,
rng=None,
output_path=None):
"""
General interface for graph-based semi-supervised learning for global
black box optimization problems.
Parameters
----------
graph: GraphObject
The graph defined by features and labels of nodes, and an adjacency matrix.
objective_func:
Function handle of for the objective function.
label_prop_alg: LabelPropagationAlgObject
The label propagation algorithm for graph-based semi-supervised learning.
acquisition_func: BaseAcquisitionFunctionObject
The acquisition function which will be maximized.
maximize_func: BaseMaximizerObject
The optimizers that maximize the acquisition function.
n_samples: int
The number of points to evaluate for maximize_func.
-1 is evaluating all the points on the graph.
initial_design: function
Function that returns some points which will be evaluated before the optimization loop is started.
This allows to initialize the graph.
initial_points: int
Defines the number of initial points that are evaluated before the actual optimization.
lids_init: np.ndarray(l,)
Indices of initial points to warm start label propagation.
Y_init: np.ndarray(l,1)
Function values of the already initial points.
output_path: string
Specifies the path where the intermediate output after each iteration will be saved.
If None no output will be saved to disk.
rng: np.random.RandomState
Random number generator
Returns
-------
dict with all results
"""
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations."
assert lids_init is None or lids_init in np.arange(
graph.X.shape[0]), "The initial points has to be in the sample pool."
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
if label_prop_alg == "hmn":
lp = HMN(graph)
else:
raise ValueError(
"'{}' is not a valid label propagation algorithm".format(
label_prop_alg))
if acquisition_func == "eif":
af = EIF(graph, lp)
elif acquisition_func == "random":
af = Random()
else:
raise ValueError("'{}' is not a valid acquisition function".format(
acquisition_func))
if maximize_func == "random":
max_func = RandomSampling(af, n_samples=n_samples, rng=rng)
else:
raise ValueError("'{}' is not a valid function to maximize the "
"acquisition function".format(maximize_func))
if initial_design == "random":
init_design = init_random_choice
else:
raise ValueError("'{}' is not a valid function to design the "
"initial points".format(initial_design))
gbo = GBOPT(graph,
objective_function,
lp,
af,
max_func,
initial_design=init_design,
initial_points=n_init,
rng=rng,
output_path=output_path)
x_best, f_max = gbo.run(num_iterations, lids_init, Y_init)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_max.tolist()
# Best x along training
results["incumbents"] = [inc for inc in gbo.incumbents]
results["incumbents_values"] = [val for val in gbo.incumbents_values]
results["runtime"] = gbo.runtime
results["overhead"] = gbo.time_overhead
results["labeled_indices"] = gbo.graph.lids.tolist()
results["X"] = [x.tolist() for x in gbo.graph.X[gbo.graph.lids]]
results["y"] = [y for y in gbo.graph.Y[gbo.graph.lids]]
results["predictions"] = gbo.predictions
return results
def __init__(self):
self.graph2d = graph2d
lp = HMN(self.graph2d)
super(DemoAcquisitionFunction2d, self).__init__(self.graph2d, lp)