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

{% tabs %}
{% tab title="关键词" %}
Python | NumPy | Matplotlib | seaborn | NetworkX | Pandas | scikit-learn | OpenCV | 基因算法 | 赛事选择 | 轮盘赌选择 | 组合优化 | 运输路径问题 | 约束满足 | Eggholder函数 | Himmelblau函数 | Simionescu函数 | 多模态函数 | 奇偶检测 | 粒子群 | 特征提取 | 多元自适应回归 | 网格搜索 | 像素均方值 | 结构相似性 | Java | 膳食计划 | 员工执勤 | 车辆调度 | 动植物分类 | 运动爬坡 | 杆平衡性
{% endtab %}

{% tab title="关联链接" %}
{% embed url="https://viadean.notion.site/Python-e91749d1d0804eb0955a4b00940e7196?pvs=4" %}
{% endtab %}
{% endtabs %}

{% content-ref url="../zhi-dian-mi-jin-brief" %}
[zhi-dian-mi-jin-brief](../zhi-dian-mi-jin-brief)
{% endcontent-ref %}

### 要点

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;

```java
​
//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();
​
        demo.population.initializePopulation(10);
​
        demo.population.calculateFitness();
​
        System.out.println("Generation: " + demo.generationCount + " Fittest: " + demo.population.fittest);
​
        while (demo.population.fittest < 5) {
            ++demo.generationCount;

            demo.selection();
​
            demo.crossover();
​
            if (rn.nextInt()%7 < 5) {
                demo.mutation();
            }
​

            demo.addFittestOffspring();

            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("");
​
    }
​
    void selection() {
​
        fittest = population.getFittest();

        secondFittest = population.getSecondFittest();
    }
​

    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遗传编程示例

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