normalize the loss improvements by the std or interval_loss of the neighbors

Author: basnijholt

adaptive/learner/average1D.py

@@ -37,6 +37,17 @@ def _get_neighbor_mapping_existing_points(self):
         return {k: [x for x in v if x is not None]
             for k, v in self.neighbors.items()}
 
+    def loss_per_point(self):
+        loss_per_point = {}
+        for p in self.data.keys():
+            losses = []
+            for neighbor in self.neighbors[p]:
+                if neighbor is not None:
+                    ival = tuple(sorted((p, neighbor)))
+                    losses.append(self.losses[ival])
+            loss_per_point[p] = sum(losses) / len(losses)
+        return loss_per_point
+
     def unpack_point(self, x_seed):
         return x_seed
 

adaptive/learner/average2D.py

@@ -103,6 +103,17 @@ def inside_bounds(self, xy_seed):
         xy, seed = self.unpack_point(xy_seed)
         return super().inside_bounds(xy)
 
+    def loss_per_point(self):
+        ip = self.ip()
+        losses = self.loss_per_triangle(ip)
+        loss_per_point = defaultdict(list)
+        points = list(self.data.keys())
+        for simplex, loss in zip(ip.tri.vertices, losses):
+            for i in simplex:
+                loss_per_point[points[i]].append(loss)
+        loss_per_point = {p: sum(losses) / len(losses) for p, losses in loss_per_point.items()}
+        return loss_per_point
+
     def _ensure_point(self, point):
         """Adding a point with seed = 0.
         This used in '_fill_stack' in the Learner2D."""

adaptive/learner/average_mixin.py

@@ -27,7 +27,7 @@ def data(self):
 
     @property
     def data_sem(self):
-        return {k: v.standard_error if v.n >= self.min_values_per_point else inf
+        return {k: v.standard_error if v.n >= self.min_seeds_per_point else inf
             for k, v in self._data.items()}
 
     def mean_seeds_per_point(self):
@@ -93,6 +93,7 @@ def ask(self, n, tell_pending=True):
             if not remaining:
                 break
 
+        # change from dict to list
         points = [(point, seed) for point, seeds in points.items()
                   for seed in seeds]
         loss_improvements = [loss_improvements[point] for point in points]
@@ -119,14 +120,31 @@ def _fill_seed_stack(self, till):
         if n <= 0:
             return
 
-        new_points, new_points_losses = self._interval_losses(n)
-        existing_points, existing_points_losses = self._point_losses()
+        new_points, new_interval_losses, interval_neighbors = self._interval_losses(n)
+        existing_points, existing_points_sem_losses, point_neighbors = self._point_losses()
+        assert not interval_neighbors.keys() & point_neighbors.keys()
+
+        neighbors = {**interval_neighbors, **point_neighbors}
+
+        def normalize(points, losses, other_losses):
+            for i, ((point, _), loss_improvement) in enumerate(zip(points, losses)):
+                loss_other = sum(other_losses[p] for p in neighbors[point]) / len(neighbors[point])
+                normalized_loss = loss_improvement + sqrt(loss_improvement * loss_other)
+                losses[i] = min(normalized_loss, inf)
+
+        if neighbors:
+            sem_losses = self.data_sem
+            interval_losses = self.loss_per_point()
+            normalize(new_points, new_interval_losses, sem_losses)
+            normalize(existing_points, existing_points_sem_losses, interval_losses)
 
         points = new_points + existing_points
-        loss_improvements = new_points_losses + existing_points_losses
+        loss_improvements = new_interval_losses + existing_points_sem_losses
 
-        loss_improvements, points = zip(*sorted(
-            zip(loss_improvements, points), reverse=True))  # ANTON: sort by (loss_improvement / nseeds)
+        priority = [(-loss / nseeds, loss, (point, nseeds))
+            for loss, (point, nseeds) in zip(loss_improvements, points)]
+
+        _, loss_improvements, points = zip(*sorted(priority))
 
         # Add points to the _seed_stack, it can happen that its
         # length exceeds the number of requested points.
@@ -149,12 +167,12 @@ def _mean_seeds_per_neighbor(self, neighbors):
             for p, ns in neighbors.items()}
 
     def _interval_losses(self, n):
-        """Add new points with at least self.min_values_per_point points
+        """Add new points with at least self.min_seeds_per_point points
         or with as many points as the neighbors have on average."""
         points, loss_improvements = self._ask_points_without_adding(n)
         if len(self._data) < 4:  # ANTON: fix (4) to bounds
-            points = [(p, self.min_values_per_point) for p, s in points]
-            return points, loss_improvements
+            points = [(p, self.min_seeds_per_point) for p, s in points]
+            return points, loss_improvements, {}
 
         only_points = [p for p, s in points]  # points are [(x, seed), ...]
         neighbors = self._get_neighbor_mapping_new_points(only_points)
@@ -163,15 +181,15 @@ def _interval_losses(self, n):
         points = []
         for p in only_points:
             n_neighbors = int(mean_seeds_per_neighbor[p])
-            nseeds = max(n_neighbors, self.min_values_per_point)
+            nseeds = max(n_neighbors, self.min_seeds_per_point)
             points.append((p, nseeds))
 
-        return points, loss_improvements
+        return points, loss_improvements, neighbors
 
     def _point_losses(self, fraction=1):
         """Double the number of seeds."""
         if len(self.data) < 4:
-            return [], []
+            return [], [], {}
         scale = self.value_scale()
         points = []
         loss_improvements = []
@@ -181,8 +199,7 @@ def _point_losses(self, fraction=1):
 
         for p, sem in self.data_sem.items():
             N = self.n_values(p)
-            n_more = int(fraction * N)  # double the amount of points
-            n_more = max(n_more, 1)  # at least 1 point
+            n_more = self.n_values(p)  # double the amount of points
             points.append((p, n_more))
             needs_more_data = mean_seeds_per_neighbor[p] > 1.5 * N
             if needs_more_data:
@@ -195,7 +212,7 @@ def _point_losses(self, fraction=1):
                 # and multiply them by a weight average_priority.
                 loss_improvement = self.average_priority * sem_improvement / scale
             loss_improvements.append(loss_improvement)
-        return points, loss_improvements
+        return points, loss_improvements, neighbors
 
     def _get_data(self):
         # change DataPoint -> dict for saving