Exemplo n.º 1
0
def scores2(individual, stars, configurations):
    """
    Used to score points
    :param individual: jmoo_individual
    :param stars: Star formation for STORM
    :param configurations: Configuration from jmoo_properties
    :return: list of N(determined by STORM_SPLIT)  best poles (numbers), individual
    """
    individual.anyscore = -1e30
    nearest_contours = []
    for count, star in enumerate(stars):
        try:
            a = euclidean_distance(individual.decisionValues,
                                   star.east.decisionValues)
            b = euclidean_distance(individual.decisionValues,
                                   star.west.decisionValues)
            c = euclidean_distance(star.east.decisionValues,
                                   star.west.decisionValues)
            x = (a**2 + c**2 - b**2) / (2 * c)
            y = (a**2 - x**2)**0.5
            # Difference in objective values
            diff = euclidean_distance(star.east.fitness.fitness,
                                      star.west.fitness.fitness)
            temp_score = ((b / a) * diff / (y**2) * (1 / c))
        except (ZeroDivisionError, ValueError), e:
            # Assumption for ZeroDivisionError: The cases where the code would be when a=0 (individual is east)
            # | y=0 (on the line) | c=0 east and west are the same point. If these things happen then we assign
            # a really high score to this individual.
            # Assumption for ValueError: The above formula works under the assumption that a, b < c, but it might not be
            # the case. For such cases we assign a high score.
            temp_score = 1e32
        nearest_contours.append([count, temp_score])
Exemplo n.º 2
0
def scores2(individual, stars, configurations):
    """
    Used to score points
    :param individual: jmoo_individual
    :param stars: Star formation for STORM
    :param configurations: Configuration from jmoo_properties
    :return: list of N(determined by STORM_SPLIT)  best poles (numbers), individual
    """
    individual.anyscore = -1e30
    nearest_contours = []
    for count, star in enumerate(stars):
        try:
            a = euclidean_distance(individual.decisionValues, star.east.decisionValues)
            b = euclidean_distance(individual.decisionValues, star.west.decisionValues)
            c = euclidean_distance(star.east.decisionValues, star.west.decisionValues)
            x = (a ** 2 + c ** 2 - b ** 2) / (2 * c)
            y = (a ** 2 - x ** 2) ** 0.5
            # Difference in objective values
            diff = euclidean_distance(star.east.fitness.fitness, star.west.fitness.fitness)
            temp_score = (b / a) * diff / (y ** 2) * (1 / c)
        except (ZeroDivisionError, ValueError), e:
            # Assumption for ZeroDivisionError: The cases where the code would be when a=0 (individual is east)
            # | y=0 (on the line) | c=0 east and west are the same point. If these things happen then we assign
            # a really high score to this individual.
            # Assumption for ValueError: The above formula works under the assumption that a, b < c, but it might not be
            # the case. For such cases we assign a high score.
            temp_score = 1e32
        nearest_contours.append([count, temp_score])
Exemplo n.º 3
0
    def get_extreme_points(self, number_of_generations):
        """This method should be used to find the extreme points of particular generation across all the algorithms"""
        from Techniques.flatten_list import flatten
        points = []
        points.extend(flatten([d.get_frontiers_collection(number_of_generations) for d in self.data]))
        print len(points)
        objectives = [point.objectives for point in points]
        maps_objectives = [[-1 for _ in objectives] for _ in objectives]
        from Techniques.euclidean_distance import euclidean_distance
        for i, ii in enumerate(objectives):
            for j, jj in enumerate(objectives):
                if maps_objectives[i][j] == -1:
                    maps_objectives[i][j] = euclidean_distance(ii, jj)
                    maps_objectives[j][i] = euclidean_distance(ii, jj)
                elif i == j:
                    maps_objectives[i][j] = 0

        print maps_objectives
        max_distance = max([max(maps_objective) for maps_objective in maps_objectives])
        indexes = [[(i, j) for j, distance in enumerate(distances) if distance == max_distance] for i, distances in
                   enumerate(maps_objectives)]
        index = [index for index in indexes if len(index) > 0][-1][-1]  # Hack: To handle list of lists
        # indexes should always be a multiple of 2. And if there more than 2 entries in indexes just use any one.

        return objectives[index[0]], objectives[index[1]]
Exemplo n.º 4
0
def scores(individual, stars):
    cols = len(stars[0].east.fitness.fitness)
    temp = -1e32
    selected = -1
    individual.anyscore = -1e30
    for count, star in enumerate(stars):
        try:
            a = euclidean_distance(individual.decisionValues,
                                   star.east.decisionValues)
            b = euclidean_distance(individual.decisionValues,
                                   star.west.decisionValues)
            c = euclidean_distance(star.east.decisionValues,
                                   star.west.decisionValues)
            x = (a**2 + c**2 - b**2) / (2 * c)
            y = (a**2 - x**2)**0.5
            r = len(stars) - 1  # Number of poles - midpoint

            diff = euclidean_distance(star.east.fitness.fitness,
                                      star.west.fitness.fitness)
            temp_score = ((b / a) * diff / (y**2 * c))
        except:
            temp_score = 1e32

        if temp < temp_score:
            temp = temp_score
            selected = count

    assert (selected > -1), "Something's wrong"
    individual.anyscore = temp
    return selected, individual
Exemplo n.º 5
0
def scores(individual, stars):
    cols = len(stars[0].east.fitness.fitness)
    temp = -1e32
    selected = -1
    individual.anyscore = -1e30
    for count, star in enumerate(stars):
        try:
            a = euclidean_distance(individual.decisionValues, star.east.decisionValues)
            b = euclidean_distance(individual.decisionValues, star.west.decisionValues)
            c = euclidean_distance(star.east.decisionValues, star.west.decisionValues)
            x = (a ** 2 + c ** 2 - b ** 2) / (2 * c)
            y = (a ** 2 - x ** 2) ** 0.5
            r = len(stars) - 1  # Number of poles - midpoint

            diff = euclidean_distance(star.east.fitness.fitness, star.west.fitness.fitness)
            temp_score = (b / a) * diff / (y ** 2 * c)
        except:
            temp_score = 1e32

        if temp < temp_score:
            temp = temp_score
            selected = count

    assert selected > -1, "Something's wrong"
    individual.anyscore = temp
    return selected, individual
Exemplo n.º 6
0
    def get_extreme_points(self, number_of_generations):
        """This method should be used to find the extreme points of particular generation across all the algorithms"""
        from Techniques.flatten_list import flatten
        points = []
        points.extend(
            flatten([
                d.get_frontiers_collection(number_of_generations)
                for d in self.data
            ]))
        print len(points)
        objectives = [point.objectives for point in points]
        maps_objectives = [[-1 for _ in objectives] for _ in objectives]
        from Techniques.euclidean_distance import euclidean_distance
        for i, ii in enumerate(objectives):
            for j, jj in enumerate(objectives):
                if maps_objectives[i][j] == -1:
                    maps_objectives[i][j] = euclidean_distance(ii, jj)
                    maps_objectives[j][i] = euclidean_distance(ii, jj)
                elif i == j:
                    maps_objectives[i][j] = 0

        print maps_objectives
        max_distance = max(
            [max(maps_objective) for maps_objective in maps_objectives])
        indexes = [[(i, j) for j, distance in enumerate(distances)
                    if distance == max_distance]
                   for i, distances in enumerate(maps_objectives)]
        index = [index for index in indexes
                 if len(index) > 0][-1][-1]  # Hack: To handle list of lists
        # indexes should always be a multiple of 2. And if there more than 2 entries in indexes just use any one.

        return objectives[index[0]], objectives[index[1]]
Exemplo n.º 7
0
def find_extreme_points(points):
    from Techniques.euclidean_distance import euclidean_distance
    random_point = choice(points)
    distances = [euclidean_distance(point, random_point) for point in points]
    first_point = points[distances.index(max(distances))]
    distances = [euclidean_distance(point, first_point) for point in points]
    second_point = points[distances.index(max(distances))]
    return [first_point, second_point]
Exemplo n.º 8
0
def find_extreme(one, population):
    temp = []
    for individual in population:
        temp_distance = euclidean_distance(one.decisionValues, individual.decisionValues), individual
        assert temp_distance > 1, "Something's wrong"
        temp.append([temp_distance, individual])
    return sorted(temp, key=lambda x: x[0], reverse=True)[0][1]
Exemplo n.º 9
0
def find_extreme(one, population):
    temp = []
    for individual in population:
        temp_distance = euclidean_distance(
            one.decisionValues, individual.decisionValues), individual
        assert (temp_distance > 1), "Something's wrong"
        temp.append([temp_distance, individual])
    return sorted(temp, key=lambda x: x[0], reverse=True)[0][1]
Exemplo n.º 10
0
 def generate_directions(problem):
     def gen(point):
         r = sum([pp**2 for pp in point])**0.5
         return [round(p/r,3) for p in point]
     coordinates = [gen([random.uniform(0, 1) for _ in xrange(len(problem.decisions))]) for _ in xrange(jmoo_properties.ANYWHERE_POLES * 2)]
     for co in coordinates:
         assert(int(round(euclidean_distance(co, [0 for _ in xrange(len(problem.decisions))]))) == 1), "Something's wrong"
     return coordinates
Exemplo n.º 11
0
def create_distance_matrix(population):
    weights = [pop.weight for pop in population]
    distance_matrix = [[[0, i] for i, _ in enumerate(xrange(len(weights)))] for _ in xrange(len(weights))]
    for i in xrange(len(weights)):
        for j in xrange(len(weights)):
            distance_matrix[i][j][0] = euclidean_distance(weights[i], weights[j])
        assert(distance_matrix[i][i][0] == 0), "Diagonal of Distance matrix should be 0"
    return distance_matrix
Exemplo n.º 12
0
def IGD(approximation_points, original_points):

    summ = 0
    for o in original_points:
        min_distance = 1e32
        for a in approximation_points:
            min_distance = min(min_distance, euclidean_distance(o, a))
        summ += min_distance
    return summ / len(original_points)
Exemplo n.º 13
0
def find_poles2(problem, population):
    def midpoint(population):
        def median(lst):
            import numpy
            return numpy.median(numpy.array(lst))

        mdpnt = []
        for dec in xrange(len(population[0].decisionValues)):
            mdpnt.append(
                median([pop.decisionValues[dec] for pop in population]))
        assert (len(mdpnt) == len(
            population[0].decisionValues)), "Something's wrong"
        # print mdpnt
        return jmoo_individual(problem, mdpnt, None)

    def generate_directions(problem):
        def gen(point):
            r = sum([pp**2 for pp in point])**0.5
            return [round(p / r, 3) for p in point]

        coordinates = [
            gen([random.uniform(0, 1) for _ in xrange(len(problem.decisions))])
            for _ in xrange(jmoo_properties.ANYWHERE_POLES * 2)
        ]
        for co in coordinates:
            assert (int(
                round(
                    euclidean_distance(
                        co, [0 for _ in xrange(len(problem.decisions))
                             ]))) == 1), "Something's wrong"
        return coordinates

    # find midpoint
    mid_point = midpoint(population)
    # find directions
    directions = generate_directions(problem)
    # draw a star
    poles = []
    for direction in directions:
        mine = -1e32
        temp_pole = None
        for pop in population:
            transformed_dec = [
                (p - m)
                for p, m in zip(pop.decisionValues, mid_point.decisionValues)
            ]
            y = perpendicular_distance(direction, transformed_dec)
            c = euclidean_distance(transformed_dec,
                                   [0 for _ in xrange(len(problem.decisions))])
            # print c, y
            if mine < (c - y):
                mine = c - y
                temp_pole = pop
        poles.append(temp_pole)

    stars = rearrange(problem, mid_point, poles)
    return stars
Exemplo n.º 14
0
def IGD(approximation_points, original_points):

    summ = 0
    for o in original_points:
        min_distance = 1e32
        for a in approximation_points:
            min_distance = min(min_distance, euclidean_distance(o, a))
        summ += min_distance
    return summ/len(original_points)
Exemplo n.º 15
0
def create_distance_matrix(population):
    weights = [pop.weight for pop in population]
    distance_matrix = [[[0, i] for i, _ in enumerate(xrange(len(weights)))]
                       for _ in xrange(len(weights))]
    for i in xrange(len(weights)):
        for j in xrange(len(weights)):
            distance_matrix[i][j][0] = euclidean_distance(
                weights[i], weights[j])
        assert (distance_matrix[i][i][0] == 0
                ), "Diagonal of Distance matrix should be 0"
    return distance_matrix
Exemplo n.º 16
0
 def furthest(one, all_members):
     ret = None
     ret_distance = -1 * 1e10
     for member in all_members:
         if equal_list(one, member) is True:
             continue
         else:
             temp = euclidean_distance(one, member)
             if temp > ret_distance:
                 ret = member
                 ret_distance = temp
     return ret
Exemplo n.º 17
0
 def furthest(one, all_members):
     """Find the distant point (from the population) from one (point)"""
     ret = None
     ret_distance = -1 * 1e10
     for member in all_members:
         if equal_list(one, member) is True:
             continue
         else:
             temp = euclidean_distance(one, member)
             if temp > ret_distance:
                 ret = member
                 ret_distance = temp
     return ret
 def furthest(one, all_members):
     """Find the distant point (from the population) from one (point)"""
     ret = None
     ret_distance = -1 * 1e10
     for member in all_members:
         if equal_list(one, member) is True:
             continue
         else:
             temp = euclidean_distance(one, member)
             if temp > ret_distance:
                 ret = member
                 ret_distance = temp
     return ret
Exemplo n.º 19
0
def find_poles2(problem, population):
    def midpoint(population):
        def median(lst):
            import numpy

            return numpy.median(numpy.array(lst))

        mdpnt = []
        for dec in xrange(len(population[0].decisionValues)):
            mdpnt.append(median([pop.decisionValues[dec] for pop in population]))
        assert len(mdpnt) == len(population[0].decisionValues), "Something's wrong"
        # print mdpnt
        return jmoo_individual(problem, mdpnt, None)

    def generate_directions(problem):
        def gen(point):
            r = sum([pp ** 2 for pp in point]) ** 0.5
            return [round(p / r, 3) for p in point]

        coordinates = [
            gen([random.uniform(0, 1) for _ in xrange(len(problem.decisions))])
            for _ in xrange(jmoo_properties.ANYWHERE_POLES * 2)
        ]
        for co in coordinates:
            assert (
                int(round(euclidean_distance(co, [0 for _ in xrange(len(problem.decisions))]))) == 1
            ), "Something's wrong"
        return coordinates

    # find midpoint
    mid_point = midpoint(population)
    # find directions
    directions = generate_directions(problem)
    # draw a star
    poles = []
    for direction in directions:
        mine = -1e32
        temp_pole = None
        for pop in population:
            transformed_dec = [(p - m) for p, m in zip(pop.decisionValues, mid_point.decisionValues)]
            y = perpendicular_distance(direction, transformed_dec)
            c = euclidean_distance(transformed_dec, [0 for _ in xrange(len(problem.decisions))])
            # print c, y
            if mine < (c - y):
                mine = c - y
                temp_pole = pop
        poles.append(temp_pole)

    stars = rearrange(problem, mid_point, poles)
    return stars
Exemplo n.º 20
0
    def generate_directions(problem):
        def gen(point):
            r = sum([pp**2 for pp in point])**0.5
            return [round(p / r, 3) for p in point]

        coordinates = [
            gen([random.uniform(0, 1) for _ in xrange(len(problem.decisions))])
            for _ in xrange(jmoo_properties.ANYWHERE_POLES * 2)
        ]
        for co in coordinates:
            assert (int(
                round(
                    euclidean_distance(
                        co, [0 for _ in xrange(len(problem.decisions))
                             ]))) == 1), "Something's wrong"
        return coordinates
Exemplo n.º 21
0
def find_extreme_points(problem, points):
    from Techniques.euclidean_distance import euclidean_distance
    distance_matrix = [[-1 for _ in xrange(len(points))]
                       for _ in xrange(len(points))]
    for i in xrange(len(points)):
        for j in xrange(len(points)):
            if distance_matrix[i][j] == -1:
                temp_dist = euclidean_distance(points[i], points[j])
                distance_matrix[i][j] = temp_dist
                distance_matrix[j][i] = temp_dist
    max_distance = max(
        [max(maps_objective) for maps_objective in distance_matrix])
    indexes = [[(i, j) for j, distance in enumerate(distances)
                if distance == max_distance]
               for i, distances in enumerate(distance_matrix)]
    index = [index for index in indexes if len(index) > 0][-1][-1]
    return points[index[0]], points[index[1]]
Exemplo n.º 22
0
 def gamma_kernel(x, y, sigma=1):
     from Techniques.euclidean_distance import euclidean_distance
     from math import exp
     return exp(-1 * (euclidean_distance(x, y)** 2)/ (2 * (sigma ** 2)))
Exemplo n.º 23
0
def generate_distance_matrix(points):
    from Techniques.euclidean_distance import euclidean_distance
    return [[euclidean_distance(points[i], points[j]) for j in xrange(len(points))] for i in xrange(len(points))]
Exemplo n.º 24
0
def furthest(individual, population):
    from Techniques.euclidean_distance import euclidean_distance
    distances = sorted([[euclidean_distance(individual, pop), pop] for pop in population], key=lambda x: x[0], reverse=True)
    return distances[0][-1]
Exemplo n.º 25
0
def new_fastmap(problem, true_population):
    """
    Fastmap function that projects all the points on the principal component
    :param problem: Instance of the problem
    :param population: Set of points in the cluster population
    :return:
    """

    def list_equality(lista, listb):
        for a, b in zip(lista, listb):
            if a != b: return False
        return True

    from random import choice
    from Techniques.euclidean_distance import euclidean_distance

    decision_population = [pop.decisionValues for pop in true_population]
    one = choice(decision_population)
    west = furthest(one, decision_population)
    east = furthest(west, decision_population)

    west_indi = jmoo_individual(problem,west, None)
    east_indi = jmoo_individual(problem,east, None)
    west_indi.evaluate()
    east_indi.evaluate()


    # Score the poles
    n = len(problem.decisions)
    weights = []
    for obj in problem.objectives:
        # w is negative when we are maximizing that objective
        if obj.lismore:
            weights.append(+1)
        else:
            weights.append(-1)
    weightedWest = [c * w for c, w in zip(west_indi.fitness.fitness, weights)]
    weightedEast = [c * w for c, w in zip(east_indi.fitness.fitness, weights)]
    westLoss = loss(weightedWest, weightedEast, mins=[obj.low for obj in problem.objectives],
                    maxs=[obj.up for obj in problem.objectives])
    eastLoss = loss(weightedEast, weightedWest, mins=[obj.low for obj in problem.objectives],
                    maxs=[obj.up for obj in problem.objectives])

    # Determine better Pole
    if eastLoss < westLoss:
        SouthPole, NorthPole = east_indi, west_indi
    else:
        SouthPole, NorthPole = west_indi, east_indi


    east = SouthPole.decisionValues
    west = NorthPole.decisionValues

    c = euclidean_distance(east, west)
    tpopulation = []
    for one in decision_population:
        a = euclidean_distance(one, west)
        b = euclidean_distance(one, east)
        tpopulation.append([one, projection(a, b, c)])

    for tpop in tpopulation:
        for true_pop in true_population:
            if list_equality(tpop[0], true_pop.decisionValues):
                true_pop.x = tpop[-1]

    for i, true_pop in enumerate(true_population):
        if list_equality(west, true_pop.decisionValues):
            true_pop.fitness = west_indi.fitness
        elif list_equality(east, true_pop.decisionValues):
            true_pop.fitness = east_indi.fitness


    temp_list = sorted(true_population, key=lambda pop: pop.x)
    ranklist = [t.id for t in temp_list]
    return true_population, ranklist, temp_list[0], temp_list[-1]
Exemplo n.º 26
0
 def gamma_kernel(x, y, sigma=1):
     from Techniques.euclidean_distance import euclidean_distance
     from math import exp
     return exp(-1 * (euclidean_distance(x, y)**2) / (2 * (sigma**2)))
Exemplo n.º 27
0
def generate_distance_matrix(points):
    from Techniques.euclidean_distance import euclidean_distance
    return [[
        euclidean_distance(points[i], points[j]) for j in xrange(len(points))
    ] for i in xrange(len(points))]