def compute(self):
if self.sum_inst == 0:
raise NotComputableError(
'Accuracy must have at least one example before it can be computed'
)
return self.sum_metric / self.sum_inst
def compute(self):
if self._num_examples == 0:
raise NotComputableError('FalsePositiveRate must have at least one example before it can be computed.')
return self._false_positive_num/ self._num_examples
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
"GeometricMeanAbsoluteError must have at "
"least one example before it can be computed.")
return torch.exp(self._sum_of_errors / self._num_examples).item()
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
'Score must have at least one example before it can be computed.'
)
return self._sum / self._num_examples
def compute(self):
if self._num_examples == 0:
raise NotComputableError('WER must have at least one example before it can be computed')
return (self._total_edit_distance / self._num_examples) * 100
def compute(self) -> torch.Tensor:
if self._num_examples == 0:
raise NotComputableError(
"PSNR must have at least one example before it can be computed."
)
return self._sum_of_batchwise_psnr / self._num_examples
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
"TopKCategoricalAccuracy 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(
'MeanSquaredError must have at least one example before it can be computed.'
)
return self._sum_of_squared_errors / self._num_examples
def compute(self) -> float:
if self._num_examples == 0:
raise NotComputableError(
"Loss must have at least one example before it can be computed."
)
return self._sum.item() / self._num_examples
def compute(self):
if self._max_of_absolute_errors < 0:
raise NotComputableError(
"MaximumAbsoluteError must have at least one example before it can be computed."
)
return self._max_of_absolute_errors
def compute(self) -> Union[float, torch.Tensor]:
if self._num_examples == 0:
raise NotComputableError(
"TopKCategoricalAccuracy must have at least one example before it can be computed."
)
return self._num_correct.item() / self._num_examples
def compute(self) -> float:
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.item() / (self._y_sq_sum.item() - (self._y_sum.item() ** 2) / self._num_examples)
def compute(self) -> Union[float, torch.Tensor]:
if self._num_examples == 0:
raise NotComputableError(
"MeanSquaredError must have at least one example before it can be computed."
)
return self._sum_of_squared_errors.item() / self._num_examples
def compute(self) -> Union[float, torch.Tensor]:
if self._num_examples == 0:
raise NotComputableError(
'MeanAbsoluteError must have at least one example before it can be computed.'
)
return self._sum_of_distances / self._num_examples
def compute(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._num_samples == 0:
raise NotComputableError(
"MeanAbsoluteRelativeError must have at least"
"one sample before it can be computed.")
return self._sum_of_absolute_relative_errors / self._num_samples
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
'FractionalBias must have at least one example before it can be computed.'
)
return self._sum_of_errors / self._num_examples
def compute(self):
if self._num_ex == 0:
raise NotComputableError(
'Loss must have at least one example before it can be computed.')
return {k: v * 100 / self._num_ex for k, v in self._data.items()}
def compute(self):
if self._count < 2:
raise NotComputableError(
'Covariance must have at least two samples before it can be computed.'
)
return self._comoment / (self._count - 1)
def compute(self):
if self._num_examples == 0:
raise NotComputableError(
"MeanNormalizedBias must have at least one example before it can be computed."
)
return self._sum_of_errors / self._num_examples
def compute(self):
if self._count < 1:
raise NotComputableError(
'Mean must have at least one sample before it can be computed.'
)
return self._mean
def compute(self):
if self.pred_label is None or self.gold_label is None:
raise NotComputableError(
'Microf1 must have at least one example before it can be computed'
)
return f1_score(self.gold_label, self.pred_label, average='micro')
def compute(self):
if self._num_examples == 0:
raise NotComputableError('MeanAbsoluteError must have at least one example before it can be computed')
return self._sum_of_absolute_errors / self._num_examples
def compute(self) -> float:
if self._num_examples == 0:
raise NotComputableError(
"FractionalAbsoluteError must have at least one example before it can be computed."
)
return self._sum_of_errors.item() / self._num_examples
def compute(self) -> float:
if self._num_examples == 0:
raise NotComputableError(
"Accuracy must have at least one example before it can be computed."
)
return self._num_correct.item() / self._num_examples
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(
'AverageError must have at least one example before it can be computed.'
)
return torch.tensor(self.__average_errors).mean()
