def setUpMoreDims(self): self._metric = Metric('test') self._metric.process = Mock() self._metric.process.side_effect = [torch.zeros(torch.Size([])), torch.FloatTensor([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3]]), torch.FloatTensor([[0.4, 0.5, 0.6], [1.4, 1.5, 1.6]]), torch.FloatTensor([[0.7, 0.8, 0.9], [1.7, 1.8, 1.9]]), torch.ones(torch.Size([]))] self._std = Std('test') self._std.reset({}) self._target = 0.57662804083742
def setUp(self): self._metric = Metric('test') self._metric.process = Mock() self._metric.process.side_effect = [torch.zeros(torch.Size([])), torch.FloatTensor([0.1, 0.2, 0.3]), torch.FloatTensor([0.4, 0.5, 0.6]), torch.FloatTensor([0.7, 0.8, 0.9]), torch.ones(torch.Size([]))] self._std = Std('test') self._std.reset({}) self._target = 0.31622776601684
def std(clazz): """The :func:`std` decorator is used to add a :class:`.Std` to the :class:`.MetricTree` which will will output a population standard deviation value at the end of each epoch. At build time, if the inner class is not a :class:`.MetricTree`, one will be created. The :class:`.Std` will also be wrapped in a :class:`.ToDict` (with '_std' appended) for simplicity. Example: :: >>> import torch >>> from torchbearer import metrics >>> @metrics.std ... @metrics.lambda_metric('my_metric') ... def metric(y_pred, y_true): ... return y_pred + y_true ... >>> metric.reset({}) >>> metric.process({'y_pred':torch.Tensor([2]), 'y_true':torch.Tensor([2])}) # 4 {} >>> metric.process({'y_pred':torch.Tensor([3]), 'y_true':torch.Tensor([3])}) # 6 {} >>> metric.process({'y_pred':torch.Tensor([4]), 'y_true':torch.Tensor([4])}) # 8 {} >>> '%.4f' % metric.process_final()['my_metric_std'] '1.6330' :param clazz: The class to *decorate* :return: A :class:`.MetricTree` with a :class:`.Std` appended or a wrapper class that extends :class:`.MetricTree` """ return _wrap_and_add_to_tree( clazz, lambda metric: ToDict(Std(metric.name + '_std')))
def build(self): if isinstance(self.inner, MetricFactory): inner = self.inner.build() else: inner = self.inner if not isinstance(inner, MetricTree): inner = MetricTree(inner) inner.add_child(ToDict(Std(inner.name + '_std'))) return inner
def test_std_dim(self): std = Std('test', dim=0) std.process(torch.Tensor([[1., 2.], [3., 4.]])) std.process(torch.Tensor([[4., 3.], [2., 1.]])) std.process(torch.Tensor([[1., 1.], [1., 1.]])) res = std.process_final() self.assertTrue(len(res) == 2) for m in res: self.assertTrue(abs(m - 1.2649) < 0.0001)
def std(clazz=None, unbiased=True, dim=None): """The :func:`std` decorator is used to add a :class:`.Std` to the :class:`.MetricTree` which will will output a sample standard deviation value at the end of each epoch. At build time, if the inner class is not a :class:`.MetricTree`, one will be created. The :class:`.Std` will also be wrapped in a :class:`.ToDict` (with '_std' appended) for simplicity. Example: :: >>> import torch >>> from torchbearer import metrics >>> @metrics.std ... @metrics.lambda_metric('my_metric') ... def metric(y_pred, y_true): ... return y_pred + y_true ... >>> metric.reset({}) >>> metric.process({'y_pred':torch.Tensor([2]), 'y_true':torch.Tensor([2])}) # 4 {} >>> metric.process({'y_pred':torch.Tensor([3]), 'y_true':torch.Tensor([3])}) # 6 {} >>> metric.process({'y_pred':torch.Tensor([4]), 'y_true':torch.Tensor([4])}) # 8 {} >>> '%.4f' % metric.process_final()['my_metric_std'] '2.0000' Args: clazz: The class to *decorate* unbiased (bool): See :class:`.Std` dim (int, tuple): See :class:`.Std` Returns: A :class:`.MetricTree` with a :class:`.Std` appended or a wrapper class that extends :class:`.MetricTree` """ if clazz is None: def decorator(clazz): return std(clazz, unbiased=unbiased, dim=dim) return decorator return _wrap_and_add_to_tree( clazz, lambda metric: ToDict( Std(metric.name + '_std', unbiased=unbiased, dim=dim)))
class TestStd(unittest.TestCase): def setUp(self): self._metric = Metric('test') self._metric.process = Mock() self._metric.process.side_effect = [torch.zeros(torch.Size([])), torch.FloatTensor([0.1, 0.2, 0.3]), torch.FloatTensor([0.4, 0.5, 0.6]), torch.FloatTensor([0.7, 0.8, 0.9]), torch.ones(torch.Size([]))] self._std = Std('test') self._std.reset({}) self._target = 0.31622776601684 def test_train(self): self._std.train() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result) def test_validate(self): self._std.eval() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result)
class TestStd(unittest.TestCase): def setUp(self): self._metric = Metric('test') self._metric.process = Mock() self._metric.process.side_effect = [ torch.zeros(torch.Size([])), torch.FloatTensor([0.1, 0.2, 0.3]), torch.FloatTensor([0.4, 0.5, 0.6]), torch.FloatTensor([0.7, 0.8, 0.9]), torch.ones(torch.Size([])) ] self._std = Std('test', unbiased=False) self._std.reset({}) self._target = 0.31622776601684 def test_train(self): self.setUp() self._std.train() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result, places=5) def test_validate(self): self.setUp() self._std.eval() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result, places=5) def test_precision_error(self): self.setUp() self._std.train() val = torch.tensor([0.55]) for i in range(2): self._std.process(val) result = self._std.process_final({}) self.assertEqual(0, result) def setUpMoreDims(self): self._metric = Metric('test') self._metric.process = Mock() self._metric.process.side_effect = [ torch.zeros(torch.Size([])), torch.FloatTensor([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3]]), torch.FloatTensor([[0.4, 0.5, 0.6], [1.4, 1.5, 1.6]]), torch.FloatTensor([[0.7, 0.8, 0.9], [1.7, 1.8, 1.9]]), torch.ones(torch.Size([])) ] self._std = Std('test', unbiased=False) self._std.reset({}) self._target = 0.57662804083742 def test_more_dims(self): self.setUpMoreDims() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result, places=5) def test_std_dim(self): std = Std('test', dim=0) std.process(torch.Tensor([[1., 2.], [3., 4.]])) std.process(torch.Tensor([[4., 3.], [2., 1.]])) std.process(torch.Tensor([[1., 1.], [1., 1.]])) res = std.process_final() self.assertTrue(len(res) == 2) for m in res: self.assertTrue(abs(m - 1.2649) < 0.0001)
class TestStd(unittest.TestCase): def setUp(self): self._metric = Metric('test') self._metric.process = Mock() self._metric.process.side_effect = [torch.zeros(torch.Size([])), torch.FloatTensor([0.1, 0.2, 0.3]), torch.FloatTensor([0.4, 0.5, 0.6]), torch.FloatTensor([0.7, 0.8, 0.9]), torch.ones(torch.Size([]))] self._std = Std('test') self._std.reset({}) self._target = 0.31622776601684 def test_train(self): self.setUp() self._std.train() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result) def test_validate(self): self.setUp() self._std.eval() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result) def test_precision_error(self): self.setUp() self._std.train() val = torch.tensor([0.55]) for i in range(2): self._std.process(val) result = self._std.process_final({}) self.assertEqual(0, result) def setUpMoreDims(self): self._metric = Metric('test') self._metric.process = Mock() self._metric.process.side_effect = [torch.zeros(torch.Size([])), torch.FloatTensor([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3]]), torch.FloatTensor([[0.4, 0.5, 0.6], [1.4, 1.5, 1.6]]), torch.FloatTensor([[0.7, 0.8, 0.9], [1.7, 1.8, 1.9]]), torch.ones(torch.Size([]))] self._std = Std('test') self._std.reset({}) self._target = 0.57662804083742 def test_more_dims(self): self.setUpMoreDims() for i in range(5): self._std.process(self._metric.process()) result = self._std.process_final({}) self.assertAlmostEqual(self._target, result)