(BalancingLearner) make new balancinglearner that looks at the total loss rather than loss improvement

[basnijholt]

(original issue on GitLab)

opened by Jorn Hoofwijk (@Jorn) at 2018-09-20T11:19:48.680Z

Suggestion is to implement a new balancing-learner that is a drop-in replacement for the old one, which doesn't requests points from the learners unless they are actually going to be used. So we would look at the total loss of each learner rather than the loss-improvement.

• This would probably be faster as we do not need to suggest a new point in order to sort the learners. The actual difference should be tested
• We do not require the learners to support ask(..., add_data=False)
  • This would very likely also solve gitlab:#87
  • This would also be nice for the ND-learner
• Probably in practice, the outcome would be the similar to the normal balancinglearner
• The logic should be simpler (as in less code to maintain) and we do not need to keep track of the suggested points
• We should analyse in what cases the current implementation behaves differently from the proposed implementation and if it is an improvement or worse.

Suggestion is to test it out, if it works nicely we will adopt

[basnijholt]

originally posted by Jorn Hoofwijk (@Jorn) at 2018-09-20T11:24:26.412Z on GitLab

also since as far as I am aware, the balancinglearner is the only reason why we ever ask for the loss_improvement. then in the far future, we could return only the list of point when you ask for data,

[basnijholt]

originally posted by Jorn Hoofwijk (@Jorn) at 2018-09-20T12:37:42.336Z on GitLab

actually, I hit a bit of a bummer in the learners, for example: in learner2D the loss() is defined as follows:

    def loss(self, real=True):
        if not self.bounds_are_done:
            return np.inf
        ip = self.ip() if real else self.ip_combined()
        losses = self.loss_per_triangle(ip)
        self._loss = losses.max()
        return self._loss

Since this is a O(N) operation this is actually pretty much as efficient as asking a new point, actually, since Learner2D uses a _stack to keep track of points we want to ask for, ask() would be sometimes faster than loss, both are O(N) in theory, but the usage of the stack in ask() makes it potentially faster.

However, the same does not apply to the LearnerND, although the current implementation of loss() is O(n) it can be easily modified to be O(1).

For the Learner1D we have: loss() is O(N) and ask() is O(N log N)