def _tune(self, graph=None, personalization=None, *args, **kwargs):
previous_backend = backend.backend_name()
personalization = to_signal(graph, personalization)
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
backend.load_backend(self.tuning_backend)
backend_personalization = to_signal(
graph, backend.to_array(personalization.np))
prev_dropout = kwargs.get("graph_dropout")
kwargs["graph_dropout"] = 0
best_value = -float('inf')
best_ranker = None
fraction_of_training = self.fraction_of_training if isinstance(
self.fraction_of_training,
Iterable) else [self.fraction_of_training]
for ranker in self.rankers:
values = list()
for seed, fraction in enumerate(fraction_of_training):
training, validation = split(backend_personalization,
fraction,
seed=seed)
measure = self.measure(validation, training)
values.append(
measure.best_direction() *
measure.evaluate(ranker.rank(training, *args, **kwargs)))
value = np.min(values)
if value > best_value:
best_value = value
best_ranker = ranker
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
backend.load_backend(previous_backend)
# TODO: make training back-propagate through tensorflow for combined_prediction==False
kwargs["graph_dropout"] = prev_dropout
return best_ranker, personalization if self.combined_prediction else training
def _tune(self, graph=None, personalization=None, *args, **kwargs):
previous_backend = backend.backend_name()
personalization = to_signal(graph, personalization)
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
backend.load_backend(self.tuning_backend)
backend_personalization = to_signal(
graph, backend.to_array(personalization.np))
training, validation = split(backend_personalization,
self.fraction_of_training)
measure = self.measure(validation, training)
best_params = optimize(
lambda params: -measure.best_direction() * measure.evaluate(
self._run(training, params, *args, **kwargs)),
**self.optimize_args)
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
backend.load_backend(previous_backend)
# TODO: make training back-propagate through tensorflow for combined_prediction==False (do this with a gather in the split method)
return self.ranker_generator(
best_params
), personalization if self.combined_prediction else training
def _tune(self, graph=None, personalization=None, *args, **kwargs):
previous_backend = backend.backend_name()
personalization = to_signal(graph, personalization)
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
backend.load_backend(self.tuning_backend)
backend_personalization = to_signal(
graph, backend.to_array(personalization.np))
training, validation = split(backend_personalization,
self.fraction_of_training)
measure = self.measure(validation, training)
best_value = -float('inf')
best_ranker = None
for ranker in self.rankers:
value = measure.best_direction() * measure.evaluate(
ranker.rank(training, *args, **kwargs))
if value > best_value:
best_value = value
best_ranker = ranker
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
backend.load_backend(previous_backend)
# TODO: make training back-propagate through tensorflow for combined_prediction==False
return best_ranker, personalization if self.combined_prediction else training
def _tune(self, graph=None, personalization=None, *args, **kwargs):
#graph_dropout = kwargs.get("graph_dropout", 0)
#kwargs["graph_dropout"] = 0
previous_backend = backend.backend_name()
personalization = to_signal(graph, personalization)
graph = personalization.graph
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
backend.load_backend(self.tuning_backend)
backend_personalization = to_signal(
personalization, backend.to_array(personalization.np))
#training, validation = split(backend_personalization, 0.8)
#training2, validation2 = split(backend_personalization, 0.6)
#measure_weights = [1, 1, 1, 1, 1]
#propagated = [training.np, validation.np, backend_personalization.np, training2.np, validation2.np]
measure_values = [None] * (self.num_parameters + self.autoregression)
M = self.ranker_generator(measure_values).preprocessor(graph)
#for _ in range(10):
# backend_personalization.np = backend.conv(backend_personalization.np, M)
training, validation = split(backend_personalization, 0.8)
training1, training2 = split(training, 0.5)
propagated = [training1.np, training2.np]
measures = [
self.measure(backend_personalization, training1),
self.measure(backend_personalization, training2)
]
#measures = [self.measure(validation, training), self.measure(training, validation)]
if self.basis == "krylov":
for i in range(len(measure_values)):
measure_values[i] = [
measure(p) for p, measure in zip(propagated, measures)
]
propagated = [backend.conv(p, M) for p in propagated]
else:
basis = [
arnoldi_iteration(M, p, len(measure_values))[0]
for p in propagated
]
for i in range(len(measure_values)):
measure_values[i] = [
float(measure(base[:, i]))
for base, measure in zip(basis, measures)
]
measure_values = backend.to_primitive(measure_values)
mean_value = backend.mean(measure_values, axis=0)
measure_values = measure_values - mean_value
best_parameters = measure_values
measure_weights = [1] * measure_values.shape[1]
if self.autoregression != 0:
#vals2 = -measure_values-mean_value
#measure_values = np.concatenate([measure_values, vals2-np.mean(vals2, axis=0)], axis=1)
window = backend.repeat(1. / self.autoregression,
self.autoregression)
beta1 = 0.9
beta2 = 0.999
beta1t = 1
beta2t = 1
rms = window * 0
momentum = window * 0
error = float('inf')
while True:
beta1t *= beta1
beta2t *= beta2
prev_error = error
parameters = backend.copy(measure_values)
for i in range(len(measure_values) - len(window) - 2, -1, -1):
parameters[i, :] = backend.dot(
(window),
measure_values[(i + 1):(i + len(window) + 1), :])
errors = (parameters - measure_values
) * measure_weights / backend.sum(measure_weights)
for j in range(len(window)):
gradient = 0
for i in range(len(measure_values) - len(window) - 1):
gradient += backend.dot(measure_values[i + j + 1, :],
errors[i, :])
momentum[j] = beta1 * momentum[j] + (
1 - beta1) * gradient #*np.sign(window[j])
rms[j] = beta2 * rms[j] + (1 - beta2) * gradient * gradient
window[j] -= 0.01 * momentum[j] / (1 - beta1t) / (
(rms[j] / (1 - beta2t))**0.5 + 1.E-8)
#window[j] -= 0.01*gradient*np.sign(window[j])
error = backend.mean(backend.abs(errors))
if error == 0 or abs(error - prev_error) / error < 1.E-6:
best_parameters = parameters
break
best_parameters = backend.mean(best_parameters[:self.num_parameters, :]
* backend.to_primitive(measure_weights),
axis=1) + backend.mean(mean_value)
if self.tunable_offset is not None:
div = backend.max(best_parameters)
if div != 0:
best_parameters /= div
measure = self.tunable_offset(validation, training)
base = basis[0] if self.basis != "krylov" else None
best_offset = optimize(
lambda params: -measure.best_direction() * measure(
self._run(training, [(best_parameters[i] + params[
2]) * params[0]**i + params[1] for i in range(
len(best_parameters))], base, *args, **kwargs)),
#lambda params: - measure.evaluate(self._run(training, best_parameters + params[0], *args, **kwargs)),
max_vals=[1, 0, 0],
min_vals=[0, 0, 0],
deviation_tol=0.005,
parameter_tol=1,
partitions=5,
divide_range=2)
#best_parameters += best_offset[0]
best_parameters = [
(best_parameters[i] + best_offset[2]) * best_offset[0]**i +
best_offset[1] for i in range(len(best_parameters))
]
best_parameters = backend.to_primitive(best_parameters)
if backend.sum(backend.abs(best_parameters)) != 0:
best_parameters /= backend.mean(backend.abs(best_parameters))
if self.tuning_backend is not None and self.tuning_backend != previous_backend:
best_parameters = [
float(param) for param in best_parameters
] # convert parameters to backend-independent list
backend.load_backend(previous_backend)
#kwargs["graph_dropout"] = graph_dropout
if self.basis != "krylov":
return Tautology(), self._run(
personalization, best_parameters, *args,
**kwargs) # TODO: make this unecessary
return self.ranker_generator(best_parameters), personalization
def benchmark(algorithms: Mapping[str, NodeRanking],
datasets: Any,
metric: Union[Callable[[nx.Graph], Measure], Callable[[GraphSignal, GraphSignal], Measure]] = AUC,
fraction_of_training: Union[float, Iterable[float]] = 0.5,
sensitive: Optional[Union[Callable[[nx.Graph], Measure], Callable[[GraphSignal, GraphSignal], Measure]]] = None,
seed: Union[int, Iterable[int]] = 0):
"""
Compares the outcome of provided algorithms on given datasets using a desired metric.
Args:
algorithms: A map from names to node ranking algorithms to compare.
datasets: A list of datasets to compare the algorithms on. List elements should either be strings or (string, num) tuples
indicating the dataset name and number of community of interest respectively.
metric: A method to instantiate a measure type to assess the efficacy of algorithms with.
fraction_of_training: The fraction of training samples to split on. The rest are used for testing. An
iterable of floats can also be provided to experiment with multiple fractions.
sensitive: Optinal. A generator of sensitivity-aware supervised or unsupervised measures.
Could be None (default).
seed: A seed to ensure reproducibility. Default is 0. An iterable of floats can also be provided to experimet
with multiple seeds.
Returns:
Yields an array of outcomes. Is meant to be used with wrapping methods, such as print_benchmark.
Example:
>>> import pygrank as pg
>>> algorithms = ...
>>> datasets = ...
>>> pg.benchmark_print(pg.benchmark(algorithms, datasets))
"""
if sensitive is not None:
yield [""] + [algorithm for algorithm in algorithms for suffix in [metric.__name__, sensitive.__name__]]
yield [""] + [suffix for algorithm in algorithms for suffix in [metric.__name__, sensitive.__name__]]
else:
yield [""] + [algorithm for algorithm in algorithms]
seeds = [seed] if isinstance(seed, int) else seed
fraction_of_training = [fraction_of_training] if isinstance(fraction_of_training, float) else fraction_of_training
for name, graph, group in datasets:
for training_samples in fraction_of_training:
for seed in seeds:
multigroup = isinstance(group, collections.abc.Mapping) and not isinstance(group, GraphSignal)
training, evaluation = split(group, training_samples=training_samples, seed=seed)
if sensitive is None and multigroup:
training = {group_id: to_signal(graph,{v: 1 for v in group}) for group_id, group in training.items()}
evaluation = {group_id: to_signal(graph,{v: 1 for v in group}) for group_id, group in evaluation.items()}
rank = lambda algorithm: {group_id: algorithm(graph, group) for group_id, group in training.items()}
else:
if multigroup:
training = training[0]
evaluation = evaluation[0]
sensitive_signal = to_signal(graph, {v: 1 for v in group[max(group.keys())]})
training, evaluation = to_signal(graph, {v: 1 for v in training}), to_signal(graph, {v: 1 for v in evaluation})
else:
training, evaluation = to_signal(graph, {v: 1 for v in training}), to_signal(graph, {v: 1 for v in evaluation})
if sensitive is not None:
if not multigroup:
sensitive_signal = to_signal(training, 1-evaluation.np)
#training.np = training.np*(1-sensitive_signal.np)
rank = lambda algorithm: algorithm(graph, training, sensitive=sensitive_signal)
else:
rank = lambda algorithm: algorithm(graph, training)
dataset_results = [name]
for algorithm in algorithms.values():
if metric == Time:
tic = time()
predictions = rank(algorithm)
dataset_results.append(time()-tic)
else:
predictions = rank(algorithm)
try:
dataset_results.append(metric(graph)(predictions))
except:
dataset_results.append(metric(evaluation, training)(predictions))
if sensitive is not None:
try:
dataset_results.append(sensitive(sensitive_signal, training)(predictions))
except:
dataset_results.append(sensitive(evaluation, sensitive_signal, training)(predictions))
yield dataset_results