def _get_accuracy(self, predictions: torch.FloatTensor,
y: torch.FloatTensor) -> torch.FloatTensor:
threshold = 0.5
flat_pred = predictions.contiguous().view(-1, 1)
flat_y = y.contiguous().view(-1, 1)
guess = (flat_pred > threshold).float()
is_eq = guess.eq(flat_y).float()
return is_eq.mean()
def forward(self, input: torch.FloatTensor,
target: torch.FloatTensor) -> float:
smooth = 1.
iflat = input.contiguous().view(-1)
tflat = target.contiguous().view(-1)
intersection = (iflat * tflat).sum()
A_sum = torch.sum(iflat * iflat)
B_sum = torch.sum(tflat * tflat)
return 1 - ((2. * intersection + smooth) / (A_sum + B_sum + smooth))
def _get_loss(
logits: torch.FloatTensor, targets: torch.LongTensor, target_mask: torch.FloatTensor
) -> torch.Tensor:
logits = logits.contiguous()
# shape: (batch_size, num_decoding_steps)
relevant_targets = targets.contiguous()
# shape: (batch_size, num_decoding_steps)
relevant_mask = target_mask.contiguous()
return util.sequence_cross_entropy_with_logits(logits, relevant_targets, relevant_mask)
def forward(self, input: torch.FloatTensor, target: torch.LongTensor):
"""
:param input: (N, C) where C = number of classes.
:param target: (N) where each value is 0 <= targets[i] <= C-1
:return: Scaler.
"""
if input.dim() > 2:
input = input.view(input.size(0), input.size(1),
-1) # N,C,H,W => N,C,H*W
input = input.transpose(1, 2) # N,C,H*W => N,H*W,C
input = input.contiguous().view(
-1, input.size(2)) # N,H*W,C => N*H*W,C
target = target.view(-1, 1)
logpt = F.log_softmax(input, dim=1)
logpt = logpt.gather(1, target)
logpt = logpt.view(-1)
pt = logpt.exp()
if self.alpha is not None:
if self.alpha.type() != input.data.type():
self.alpha = self.alpha.type_as(input.data)
at = self.alpha.gather(0, target.data.view(-1))
logpt = logpt * at
loss = -1 * (1 - pt)**self.gamma * logpt
if self.size_average:
return loss.mean()
else:
return loss.sum()
def forward(
self,
X: torch.FloatTensor,
edge_index: torch.LongTensor,
edge_weight: torch.FloatTensor,
) -> torch.FloatTensor:
"""
Making a forward pass through the whole architecture.
Arg types:
* **X** *(PyTorch FloatTensor)* - Node features.
* **edge_index** *(PyTorch LongTensor)* - Graph edge indices.
* **edge_weight** *(PyTorch LongTensor, optional)* - Edge weight vector.
Return types:
* **H** *(PyTorch FloatTensor)* - The hidden representation of size 2*nhid+in_channels+window-1 for each node.
"""
R = list()
S = X.view(-1, self.window, self.num_nodes, self.in_channels)
S = torch.transpose(S, 1, 2)
S = S.reshape(-1, self.window, self.in_channels)
O = [S[:, 0, :]]
for l in range(1, self.window):
O.append(S[:, l, self.in_channels - 1].unsqueeze(1))
S = torch.cat(O, dim=1)
X = self._graph_convolution_1(X, edge_index, edge_weight)
R.append(X)
X = self._graph_convolution_2(X, edge_index, edge_weight)
R.append(X)
X = torch.cat(R, dim=1)
X = X.view(-1, self.window, self.num_nodes, X.size(1))
X = torch.transpose(X, 0, 1)
X = X.contiguous().view(self.window, -1, X.size(3))
X, (H_1, _) = self._recurrent_1(X)
X, (H_2, _) = self._recurrent_2(X)
H = torch.cat([H_1[0, :, :], H_2[0, :, :], S], dim=1)
return H
def _get_edge_type_score(self, query: torch.FloatTensor,
key: torch.FloatTensor,
edge_head: torch.Tensor) -> torch.Tensor:
"""
Compute the edge type scores.
:param query: [batch_size, query_length, query_vector_dim]
:param key: [batch_size, key_length, key_vector_dim]
:param edge_head: [batch_size, query_length]
:return:
label_score: None or [batch_size, query_length, num_labels]
"""
batch_size = key.size(0)
batch_index = torch.arange(0, batch_size).view(batch_size,
1).type_as(edge_head)
# [batch_size, query_length, hidden_size]
selected_key = key[batch_index, edge_head].contiguous()
query = query.contiguous()
edge_type_score = self.edge_type_bilinear(query, selected_key)
return edge_type_score
def _get_cost(self, predictions: torch.FloatTensor,
y: torch.FloatTensor) -> torch.FloatTensor:
flat_pred = predictions.contiguous().view(-1, 1)
flat_y = y.contiguous().view(-1, 1)
cost = self.loss_fn(flat_pred, flat_y)
return cost
def expected_log_likelihood(
self,
logits: torch.Tensor,
mask: torch.ByteTensor,
unary_marginals: torch.FloatTensor,
pairwise_marginals: torch.Tensor = None) -> torch.Tensor:
"""
Computes the expected log likelihood of CRFs defined by batch of logits
with respect to a reference distribution over the random variables.
Parameters
----------
logits : torch.Tensor, required
The logits that define the CRF distribution, of shape
``(batch_size, seq_len, num_tags)``.
unary_marginals : torch.Tensor, required
Marginal probability that each sequence element is a particular tag,
according to the reference distribution. Shape is
``(batch_size, seq_len, num_tags)``.
pairwise_marginals : torch.Tensor, optional (default = ``None``)
Marginal probability that each pair of sequence elements is a
particular pair of tags, according to the reference distribution.
Shape is ``(batch_size, seq_len - 1, num_tags, num_tags)``, so
pairwise_marginals[:, 0, 0, 0] is the probability that the first
and second tags in each sequence are both 0,
pairwise_marginals[:, 1, 0, 0] is the probability that the second
and and third tags in each sequence are both 0, etc. If None,
pairwise_marginals will be computed from unary_marginals assuming
that they are independent in the reference distribution.
mask : ``torch.ByteTensor``
The text field mask for the input tokens of shape
``(batch_size, seq_len)``.
"""
batch_size, seq_len, num_tags = logits.size()
# We compute the partition function before rearranging the inputs
partition = self._input_likelihood(logits, mask)
# Transpose batch size and sequence dimensions
logits = logits.transpose(
0, 1).contiguous() # (seq_len, batch_size, num_tags)
mask = mask.float().transpose(0,
1).contiguous() # (seq_len, batch_size)
unary_marginals = unary_marginals.transpose(
0, 1) # (seq_len, batch_size, num_tags)
unary_marginals = unary_marginals.contiguous()
if pairwise_marginals is not None:
pairwise_marginals = pairwise_marginals.transpose(
0, 1) # (seq_len - 1, batch_size, num_tags, num_tags)
pairwise_marginals = pairwise_marginals.contiguous()
else:
pairwise_marginals = torch.zeros(
(seq_len - 1, batch_size, num_tags, num_tags),
device=logits.device.type)
for i in range(seq_len - 1):
for j in range(batch_size):
temp1 = unary_marginals[i, j]
temp2 = unary_marginals[i + 1, j]
temp = torch.ger(temp1, temp2)
pairwise_marginals[i, j, :, :] = temp
# Start with the transition scores from start_tag to the
# first tag in each input
if self.include_start_end_transitions:
temp = self.start_transitions.unsqueeze(0) # (1, num_tags)
temp = temp * unary_marginals[0] # (batch_size, num_tags)
score = temp.sum(dim=1) # (batch_size,)
else:
score = torch.zeros((batch_size, ),
device=logits.device.type) # (batch_size,)
# Add up the scores for the expected transitions and all
# the inputs but the last
for i in range(seq_len - 1):
# Adds contributions from logits
temp = logits[i] * unary_marginals[i] # (batch_size, num_tags)
temp = temp.sum(dim=1) # (batch_size,)
score += temp * mask[i]
# Adds contributions from transitions from i to i+1
temp = self.transitions.unsqueeze(0) # (1, num_tags, num_tags)
temp = temp * pairwise_marginals[
i] # (batch_size, num_tags, num_tags)
temp = temp.sum(dim=2).sum(dim=1) # (batch_size,)
score += temp * mask[i + 1]
# Transition from last state to "stop" state.
# Computes score of transitioning to `stop_tag` from
# each last token.
if self.include_start_end_transitions:
# To start, we need to find the last token for
# each instance.
index0 = mask.sum(dim=0).long() - 1 # (batch_size,)
index1 = torch.arange(0, batch_size,
dtype=torch.long) # (batch_size,)
last_marginals = unary_marginals[
index0, index1, :] # (batch_size, num_tags)
temp = self.end_transitions.unsqueeze(0) # (1, num_tags)
temp = temp * last_marginals # (batch_size, num_tags)
temp = temp.sum(dim=1) # (batch_size,)
score += temp
# Adds the last input if it's not masked.
last_scores = logits[-1] * unary_marginals[
-1] # (batch_size, num_tags)
last_scores = last_scores.sum(dim=1) # (batch_size,)
score += last_scores * mask[-1]
# Finally we subtract partition function and return sum
return torch.sum(score - partition)
def forward(self, input : torch.FloatTensor, hidden : torch.FloatTensor) \
-> Tuple[torch.FloatTensor, torch.FloatTensor]:
input = input.contiguous()
hidden = hidden.expand(self.num_layers, -1, -1).contiguous()
output, hidden = self.gru(input, hidden)
return self.softmax(input), hidden[0]
