Python遗传编程运动测试和计划调度安排之一

要点

1. Python使用库：数值处理库NumPy，绘图库Matplotlib，统计数据可视化seaborn，结构图分析NetworkX，数据分析Pandas，预测性机器学习scikit-learn和视觉图形处理OpenCV
2. 基因算法解决问题：组合优化处理运输路径，约束满足处理分配和调度计划，基因算子函数优化（Eggholder函数，Himmelblau函数，Simionescu函数和多模态函数），奇偶检测和粒子群优化
3. 解决特征提取问题：多元自适应回归数据集，动物分类特征
4. 超参数调整问题：自适应提升算法分类器，网格搜索
5. 图像重建应用方式：像素均方值，结构相似性

遗传算法

遗传算法是一种启发式搜索，其灵感来自查尔斯·达尔文的自然进化论。 该算法反映了自然选择的过程，选择最适应的个体进行繁殖，以产生下一代的后代。

自然选择的过程始于从种群中选择最适应的个体。 它们产生的后代继承了父母的特征，并将被添加到下一代。 如果父母有更好的身体素质，他们的后代就会比父母更好，有更好的生存机会。 这个过程不断迭代，最终会找到最适应个体的一代。

这个概念可以应用于搜索问题。我们考虑一个问题的一组解决方案，并从中选择一组最好的解决方案。

遗传算法考虑五个阶段：

1. 初始种群

   该过程从一组称为总体的个体开始。每个人都是你想要解决的问题的一个解。个体的特征是由一组称为基因的参数（变量）来表征。基因连接成串，形成染色体（溶液）。在遗传算法中，个体的基因组使用字母表形式的字符串来表示。通常，使用二进制值（1 和 0 的字符串）。我们说我们在染色体中编码基因。

2. 适应度函数

   适应度函数决定了个体的适应程度（个体与其他个体竞争的能力）。 它为每个人提供一个健康分数。 个体被选择进行繁殖的概率基于其适应度得分。

3. 选择

   选择阶段的想法是选择最适应的个体，让他们将基因传递给下一代。根据健康分数选择两对个体（父母）。适应度高的个体有更多的机会被选择进行繁殖。

4. 交叉

   交叉是遗传算法中最重要的阶段。对于每对要交配的父母，从基因中随机选择一个交叉点。后代是通过交换父母的基因而产生的，直到达到交叉点。

5. 变种

   在某些新形成的后代中，它们的某些基因可能会发生低随机概率的突变。这意味着位串中的一些位可以被翻转。发生突变是为了维持种群内的多样性并防止过早收敛。

如果种群已经收敛（不会产生与上一代显着不同的后代），则算法终止。那么就说遗传算法给我们的问题提供了一套解。

应用场景

1. 神经网络
2. 数据挖掘和聚类分析
3. 图像处理
4. 无线传感器网络
5. 运输和路径问题
6. 机械工程设计
7. 制造系统
8. 金融市场
9. 医药科学
10. 任务调度
11. 经济学
12. 机器人

Java 实现示例

下面给出了 Java 中遗传算法的示例实现。给定一组 5 个基因，每个基因可以保存二进制值 0 和 1 之一。适应度值计算为基因组中存在的 1 的数量。如果有五个 1，那么它具有最大适应度。如果没有 1，则它具有最小适应度。该遗传算法试图最大化适应度函数，以提供由最适应个体（即具有五个 1 的个体）组成的种群。注意：在这个例子中，经过交叉和变异后，最不适应的个体被新的最适应的后代所取代。

import java.util.Random;

//Main class
public class SimGA {

    Population population = new Population();
    int generationCount = 0;

    public static void main(String[] args) {

        Random rn = new Random();

        SimpleDemoGA demo = new SimpleDemoGA();

        //Initialize population
        demo.population.initializePopulation(10);

        //Calculate fitness of each individual
        demo.population.calculateFitness();

        System.out.println("Generation: " + demo.generationCount + " Fittest: " + demo.population.fittest);

        //While population gets an individual with maximum fitness
        while (demo.population.fittest < 5) {
            ++demo.generationCount;

            //Do selection
            demo.selection();

            //Do crossover
            demo.crossover();

            //Do mutation under a random probability
            if (rn.nextInt()%7 < 5) {
                demo.mutation();
            }

            //Add fittest offspring to population
            demo.addFittestOffspring();

            //Calculate new fitness value
            demo.population.calculateFitness();

            System.out.println("Generation: " + demo.generationCount + " Fittest: " + demo.population.fittest);
        }

        System.out.println("\nSolution found in generation " + demo.generationCount);
        System.out.print("Genes: ");
        for (int i = 0; i < 5; i++) {
            System.out.print(demo.population.getFittest().genes[i]);
        }

        System.out.println("");

    }

    //Selection
    void selection() {

        //Select the most fittest individual
        fittest = population.getFittest();

        //Select the second most fittest individual
        secondFittest = population.getSecondFittest();
    }

    //Crossover
    void crossover() {
        Random rn = new Random();

        //Select a random crossover point
        int crossOverPoint = rn.nextInt(population.individuals[0].geneLength);

        //Swap values among parents
        for (int i = 0; i < crossOverPoint; i++) {
            int temp = fittest.genes[i];
            fittest.genes[i] = secondFittest.genes[i];
            secondFittest.genes[i] = temp;

        }

    }

    void mutation() {
        Random rn = new Random();

        int mutationPoint = rn.nextInt(population.individuals[0].geneLength);

        //Flip values at the mutation point
        if (fittest.genes[mutationPoint] == 0) {
            fittest.genes[mutationPoint] = 1;
        } else {
            fittest.genes[mutationPoint] = 0;
        }

        mutationPoint = rn.nextInt(population.individuals[0].geneLength);

        if (secondFittest.genes[mutationPoint] == 0) {
            secondFittest.genes[mutationPoint] = 1;
        } else {
            secondFittest.genes[mutationPoint] = 0;
        }
    }

    Individual getFittestOffspring() {
        if (fittest.fitness > secondFittest.fitness) {
            return fittest;
        }
        return secondFittest;
    }

    void addFittestOffspring() {

        fittest.calcFitness();
        secondFittest.calcFitness();

        int leastFittestIndex = population.getLeastFittestIndex();

        population.individuals[leastFittestIndex] = getFittestOffspring();
    }

}

class Individual {

    int fitness = 0;
    int[] genes = new int[5];
    int geneLength = 5;

    public Individual() {
        Random rn = new Random();

        for (int i = 0; i < genes.length; i++) {
            genes[i] = Math.abs(rn.nextInt() % 2);
        }

        fitness = 0;
    }

    public void calcFitness() {

        fitness = 0;
        for (int i = 0; i < 5; i++) {
            if (genes[i] == 1) {
                ++fitness;
            }
        }
    }

}

class Population {

    int popSize = 10;
    Individual[] individuals = new Individual[10];
    int fittest = 0;

    public void initializePopulation(int size) {
        for (int i = 0; i < individuals.length; i++) {
            individuals[i] = new Individual();
        }
    }

    public Individual getFittest() {
        int maxFit = Integer.MIN_VALUE;
        int maxFitIndex = 0;
        for (int i = 0; i < individuals.length; i++) {
            if (maxFit <= individuals[i].fitness) {
                maxFit = individuals[i].fitness;
                maxFitIndex = i;
            }
        }
        fittest = individuals[maxFitIndex].fitness;
        return individuals[maxFitIndex];
    }

    public Individual getSecondFittest() {
        int maxFit1 = 0;
        int maxFit2 = 0;
        for (int i = 0; i < individuals.length; i++) {
            if (individuals[i].fitness > individuals[maxFit1].fitness) {
                maxFit2 = maxFit1;
                maxFit1 = i;
            } else if (individuals[i].fitness > individuals[maxFit2].fitness) {
                maxFit2 = i;
            }
        }
        return individuals[maxFit2];
    }

    public int getLeastFittestIndex() {
        int minFitVal = Integer.MAX_VALUE;
        int minFitIndex = 0;
        for (int i = 0; i < individuals.length; i++) {
            if (minFitVal >= individuals[i].fitness) {
                minFitVal = individuals[i].fitness;
                minFitIndex = i;
            }
        }
        return minFitIndex;
    }

    public void calculateFitness() {

        for (int i = 0; i < individuals.length; i++) {
            individuals[i].calcFitness();
        }
        getFittest();
    }

}

修改上述代码，输出可视化数据。

Python遗传编程示例

• 运输路径选择和算子函数优化
• 最大化方程式结果
• 平衡膳食计划数值计算
• 员工执勤班次安排
• 通勤路径和车辆调度
• 奇偶检测和粒子群优化
• 动植物分类特征
• 像素均方值和结构相似性图像重建
• 汽车运动爬坡判断
• 垂直杆平衡性判断

参阅一：计算思维

参阅二：亚图跨际