An Efficient Approach to Non-dominated Sorting for Evolutionary Multi-objective Optimization

Reference

Zhang X, Tian Y, Cheng R, et al. An efficient approach to nondominated sorting for evolutionary multiobjective optimization[J]. IEEE Transactions on Evolutionary Computation, 2014, 19(2): 201-213.

Python code implementation

import numpy as np
import functools
import time

# O(n) 当n等于一千万(10000000)时大概 1s

Pop_Size = 1000  # 种群大小
N = 10  # 决策空间大小
M = 10  # 目标数


class Individual(object):

    def __init__(self, gene, func):
        self.gene = gene
        self.func = func
        pass

    def __str__(self):
        return '[gene=%s\n func=%s]\n' % (self.gene, self.func)

    __repr__ = __str__

    pass


def cmp(pop1, pop2):
    i = 0
    while i < M:
        if pop1.func[i] < pop2.func[i]:
            return -1
        elif pop1.func[i] > pop2.func[i]:
            return 1
        else:
            i += 1
            # return 0
            pass
        pass
    return 0


def init_population():
    population = []
    for i in range(Pop_Size):
        gene = [np.random.randint(0, 2) for j in range(N)]
        func = [np.random.randint(0, Pop_Size/2) for j in range(M)]
        pop = Individual(gene, func)
        population.append(pop)
        pass
    return population


def jude_dominating(p, q):
    # 最小化问题
    i = 0
    flag = True
    cnt = 0
    while i < M:
        if p.func[i] > q.func[i]:
            flag = False
            break
            pass
        elif p.func[i] == q.func[i]:
            cnt += 1
            pass
        i += 1
        pass
    if flag:
        if cnt < M:  # 不能所有目标相等
            return True
        else:
            return False
        pass
    else:  # 存在一个目标不小于则不支配
        return False

    pass


def fast_sort(population):
    s = {}
    n = {}
    f = []
    pt = []  # 记录一层非支配层
    for p in population:
        st = []  # p支配的个体
        nt = 0  # 支配p的个体数
        for q in population:
            if jude_dominating(p, q):
                st.append(q)
                pass
            elif jude_dominating(q, p):
                nt += 1
                pass
            pass
        # s[p.idx] = st  # 第i个个体所支配的个体集合
        s[id(p)] = st
        # n[p.idx] = nt  # 支配的第i个个体的个体数
        n[id(p)] = nt
        if nt == 0:  # 没有个体支配p
            pt.append(p)
            pass
        pass
    f.append(pt)
    i = 0
    while len(f[i]) > 0:  # 由于判断条件，会多一个空层
        pt = []
        for p in f[i]:
            # for q in s[p.idx]:  # q下一层支配，则-1
            for q in s[id(p)]:  # q下一层支配，则-1
                n[id(q)] -= 1
                # n[q.idx] -= 1
                # if n[q.idx] == 0:  # 不存在支配q的个体，则加入当前层
                if n[id(q)] == 0:  # 不存在支配q的个体，则加入当前层
                    pt.append(q)
                    pass
                pass
            pass
        i += 1
        f.append(pt)
        pass
    f.pop()
    return f


def sequential_search_strategy(p, f):
    x = len(f)  # 已经被分配的支配层数
    k = 0  # 当前检索的层
    while True:
        flag = False
        for q in reversed(f[k]):
            if jude_dominating(q, p):
                flag = True
                break
                pass
            pass
        if flag:  # p 被f[k]中的个体支配
            k += 1
            if k >= x:
                t = []
                f.append(t)
                # return x + 1
                x += 1
                f[k].append(p)
                break
                pass
            pass

        else:  # p 不被f[k]中的个体支配
            # return k
            f[k].append(p)
            break
            pass

        pass
    pass


# 二分思想
def binary_search_strategy(p, f):
    x = len(f)  # 已经找到的支配层数
    k_min = 0  # 检索的最底层
    k_max = x  # 检索的最高层
    # k = int(np.floor((k_max+k_min)/2 + 1/2))  # 当前检索的层
    k = int((k_max+k_min)/2)
    while True:
        flag = False
        for q in reversed(f[k]):
            if jude_dominating(q, p):
                flag = True
                break
                pass
            pass

        if flag:  # k小了，要往上层走，直到k==k_max-1
            # k_min = k  # k层能支配p 需要判断高层是否有支配p的。
            if (k == k_max-1) and (k_max < x):  # k是支配p的直接上一层
                # return k_max
                f[k_max].append(p)
                break
                pass
            elif k == x-1:  # 已存在的最后一层(k)支配p,则需要新加入一层
                # return x+1
                # x += 1
                t = []
                f.append(t)
                f[x].append(p)
                x += 1
                break
                pass
            else:  # k层能支配p 但不是直接支配p的一层 需要判断高层是否有支配p的。
                # k = np.floor((k_max + k_min)/2 + 1/2)
                k_min = k
                k = int((k_max + k_min)/2)
                pass
            pass

        else:  # k大了，要往下层走，直到k==k_min+1
            if k == k_min:  # 当k==k_min 说明k是不能支配p的最小一层(就是说比k小的层通通支配p)
                # return k
                f[k].append(p)
                break
                pass
            else:  # k层不能支配p 但不是最小的层 需要往下层走。
                k_max = k
                k = int((k_max+k_min)/2)
                pass
            pass

        pass
    pass


def ens_ss(population):

    f = [[]]
    # population_sort = sorted(population, key=lambda individual: individual.f1)
    # print(population)
    population_sort = sorted(population, key=functools.cmp_to_key(cmp))
    # print(population_sort)
    for pop in population_sort:
        sequential_search_strategy(pop, f)
        # binary_search_strategy(pop, f)
        pass
    return f


def ens_bs(population):

    f = [[]]
    # population_sort = sorted(population, key=lambda individual: individual.f1)
    # print(population)
    population_sort = sorted(population, key=functools.cmp_to_key(cmp))
    # print(population_sort)
    for pop in population_sort:
        # sequential_search_strategy(pop, f)
        binary_search_strategy(pop, f)
        pass
    return f


pp = init_population()

print('********************fast_sort********************')
t1 = time.time()
ff = fast_sort(pp)
print(time.time()-t1)

# for tt in ff:
#     print('front size=', len(tt))
#     print(tt)
#     pass

print('********************binary_search********************')
t1 = time.time()
ff = ens_bs(pp)
print(time.time()-t1)

# for tt in ff:
#     print('front size=', len(tt))
#     print(tt)
#     pass

print('********************sequential_search********************')
t1 = time.time()
ff = ens_ss(pp)
print(time.time()-t1)

# for tt in ff:
#     print('front size=', len(tt))
#     print(tt)
#     pass

Run result

 Result analysis

当种群大小population_size=1000,目标数M=10时，binary_search 和 sequential_search 都是该论文提出的非支配排序方法，从运行结果能看出，该论文提出的排序方法优于传统的快速非支配排序算法(fast_sort[1])。

[1] Deb K, Pratap A, Agarwal S, et al. A fast and elitist multiobjective genetic algorithm: NSGA-II[J]. IEEE transactions on evolutionary computation, 2002, 6(2): 182-197.

MOEAs的相关研究及应用

参考

[4] Yang X, Zou J, Yang S, et al. A Fuzzy Decision Variables Framework for Large-scale Multiobjective Optimization[J]. IEEE Transactions on Evolutionary Computation, 2021.

[5] Zou J, Yang X, Liu Z, et al. Multiobjective Bilevel Optimization Algorithm Based on Preference Selection to Solve Energy Hub System Planning Problems[J]. Energy, 2021: 120995.

[6] Liu J, Yang X, Liu Z, et al. Investigation and evaluation of building energy flexibility with energy storage system in hot summer and cold winter zones[J]. Journal of Energy Storage, 2022, 46: 103877.