python DEAP库多处理器

我想使用基于python的框架DEAP解决一个多目标优化问题。由于耗时的进程，我需要使用我所有的CPU能力来计算。因此，我按照中的建议使用了多处理库，但它导致

PicklingError:Can't pickle:attribute lookup\uuuuuu内置函数失败

。 我的代码太长，无法写下来，但下面的代码与我的代码相似，并导致相同的错误。你能告诉我哪里出错吗？ 提前谢谢

import multiprocessing
from deap import creator, base, tools, algorithms
import random
import matplotlib.pyplot as plt
def TEST(dec_var):
    return dec_var[0]**2+dec_var[1]**2,(dec_var[0]-2)**2+dec_var[1]**2
def feasible(dec_var):
    if all(i>0 for i in dec_var):
        return True
    return False

creator.create("FitnessMin", base.Fitness, weights=(-1.0,-1.0))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox=base.Toolbox()

toolbox.register("uniform", random.uniform, 0.0, 7.0)
toolbox.register("individual",tools.initRepeat,creator.Individual,toolbox.uniform ,n=2)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.1)
toolbox.register("select", tools.selNSGA2)
toolbox.register("evaluate", TEST)
toolbox.decorate("evaluate", tools.DeltaPenalty(feasible,(1000,1000)))

def main(seed=None):
    random.seed(seed)

    NGEN = 250
    MU = 100
    CXPB = 0.9

    stats_func1 = tools.Statistics(key=lambda ind: ind.fitness.values[0])
    stats_func2 = tools.Statistics(key=lambda ind: ind.fitness.values[1])
    stats = tools.MultiStatistics(func1=stats_func1, func2=stats_func2)
    stats.register("avg", numpy.mean, axis=0)
    stats.register("std", numpy.std, axis=0)
    stats.register("min", numpy.min, axis=0)
    stats.register("max", numpy.max, axis=0)

    logbook = tools.Logbook()
    logbook.header = "gen", "evals", "func1","func2"
    logbook.chapters["func1"].header = "min", "max"
    logbook.chapters["func2"].header = "min", "max"    
    pop = toolbox.population(n=MU)


    invalid_ind = [ind for ind in pop if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit


    pop = toolbox.select(pop, len(pop))
    record = stats.compile(pop)
    logbook.record(gen=0, evals=len(invalid_ind), **record)
    print(logbook.stream)


    for gen in range(1, NGEN):

        offspring = tools.selTournamentDCD(pop, len(pop))
        offspring = [toolbox.clone(ind) for ind in offspring]

        for ind1, ind2 in zip(offspring[::2], offspring[1::2]):
            if random.random() <= CXPB:
                toolbox.mate(ind1, ind2)

            toolbox.mutate(ind1)
            toolbox.mutate(ind2)
            del ind1.fitness.values, ind2.fitness.values


        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit


        pop = toolbox.select(pop + offspring, MU)
        record = stats.compile(pop)
        logbook.record(gen=gen, evals=len(invalid_ind), **record)
        print(logbook.stream)



    return pop, logbook
if __name__ == "__main__":
    pool = multiprocessing.Pool(processes=4)
    toolbox.register("map", pool.map)
    pop, stats = main()
    pool.close()
    print pop

导入多处理
从deap导入创建者、库、工具、算法
随机输入
将matplotlib.pyplot作为plt导入
def测试（dec_var）：
返回dec_var[0]**2+dec_var[1]**2，（dec_var[0]-2）**2+dec_var[1]**2
def可行（dec_var）：
如果全部（12月变量中的i大于0）：
返回真值
返回错误
create（“FitnessMin”，base.Fitness，weights=（-1.0，-1.0））
creator.create（“个人”，列表，fitness=creator.FitnessMin）
toolbox=base.toolbox（）
工具箱寄存器（“统一”，random.uniform，0.0，7.0）
toolbox.register（“个人”，tools.initRepeat，creator.individual，toolbox.uniform，n=2）
toolbox.register（“填充”，tools.initRepeat，list，toolbox.individual）
toolbox.register（“mate”，tools.cxTwoPoint）
寄存器（“mutate”，tools.mut，mu=0，sigma=1，indpb=0.1）
toolbox.register（“选择”，tools.selNSGA2）
工具箱。注册表（“评估”，测试）
工具箱。装饰（“评估”，工具。DeltaPenalty（可行，（10001000）））
def主（种子=无）：
随机。种子（种子）
NGEN=250
μ=100
CXPB=0.9
stats\u func1=tools.Statistics（key=lambda ind:ind.fitness.values[0]）
stats\u func2=tools.Statistics（key=lambda ind:ind.fitness.values[1]）
stats=tools.MultiStatistics（func1=stats\u func1，func2=stats\u func2）
统计寄存器（“平均值”，numpy.mean，轴=0）
统计寄存器（“标准”，numpy.std，轴=0）
统计寄存器（“min”，numpy.min，axis=0）
stats.register（“max”，numpy.max，axis=0）
日志=工具。日志（）
logbook.header=“gen”、“evals”、“func1”、“func2”
日志。章节[“func1”]。header=“最小”、“最大”
日志。章节[“func2”]。header=“最小”、“最大”
pop=工具箱。人口（n=MU）
无效的_ind=[如果不是ind.fitness.valid，则为pop中的ind指定ind]
fitnesses=toolbox.map（toolbox.evaluate，无效）
对于ind，适合拉链（无效ind，适合度）：
ind.fitness.values=fit
pop=工具箱。选择（pop，len（pop））
record=stats.compile（pop）
日志记录（gen=0，evals=len（无效标识），**记录）
打印（日志.流）
对于范围内的发电机（1，NGEN）：
子代=工具。selTournamentDCD（pop，len（pop））
后代=[toolbox.clone（ind）用于后代中的ind]
对于ind1，zip中的ind2（子代[：：2]，子代[1:：2]）：
如果random.random（）这在您链接的文档页面上有说明：

lambda函数的pickle在Python中还不可用

您正在
stats\u func1
和
stats\u func2
中使用lambda函数–只需将它们移动到全局函数，然后重试：

def stats_key_1（ind）：
返回ind.fitness.value[0]
def统计键2（ind）：
返回ind.fitness.values[1]
# ... 剪
def主（种子=无）：
# ... 剪
stats\u func1=tools.Statistics（key=stats\u key\u 1）
stats\u func2=tools.Statistics（key=stats\u key\u 1）
这在您链接的文档页面上有所说明：

lambda函数的pickle在Python中还不可用

您正在
stats\u func1
和
stats\u func2
中使用lambda函数–只需将它们移动到全局函数，然后重试：

def stats_key_1（ind）：
返回ind.fitness.value[0]
def统计键2（ind）：
返回ind.fitness.values[1]
# ... 剪
def主（种子=无）：
# ... 剪
stats\u func1=tools.Statistics（key=stats\u key\u 1）
stats\u func2=tools.Statistics（key=stats\u key\u 1）
非常感谢您的帮助。似乎将函数移动到全局函数可以防止产生错误，但它不会产生多核处理。仍然只有一个核心有效。嗨@Sina_Alef我也有同样的问题。你解决了吗？我感谢你的帮助。似乎将函数移动到全局函数可以防止产生错误，但它不会产生多核处理。仍然只有一个核心有效。嗨@Sina_Alef我也有同样的问题。你解决了吗？