def compute(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
if len(self._predictions) < 1 or len(self._targets) < 1:
raise NotComputableError("PrecisionRecallCurve must have at least one example before it can be computed.")
_prediction_tensor = torch.cat(self._predictions, dim=0)
_target_tensor = torch.cat(self._targets, dim=0)
ws = idist.get_world_size()
if ws > 1 and not self._is_reduced:
# All gather across all processes
_prediction_tensor = cast(torch.Tensor, idist.all_gather(_prediction_tensor))
_target_tensor = cast(torch.Tensor, idist.all_gather(_target_tensor))
self._is_reduced = True
if idist.get_rank() == 0:
# Run compute_fn on zero rank only
precision, recall, thresholds = self.compute_fn(_prediction_tensor, _target_tensor)
precision = torch.tensor(precision)
recall = torch.tensor(recall)
# thresholds can have negative strides, not compatible with torch tensors
# https://discuss.pytorch.org/t/negative-strides-in-tensor-error/134287/2
thresholds = torch.tensor(thresholds.copy())
else:
precision, recall, thresholds = None, None, None
if ws > 1:
# broadcast result to all processes
precision = idist.broadcast(precision, src=0, safe_mode=True)
recall = idist.broadcast(recall, src=0, safe_mode=True)
thresholds = idist.broadcast(thresholds, src=0, safe_mode=True)
return precision, recall, thresholds
def compute(self) -> torch.Tensor:
if self._num_examples == 0:
raise NotComputableError(
"SSIM must have at least one example before it can be computed."
)
return torch.sum(self._sum_of_batchwise_ssim /
self._num_examples) # type: ignore[arg-type]
def compute(self):
if self._num_distributions.eq(0):
raise NotComputableError(
'Accuracy must have at least one example before it can be computed'
)
ppl = self._perplexities_sum / self._num_distributions
return ppl
def compute(self):
if (self._num_examples['combined_loss'] == 0):
raise NotComputableError(
'Loss must have at least one example before it can be computed.'
+ str(self._num_examples))
combined_loss = self._sum['combined_loss'] / self._num_examples[
'combined_loss']
relevance_loss = self._sum['relevance_loss'] / self._num_examples[
'relevance_loss']
results = {
'combined_loss': combined_loss,
'relevance_loss': relevance_loss
}
if "diversity_loss" in self._sum:
diversity_loss = self._sum['diversity_loss'] / self._num_examples[
'diversity_loss']
results["diversity_loss"] = diversity_loss
if "context_loss" in self._sum:
context_loss = self._sum['context_loss'] / self._num_examples[
'context_loss']
results["context_loss"] = context_loss
return results
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
'MeanSquaredError must have at least one example before it can be computed.'
)
return torch.mean(
torch.div(self._sum_of_squared_errors, self._num_examples))
def compute(self) -> float:
if len(self._probs) < 1:
raise NotComputableError(
"Inception score must have at least one example before it can be computed."
)
ws = idist.get_world_size()
_probs_tensor = torch.cat(self._probs, dim=0)
if ws > 1 and not self._is_reduced:
_probs_tensor = cast(torch.Tensor, idist.all_gather(_probs_tensor))
self._is_reduced = True
result = 0.0
if idist.get_rank() == 0:
N = _probs_tensor.shape[0]
scores = torch.zeros((self.n_splits, ))
for i in range(self.n_splits):
part = _probs_tensor[i * (N // self.n_splits):(i + 1) *
(N // self.n_splits)]
kl = part * (torch.log(part) -
torch.log(torch.mean(part, dim=0)))
kl = torch.mean(torch.sum(kl, dim=1))
scores[i] = torch.exp(kl)
result = torch.mean(scores).item()
if ws > 1:
result = cast(float, idist.broadcast(result, src=0))
return result
def compute(self):
""" """
if self._num_examples == 0:
raise NotComputableError(
"Accuracy must have at least one example before it can be computed."
)
return self._num_correct / self._num_examples
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
"CustomAccuracy must have at least one example before it can be computed."
)
return (self._sum_percentages / self._num_examples) * 100
def compute_impl(self):
if not self._preds:
raise NotComputableError("NRMSE must have at least one example before it can be computed.")
pred = torch.stack(self._preds).numpy()
tgt = torch.stack(self._tgts).numpy()
return nrmse_skimage(pred, tgt, norm_type=self.norm_type)
def compute(self) -> Union[Any, torch.Tensor, numbers.Number]:
if self.num_examples < 1:
raise NotComputableError(
"{} must have at least one example before" " it can be computed.".format(self.__class__.__name__)
)
return self.accumulator / self.num_examples
def compute(self) -> torch.Tensor:
if self.num_examples < 1:
raise NotComputableError(
"{} must have at least one example before" " it can be computed.".format(self.__class__.__name__)
)
return torch.exp(self.accumulator / self.num_examples)
def _compute_macro(self) -> torch.Tensor:
if self._num_sentences == 0:
raise NotComputableError(
"Bleu must have at least one example before it can be computed."
)
return self._sum_of_bleu / self._num_sentences
def compute(self):
if self.false_negatives + self.true_positives == 0:
raise NotComputableError(
'Accuracy must have at least one example before it can be computed.'
)
return float(self.true_positives) / float(self.false_negatives +
self.true_positives)
def compute(self):
""" """
if self._num_examples == 0:
raise NotComputableError(
"Loss must have at least one example before it can be computed."
)
return self._sum_generator_loss / self._num_examples, self._sum_discriminator_loss / self._num_examples
def compute(self) -> Union[torch.Tensor, float]:
is_scalar = not isinstance(self._positives,
torch.Tensor) or self._positives.ndim == 0
if is_scalar and self._positives == 0:
raise NotComputableError(
f"{self.__class__.__name__} must have at least one example before it can be computed."
)
if not self._is_reduced:
if not (self._type == "multilabel" and not self._average):
self._true_positives = idist.all_reduce(
self._true_positives) # type: ignore[assignment]
self._positives = idist.all_reduce(
self._positives) # type: ignore[assignment]
else:
self._true_positives = cast(
torch.Tensor, idist.all_gather(self._true_positives))
self._positives = cast(torch.Tensor,
idist.all_gather(self._positives))
self._is_reduced = True # type: bool
result = self._true_positives / (self._positives + self.eps)
if self._average:
return cast(torch.Tensor, result).mean().item()
else:
return result
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
"R2Score must have at least one example before it can be computed."
)
return 1 - self._sum_of_errors / (
self._y_sq_sum - (self._y_sum**2) / self._num_examples)
def compute_impl(self):
if self._num_examples == 0:
raise NotComputableError(
"PSNR must have at least one example before it can be computed."
)
return self._sum / self._num_examples
def _update(self, output):
y_pred, y = output
if (y == 0).any():
raise NotComputableError("The ground truth has 0.")
absolute_error = torch.abs(y_pred - y.view_as(y_pred)) / torch.abs(y.view_as(y_pred))
self._sum_of_absolute_relative_errors += torch.sum(absolute_error).item()
self._num_samples += y.size()[0]
def compute(self):
if self.all_embeddings is None:
raise NotComputableError(
'EmbeddingInfo must have at least one example before it can be computed.'
)
return self.all_embeddings.cpu(), self.all_image_data.cpu(
), self.all_targets
def compute(self) -> float:
if len(self._predictions) < 1 or len(self._targets) < 1:
raise NotComputableError(
"EpochMetric must have at least one example before it can be computed."
)
_prediction_tensor = torch.cat(self._predictions, dim=0)
_target_tensor = torch.cat(self._targets, dim=0)
ws = idist.get_world_size()
if ws > 1 and not self._is_reduced:
# All gather across all processes
_prediction_tensor = cast(torch.Tensor,
idist.all_gather(_prediction_tensor))
_target_tensor = cast(torch.Tensor,
idist.all_gather(_target_tensor))
self._is_reduced = True
result = 0.0
if idist.get_rank() == 0:
# Run compute_fn on zero rank only
result = self.compute_fn(_prediction_tensor, _target_tensor)
if ws > 1:
# broadcast result to all processes
result = cast(float, idist.broadcast(result, src=0))
return result
def compute(self) -> Union[float, torch.Tensor]:
if self.num_examples < 1:
raise NotComputableError(
f"{self.__class__.__name__} must have at least one example before it can be computed."
)
return self.accumulator / self.num_examples
def compute(self):
""" """
if self._num_examples_positive == 0 or self._num_examples_negative == 0:
raise NotComputableError("AverageDistances needs at least one example per target to be computed.")
return (
self._sum_positive_distances / self._num_examples_positive,
self._sum_negative_distances / self._num_examples_negative,
)
def compute(self, prefix=None) -> dict:
if self._num_examples == 0:
raise NotComputableError("TopKCategoricalAccuracy must have at"
"least one example before it can be computed.")
if prefix is None:
return {f"top_k@{k}": self._num_correct[k] / self._num_examples for k in self.k_s}
else:
return {f"{prefix}top_k@{k}": self._num_correct[k] / self._num_examples for k in self.k_s}
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
'Accuracy must have at least one example before it can be computed.'
)
return self._l1_loss_age / self._num_examples,\
self._num_correct[0] / self._num_examples,\
self._num_correct[1] / self._num_examples
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
'RootMeanSquaredError must have at least one example before it can be computed.'
)
mse = self._sum_of_squared_errors / self._num_examples
return torch.sqrt(mse).cpu().numpy()
def compute(self) -> float:
if self._num_examples == 0:
raise NotComputableError(
"GeometricMeanAbsoluteError must have at least one example before it can be computed."
)
return torch.exp(
cast(torch.Tensor, self._sum_of_errors) /
self._num_examples).item()
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
'Confusion matrix must have at least one example before it can be computed.'
)
if self.average_samples:
return self.confusion_matrix / self._num_examples
return self.confusion_matrix.cpu()
def compute(self):
for k in self.kv_sum_metric.keys():
if self.kv_sum_inst[k] == 0:
raise NotComputableError('Accuracy must have at least one example before it can be computed')
metric_value = self.kv_sum_metric[k] / self.kv_sum_inst[k]
self.kv_metric[k] = metric_value.item()
return self.kv_metric
def _update(self, output):
y_pred, y = output
if (y == 0).any():
raise NotComputableError("The ground truth has 0.")
errors = (y.view_as(y_pred) - y_pred) / y
self._sum_of_errors += torch.sum(errors).item()
self._num_examples += y.shape[0]
def compute(self):
if self._actual is None:
raise NotComputableError('Recall must have at least one example before it can be computed')
result = self._true_positives / self._actual
result[result != result] = 0.0
if self._average:
return result.mean().item()
else:
return result
