遗传算法学习(一)

1. pygad 3.3.1 pip install pygad
2. genetic-algorithm-python
3. GeneticAlgorithmPython
4. 遗传算法（Genetic Algorithm）详解与实现get
5. 遗传算法 (Genetic Algorithm, GA) 详解与实现get
6. 遗传算法实践详解（deap框架初体验）get
7. 遗传算法（二）——编码get
8. Hands-On-Genetic-Algorithms-with-Python-Second-Edition
9. 遗传算法 定义+特性+原理+公式+Python示例代码（带详细注释）get

import random

# 定义个体类，代表种群中的一个个体
class Individual:
    def __init__(self, genes):
        self.genes = genes  # 个体的基因序列
        self.fitness = self.calculate_fitness()  # 个体的适应度

    def calculate_fitness(self):
        # 计算适应度函数，这里以基因的平方和为例
        # 适应度函数应根据具体问题进行定义
        return sum(x ** 2 for x in self.genes)

# 初始化种群
def initialize_population(size, gene_length):
    # size: 种群的大小
    # gene_length: 个体基因序列的长度
    # 生成初始种群，每个个体由随机生成的基因序列组成
    return [Individual([random.randint(-10, 10) for _ in range(gene_length)]) for _ in range(size)]

# 选择过程
def selection(population, num_parents):
    # 根据适应度排序，选择适应度最高的个体作为父母
    # population: 当前种群
    # num_parents: 选择的父母数量
    sorted_population = sorted(population, key=lambda x: x.fitness, reverse=True)
    return sorted_population[:num_parents]

# 交叉过程
def crossover(parent1, parent2):
    # 单点交叉
    # parent1, parent2: 选择的两个父本个体
    # 随机选择交叉点，交换父本基因，生成两个子代
    point = random.randint(1, len(parent1.genes) - 1)
    child1_genes = parent1.genes[:point] + parent2.genes[point:]
    child2_genes = parent2.genes[:point] + parent1.genes[point:]
    return Individual(child1_genes), Individual(child2_genes)

# 变异过程
def mutation(individual, mutation_rate=0.01):
    # 对个体的基因序列进行随机变异
    # individual: 要变异的个体
    # mutation_rate: 变异概率
    for i in range(len(individual.genes)):
        if random.random() < mutation_rate:
            # 对每个基因位以一定的概率进行增减操作
            individual.genes[i] += random.randint(-1, 1)
    # 更新个体的适应度
    individual.fitness = individual.calculate_fitness()

# 遗传算法主函数
def genetic_algorithm(population_size, gene_length, num_generations):
    # population_size: 种群大小
    # gene_length: 基因长度
    # num_generations: 进化代数
    # 初始化种群
    population = initialize_population(population_size, gene_length)
    for _ in range(num_generations):
        # 选择
        parents = selection(population, population_size // 2)
        next_generation = []
        # 生成新一代
        while len(next_generation) < population_size:
            parent1, parent2 = random.sample(parents, 2)
            child1, child2 = crossover(parent1, parent2)
            mutation(child1)
            mutation(child2)
            next_generation.extend([child1, child2])
        population = next_generation
        # 每一代选出适应度最高的个体
        best_individual = max(population, key=lambda x: x.fitness)
        print(f"最优适应度: {best_individual.fitness}")
    return best_individual

# 运行算法
best = genetic_algorithm(100, 5, 50)
print(f"最优个体基因: {best.genes}")

10. python遗传算法(详解)get
11. 遗传算法详解及代码实现 get
12. 遗传算法入门详解 get
13. 遗传算法 定义+特性+原理+公式+Python示例代码（带详细注释） get
14. 10分钟搞懂遗传算法(含源码) get
15. python遗传算法(详解) get

三.主要步骤
1）种群初始化。我们需要首先通过随机生成的方式来创造一个种群，一般该种群的数量为100~500，这里我们采用二进制将一个染色体(解)编码为基因型。随后用进制转化，将二进制的基因型转化成十进制的表现型。
2）适应度计算(种群评估)。这里我们直接将目标函数值作为个体的适应度。
3）选择(复制)操作。根据种群中个体的适应度大小，通过轮盘赌等方式将适应度高的个体从当前种群中选择出来。其中轮盘赌即是与适应度成正比的概率来确定各个个体遗传到下一代群体中的数量。
具体步骤如下：
(1)首先计算出所有个体的适应度总和Σfi。
(2)其次计算出每个个体的相对适应度大小fi/Σfi，类似于softmax。
(3)再产生一个0到1之间的随机数，依据随机数出现在上述哪个概率区域内来确定各个个体被选中的次数。

4）交叉(交配)运算。该步骤是遗传算法中产生新的个体的主要操作过程，它用一定的交配概率阈值(pc，一般是0.4到0.99)来控制是否采取单点交叉，多点交叉等方式生成新的交叉个体。
具体步骤如下：
(1)先对群体随机配对。
(2)再随机设定交叉点的位置。
(3)再互换配对染色体间的部分基因。

5）变异运算。该步骤是产生新的个体的另一种操作。一般先随机产生变异点，再根据变异概率阈值(pm,一般是0.0001到0.1)将变异点的原有基因取反。

6）终止判断。如果满足条件(迭代次数，一般是200~500)则终止算法，否则返回step2。

2.适应度计算
个体适应度与其对应的个体表现型x的目标函数值相关联，x越接近于目标函数的最优点，其适应度越大，从而其存活的概率越大。反之适应度越小，存活概率越小。这就引出一个问题关于适应度函数的选择，本例中，函数值总取非负值(删去了。。。)，以函数最大值为优化目标，故直接将目标函数作为适应度函数。这里我们直接将目标函数2*sin(x)+cos作为个体适应度。如果，你想优化的是多元函数的话，需要将个体中基因型的每个变量提取出来，分别带入目标函数。比如说：我们想求x1+lnx2的最大值。基因编码为4位编码，其中前两位是x1，后两位是x2。那么我们在求适应度的时候，需要将这两个值分别带入f(x1)=x,f(x2)=lnx。再对f(x1)和f(x2)求和得到此个体的适应度，具体的在此篇中有详解。在本篇中，虽然染色体长度为10,但是实际上只有一个变量。
16. 第九课 遗传算法（ Genetic Algorithm, GA）
遗传算法是从代表问题可能潜在的解集的一个种群（ population） 开始的， 而一个种群则由经过基因（ gene） 编码的一定数目的个体(individual)组成。 因此， 第一步需要实现从表现型到基因型的映射即编码工作。 初代种群产生之后， 按照适者生存和优胜劣汰的原理， 逐代（ generation） 演化产生出越来越好的近似解， 在每一代， 根据问题域中个体的适应度(fitness)大小选择个体，借助于自然遗传学的遗传算子(genetic operators) 进行组合交叉和变异， 产生出代表新的解集的种群。 这个过程将导致种群像自然进化一样， 后生代种群比前代更加适应于环境， 末代种群中的最优个体经过解码（ decoding） ， 可以作为问题近似最优解。

遗传算法的基本步骤：
编码： GA在进行搜索之前先将解空间的解数据表示成遗传空间的基因型串结构数据，这些串结构数据的不同组合便构成了不同的点。
初始群体的生成：随机产生N个初始串结构数据， 每个串结构数据称为一个个体， N个个体构成了一个群体。 GA以这N个串结构数据作为初始点开始进化。
适应度评估：适应度表明个体或解的优劣性。不同的问题， 适应性函数的定义方式也不同。
选择：选择的目的是为了从当前群体中选出优良的个体， 使它们有机会作为父代为下一代繁殖子孙。 遗传算法通过选择过程体现这一思想， 进行选择的原则是适应性强的个体为下一代贡献一个或多个后代的概率大。 选择体现了达尔文的适者生存原则。
交叉：交叉操作是遗传算法中最主要的遗传操作。 通过交叉操作可以得到新一代个体，新个体组合了其父辈个体的特性。 交叉体现了信息交换的思想。
变异：变异首先在群体中随机选择一个个体， 对于选中的个体以一定的概率随机地改变串结构数据中某个串的值。同生物界一样， GA中变异发生的概率很低， 通常取值很小。

17. 超详细的遗传算法(Genetic Algorithm)解析get

其主要特点是直接对结构对象进行操作，不存在求导和函数连续性的限定；具有内在的隐并行性和更好的全局寻优能力；采用概率化的寻优方法，不需要确定的规则就能自动获取和指导优化的搜索空间，自适应地调整搜索方向。

遗传算法以一种群体中的所有个体为对象，并利用随机化技术指导对一个被编码的参数空间进行高效搜索。其中，选择、交叉和变异构成了遗传算法的遗传操作；参数编码、初始群体的设定、适应度函数的设计、遗传操作设计、控制参数设定五个要素组成了遗传算法的核心内容。

基因型(genotype)：性状染色体的内部表现；
表现型(phenotype)：染色体决定的性状的外部表现，或者说，根据基因型形成的个体的外部表现；
进化(evolution)：种群逐渐适应生存环境，品质不断得到改良。生物的进化是以种群的形式进行的。
适应度(fitness)：度量某个物种对于生存环境的适应程度。
选择(selection)：以一定的概率从种群中选择若干个个体。一般，选择过程是一种基于适应度的优胜劣汰的过程。
复制(reproduction)：细胞分裂时，遗传物质DNA通过复制而转移到新产生的细胞中，新细胞就继承了旧细胞的基因。
交叉(crossover)：两个染色体的某一相同位置处DNA被切断，前后两串分别交叉组合形成两个新的染色体。也称基因重组或杂交；
变异(mutation)：复制时可能（很小的概率）产生某些复制差错，变异产生新的染色体，表现出新的性状。
编码(coding)：DNA中遗传信息在一个长链上按一定的模式排列。遗传编码可看作从表现型到基因型的映射。
解码(decoding)：基因型到表现型的映射。
个体（individual）：指染色体带有特征的实体；
种群（population）：个体的集合，该集合内个体数称为种群

18. python如何做遗传算法get

def single_point_crossover(parent1, parent2):
    crossover_point = np.random.randint(1, len(parent1)-1)
    child1 = np.concatenate((parent1[:crossover_point], parent2[crossover_point:]))
    child2 = np.concatenate((parent2[:crossover_point], parent1[crossover_point:]))
    return child1, child2

变异操作（Mutation）是对个体的基因进行随机变动，以增加种群的多样性。常见的变异方法包括位变异、交换变异和插入变异。

def mutation(individual, mutation_rate):
    for i in range(len(individual)):
        if np.random.rand() < mutation_rate:
            individual[i] = 1 - individual[i]
    return individual

def genetic_algorithm(pop_size, gene_length, generations, mutation_rate):
    population = initialize_population(pop_size, gene_length)
    for generation in range(generations):
        new_population = []
        fitness = np.array([fitness_function(ind) for ind in population])
        for _ in range(pop_size // 2):
            parent1 = roulette_wheel_selection(population, fitness)
            parent2 = roulette_wheel_selection(population, fitness)
            child1, child2 = single_point_crossover(parent1, parent2)
            child1 = mutation(child1, mutation_rate)
            child2 = mutation(child2, mutation_rate)
            new_population.extend([child1, child2])
        population = np.array(new_population)
    best_individual = population[np.argmax([fitness_function(ind) for ind in population])]
    return best_individual

DEAP（Distributed Evolutionary Algorithms in Python）是一个功能强大的进化计算框架，支持遗传算法、遗传编程等多种进化算法。

from deap import base, creator, tools, algorithms
import random

creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)
toolbox = base.Toolbox()
toolbox.register("attr_bool", random.randint, 0, 1)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, gene_length)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", fitness_function)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
toolbox.register("select", tools.selTournament, tournsize=3)
population = toolbox.population(n=pop_size)
algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.2, ngen=generations, stats=None, halloffame=None, verbose=True)

PyGAD是另一个常用的遗传算法库，具有简单易用的特点，适合快速实现和测试遗传算法。

import pygad
import numpy as np

def fitness_func(solution, solution_idx):
    return np.sum(solution)

gene_space = [0, 1]
num_generations = 100
num_parents_mating = 4
sol_per_pop = 8
num_genes = gene_length
ga_instance = pygad.GA(gene_space=gene_space,
                       num_generations=num_generations,
                       num_parents_mating=num_parents_mating,
                       fitness_func=fitness_func,
                       sol_per_pop=sol_per_pop,
                       num_genes=num_genes)

ga_instance.run()
solution, solution_fitness, solution_idx = ga_instance.best_solution()
print("Best solution:", solution)
print("Fitness value of the best solution:", solution_fitness)

19. 基于Python手把手教你实现一个遗传算法（含具体源码，以及UI演变过程）get
20. 遗传算法详解 附python代码实现get
21. 【算法】超详细的遗传算法(Genetic Algorithm)解析get
    浮点法，是指个体的每个基因值用某一范围内的一个浮点数来表示。在浮点数编码方法中，必须保证基因值在给定的区间限制范围内，遗传算法中所使用的交叉、变异等遗传算子也必须保证其运算结果所产生的新个体的基因值也在这个区间限制范围内。
    浮点数编码方法有下面几个优点：
    (1)适用于在遗传算法中表示范围较大的数。
    (2)适用于精度要求较高的遗传算法。
    (3)便于较大空间的遗传搜索。
    (4)改善了遗传算法的计算复杂性，提高了运算效率。
    (5)便于遗传算法与经典优化方法的混合使用。
    (6)便于设计针对问题的专门知识的知识型遗传算子。
    (7)便于处理复杂的决策变量约束条件。
    符号编码法是指个体染色体编码串中的基因值取自一个无数值含义、而只有代码含义的符号集如｛A,B,C…｝。
    符号编码的主要优点是：
    (1)符合有意义积术块编码原则。
    (2)便于在遗传算法中利用所求解问题的专门知识。
    (3)便于遗传算法与相关近似算法之间的混合使用。

常用的选择算子：
(1)轮盘赌选择（Roulette Wheel Selection）：是一种回放式随机采样方法。每个个体进入下一代的概率等于它的适应度值与整个种群中个体适应度值和的比例。选择误差较大。
(2)随机竞争选择（Stochastic Tournament）：每次按轮盘赌选择一对个体，然后让这两个个体进行竞争，适应度高的被选中，如此反复，直到选满为止。
(3)最佳保留选择：首先按轮盘赌选择方法执行遗传算法的选择操作，然后将当前群体中适应度最高的个体结构完整地复制到下一代群体中。
(4)无回放随机选择（也叫期望值选择Excepted Value Selection）：根据每个个体在下一代群体中的生存期望来进行随机选择运算。方法如下:
（a） 计算群体中每个个体在下一代群体中的生存期望数目N。
（b） 若某一个体被选中参与交叉运算，则它在下一代中的生存期望数目减去0.5，若某一个体未被选中参与交叉运算，则它在下一代中的生存期望数目减去1.0。
（c） 随着选择过程的进行，若某一个体的生存期望数目小于0时，则该个体就不再有机会被选中。
(5)确定式选择：按照一种确定的方式来进行选择操作。具体操作过程如下：
（a） 计算群体中各个个体在下一代群体中的期望生存数目N。
（b） 用N的整数部分确定各个对应个体在下一代群体中的生存数目。
（c） 用N的小数部分对个体进行降序排列，顺序取前M个个体加入到下一代群体中。至此可完全确定出下一代群体中Ｍ个个体。
(6)无回放余数随机选择：可确保适应度比平均适应度大的一些个体能够被遗传到下一代群体中，因而选择误差比较小。
(7)均匀排序：对群体中的所有个体按期适应度大小进行排序，基于这个排序来分配各个个体被选中的概率。
(8)最佳保存策略：当前群体中适应度最高的个体不参与交叉运算和变异运算，而是用它来代替掉本代群体中经过交叉、变异等操作后所产生的适应度最低的个体。
(9)随机联赛选择：每次选取几个个体中适应度最高的一个个体遗传到下一代群体中。
(10)排挤选择：新生成的子代将代替或排挤相似的旧父代个体，提高群体的多样性。