def rank(self, graph=None, personalization=None, *args, **kwargs):
personalization = to_signal(graph, personalization)
norm = backend.sum(backend.abs(personalization.np))
ranks = self.ranker(graph, personalization, *args, **kwargs)
if norm != 0:
ranks.np = ranks.np * norm / backend.sum(backend.abs(ranks.np))
return ranks
def rank(self,
graph: GraphSignalGraph = None,
personalization: GraphSignalData = None,
warm_start: GraphSignalData = None,
graph_dropout: float = 0,
*args,
**kwargs) -> GraphSignal:
personalization = to_signal(graph, personalization)
self._prepare(personalization)
personalization = self.personalization_transform(personalization)
personalization_norm = backend.sum(backend.abs(personalization.np))
if personalization_norm == 0:
return personalization
personalization = to_signal(personalization,
personalization.np / personalization_norm)
ranks = to_signal(
personalization,
backend.copy(personalization.np)
if warm_start is None else warm_start)
M = self.preprocessor(personalization.graph)
self.convergence.start()
self._start(backend.graph_dropout(M, graph_dropout), personalization,
ranks, *args, **kwargs)
while not self.convergence.has_converged(ranks.np):
self._step(backend.graph_dropout(M, graph_dropout),
personalization, ranks, *args, **kwargs)
self._end(backend.graph_dropout(M, graph_dropout), personalization,
ranks, *args, **kwargs)
ranks.np = ranks.np * personalization_norm
return ranks
def __culep(self, personalization: BackendPrimitive,
sensitive: BackendPrimitive, ranks: BackendPrimitive,
params: List[float]):
ranks = ranks.np / backend.max(ranks.np)
#personalization = personalization / backend.max(personalization)
res = ranks if self.parameter_buckets == 0 else 0
for i in range(self.parameter_buckets):
a = sensitive * (params[0 + 4 * i] -
params[1 + 4 * i]) + params[1 + 4 * i]
b = sensitive * (params[2 + 4 * i] -
params[3 + 4 * i]) + params[3 + 4 * i]
if self.error_skewing:
res = res + (1 - a) * backend.exp(
b * (ranks - personalization)) + a * backend.exp(
-b * (ranks - personalization))
else:
res = res + (1 - a) * backend.exp(
b * backend.abs(ranks - personalization)
) + a * backend.exp(-b * backend.abs(ranks - personalization))
return (1.0 - params[-1]) * res + personalization * params[-1]
def _run(self,
personalization: GraphSignal,
params: object,
base=None,
*args,
**kwargs):
params = backend.to_primitive(params)
div = backend.sum(backend.abs(params))
if div != 0:
params = params / div
if self.basis != "krylov":
if base is None:
M = self.ranker_generator(params).preprocessor(
personalization.graph)
base = arnoldi_iteration(M, personalization.np, len(params))[0]
ret = 0
for i in range(backend.length(params)):
ret = ret + params[i] * base[:, i]
return to_signal(personalization, ret)
return self.ranker_generator(params).rank(personalization, *args,
**kwargs)
def evaluate(self, scores: GraphSignalData) -> BackendPrimitive:
known_scores, scores = self.to_numpy(scores)
return 1 - backend.sum(
backend.abs(known_scores - scores)) / backend.length(scores)
def evaluate(self, scores: GraphSignalData) -> BackendPrimitive:
known_scores, scores = self.to_numpy(scores)
return backend.max(backend.abs(known_scores - scores))
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