Genetic Programming遗传规划python库教程(gplearn和DEAP)

这篇具有很好参考价值的文章主要介绍了Genetic Programming遗传规划python库教程(gplearn和DEAP)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

以下内容来自官网教程

DEAP Basic tutorials:进化计算框架,提供了多种算法所需模块(GA, GP, DE, PSO…)
gplearn Welcome to gplearn’s documentation:python GP库,提供了符号回归,分类等方法

1.gplearn

1.1 Introduction(介绍)

gplearn用python实现Genetic Programming,和scikit-learn一样提供了可兼容API,GP在很多领域得到了广泛应用,gplearn主要用于解决Symbolic regression(符合回归)问题。Symbolic regression是一种机器学习技术,用于找到描述某种关系的基础数学表达式。它首先构建一组朴素的随机公式来表示已知自变量与其因变量之间的关系,基于公式可以为输入预测输出,通过与实际目标值对比 ,从种群中选择最适合的个体进行遗传操作,进化得到下一代程序。gplearn保留了scikit-learn中的fit/predict API,简单的用法如:

est = SymbolicRegressor()
est.fit(X_train, y_train)
y_pred = est.predict(X_test)

为了能定制化解决问题,gplearn提供了很多更细分的模块。gplearn主要致辞以下三类问题:

  • SymbolicRegressor:符号回归
  • SymbolicClassifier:二分类
  • SymbolicTransformer:自动化特征工程的转换

1.1.1 Representation(表达)

正如前面提到,GP想要找到一种数学表达式能代表某种关系,假设现在有两个变量x0和x1,其数学表达式和树存储的前序表达式如下
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库
每个表达式中,有variables(变量),constants(常数)和functions(函数),在上面的例子中,函数有add,sub,mul,变量为x1和x0,常数为3.0和5.0。variables和constants称为terminals,terminals和functions称为primitive set(原始集)。用树表示表达式,如图深色点为functions,叶子结点为terminals。可以通过对树回溯得到原始表达式,从叶子结点开始,x0x0以及3.0x1,然后两个结果相减,相减结果与0.5相加(用栈处理)
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库
对于 GP,子表达式或子树可以替换为任何其他计算结果为数字的有效表达式,包括常量。 该子表达式,以及任何更大的子表达式,例如减法函数下面的所有内容,都在前序表达式中彼此相邻,也就是python列表中是相邻的,比如3.0和x1一定相临,这样即便进行交叉和变异也能容易通过编程实现。
每个function有一个属性称为arity,也就是传入参数的数量,大部分function需要传入两个参数,比如sub需要x和y才能执行相减,有一些比如np.abs()取绝对值只需要一个。在明确我们的函数集里所有function所需的arity后,用python列表就很容易能计算前序表达式。
gplearn中可用的函数集由初始化时的参数设置,默认包括addition, subtraction, division 和 multiplication,可以选择的function如下
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库
只需在传入参数function_set选择即可,如果有自定义的function,可以通过functions.make_function()实现,比如自定义一个函数logical

gp = SymbolicTransformer(function_set=['add', 'sub', 'mul', 'div'])
def _logical(x1, x2, x3, x4):
    return np.where(x1 > x2, x3, x4)

logical = make_function(function=_logical, name='logical', arity=4)
gp = SymbolicTransformer(function_set=['add', 'sub', 'mul', 'div', logical])

1.1.2 Fitness(适应度)

每个公式都是一段可执行的程序,我们需要确定它的执行结果。 从达尔文进化角度来看,用来评价每个个体的称为适应度,这和机器学习中的score,error,loss类似。在GP中,通过对某些指标的最小化或者最大化选择合适的程序进化。
gplearn中的评价标准通过metric参数设置,对于SymbolicRegressor包括mse,rmse,对于SymbolicTransformer包括pearson,spearman,对于SymbolicClassifier包括log loss等。如果有自定义的适应度可以通过fitness.make_fitness()实现,比如想要使用MAPE (mean absolute percentage error)误差

def _mape(y, y_pred, w):
    """Calculate the mean absolute percentage error."""
    diffs = np.abs(np.divide((np.maximum(0.001, y) - np.maximum(0.001, y_pred)),
                             np.maximum(0.001, y)))
    return 100. * np.average(diffs, weights=w)
    
mape = make_fitness(function=_mape, greater_is_better=False)
est = SymbolicRegressor(metric=mape, verbose=1)

1.1.3 Closure

在函数计算过程中,有一些function是需要保护的,比如division,如果除数刚好为0,就会出现error,因此这些functions需要适当调整保证能输出一个有效值。在gplearn
有以下被保护的函数:

  • division:分母介于-0.001和0.001,就返回1.0
  • 平方根返回参数绝对值的平方根
  • log 返回参数绝对值的对数,或者对于小于 0.001 的非常小的值,它返回 0.0
  • 相反数,如果参数介于 -0.001 和 0.001 之间,则返回 0.0。

如果用的自定义的functions.make_function()一定要保证不会出现无效的操作

1.2 Genetic operators

1.2.1 Initialization(初始化)

运行GP首先需要一群初始化种群,初始化需要考虑以下参数

  • init_depth:树的深度范围,init_depth包括两个整数代表初始树的深度,树的深度产生的约束效果与初始化方法有关(后面描述),通常来说设置2-6
  • population_size:初始化种群大小(树的多少),如果你的变量,函数集很少,小的种群便可以,如果有很多变量,就需更大的种群数
  • init_method:初始化方法有三种,'grow', 'full', 和 'half and half'。在'grow'方法中,每次可以随机从函数集和终端集中选择结点,这可能会出现比init_depth更小的树,因此终端集只能出现在叶子结点,这种方法生成的树也是非对称的。如果你的数据中有很多变量,那么更大可能会出现初始深度更小的树,相反如果变量少,函数多,那么程序更可能到达最大深度。在'full'方法中,依次从函数集中选择结点,除非遇到最大深度,从终端集中选择一个作为叶子结点,这样生成的树比较拥挤和对称。默认为'half and half'方法,也就是种群中一半通过'grow',,一半通过'full',下面分别为full和grow
    gplearn,运筹优化,python,进化算法,遗传规划,DEAP库

1.2.2 Selection(选择)

在有了一群程序后,我们需要决定哪些能进化到下一代,在gplearn中是通过tournaments的方式,从种群中随机选择一个小子集,彼此竞争,子集的大小由tournament_size参数决定,其中适应度最高的个体会选择进入下一代。tournament_size越大,越容易找到更合适的程序,进化越快收敛到某个解,tournament_size越小,可以保留种群的多样性,但是进化也更耗费时间。使用适应度值找到最合适的个体生存后,这些个体并不是直接进入下一代,而是先进行遗传操作

1.2.3 Crossover(交叉)

交叉是为了混合基因,通过参数p_crossover决定。需要执行两次tournaments找到两个赢家,第一个作为父代,第二个作为捐赠者,从父代中随机选择一个子树用捐赠者的随机子树代替
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库

1.2.4 Mutation(变异)

  • Subtree Mutation(子树变异)

子树变异是比较激进的变异方法,通过参数p_subtree_mutation决定,首先选择一个tournaments赢家,随机选择其子树被替代,另一个捐赠子树是随机生成的,再插入到原来的树中,由于变异的部分是完全随机的,因此也保留了种群的多样性
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库

  • Hoist Mutation(提升变异)

Hoist Mutation是一种对抗膨胀的变异操作,由p_hoist_mutation 参数控制。这种变异是去除掉tournaments赢家的部分基因。从tournaments赢家中选择一个随机子树。 然后选择该子树的随机子树,并将其“提升”到原始子树的位置以形成下一代。
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库

  • Point Mutation(点变异)

点变异是GP中比较常用的变异方法,p_point_replace决定了替代的结点数量,和子树变异一样,它会将没有使用的函数和运算符重新引入种群以保持多样性。选择一个tournaments赢家,然后随机替代其中的一些结点,终端结点用终端集代替,函数结点用函数集代替
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库

  • Reproduction(重组)

如果上述遗传操作的概率之和小于一,则遗传操作的平衡将落在重组上。 也就是说,锦标赛获胜者被克隆并进入下一代未修改。

1.2.5 Termination(结束)

有两种方式进化过程会终止,第一种是到达最大迭代数,通过参数generations控制,另一种是种群中至少有一个个体适应度超过了stopping_criteria,表明已经找到了一个比较好的解

1.3 Bloat

一个程序的大小主要指:深度和长度。深度是根结点到叶子结点的最远距离,只有一个值的程序深度为0,长度是数学表达式元素的个数,等于总结点数。在GP中,并不是程序越大越好,相反程序越来越大,增加计算时间,但是适应度可能没有任何提升,这种现象称为bloat
在GP中,选择过程中对于更大但是适应度更差的个体使用penalized fitness作为标准,因此如果两个个体适应度一样,优先选择更小的程序。parsimony_coefficient参数控制了惩罚程度,最近文献中提出的covariant parsimony method方法可以通过设置parsimony_coefficient='auto'实现,这种方法根据适应度值和程序大小关系自动调整惩罚因子,另一种可以通过基因操作实现,比如hoist mutation会去掉程序的一个部分。也可以在你的数据里增加子采样使种群更丰富,参数max_samples控制,默认不使用。

1.4 Symbolic Regressor(case)

假设现在要拟合的一个表达式如下
gplearn,运筹优化,python,进化算法,遗传规划,DEAP库
首先生成一些随机合成数据展示图像

import numpy as np
import matplotlib.pyplot as plt

x0 = np.arange(-1, 1, 1/10.)
x1 = np.arange(-1, 1, 1/10.)
x0, x1 = np.meshgrid(x0, x1)
y_truth = x0**2 - x1**2 + x1 - 1
ax = plt.figure().add_subplot(projection='3d')
ax.set_xlim(-1, 1)
ax.set_ylim(-1, 1)
surf = ax.plot_surface(x0, x1, y_truth, rstride=1, cstride=1, color='green', alpha=0.5)
plt.show(

gplearn,运筹优化,python,进化算法,遗传规划,DEAP库
创建训练数据集

from sklearn.utils import check_random_state
rng = check_random_state(0)
x_train = rng.uniform(-1, 1, 100).reshape(50, 2)
y_train = x_train[:, 0]**2 - x_train[:, 1]**2 + x_train[:, 1] - 1
x_test = rng.uniform(-1, 1, 100).reshape(50, 2)
y_test = x_test[:, 0]**2 - x_test[:, 1]**2 + x_test[:, 1] - 1

训练数据

est_gp = SymbolicRegressor(population_size=5000,
                           generations=20, stopping_criteria=0.01,
                           p_crossover=0.7, p_subtree_mutation=0.1,
                           p_hoist_mutation=0.05, p_point_mutation=0.1,
                           max_samples=0.9, verbose=1,
                           parsimony_coefficient=0.01, random_state=0)
est_gp.fit(x_train, y_train)
    |   Population Average    |             Best Individual              |
---- ------------------------- ------------------------------------------ ----------
 Gen   Length          Fitness   Length          Fitness      OOB Fitness  Time Left
   0    38.13          458.578        5         0.320666         0.556764      1.10m
   1     9.97          1.70233        5         0.320202         0.624787     36.56s
   2     7.72          1.94456       11         0.239537         0.533148     33.74s
   3     5.41         0.990157        7         0.235676         0.719906     29.37s
   4     4.66         0.894443       11         0.103946         0.103946     27.59s
   5     5.41         0.940242       11         0.060802         0.060802     26.33s
   6     6.78          1.09536       11      0.000781474      0.000781474     23.92s

输出最优解

print(est_gp._program)
sub(add(-0.999, X1), mul(sub(X1, X0), add(X0, X1)))

2.DEAP

2.1 Creating Types

如何使用creator创建算法中需要的各个模块;初始化使用toolbox

2.1.1 Fitness

Fitness类需要传入参数weights,最小化用负数,最大化用正数,create()函数至少需要传入两个参数,一个是创建的类的名字,一个是基类。个体的适应度值会通过toolbox中的evaluate计算出来,此处创建Fitness类是表明优化方向。

# 单目标最小化
creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
# 多目标:最小化,最大化
creator.create("FitnessMulti", base.Fitness, weights=(-1.0, 1.0))

2.1.2 Individual

由于各种算法GA, GP, ES, PSO, DE等个体类型多样,不可能提供所有的个体编码,以下是能用creator创建的个体以及使用toolbox初始化这些个体。主要包括以下个体类型:列表形式的数字,排列组合,树,进化策略,粒子等

  • List of Floats

个体是简单的包含浮点数的列表,首先用creator创建Individual类,类型为list,属性为前面定义的适应度

import random

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

creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

IND_SIZE=10

toolbox = base.Toolbox()
toolbox.register("attr_float", random.random)
toolbox.register("individual", tools.initRepeat, creator.Individual,
                 toolbox.attr_float, n=IND_SIZE)

使用register()方法在工具箱中添加了两个别名,attr_floatindividualregister()方法需要至少传入两个参数:别名和与其相关的函数功能。attr_float代表random.random函数,也就是随机生成个体的方法,individual创建了initRepeat()快捷方式,通过attr_float方法生成前面定义的个体。

  • Permutation

与前面方法类似,只是每个个体是一个排列组合,因此用的indices,从给定序列里随机采样IND_SIZE个数

import random

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

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

IND_SIZE=10

toolbox = base.Toolbox()
toolbox.register("indices", random.sample, range(IND_SIZE), IND_SIZE)
toolbox.register("individual", tools.initIterate, creator.Individual,
                 toolbox.indices)
  • Arithmetic Expression

主要用于GP中基于树的个体,个体类型为PrimitiveTree,创建前先确定原始集PrimitiveSet,传入两个参数,一个是集合命名,一个是变量个数,如下原始集中有3个function和一个变量,其表达式生成方式设置为genHalfAndHalf()

import operator

from deap import base
from deap import creator
from deap import gp
from deap import tools

pset = gp.PrimitiveSet("MAIN", arity=1)
pset.addPrimitive(operator.add, 2)
pset.addPrimitive(operator.sub, 2)
pset.addPrimitive(operator.mul, 2)

creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin,
               pset=pset)

toolbox = base.Toolbox()
toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)
toolbox.register("individual", tools.initIterate, creator.Individual,
                 toolbox.expr)

除此还有Evolution Strategy,Particle,A Funky One等个体定义方式

2.1.3 Population

种群方式有以下:包Bag,网格Grid,群Swarm,子种群Demes,Seeding a Population等

  • Bag

Bag种群是最常用的类型,没有特定的顺序,通常使用列表来实现。 由于Bag没有特定属性,因此不需要任何特殊类。 直接使用工具箱和 initRepeat() 函数初始化种群。比如遗传算法种群就是各个个体一起存放在列表里。先在工具箱里注册,然后调用toolbox.population()会返回种群,n为种群大小

toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.population(n=100)

2.2 Operators and Algorithms

在创建完个体种群后,还需要对这些个体执行基因操作。随机创建一个个体用于后面的示例,个体为列表存储的浮点数,适应度值目前为空,因此还没有评估。

import random
from deap import base
from deap import creator
from deap import tools
IND_SIZE = 5
creator.create("FitnessMin", base.Fitness, weights=(-1.0, -1.0))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("attr_float", random.random)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=IND_SIZE)
ind1 = toolbox.individual()
print(ind1)
print(ind1.fitness.valid)
[0.6383518264585538, 0.6825024981834429, 0.3265116106141692, 0.9671414417759829, 0.6941481904147978]
False

2.2.1 Evaluation

对解进行评价获得适应度值是算法应用时最需要定制化的模块,也就是自己写,通常来说evaluate模块输入一个个体,输出一个元组,代表该个体的适应度值,每个个体的fitness都有valid属性,代表该个体是否已经被评价。返回元组是因为多目标优化问题需要多个适应度值。

def evaluate(individual):
    a = sum(individual)
    b = len(individual)
    return a, 1.0/b

ind1.fitness.values = evaluate(ind1)
print(ind1.fitness)
print(ind1.fitness.valid)
(3.389497314678003, 0.2)
True

2.2.2 Mutation

deap.tools里提供了很多变异操作,注意在变异时会改变自身,因此如果要保留原来的个体,先复制再变异,同时删除变异后个体的适应度值,因为发生了改变

mutant = toolbox.clone(ind1)
ind2, = tools.mutGaussian(mutant, mu=0.0, sigma=0.2, indpb=0.2)
del mutant.fitness.values
print(ind2 is mutant)
print(mutant is ind1)
True
False

2.2.3 Crossover

同变异一样,deap.tools里也提供了很多,交叉算子的一般规则是它们只与个体交配,这意味着如果必须保留原始个体或参考其他个体,则必须在与个体交配之前制作独立副本。

child1, child2 = [toolbox.clone(ind) for ind in (ind1, ind2)]
tools.cxBlend(child1, child2, 0.5)
del child1.fitness.values
del child2.fitness.values

2.2.4 Selection

选择操作需要传入两个参数:需要选择的个体列表和选择的数量

ind1 = toolbox.individual()
ind2 = toolbox.individual()
selected = tools.selBest([ind1, ind2], 2)
print(ind1 in selected)

通常在选择之后或变异之前对整个种群进行复制

selected = toolbox.select(population, LAMBDA)
offspring = [toolbox.clone(ind) for ind in selected]

2.2.5 Using the Toolbox

toolbox包含了所有的进化工具,从目标初始化到评估个体,toolbox能够很简单的配置一个算法需要的模块,有两个方法,register()unregister(),分别是添加和移除工具。使用toolbox注册进化工具,通常包括以下内容:mate(), mutate(), evaluate() and select()。将tools中的进化算子直接封装注册到toolbox中。

from deap import base
from deap import tools

toolbox = base.Toolbox()

def evaluateInd(individual):
    # Do some computation
    return result,

toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluateInd)

2.2.6 Algorithms

algorithms模块中提供了好几种算法,首先为算法组建好toolbox,也就是定义好了个体编码,基因算子,种群等,然后就可以运行算法。通常需要5个传入参数:种群,toolbox,交叉率,变异率,迭代数

from deap import algorithms
algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=50)

2.3 Computing Statistics

2.3.1 Single-objective Statistics

tools中的Statistics能用于统计训练数据,Statistics对象首先需要传入一个关键词,作用到数据上,获得数据集,比如统计个体的适应度值,然后通过register方法注册一些方法可以得到数据的统计值,比如均值,方差等。

stats = tools.Statistics(key=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)

在添加完Statistics中的工具后,对运行后的种群进行统计,使用compile方法
以前面的toolbox为例,

pop, logbook = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=0, stats=stats, verbose=True)
record = stats.compile(pop)
print(record)
{'avg': 1.0280724547834108, 'std': 0.9585341482492478, 'min': -0.5192935690712837, 'max': 3.2460831125587752}

2.3.2 Multi-objective Statistics

如果是多目标,在注册时可选择维度

stats = tools.Statistics(key=lambda ind: ind.fitness.values)
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)
>>> print(record)
{'std': array([ 4.96]), 'max': array([ 63.]), 'avg': array([ 50.2]),
'min': array([ 39.])}

2.3.3 Multiple Statistics

也可以统计不同的属性,使用tools.MultiStatistics方法将每个属性数据结合一起

stats_fit = tools.Statistics(key=lambda ind: ind.fitness.values)
stats_size = tools.Statistics(key=len)
mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size)
mstats.register("avg", numpy.mean)
mstats.register("std", numpy.std)
mstats.register("min", numpy.min)
mstats.register("max", numpy.max)
record = mstats.compile(pop)
>>> print(record)
{'fitness': {'std': 1.64, 'max': 6.86, 'avg': 1.71, 'min': 0.166},
'size': {'std': 1.89, 'max': 7, 'avg': 4.54, 'min': 3}}

2.3.4 Logging Data

产生的数据也可以保存下来,使用tools中的Logbook实现

logbook = tools.Logbook()
logbook.record(gen=0, evals=30, **record)
logbook.header = "gen", "avg", "spam"
>>> print(logbook)
gen   avg      spam
0     [ 50.2]

2.4 Artificial Ant Problem(case)

完整代码见ant.py,使用GP求解Artificial Ant Problem,首先定义原始集,其中有一些自定义的function

def progn(*args):
    for arg in args:
        arg()

def prog2(out1, out2):
    return partial(progn, out1, out2)

def prog3(out1, out2, out3):
    return partial(progn, out1, out2, out3)

def if_then_else(condition, out1, out2):
    out1() if condition() else out2()
    
pset = gp.PrimitiveSet('Main', 0)
pset.addPrimitive(ant.if_food_ahead, 2)
pset.addPrimitive(prog2, 2)
pset.addPrimitive(prog3, 3)
pset.addTerminal(ant.move_forward)
pset.addTerminal(ant.turn_left)
pset.addTerminal(ant.turn_right)

构建toolbox

creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax)

toolbox = base.Toolbox()
toolbox.register("expr_init", gp.genFull, pset=pset, min_=1, max_=2)
toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr_init)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

toolbox.register("evaluate", evalArtificialAnt)
toolbox.register("select", tools.selTournament, tournsize=7)
toolbox.register("mate", gp.cxOnePoint)
toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset)

其中evaluate部分需要自定义,定义一个仿真环境,用于求解每个解的适应度值,定义evalArtificialAnt函数

class AntSimulator(object):
    def if_food_ahead(self, out1, out2):
        return partial(if_then_else, self.sense_food, out1, out2)
    def run(self,...)
.........
def evalArtificialAnt(individual):
    # Transform the tree expression to functional Python code
    routine = gp.compile(individual, pset)
    # Run the generated routine
    ant.run(routine)
    return ant.eaten,

主循环文章来源地址https://www.toymoban.com/news/detail-535549.html

def main():
    random.seed(69)

    with  open("Other/ant/santafe_trail.txt") as trail_file:
      ant.parse_matrix(trail_file)

    pop = toolbox.population(n=300)
    hof = tools.HallOfFame(1)
    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)

    algorithms.eaSimple(pop, toolbox, 0.5, 0.2, 5, stats, halloffame=hof)

    return pop, hof, stats

if __name__ == "__main__":
    main()
gen	nevals	avg    	std    	min	max
0  	300   	1.71667	3.00273	0  	14 
1  	178   	5.08667	4.65107	0  	31 
2  	196   	7.66667	6.08568	0  	31 
3  	185   	9.7    	8.11809	0  	36 
4  	164   	14.5833	11.2376	0  	44 
5  	172   	18.3233	14.0275	0  	44 

到了这里,关于Genetic Programming遗传规划python库教程(gplearn和DEAP)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 路径规划问题的遗传算法实现(python代码)

        遗传算法是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型,是一种通过模拟自然进化过程搜索最优解的方法。该算法通过数学的方式,利用计算机仿真运算,将问题的求解过程转换成类似生物进化中的染色体基因的交叉、变异等过程。     路径

    2024年02月04日
    浏览(46)
  • DEAP库文档教程二-----创建类型

    本节将展示如何通过 creator 创建类型以及如何使用 toolbox 进行初始化。 1、Fitness 已经提供的Fitness类是一个抽象类,它需要weight来使得它成为一个函数。一个最小化的适应度是通过负权重构建的,而一个最大化适应度则需要正权重。 creat()函数至少需要两个元素 ,一个是别名

    2024年02月10日
    浏览(40)
  • 动态规划Dynamic Programming

     上篇文章我们简单入门了动态规划(一般都是简单的上楼梯,分析数据等问题)点我跳转,今天给大家带来的是路径问题,相对于上一篇在一维中摸爬滚打,这次就要上升到二维解决问题,但都用的是动态规划思想嘛,所以大差不差,且听我慢慢道来。 还是用一样的方法,

    2024年03月27日
    浏览(52)
  • 动态规划(Dynamic Programming)详解

    引言: 动态规划(Dynamic Programming,简称DP)是计算机科学与数学领域中的一个经典算法设计策略,用于解决具有重叠子问题和最优子结构特性的复杂问题。它通过将问题分解为更小的子问题来避免重复计算,从而提高效率。本文旨在详细介绍动态规划的基本概念、原理、实现

    2024年04月13日
    浏览(41)
  • 使用 Python库DEAP的多目标优化示例

       在优化领域,困难往往不是来自为单个问题找到最佳解决方案,而是来自管理具有多个经常相互冲突的目标的复杂问题环境。这就是多目标优化 (MOO) 发挥作用的地方,它提供了一个解决此类多方面问题的框架。本文探讨了 MOO 的核心及其数学基础,并提供了一个动手

    2024年04月26日
    浏览(31)
  • 算法——动态规划(DP,Dynamic Programming)

    动态规划常用于解决优化问题。 动态规划通常以自底向上或自顶向下的方式进行求解。 自底向上的动态规划从最简单的子问题开始,逐步解决更复杂的问题,直到达到原始问题。 自顶向下的动态规划则从原始问题出发,分解成子问题,并逐步求解这些子问题。 动态规划算法

    2024年02月02日
    浏览(53)
  • 【数据结构】动态规划(Dynamic Programming)

    求解决策过程(decision process)最优化的数学方法。 将多阶段决策过程转化为一系列单阶段问题,利用各阶段之间的关系,逐个求解。 与分治法类似,将待求解问题 分解成若干个子问题 。 但是经分解得到的子问题往往 不是相互独立 的。 如果使用分治法求解问题,有些子问

    2024年02月03日
    浏览(43)
  • 浅析动态规划(Dynamic Programming,DP)

    动态规划可以理解为递归,只不过递归是通过函数实现,动态规划通过循环实现! 动态规划有多好用我就不过多介绍,写这篇文章的时候我也不是熟练掌握,只是单纯记录一下我的学习经历并分享一些我的心得体会,仅此而已。 推荐看一下这个视频,对你的理解应该会有所

    2024年04月27日
    浏览(41)
  • 数据结构与算法 | 动态规划算法(Dynamic Programming)

    上一篇文末已经提到了记忆化搜索是动态规划(Dynamic Programming)的一种形式,是一种自顶向下(Top-Down)的思考方式,通常采用递归的编码形式;既然动态规划有自顶向下(Top-Down)的递归形式,自然想到对应的另外一种思考方式 自底向上( Bottom-Up ) ,也就是本篇要写的内

    2024年02月05日
    浏览(46)
  • 数据结构与算法:动态规划(Dynamic Programming)详解

    动态规划(Dynamic Programming,简称DP) 是一种在数学、管理科学、计算机科学、经济学和生物信息学等领域中使用的,通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划经常被用于求解优化问题。 动态规划的核心思想是将复杂问题分解为更小的子问

    2024年04月25日
    浏览(48)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包