def get_probabilities(self, utility, lambda_k):
"""
This method calculates the probability of choosing an object from the query set using the following parameters of the model which are used:
* **weights** (:math:`w`): Weights to get the utility of the object :math:`Y_i = U(x_i) = w \\cdot x_i`
* **lambda_k** (:math:`\\lambda_k`): Lambda is the measure of independence amongst the obejcts in the nest :math:`B_k`
The probability of choosing the object :math:`x_i` from the query set :math:`Q`:
.. math::
P_i = \\sum_{j \\in I \\setminus i} P_{{i} \\lvert {ij}} P_{ij} \\enspace where, \\\\
P_{i \\lvert ij} = \\frac{\\boldsymbol{e}^{^{Y_i} /_{\\lambda_{ij}}}}{\\boldsymbol{e}^{^{Y_i} /_{\\lambda_{ij}}} + \\boldsymbol{e}^{^{Y_j} /_{\\lambda_{ij}}}} \\enspace ,\\\\
P_{ij} = \\frac{{\\left( \\boldsymbol{e}^{^{V_i}/{\\lambda_{ij}}} + \\boldsymbol{e}^{^{V_j}/{\\lambda_{ij}}} \\right)}^{\\lambda_{ij}}}{\\sum_{k=1}^{n-1} \\sum_{\\ell = k + 1}^{n} {\\left( \\boldsymbol{e}^{^{V_k}/{\\lambda_{k\\ell}}} + \\boldsymbol{e}^{^{V_{\\ell}}/{\\lambda_{k\\ell}}} \\right)}^{\\lambda_{k\\ell}}}
Parameters
----------
utility : theano tensor
(n_instances, n_objects)
Utility :math:`Y_i` of the objects :math:`x_i \\in Q` in the query sets
lambda_k : theano tensor (range : [alpha, 1.0])
(n_nests)
Measure of independence amongst the obejcts in each nests
Returns
-------
p : theano tensor
(n_instances, n_objects)
Choice probabilities :math:`P_i` of the objects :math:`x_i \\in Q` in the query sets
"""
n_objects = self.n_objects
nests_indices = self.nests_indices
n_nests = self.n_nests
lambdas = tt.ones((n_objects, n_objects), dtype=np.float)
for i, p in enumerate(nests_indices):
r = [p[0], p[1]]
c = [p[1], p[0]]
lambdas = tt.set_subtensor(lambdas[r, c], lambda_k[i])
uti_per_nest = tt.transpose(utility[:, None, :] / 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 = ttu.logsumexp(x).reshape((-1, n_nests))
pnk = tt.exp(log_sum_exp_nest * lambda_k -
ttu.logsumexp(log_sum_exp_nest * lambda_k))
p = tt.zeros(tuple(utility.shape), dtype=float)
for i in range(n_nests):
i1, i2 = nests_indices[i]
x1 = tt.exp(uti_per_nest[:, i1, i2] -
log_sum_exp_nest[:, i]) * pnk[:, i]
x2 = np.exp(uti_per_nest[:, i2, i1] -
log_sum_exp_nest[:, i]) * pnk[:, i]
p = tt.set_subtensor(p[:, i1], p[:, i1] + x1)
p = tt.set_subtensor(p[:, i2], p[:, i2] + x2)
return p
def get_probabilities(self, utility, lambda_k, utility_k):
"""
This method calculates the probability of choosing an object from the query set using the following parameters of the model which are used:
* **weights** (:math:`w`): Weights to get the utility of the object :math:`Y_i = U(x_i) = w \\cdot x_i`
* **weights_k** (:math:`w_k`): Weights to get the utility of the next :math:`W_k = U_k(x) = w_k \\cdot c_k`, where :math:`c_k` is the center of the object space of nest :math:`B_k`
* **lambda_k** (:math:`\\lambda_k`): Lambda is the measure of independence amongst the obejcts in the nest :math:`B_k`
The probability of choosing the object :math:`x_i` from the query set :math:`Q`:
.. math::
P_i = \\frac{\\boldsymbol{e}^{ ^{Y_i} /_{\\lambda_k}}}{\\sum_{j \\in B_k} \\boldsymbol{e}^{^{Y_j} /_{\\lambda_k}}} \\frac {\\boldsymbol{e}^{W_k + \\lambda_k I_k}} {\\sum_{\\ell = 1}^{K} \\boldsymbol{e}^{ W_{\\ell } + \\lambda_{\\ell} I_{\\ell}}} \\quad i \\in B_k \\enspace , \\\\
where,\\enspace I_k = \\ln \\sum_{ j \\in B_k} \\boldsymbol{e}^{^{Y_j} /_{\\lambda_k}}
Parameters
----------
utility : theano tensor
(n_instances, n_objects)
Utility :math:`Y_i` of the objects :math:`x_i \\in Q` in the query sets
lambda_k : theano tensor (range : [alpha, 1.0])
(n_nests)
Measure of independence amongst the obejcts in each nests
utility_k : theano tensor
(n_instances, n_nests)
Utilities of the nests :math:`B_k \\in \\mathcal{B}`
Returns
-------
p : theano tensor
(n_instances, n_objects)
Choice probabilities :math:`P_i` of the objects :math:`x_i \\in Q` in the query sets
"""
n_instances, n_objects = self.y_nests_.shape
pni_k = tt.zeros((n_instances, n_objects))
ivm = tt.zeros((n_instances, self.n_nests))
for i in range(self.n_nests):
rows, cols = tt.neq(self.y_nests_, i).nonzero()
sub_tensor = tt.set_subtensor(utility[rows, cols], -1e50)
ink = ttu.logsumexp(sub_tensor)
rows, cols = tt.eq(self.y_nests_, i).nonzero()
pni_k = tt.set_subtensor(pni_k[rows, cols],
tt.exp(sub_tensor - ink)[rows, cols])
ivm = tt.set_subtensor(ivm[:, i],
lambda_k[i] * ink[:, 0] + utility_k[i])
pk = tt.exp(ivm - ttu.logsumexp(ivm))
pn_k = tt.zeros((n_instances, n_objects))
for i in range(self.n_nests):
rows, cols = tt.eq(self.y_nests_, i).nonzero()
p = tt.ones((n_instances, n_objects)) * pk[:, i][:, None]
pn_k = tt.set_subtensor(pn_k[rows, cols], p[rows, cols])
p = pni_k * pn_k
return p
def get_probabilities(self, utility, lambda_k, alpha_ik):
"""
This method calculates the probability of choosing an object from the query set using the following parameters of the model which are used:
* **weights** (:math:`w`): Weights to get the utility of the object :math:`Y_i = U(x_i) = w \\cdot x_i`
* **weights_k** (:math:`w_k`): Weights to get fractional allocation of each object :math:'x_j' in :math:'Q' to each nest math:`B_k` as :math:`\\alpha_{ik} = w_k \\cdot x_i`.
* **lambda_k** (:math:`\\lambda_k`): Lambda for nest :math:`B_k` for correlations between the obejcts.
The probability of choosing the object :math:`x_i` from the query set :math:`Q`:
.. math::
P_i = \\sum_{\\substack{B_k \\in \\mathcal{B} \\ i \\in B_k}} P_{i \\lvert {B_k}} P_{B_k} \\enspace where, \\\\
P_{B_k} = \\frac{{\\left(\\sum_{j \\in B_k} {\\left(\\alpha_{jk} \\boldsymbol{e}^{V_j} \\right)}^ {^{1}/{\\lambda_k}} \\right)}^{\\lambda_k}}{\\sum_{\\ell = 1}^{K} {\\left( \\sum_{j \\in B_{\\ell}} {\\left( \\alpha_{j\\ell} \\boldsymbol{e}^{V_j} \\right)}^{^{1}/{\\lambda_\\ell}} \\right)^{\\lambda_{\\ell}}}} \\\\
P_{{i} \\lvert {B_k}} = \\frac{{\\left(\\alpha_{ik} \\boldsymbol{e}^{V_i} \\right)}^{^{1}/{\\lambda_k}}}{\\sum_{j \\in B_k} {\\left(\\alpha_{jk} \\boldsymbol{e}^{V_j} \\right)}^{^{1}/{\\lambda_k}}} \\enspace ,
Parameters
----------
utility : theano tensor
(n_instances, n_objects)
Utility :math:`Y_i` of the objects :math:`x_i \\in Q` in the query sets
lambda_k : theano tensor (range : [alpha, 1.0])
(n_nests)
Measure of independence amongst the obejcts in each nests
alpha_ik : theano tensor
(n_instances, n_objects, n_nests)
Fractional allocation of each object :math:`x_i` in each nest math:`B_k`
Returns
-------
p : theano tensor
(n_instances, n_objects)
Choice probabilities :math:`P_i` of the objects :math:`x_i \\in Q` in the query sets
"""
n_nests = self.n_nests
n_instances, n_objects = utility.shape
pik = tt.zeros((n_instances, n_objects, n_nests))
sum_per_nest = tt.zeros((n_instances, n_nests))
for i in range(n_nests):
uti = (utility + tt.log(alpha_ik[:, :, i])) * 1 / lambda_k[i]
sum_n = ttu.logsumexp(uti)
pik = tt.set_subtensor(pik[:, :, i], tt.exp(uti - sum_n))
sum_per_nest = tt.set_subtensor(
sum_per_nest[:, i], sum_n[:, 0] * lambda_k[i]
)
pnk = tt.exp(sum_per_nest - ttu.logsumexp(sum_per_nest))
pnk = pnk[:, None, :]
p = pik * pnk
p = p.sum(axis=2)
return p
def get_probabilities(self, utility, lambda_k, alpha_ik):
n_nests = self.n_nests
n_instances, n_objects = utility.shape
pik = tt.zeros((n_instances, n_objects, n_nests))
sum_per_nest = tt.zeros((n_instances, n_nests))
for i in range(n_nests):
uti = (utility + tt.log(alpha_ik[:, :, i])) * 1 / lambda_k[i]
sum_n = ttu.logsumexp(uti)
pik = tt.set_subtensor(pik[:, :, i], tt.exp(uti - sum_n))
sum_per_nest = tt.set_subtensor(sum_per_nest[:, i],
sum_n[:, 0] * lambda_k[i])
pnk = tt.exp(sum_per_nest - ttu.logsumexp(sum_per_nest))
pnk = pnk[:, None, :]
p = pik * pnk
p = p.sum(axis=2)
return p
def get_probability(self, utility, lambda_k, utility_k):
n_instances, n_objects = self.y_nests.shape
pni_k = tt.zeros((n_instances, n_objects))
ivm = tt.zeros((n_instances, self.n_nests))
for i in range(self.n_nests):
rows, cols = tt.neq(self.y_nests, i).nonzero()
sub_tensor = tt.set_subtensor(utility[rows, cols], -1e50)
ink = ttu.logsumexp(sub_tensor)
rows, cols = tt.eq(self.y_nests, i).nonzero()
pni_k = tt.set_subtensor(pni_k[rows, cols],
tt.exp(sub_tensor - ink)[rows, cols])
ivm = tt.set_subtensor(ivm[:, i],
lambda_k[i] * ink[:, 0] + utility_k[i])
pk = tt.exp(ivm - ttu.logsumexp(ivm))
pn_k = tt.zeros((n_instances, n_objects))
for i in range(self.n_nests):
rows, cols = tt.eq(self.y_nests, i).nonzero()
p = tt.ones((n_instances, n_objects)) * pk[:, i][:, None]
pn_k = tt.set_subtensor(pn_k[rows, cols], p[rows, cols])
p = pni_k * pn_k
return p
def get_probabilities(self, utility, lambda_k):
n_objects = self.n_objects
nests_indices = self.nests_indices
n_nests = self.n_nests
lambdas = tt.ones((n_objects, n_objects), dtype=np.float)
for i, p in enumerate(nests_indices):
r = [p[0], p[1]]
c = [p[1], p[0]]
lambdas = tt.set_subtensor(lambdas[r, c], lambda_k[i])
uti_per_nest = tt.transpose(utility[:, None, :] / 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 = ttu.logsumexp(x).reshape((-1, n_nests))
pnk = tt.exp(log_sum_exp_nest * lambda_k - ttu.logsumexp(log_sum_exp_nest * lambda_k))
p = tt.zeros(tuple(utility.shape), dtype=float)
for i in range(n_nests):
i1, i2 = nests_indices[i]
x1 = tt.exp(uti_per_nest[:, i1, i2] - log_sum_exp_nest[:, i]) * pnk[:, i]
x2 = np.exp(uti_per_nest[:, i2, i1] - log_sum_exp_nest[:, i]) * pnk[:, i]
p = tt.set_subtensor(p[:, i1], p[:, i1] + x1)
p = tt.set_subtensor(p[:, i2], p[:, i2] + x2)
return p
