Python 如何使用Deap最小化函数？

我需要使用遗传算法和粒子群优化算法最小化一个函数

不同的帖子建议使用（我正在使用python），但我甚至不知道如何开始

我们可以考虑例如f在区间

i=arange(-10,10,0.1)
def f(x):
    return x*sin(x)

如何使用DEAP最小化此函数？

我已经解决了

这是我的密码

t1=linspace(-50,50,100)
sig1=sin(t1/2)+np.random.normal(scale=0.1,size=len(t1))
sig2=sin(t1/2)+np.random.normal(scale=0.1,size=len(t1))



f0=interp1d(t1,sig1,kind="cubic",bounds_error=False,fill_value=-10000)
g=interp1d(t1,sig2,kind="cubic",bounds_error=False,fill_value=10000)
#true value that  I would like to estimate
A=2
B=0.8
C=0

def s(t):
    return A+B*t+C*t*t

def inv_s(t):
    return (t-B)/A

def f(t):
    return f0(s(t))

def hat_s(t,a,b):
    return t*b+a


Ig=arange(t1.min(),t1.max(),1)
If=(Ig-A)/B
I_min=max(If.min(),Ig.min())
I_max=min(If.max(),Ig.max())


J=linspace(min(If.min(),Ig.min()),max(If.max(),Ig.max()))
I=linspace(I_min,I_max,1000)  

#plot(J,f(J),J,g(J))
#ylim(-1.2,1.2)


def cost(x,T=I):
    a=x[0]
    b=x[1]
    return norm(g(b*T+a)-f(T))/len(T),







import operator
import random

import numpy

from deap import base
from deap import benchmarks
from deap import creator
from deap import tools

creator.create("FitnessMax", base.Fitness, weights=(-1.0,))
creator.create("Particle", list, fitness=creator.FitnessMax, speed=list, 
    smin=None, smax=None, best=None)

def generate(size, pmin, pmax, smin, smax):
    part = creator.Particle(random.uniform(pmin, pmax) for _ in range(size)) 
    part.speed = [random.uniform(smin, smax) for _ in range(size)]
    part.smin = smin
    part.smax = smax
    return part

def updateParticle(part, best, phi1, phi2):
    u1 = (random.uniform(0, phi1) for _ in range(len(part)))
    u2 = (random.uniform(0, phi2) for _ in range(len(part)))
    v_u1 = map(operator.mul, u1, map(operator.sub, part.best, part))
    v_u2 = map(operator.mul, u2, map(operator.sub, best, part))
    part.speed = list(map(operator.add, part.speed, map(operator.add, v_u1, v_u2)))
    for i, speed in enumerate(part.speed):
        if speed < part.smin:
            part.speed[i] = part.smin
        elif speed > part.smax:
            part.speed[i] = part.smax
    part[:] = list(map(operator.add, part, part.speed))

toolbox = base.Toolbox()
toolbox.register("particle", generate, size=2, pmin=-6, pmax=6, smin=-3, smax=3)
toolbox.register("population", tools.initRepeat, list, toolbox.particle)
toolbox.register("update", updateParticle, phi1=2.0, phi2=2.0)
toolbox.register("evaluate", cost)

def main():
    pop = toolbox.population(n=5)
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", numpy.mean)
    stats.register("std", numpy.std)
    stats.register("min", numpy.min)
    stats.register("max", numpy.max)

    logbook = tools.Logbook()
    logbook.header = ["gen", "evals"] + stats.fields

    GEN = 1000
    best = None

    for g in range(GEN):
        for part in pop:
            part.fitness.values = toolbox.evaluate(part)
            if not part.best or part.best.fitness < part.fitness:
                part.best = creator.Particle(part)
                part.best.fitness.values = part.fitness.values
            if not best or best.fitness < part.fitness:
                best = creator.Particle(part)
                best.fitness.values = part.fitness.values
        for part in pop:
            toolbox.update(part, best)

        # Gather all the fitnesses in one list and print the stats
        logbook.record(gen=g, evals=len(pop), **stats.compile(pop))
        print(logbook.stream)
        print "  Best so far: %s - %s" % (best, best.fitness)

    return pop, logbook, best

pop,logbook,best= main()
print "best=",best,"A,B=",(A,B)

t1=linspace（-50,50100）
sig1=sin（t1/2）+np.随机.正常（标度=0.1，大小=len（t1））
sig2=sin（t1/2）+np.随机.正常（标度=0.1，大小=len（t1））
f0=interp1d（t1，sig1，kind=“cubic”，bounds\u error=False，fill\u value=-10000）
g=interp1d（t1，sig2，kind=“cubic”，bounds\u error=False，fill\u value=10000）
#我想估算的真实价值
A=2
B=0.8
C=0
def s（t）：
返回A+B*t+C*t*t
def库存（t）：
返回（t-B）/A
def f（t）：
返回f0（s（t））
def hat_s（t、a、b）：
返回t*b+a
Ig=arange（t1.min（），t1.max（），1）
如果=（Ig-A）/B
I_min=max（If.min（），Ig.min（））
I_max=min（If.max（），Ig.max（））
J=linspace（min（If.min（），Ig.min（）），max（If.max（），Ig.max（））
I=linspace（I_最小值，I_最大值，1000）
#地块（J，f（J），J，g（J））
#ylim（-1.2,1.2）
def成本（x，T=I）：
a=x[0]
b=x[1]
返回范数（g（b*T+a）-f（T））/len（T），
进口经营者
随机输入
进口numpy
来自deap进口基地
来自deap的进口基准
来自deap导入创建者
来自deap导入工具
create（“FitnessMax”，base.Fitness，weights=（-1.0，））
creator.create（“粒子”，列表，fitness=creator.FitnessMax，speed=list，
smin=None，smax=None，best=None）
def生成（大小、pmin、pmax、smin、smax）：
零件=创建者.粒子（随机.均匀（pmin，pmax）用于范围内（尺寸））
part.speed=[范围（大小）内的随机均匀（smin，smax）]
part.smin=smin
part.smax=smax
返回部分
def updateParticle（零件，最佳，phi1，phi2）：
u1=（随机均匀（0，phi1）用于范围内（len（部分）））
u2=（随机均匀（0，phi2）用于范围内（len（部分）））
v_u1=map（operator.mul，u1，map（operator.sub，part.best，part））
v_u2=map（operator.mul，u2，map（operator.sub，best，part））
part.speed=列表（map（operator.add，part.speed，map（operator.add，v_u1，v_u2）））
对于i，枚举中的速度（部分速度）：
如果速度part.smax：
part.speed[i]=part.smax
部件[：]=列表（映射（operator.add、部件、部件.speed））
toolbox=base.toolbox（）
寄存器（“粒子”，生成，大小=2，pmin=-6，pmax=6，smin=-3，smax=3）
注册表（“填充”，tools.initRepeat，list，toolbox.particle）
寄存器（“更新”，updateParticle，phi1=2.0，phi2=2.0）
工具箱。登记（“评估”，成本）
def main（）：
pop=工具箱。人口（n=5）
stats=tools.Statistics（lambda ind:ind.fitness.values）
统计寄存器（“平均值”，numpy.mean）
统计寄存器（“标准”，numpy.std）
统计寄存器（“min”，numpy.min）
stats.register（“max”，numpy.max）
日志=工具。日志（）
logbook.header=[“gen”，“evals”]+stats.fields
GEN=1000
最佳=无
对于范围内的g（GEN）：
对于pop中的部分：
part.fitness.values=toolbox.evaluate（部分）
如果不是part.best或part.best.fitness

实际上有一个例子：

---

请注意，我是一名DEAP开发人员。

我意识到我的回复太晚了，但希望我能帮助一些刚刚加入DEAP库的人

为了最大限度地降低成本，您必须创建FitnessMin类，如下所示：

creator.create("FitnessMin", base.Fitness, weights=(-1.0,))

请注意，我的权重是-1.0，如果我们将其设为1.0，我们将最大化

然后，一旦你这样做，将健身课程应用到你的个人身上，这基本上就是你想要训练的染色体：

creator.create("Individual", list, fitness=creator.FitnessMin)

---

看看DEAP库中的eaSimple，因为它是最好的开始。下面是DEAP提供的一个现成算法列表：

我已将基础适应度中的

权重=（1.0，）

更改为

权重=（-1.0，）

---

这是工作

不幸的是，没有“DEAP”标签。