def _get_probabilities_np(self, utility, lambda_k):
n_objects = self.n_objects_fit_
nests_indices = self.nests_indices
n_nests = self.n_nests
temp_lambdas = np.ones((n_objects, n_objects), lambda_k.dtype)
temp_lambdas[nests_indices[:, 0], nests_indices[:, 1]] = temp_lambdas.T[
nests_indices[:, 0], nests_indices[:, 1]
] = lambda_k
uti_per_nest = np.transpose((utility[:, None] / temp_lambdas), (0, 2, 1))
ind = np.array([[[i1, i2], [i2, i1]] for i1, i2 in nests_indices])
ind = ind.reshape(2 * n_nests, 2)
x = uti_per_nest[:, ind[:, 0], ind[:, 1]].reshape(-1, 2)
log_sum_exp_nest = npu.logsumexp(x).reshape(-1, n_nests)
pnk = np.exp(
log_sum_exp_nest * lambda_k - npu.logsumexp(log_sum_exp_nest * lambda_k)
)
p = np.zeros(tuple(utility.shape), dtype=float)
for i in range(n_nests):
i1, i2 = nests_indices[i]
p[:, i1] += (
np.exp(uti_per_nest[:, i1, i2] - log_sum_exp_nest[:, i]) * pnk[:, i]
)
p[:, i2] += (
np.exp(uti_per_nest[:, i2, i1] - log_sum_exp_nest[:, i]) * pnk[:, i]
)
return p
def _get_probabilities_np(self, utility, lambda_k, alpha_ik):
n_nests = self.n_nests
n_instances, n_objects = utility.shape
pik = np.zeros((n_instances, n_objects, n_nests))
sum_per_nest_x = np.zeros((n_instances, n_nests))
for i in range(n_nests):
uti = (utility + np.log(alpha_ik[:, :, i])) * 1 / lambda_k[i]
sum_n = npu.logsumexp(uti)
pik[:, :, i] = np.exp(uti - sum_n)
sum_per_nest_x[:, i] = sum_n[:, 0] * lambda_k[i]
pnk = np.exp(sum_per_nest_x - npu.logsumexp(sum_per_nest_x))
pnk = pnk[:, None, :]
p = pik * pnk
p = p.sum(axis=2)
return p
def _get_probabilities_np(self, Y_n, utility, lambda_k, utility_k):
n_instances, n_objects = Y_n.shape
pni_k = np.zeros((n_instances, n_objects))
ivm = np.zeros((n_instances, self.n_nests))
for i in range(self.n_nests):
sub_tensor = np.copy(utility)
sub_tensor[np.where(Y_n != i)] = -1e50
ink = npu.logsumexp(sub_tensor)
pni_k[np.where(Y_n == i)] = np.exp(sub_tensor -
ink)[np.where(Y_n == i)]
ivm[:, i] = lambda_k[i] * ink[:, 0] + utility_k[i]
pk = np.exp(ivm - npu.logsumexp(ivm))
pn_k = np.zeros((n_instances, n_objects))
for i in range(self.n_nests):
rows, cols = np.where(Y_n == i)
p = np.ones((n_instances, n_objects)) * pk[:, i][:, None]
pn_k[rows, cols] = p[rows, cols]
p = pni_k * pn_k
return p
