Metrics general supplementary checking before `compute`

As discussed here, the following assumption:

All metrics that has not been updated yet after last reset should raise NotComputableError when compute is called

holds for any metric. Today we check metric specific variable _num_examples if it’s equal zero and raise exception if it is the case. This behaviour can be replaced directly in Metric by counting the number of update calls between reset and before compute.
An example implementation is proposed by @zasdfgbnm :

class Metric:
    def  __init__(self, ...):
        ......

        def wrapped_reset():
            self._updated = False
            self.reset()
        self.reset = functools.wraps(self.reset)(wrapped_reset)

        def wrapped_update(output):
            self._updated = True
            self.update(output)
        self.update =  functools.wraps(self.update)(wrapped_update)

        def wrapped_compute():
            if not self._updated:
                raise NotComputableError('not updated before compute')
            return self.compute()
        self.compute =  functools.wraps(self.compute)(wrapped_compute)

Let’s discuss here what we can do.

cc @zasdfgbnm

[zasdfgbnm]

@vfdev-5 It is a little bit similar, but for this the operands are classes like Precision, and the result are also class. The idea is, if A and B are classes for metrics, then A + B is another class for a new metric. Should be something like

class MetricMeta(type):

    def __add__(cls1, cls2):
        if "signature of __init__ of cls1 and cls2 does not match":
            raise "can not add cls1 and cls2"

        class Result(Metric):

            def __init__(self, *args, **kwargs):
                self.obj1 = cls1(*args, **kwargs)
                self.obj2 = cls2(*args, **kwargs)

            def reset(self):
                self.obj1.reset()
                self.obj2.reset()

            def update(self, output):
                self.obj1.update(output)
                self.obj2.update(output)

            def compute(self):
                return self.obj1.compute() + self.obj2.compute()

        return Result

[zasdfgbnm]

@vfdev-5 I opened a new issue for the metaclass problem: https://github.com/pytorch/ignite/issues/337