NSGA2 Python实现

NSGA2 Python实现#importingnecessarymodulesimportmathimportrandomimportmatplotlib.pyplotasPlt#FirstFunctiontooptimizedeffunction1(x1,x2):value=-x1*2+x2returnvalue#SecondFunctiontooptimizedeffunction2(x1,x2):value=-x1*5*x2

大家好,又见面了,我是你们的朋友全栈君。

#importing necessary modules
import math
import random
import matplotlib.pyplot as Plt


#First Function to optimize
def function1(x1,x2):
    value = -x1*2 + x2
    return value
#Second Function to optimize
def function2(x1,x2):

    value = -x1*5*x2
    return value

def index_of(a,list):
    for i in range(0,len(list)):
        if a == list[i]:
            return i
    return 0

#求rank
def cd_index(front,f_values):
    #将front中的目标值排序,
    sorted_index = []
    for i in range(0, len(front)):
        temp_list = []
        temp_index =[]
        for j in front[i]:
            temp_list.append(f_values[j])
        temp_list.sort()
        for n in range(0,len(temp_list)):
            temp_index.append(index_of(temp_list[n],f_values))
        sorted_index.append(temp_index)
    return sorted_index

#求单个目标拥挤度
def crowding_distance(front,f_values):
    #将front中的目标值排序,
    sorted_values = []
    for i in range(0, len(front)):
        temp_list = []
        temp_index =[]
        for j in front[i]:
            temp_list.append(f_values[j])
        temp_list.sort()
        for n in range(0,len(temp_list)):
            temp_index.append(index_of(temp_list[n],f_values))
        sorted_values.append(temp_list)
     #计算拥挤度
    distance = [[] for i in range(0, len(front))]
    for i in range(0, len(front)):
        if len(front[i]) == 1:
            distance[i].append(math.inf)
        elif len(front[i]) == 2:
            distance[i].append(math.inf)
            distance[i].append(math.inf)
        else:
            distance[i].append(math.inf)
            for k in range(1,len(front[i])-1):
                if max(sorted_values[i]) == min(sorted_values[i]):
                    break
                distance[i].append((sorted_values[i][k+1]-sorted_values[i][k-1])/(max(sorted_values[i])-min(sorted_values[i])))
            distance[i].append(math.inf)
    return distance

#求总拥挤度
def Get_TOTAL_Distance(front,f1,f2):
    Tol_Dis = [[] for i in range(0, len(front))]
    tem_tol = []
    crowding_distance1 = crowding_distance(front, f1)  # 每个个体在f1上的拥挤度
    crowding_distance2 = crowding_distance(front, f2)  # 每个个体在f2上的拥挤度
    sorted_index1 = cd_index(front, f1)  # 对f1排序后的个体变换
    sorted_index2 = cd_index(front, f2)  # 对f1排序后的个体变换
    for i in range(0, len(sorted_index1)):
        for j in sorted_index1[i]:
            tem_tol.append(
                crowding_distance1[i][sorted_index1[i].index(j)] + crowding_distance2[i][sorted_index2[i].index(j)])
        Tol_Dis.append(tem_tol)
    return Tol_Dis


def fast_non_dominated_sort(values1,values2):
    S = [[] for i in range(0,len(values1))]
    front = [[]]
    n = [0 for i in range(0,len(values1))]

    for p in range(0,len(values1)):
        #S[p] = []
        #n[p] = 0
        for q in range(0,len(values1)):
            if ( values1[p] < values1[q] and values2[p] < values2[q]) or \
                    (values1[p] < values1[q] and values2[p] <= values2[q]) or \
                    (values1[p] <= values1[q] and values2[p] < values2[q]) :
                S[p].append(q)
            elif ( values1[p] > values1[q] and values2[p] > values2[q]) or \
                    (values1[p] > values1[q] and values2[p] >= values2[q]) or \
                    (values1[p] >= values1[q] and values2[p] > values2[q]) :
                n[p] += 1
        if n[p] == 0:
            front[0].append(p)
    i = 0
    while( front[i] != []):
        Q = []
        for p in front[i]:
            for q in S[p]:
                n[q] -= 1
                if(n[q] == 0):
                    Q.append(q)
        i += 1
        front.append(Q)
    del front[len(front)-1]
    return front

#离散重组
def crossover(a,b):
    r = random.random()
    list = []
    A =[0,0]
    B = [0,0]
    if r>0.5:
        A[0] = mutation(a[0])
        B[1] = mutation(b[1])
        list.append(A[0])
        list.append(B[1])
        return list
    else:
        A[1] = mutation(a[1])
        B[0] = mutation(b[0])
        list.append(B[0])
        list.append(A[1])
        return list

def mutation(a):
    mutation_pro=random.random()
    pop = 0
    if mutation_pro <0.05 :
        pop = min_x[0] + (max_x[0]-min_x[0])*random.random()
        return pop
    elif mutation_pro >0.05 and mutation_pro <0.1 :
        pop = min_x[1] + (max_x[1] - min_x[1]) * random.random()
        return pop
    else:
        return a



#Main program
popsize = 50
max_gen = 200

#Initialization
min_x = [-1,1]
max_x = [2,6]
pop = [[] for i in range(0,popsize)]
for i in range(0,popsize):
    for j in range(0,len(min_x)):
        pop[i].append(min_x[j]+(max_x[j]-min_x[j])*random.random())

gen = 0
while gen<max_gen:
    #Selection
    f1_values = [function1(pop[i][0], pop[i][1]) for i in range(0, popsize)]  # 得到每个个体的目标1值f1
    f2_values = [function2(pop[i][0], pop[i][1]) for i in range(0, popsize)]  # 得到每个个体的目标2值f2
    Front = fast_non_dominated_sort(f1_values[:],f2_values[:])#非支配排序
    #计算拥挤度
    Tol_Dis = Get_TOTAL_Distance(Front,f1_values,f2_values)

    pop2 = pop[:]
    # Generating offsprings
    while (len(pop2)!= 2*popsize) :
        p1 = random.randint(0,popsize-1)
        p2 = random.randint(0, popsize - 1)
        pop2.append(crossover(pop[p1],pop[p2]))

    f1_values1 = [function1(pop2[i][0], pop2[i][1]) for i in range(0, 2*popsize)]  # 得到每个个体的目标1值f1
    f2_values1 = [function2(pop2[i][0], pop2[i][1]) for i in range(0, 2*popsize)]  # 得到每个个体的目标2值f2
    Front1 = fast_non_dominated_sort(f1_values1[:], f2_values1[:])  # 非支配排序
    # 计算拥挤度
    Tol_Dis1 = Get_TOTAL_Distance(Front1, f1_values1, f2_values1)
    #Select
    num = 0
    new_pop_index = []
    for i in range(0, len(Front1)):
        if len(Front1[i]) < (popsize - num):  # 非支配排序选择 popsize是初代种群个数
            for j in range(0,len(Front1[i])):
                new_pop_index.append(Front1[i][j])
        else:  # 拥挤度选择
            for j in range(0, popsize - num):
                new_pop_index.append(Front1[i][j])
                if len(new_pop_index)== popsize:
                    break;
        num += len(Front1[i])
    new_pop = [pop2[i] for i in new_pop_index]
    pop = new_pop
    gen +=1

#plot
function1 = [i * -1  for i in f1_values]
function2 = [j * -1  for j in f2_values]
Plt.xlabel('Function 1 ',fontsize = 15)
Plt.ylabel('Function 2 ',fontsize = 15)
Plt.scatter(function1,function2)
Plt.show()



版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/144579.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 匹配滤波(四种滤波器的幅频特性)

    匹配滤波(matchedfiltering)是最佳滤波的一种。当输入信号具有某一特殊波形时,其输出达到最大。在形式上,一个匹配滤波器由以按时间反序排列的输入信号构成。且滤波器的振幅特性与信号的振幅谱一致。因此,对信号的匹配滤波相当于对信号进行自相关运算。配滤波器是一种非常重要的滤波器,广泛应用与通信、雷达等系统中。从上面的理论推导可以看到,当输出信噪比为最大值的时候,滤波器的传递函数与输入信号的频谱函数满足特定的关系,式2.10就反映了这个关系。满足这种关系的线性滤波器,称之为匹配滤波…

  • Linux下tar解压到当前目录,zip压缩,tar压缩,tar解压[通俗易懂]

    Linux下tar解压到当前目录,zip压缩,tar压缩,tar解压[通俗易懂]很多时候我们需要把文件解压到当前目录,命令如下:tar-zxvfvscode-server-linux-x64.tar.gz-C./有时候很讨厌,因为tar.gz的包里就存在一个与压缩包同名的目录,这种情况的话需要先解压,再拷贝:tar-zxvfvscode-server-linux-x64.tar.gz-C./mvvscode-server-linux-x64/*….

  • 经典sql实例大全

    经典sql实例大全经典sql实例大全

  • 环保产品有哪些项目_项目环境分析

    环保产品有哪些项目_项目环境分析一、开发环境:开发环境是程序猿们专门用于开发的服务器,配置可以比较随意,为了开发调试方便,一般打开全部错误报告。通俗的讲,项目尚且在编码阶段,我们的代码一般在开发环境中,不会在生产环境中,生产环境组成:操作系统,web服务器,语言环境。二、测试环境:一般是克隆一份生产环境的配置,一个程序在测试环境工作不正常,那么肯定不能把它发布到生产机上。通常指项目测试,修改bug阶段。三、生产环境(pro):是指正式提供对外服务的,一般会关掉错误报告,打开错误日志。可以理解为包含所有的功能的环境,任何项目所使用

  • 圆周率的前十万亿位_圆周率算到60万亿位

    圆周率的前十万亿位_圆周率算到60万亿位3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644…

  • 每天一道算法_7_Biorhythms

    DescriptionSome people believe that there are three cycles in a person’s life that start the day he or she is born. These three cycles are the physical, emotional, and intellectual cycles, and they

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号