Datasets:
File size: 6,694 Bytes
84a242a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | # additive loss implementation from pytorchltr repo
# https://github.com/rjagerman/pytorchltr/blob/master/pytorchltr/loss/pairwise_additive.py
import torch as _torch
# Dependecy
def batch_pairs(x: _torch.Tensor) -> _torch.Tensor:
"""Returns a pair matrix
This matrix contains all pairs (i, j) as follows:
p[_, i, j, 0] = x[_, i]
p[_, i, j, 1] = x[_, j]
Args:
x: The input batch of dimension (batch_size, list_size) or
(batch_size, list_size, 1).
Returns:
Two tensors of size (batch_size, list_size ^ 2, 2) containing
all pairs.
"""
if x.dim() == 2:
x = x.reshape((x.shape[0], x.shape[1], 1))
# Construct broadcasted x_{:,i,0...list_size}
x_ij = _torch.repeat_interleave(x, x.shape[1], dim=2)
# Construct broadcasted x_{:,0...list_size,i}
x_ji = _torch.repeat_interleave(x.permute(0, 2, 1), x.shape[1], dim=1)
return _torch.stack([x_ij, x_ji], dim=3)
class _PairwiseAdditiveLoss(_torch.nn.Module):
"""Pairwise additive ranking losses.
Implementation of linearly decomposible additive pairwise ranking losses.
This includes RankSVM hinge loss and variations.
"""
def __init__(self):
r""""""
super().__init__()
def _loss_per_doc_pair(self, score_pairs: _torch.FloatTensor,
rel_pairs: _torch.LongTensor) -> _torch.FloatTensor:
"""Computes a loss on given score pairs and relevance pairs.
Args:
score_pairs: A tensor of shape (batch_size, list_size,
list_size, 2), where each entry (:, i, j, :) indicates a pair
of scores for doc i and j.
rel_pairs: A tensor of shape (batch_size, list_size, list_size, 2),
where each entry (:, i, j, :) indicates the relevance
for doc i and j.
Returns:
A tensor of shape (batch_size, list_size, list_size) with a loss
per document pair.
"""
raise NotImplementedError
def _loss_reduction(self,
loss_pairs: _torch.FloatTensor) -> _torch.FloatTensor:
"""Reduces the paired loss to a per sample loss.
Args:
loss_pairs: A tensor of shape (batch_size, list_size, list_size)
where each entry indicates the loss of doc pair i and j.
Returns:
A tensor of shape (batch_size) indicating the loss per training
sample.
"""
return loss_pairs.view(loss_pairs.shape[0], -1).sum(1)
def _loss_modifier(self, loss: _torch.FloatTensor) -> _torch.FloatTensor:
"""A modifier to apply to the loss."""
return loss
def forward(self, scores: _torch.FloatTensor, relevance: _torch.LongTensor,
n: _torch.LongTensor) -> _torch.FloatTensor:
"""Computes the loss for given batch of samples.
Args:
scores: A batch of per-query-document scores.
relevance: A batch of per-query-document relevance labels.
n: A batch of per-query number of documents (for padding purposes).
"""
# Reshape relevance if necessary.
if relevance.ndimension() == 2:
relevance = relevance.reshape(
(relevance.shape[0], relevance.shape[1], 1))
if scores.ndimension() == 2:
scores = scores.reshape((scores.shape[0], scores.shape[1], 1))
# Compute pairwise differences for scores and relevances.
score_pairs = batch_pairs(scores)
rel_pairs = batch_pairs(relevance)
# Compute loss per doc pair.
loss_pairs = self._loss_per_doc_pair(score_pairs, rel_pairs)
# Mask out padded documents per query in the batch
n_grid = n[:, None, None].repeat(1, score_pairs.shape[1],
score_pairs.shape[2])
arange = _torch.arange(score_pairs.shape[1],
device=score_pairs.device)
range_grid = _torch.max(*_torch.meshgrid([arange, arange]))
range_grid = range_grid[None, :, :].repeat(n.shape[0], 1, 1)
loss_pairs[n_grid <= range_grid] = 0.0
# Reduce final list loss from per doc pair loss to a per query loss.
loss = self._loss_reduction(loss_pairs)
# Apply a loss modifier.
loss = self._loss_modifier(loss)
# Return loss
return loss
class PairwiseHingeLoss(_PairwiseAdditiveLoss):
r"""Pairwise hinge loss formulation of SVMRank:
.. math::
l(\mathbf{s}, \mathbf{y}) = \sum_{y_i > y _j} max\left(
0, 1 - (s_i - s_j)
\right)
Shape:
- input scores: :math:`(N, \texttt{list_size})`
- input relevance: :math:`(N, \texttt{list_size})`
- input n: :math:`(N)`
- output: :math:`(N)`
"""
def _loss_per_doc_pair(self, score_pairs, rel_pairs):
score_pair_diffs = score_pairs[:, :, :, 0] - score_pairs[:, :, :, 1]
rel_pair_diffs = rel_pairs[:, :, :, 0] - rel_pairs[:, :, :, 1]
loss = 1.0 - score_pair_diffs
loss[rel_pair_diffs <= 0.0] = 0.0
loss[loss < 0.0] = 0.0
return loss
class PairwiseDCGHingeLoss(PairwiseHingeLoss):
r"""Pairwise DCG-modified hinge loss:
.. math::
l(\mathbf{s}, \mathbf{y}) =
\frac{-1}{\log\left(
2 + \sum_{y_i > y_j}
max\left(0, 1 - (s_i - s_j)\right)
\right)}
Shape:
- input scores: :math:`(N, \texttt{list_size})`
- input relevance: :math:`(N, \texttt{list_size})`
- input n: :math:`(N)`
- output: :math:`(N)`
"""
def _loss_modifier(self, loss):
return -1.0 / _torch.log(2.0 + loss)
class PairwiseLogisticLoss(_PairwiseAdditiveLoss):
r"""Pairwise logistic loss formulation of RankNet:
.. math::
l(\mathbf{s}, \mathbf{y}) = \sum_{y_i > y_j} \log_2\left(1 + e^{
-\sigma \left(s_i - s_j\right)
}\right)
Shape:
- input scores: :math:`(N, \texttt{list_size})`
- input relevance: :math:`(N, \texttt{list_size})`
- input n: :math:`(N)`
- output: :math:`(N)`
"""
def __init__(self, sigma: float = 1.0):
"""
Args:
sigma: Steepness of the logistic curve.
"""
super().__init__()
self.sigma = sigma
def _loss_per_doc_pair(self, score_pairs, rel_pairs):
score_pair_diffs = score_pairs[:, :, :, 0] - score_pairs[:, :, :, 1]
rel_pair_diffs = rel_pairs[:, :, :, 0] - rel_pairs[:, :, :, 1]
loss = _torch.log2(1.0 + _torch.exp(-self.sigma * score_pair_diffs))
loss[rel_pair_diffs <= 0.0] = 0.0
return loss |