def simplify(self): # type: (ResultSet) -> None # Remove single points from the yup and ylow closures, i.e., rectangles rect with: # rect.min_corner == rect.max_corner # These kind of rectangles appear when the dicothomic search cannot find an intersection of the diagonal # with the Pareto front self.ylow = [li for li in self.ylow if li.norm() != 0.0] self.yup = [li for li in self.yup if li.norm() != 0.0] # Single points may appear in the boundary, so we don't remove them # self.border = [li for li in self.border if li.norm() != 0] # Get the highest (upper right) values of self.ylow; i.e., those points that are closer to self.yup extended_ylow = [Rectangle(self.xspace.min_corner, r.max_corner) for r in self.ylow] # extended_yup = [Rectangle(r.min_corner, self.xspace.max_corner) for r in self.yup] # Get the lowest (lower left) values of self.yup; i.e., those points that are closer to self.ylow # extended_ylow = [Rectangle(self.xspace.min_corner, ylow_point) for ylow_point in self.get_points_pareto_ylow()] extended_yup = [Rectangle(yup_point, self.xspace.max_corner) for yup_point in self.get_points_pareto_yup()] self.border = Rectangle.difference_rectangles(self.xspace, extended_ylow + extended_yup) self.yup = Rectangle.difference_rectangles(self.xspace, extended_ylow + self.border) self.ylow = Rectangle.difference_rectangles(self.xspace, extended_yup + self.border)
def multidim_search_opt_3(xspace, oracle, epsilon=EPS, delta=DELTA, max_step=STEPS, blocking=False, sleep=0.0, logging=True): # type: (Rectangle, Oracle, float, float, float, bool, float, bool) -> ResultSet # xspace is a particular case of maximal rectangle # xspace = [min_corner, max_corner]^n = [0, 1]^n # xspace.min_corner = (0,) * n # xspace.max_corner = (1,) * n # Dimension n = xspace.dim() # Set of comparable and incomparable rectangles, represented by 'alpha' indices comparable = comp(n) incomparable = incomp(n) # comparable = [zero, one] # incomparable = list(set(alpha) - set(comparable)) # with: # zero = (0_1,...,0_n) # one = (1_1,...,1_n) # List of incomparable rectangles # border = [xspace] # border = SortedListWithKey(key=Rectangle.volume) border = SortedSet([], key=Rectangle.volume) border.add(xspace) lattice_border_ylow = Lattice(dim=xspace.dim(), key=lambda x: x.min_corner) lattice_border_yup = Lattice(dim=xspace.dim(), key=lambda x: x.max_corner) lattice_border_ylow.add(xspace) lattice_border_yup.add(xspace) ylow = [] yup = [] # x_minimal = points from 'x' that are strictly incomparable (Pareto optimal) ylow_minimal = [] yup_minimal = [] # oracle function f = oracle.membership() error = (epsilon,) * n vol_total = xspace.volume() vol_yup = 0 vol_ylow = 0 vol_border = vol_total step = 0 RootSearch.logger.debug('xspace: {0}'.format(xspace)) RootSearch.logger.debug('vol_border: {0}'.format(vol_border)) RootSearch.logger.debug('delta: {0}'.format(delta)) RootSearch.logger.debug('step: {0}'.format(step)) RootSearch.logger.debug('incomparable: {0}'.format(incomparable)) RootSearch.logger.debug('comparable: {0}'.format(comparable)) # Create temporary directory for storing the result of each step tempdir = tempfile.mkdtemp() RootSearch.logger.info( 'Report\nStep, Ylow, Yup, Border, Total, nYlow, nYup, nBorder, BinSearch, nBorder dominated by Ylow, nBorder dominated by Yup') while (vol_border >= delta) and (step <= max_step) and (len(border) > 0): step = step + 1 # if RootSearch.logger.isEnabledFor(RootSearch.logger.DEBUG): # RootSearch.logger.debug('border: {0}'.format(border)) # l.sort(key=Rectangle.volume) xrectangle = border.pop() lattice_border_ylow.remove(xrectangle) lattice_border_yup.remove(xrectangle) RootSearch.logger.debug('xrectangle: {0}'.format(xrectangle)) RootSearch.logger.debug('xrectangle.volume: {0}'.format(xrectangle.volume())) RootSearch.logger.debug('xrectangle.norm: {0}'.format(xrectangle.norm())) # y, segment # y = search(xrectangle.diag(), f, epsilon) y, steps_binsearch = binary_search(xrectangle.diag(), f, error) RootSearch.logger.debug('y: {0}'.format(y)) # discovered_segments.append(y) # b0 = Rectangle(xrectangle.min_corner, y.low) # b1 = Rectangle(y.high, xrectangle.max_corner) # # ylow.append(b0) # yup.append(b1) # # vol_ylow += b0.volume() # vol_yup += b1.volume() ################################ # Every Border rectangle that dominates B0 is included in Ylow b0_extended = Rectangle(xspace.min_corner, y.low) # border_overlapping_b0 = [rect for rect in border if rect.overlaps(b0_extended)] # border_overlapping_b0 = [rect for rect in border_overlapping_b0 if rect.overlaps(b0_extended)] ylow_rectangle = Rectangle(y.low, y.low) border_overlapping_b0 = lattice_border_ylow.less_equal(ylow_rectangle) # border_intersecting_b0 = [b0_extended.intersection(rect) for rect in border_overlapping_b0] ## border_nondominatedby_b0 = [rect - b0_extended for rect in border_overlapping_b0] # border_nondominatedby_b0 = [] # for rect in border_overlapping_b0: # border_nondominatedby_b0 += list(rect - b0_extended) list_idwc = (idwc(b0_extended, rect) for rect in border_overlapping_b0) border_nondominatedby_b0 = set(itertools.chain.from_iterable(list_idwc)) # border_nondominatedby_b0 = Rectangle.fusion_rectangles(border_nondominatedby_b0) # if 'rect' is completely dominated by b0_extended (i.e., rect is strictly inside b0_extended), then # set(rect - b0_extended) == {rect} # Therefore, 'rect' must be removed from 'non dominated' borders border |= border_nondominatedby_b0 border -= border_overlapping_b0 lattice_border_ylow.add_list(border_nondominatedby_b0) lattice_border_ylow.remove_list(border_overlapping_b0) lattice_border_yup.add_list(border_nondominatedby_b0) lattice_border_yup.remove_list(border_overlapping_b0) # Every Border rectangle that is dominated by B1 is included in Yup b1_extended = Rectangle(y.high, xspace.max_corner) # border_overlapping_b1 = [rect for rect in border if rect.overlaps(b1_extended)] # border_overlapping_b1 = [rect for rect in border_overlapping_b1 if rect.overlaps(b1_extended)] yup_rectangle = Rectangle(y.high, y.high) border_overlapping_b1 = lattice_border_yup.greater_equal(yup_rectangle) # border_intersecting_b1 = [b1_extended.intersection(rect) for rect in border_overlapping_b1] ## border_nondominatedby_b1 = [rect - b1_extended for rect in border_overlapping_b1] # border_nondominatedby_b1 = [] # for rect in border_overlapping_b1: # border_nondominatedby_b1 += list(rect - b1_extended) list_iuwc = (iuwc(b1_extended, rect) for rect in border_overlapping_b1) border_nondominatedby_b1 = set(itertools.chain.from_iterable(list_iuwc)) # border_nondominatedby_b1 = Rectangle.fusion_rectangles(border_nondominatedby_b1) # if 'rect' is completely dominated by b1_extended (i.e., rect is strictly inside b1_extended), then # set(rect - b1_extended) == {rect} # Therefore, 'rect' must be removed from 'non dominated' borders border |= border_nondominatedby_b1 border -= border_overlapping_b1 lattice_border_ylow.add_list(border_nondominatedby_b1) lattice_border_ylow.remove_list(border_overlapping_b1) lattice_border_yup.add_list(border_nondominatedby_b1) lattice_border_yup.remove_list(border_overlapping_b1) db0 = Rectangle.difference_rectangles(b0_extended, ylow_minimal) db1 = Rectangle.difference_rectangles(b1_extended, yup_minimal) vol_db0 = sum(b0.volume() for b0 in db0) vol_db1 = sum(b1.volume() for b1 in db1) # rs = ResultSet([], border_intersecting_b0 + [b0], border_intersecting_b1 + [b1], Rectangle()) # vol_db0 = rs.volume_ylow() - rs.overlapping_volume_ylow() # vol_db1 = rs.volume_yup() - rs.overlapping_volume_yup() vol_ylow += vol_db0 vol_yup += vol_db1 ylow.extend(db0) yup.extend(db1) ylow_minimal.append(b0_extended) yup_minimal.append(b1_extended) RootSearch.logger.debug('b0: {0}'.format(db0)) RootSearch.logger.debug('b1: {0}'.format(db1)) RootSearch.logger.debug('ylow: {0}'.format(ylow)) RootSearch.logger.debug('yup: {0}'.format(yup)) ################################ # Every rectangle in 'i' is incomparable for current B0 and for all B0 included in Ylow # Every rectangle in 'i' is incomparable for current B1 and for all B1 included in Yup ################################ yrectangle = Rectangle(y.low, y.high) i = irect(incomparable, yrectangle, xrectangle) # i = pirect(incomparable, yrectangle, xrectangle) # l.extend(i) border |= i RootSearch.logger.debug('irect: {0}'.format(i)) lattice_border_ylow.add_list(i) lattice_border_yup.add_list(i) # Remove boxes in the boundary with volume 0 boxes_null_vol = border[:border.bisect_key_left(0.0)] border -= boxes_null_vol lattice_border_ylow.remove_list(boxes_null_vol) lattice_border_yup.remove_list(boxes_null_vol) vol_border = vol_total - vol_yup - vol_ylow RootSearch.logger.info('{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}' .format(step, vol_ylow, vol_yup, vol_border, vol_total, len(ylow), len(yup), len(border), steps_binsearch, len(border_overlapping_b0), len(border_overlapping_b1))) if sleep > 0.0: rs = ResultSet(border, ylow, yup, xspace) if n == 2: rs.plot_2D_light(blocking=blocking, sec=sleep, opacity=0.7) elif n == 3: rs.plot_3D_light(blocking=blocking, sec=sleep, opacity=0.7) if logging: rs = ResultSet(border, ylow, yup, xspace) name = os.path.join(tempdir, str(step)) rs.to_file(name) return ResultSet(border, ylow, yup, xspace)
def multidim_search_opt_1(xspace, oracle, epsilon=EPS, delta=DELTA, max_step=STEPS, blocking=False, sleep=0.0, logging=True): # type: (Rectangle, Oracle, float, float, float, bool, float, bool) -> ResultSet # Xspace is a particular case of maximal rectangle # Xspace = [min_corner, max_corner]^n = [0, 1]^n # xspace.min_corner = (0,) * n # xspace.max_corner = (1,) * n # Dimension n = xspace.dim() # Set of comparable and incomparable rectangles, represented by 'alpha' indices comparable = comp(n) incomparable = incomp(n) # comparable = [zero, one] # incomparable = list(set(alpha) - set(comparable)) # with: # zero = (0_1,...,0_n) # one = (1_1,...,1_n) # List of incomparable rectangles # border = [xspace] # border = SortedListWithKey(key=Rectangle.volume) border = SortedSet([], key=Rectangle.volume) border.add(xspace) ylow = [] yup = [] # oracle function f = oracle.membership() error = (epsilon,) * n vol_total = xspace.volume() vol_yup = 0 vol_ylow = 0 vol_border = vol_total step = 0 RootSearch.logger.debug('xspace: {0}'.format(xspace)) RootSearch.logger.debug('vol_border: {0}'.format(vol_border)) RootSearch.logger.debug('delta: {0}'.format(delta)) RootSearch.logger.debug('step: {0}'.format(step)) RootSearch.logger.debug('incomparable: {0}'.format(incomparable)) RootSearch.logger.debug('comparable: {0}'.format(comparable)) # Create temporary directory for storing the result of each step tempdir = tempfile.mkdtemp() RootSearch.logger.info( 'Report\nStep, Ylow, Yup, Border, Total, nYlow, nYup, nBorder, BinSearch, nBorder dominated by Ylow, nBorder dominated by Yup') while (vol_border >= delta) and (step <= max_step) and (len(border) > 0): step = step + 1 # if RootSearch.logger.isEnabledFor(RootSearch.logger.DEBUG): # RootSearch.logger.debug('border: {0}'.format(border)) # l.sort(key=Rectangle.volume) xrectangle = border.pop() RootSearch.logger.debug('xrectangle: {0}'.format(xrectangle)) RootSearch.logger.debug('xrectangle.volume: {0}'.format(xrectangle.volume())) RootSearch.logger.debug('xrectangle.norm: {0}'.format(xrectangle.norm())) # y, segment # y = search(xrectangle.diag(), f, epsilon) y, steps_binsearch = binary_search(xrectangle.diag(), f, error) RootSearch.logger.debug('y: {0}'.format(y)) # discovered_segments.append(y) b0 = Rectangle(xrectangle.min_corner, y.low) b1 = Rectangle(y.high, xrectangle.max_corner) ylow.append(b0) yup.append(b1) vol_ylow += b0.volume() vol_yup += b1.volume() RootSearch.logger.debug('b0: {0}'.format(b0)) RootSearch.logger.debug('b1: {0}'.format(b1)) RootSearch.logger.debug('ylow: {0}'.format(ylow)) RootSearch.logger.debug('yup: {0}'.format(yup)) ################################ # Every Border rectangle that dominates B0 is included in Ylow # Every Border rectangle that is dominated by B1 is included in Yup b0_extended = Rectangle(xspace.min_corner, y.low) b1_extended = Rectangle(y.high, xspace.max_corner) # Every cube in the boundary overlaps another cube in the boundary # When cubes from the boundary are moved to ylow or yup, they may still have a complementary cube # remaining in the boundary with a non-empty intersection. border_overlapping_ylow = [r for r in ylow if r.overlaps(b0_extended)] border_overlapping_yup = [r for r in yup if r.overlaps(b1_extended)] border_overlapping_b0 = [rect for rect in border if rect.overlaps(b0_extended)] # Warning: Be aware of the overlapping areas of the cubes in the border. # If we calculate the intersection of b0_extended with all the cubes in the frontier, and two cubes # 'a' and 'b' partially overlaps, then the volume of this overlapping portion will be counted twice # border_dominatedby_b0 = [rect.intersection(b0_extended) for rect in border_overlapping_b0] # Solution: Project the 'shadow' of the cubes in the border over b0_extended. border_dominatedby_b0_shadow = Rectangle.difference_rectangles(b0_extended, border_overlapping_b0) # The negative of this image returns a set of cubes in the boundary without overlapping. # border_dominatedby_b0 will be appended to ylow. # Remove the portion of the negative that overlaps any cube that is already appended to ylow border_dominatedby_b0 = Rectangle.difference_rectangles(b0_extended, border_dominatedby_b0_shadow + border_overlapping_ylow) # border_nondominatedby_b0 = [rect - b0_extended for rect in border_overlapping_b0] border_nondominatedby_b0 = [] for rect in border_overlapping_b0: border_nondominatedby_b0 += list(rect - b0_extended) # border_nondominatedby_b0 = set() # for rect in border_overlapping_b0: # border_nondominatedby_b0 |= set(rect - b0_extended) # border_nondominatedby_b0 -= set(border_overlapping_b0) # if 'rect' is completely dominated by b0_extended (i.e., rect is strictly inside b0_extended), then # set(rect - b0_extended) == {rect} # Therefore, 'rect' must be removed from 'non dominated' borders # border -= border_overlapping_b0 border |= border_nondominatedby_b0 border -= border_overlapping_b0 border_overlapping_b1 = [rect for rect in border if rect.overlaps(b1_extended)] # Warning: Be aware of the overlapping areas of the cubes in the border. # If we calculate the intersection of b1_extended with all the cubes in the frontier, and two cubes # 'a' and 'b' partially overlaps, then the volume of this overlapping portion will be considered twice # border_dominatedby_b1 = [rect.intersection(b1_extended) for rect in border_overlapping_b1] # Solution: Project the 'shadow' of the cubes in the border over b1_extended. border_dominatedby_b1_shadow = Rectangle.difference_rectangles(b1_extended, border_overlapping_b1) # The negative of this image returns a set of cubes in the boundary without overlapping. # border_dominatedby_b1 will be appended to yup. # Remove the portion of the negative that overlaps any cube that is already appended to yup border_dominatedby_b1 = Rectangle.difference_rectangles(b1_extended, border_dominatedby_b1_shadow + border_overlapping_yup) # border_nondominatedby_b1 = [rect - b1_extended for rect in border_overlapping_b1] border_nondominatedby_b1 = [] for rect in border_overlapping_b1: border_nondominatedby_b1 += list(rect - b1_extended) # border_nondominatedby_b1 = set() # for rect in border_overlapping_b1: # border_nondominatedby_b1 |= set(rect - b1_extended) # border_nondominatedby_b1 -= set(border_overlapping_b1) # if 'rect' is completely dominated by b1_extended (i.e., rect is strictly inside b1_extended), then # set(rect - b1_extended) == {rect} # Therefore, 'rect' must be removed from 'non dominated' borders # border -= border_overlapping_b1 border |= border_nondominatedby_b1 border -= border_overlapping_b1 ylow.extend(border_dominatedby_b0) yup.extend(border_dominatedby_b1) vol_ylow += sum(b0.volume() for b0 in border_dominatedby_b0) vol_yup += sum(b1.volume() for b1 in border_dominatedby_b1) ################################ # Every rectangle in 'i' is incomparable for current B0 and for all B0 included in Ylow # Every rectangle in 'i' is incomparable for current B1 and for all B1 included in Yup ################################ yrectangle = Rectangle(y.low, y.high) i = irect(incomparable, yrectangle, xrectangle) # i = pirect(incomparable, yrectangle, xrectangle) # l.extend(i) border |= i RootSearch.logger.debug('irect: {0}'.format(i)) # Remove boxes in the boundary with volume 0 border -= border[:border.bisect_key_left(0.0)] vol_border = vol_total - vol_yup - vol_ylow RootSearch.logger.info('{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}' .format(step, vol_ylow, vol_yup, vol_border, vol_total, len(ylow), len(yup), len(border), steps_binsearch, len(border_overlapping_b0), len(border_overlapping_b1))) if sleep > 0.0: rs = ResultSet(border, ylow, yup, xspace) if n == 2: rs.plot_2D_light(blocking=blocking, sec=sleep, opacity=0.7) elif n == 3: rs.plot_3D_light(blocking=blocking, sec=sleep, opacity=0.7) if logging: rs = ResultSet(border, ylow, yup, xspace) name = os.path.join(tempdir, str(step)) rs.to_file(name) return ResultSet(border, ylow, yup, xspace)