【超参数寻优】量子遗传算法（QGA） 超参数寻优的java实现

最新推荐文章于 2023-05-27 12:18:43 发布
最新推荐文章于 2023-05-27 12:18:43 发布
阅读量677 收藏 5
点赞数
分类专栏： java 寻优算法
原文链接：https://blog.csdn.net/Luqiang_Shi/article/details/84672658
版权

【超参数寻优】量子遗传算法（QGA） 超参数寻优的java实现

本文基于【超参数寻优】量子遗传算法（QGA） 超参数寻优的python实现
这篇文章改写为Java代码实现，其中适应度计算本文简化了操作。

后期想改写成解决TSP问题的量子遗传算法，如有推荐的文章或者代码，希望各位分享给我一下。嘻嘻

如有错误，或者可以改进的地方希望各位读者指出，谢谢啦。

package com.hust.hui.alarm.common.test.path.qga;

import java.util.*;

/**
 * @program: quick_Netty
 * @description: 量子遗传算法（QGA） 超参数寻优
 * @author: Mr.Liu
 * @create: 2019-11-25 12:29
 **/
public class QGA {
    /**种群数**/
    int population_size;
    /**染色体数，对应需要寻优的参数个数**/
    int chromosome_num;
    /**染色体长度**/
    int chromosome_length;
    /**染色体十进制数值最大值**/
    double max_value;
    /**染色体十进制数值最小值**/
    double min_value;
    /**迭代次数**/
    int iter_num;
    /**量子旋转角度  **/
    double deta;

    /**
     * 初始化类参数
     * @param population_size 种群数
     * @param chromosome_num 染色体数，对应需要寻优的参数个数
     * @param chromosome_length 染色体长度
     * @param max_value 染色体十进制数值最大值
     * @param min_value 染色体十进制数值最小值
     * @param iter_num 迭代次数
     * @param deta 量子旋转角度
     */
    public QGA(int population_size, int chromosome_num, int chromosome_length,
               double max_value, double min_value, int iter_num, double deta) {
        this.population_size = population_size;
        this.chromosome_num = chromosome_num;
        this.chromosome_length = chromosome_length;
        this.max_value = max_value;
        this.min_value = min_value;
        this.iter_num = iter_num;
        this.deta = deta;
    }

    /**
     * 种群的量子形式初始化
     */
    public List<double[][]> species_origin_angle(){
        //种群的量子角度列表
        List<double[][]> population_Angle  = new ArrayList<>();
        for (int i = 0; i < chromosome_num; i++) {
            //存储每个染色体所有取值的量子角度
            double[][] tmp1 = new double[population_size][];
            for (int j = 0; j <population_size ; j++) {
                //存储量子角度
                double[] tmp2 = new double[chromosome_length];
                for (int k = 0; k < chromosome_length; k++) {
                    tmp2[k] = 3.14 * 2 * Math.random();
                }
                tmp1[j] = tmp2;
            }
            population_Angle.add(tmp1);
        }
        return population_Angle ;
    }

    /**
     * 将初始化的量子角度序列转换为种群的量子系数列表
     * @param population_Angle
     * @return
     */
    public List<double[][][]> population_Q(List<double[][]> population_Angle){
        //种群的量子系数列表
        List<double[][][]> population_Q  = new ArrayList<>();
        int size = population_Angle.size();
        for (int i = 0; i < size ; i++) {
            int length1 = population_Angle.get(i).length;
            //存储每个染色体所有取值的量子系数对
            double[][][] tmp1 = new double[length1][2][];
            for (int j = 0; j < length1; j++) {
                int length2 = population_Angle.get(i)[j].length;
                //存储每个染色体的每个取值的量子对
                double[][] tmp2 = new double[2][];
                //存储量子对的一半
                double[] tmp3 = new double[length2];
                //存储量子对的另一半
                double[] tmp4 = new double[length2];
                for (int k = 0; k < length2; k++) {
                        tmp3[k] = Math.sin(population_Angle.get(i)[j][k]);
                        tmp4[k] = Math.cos(population_Angle.get(i)[j][k]);
                }
                tmp2[0] = tmp3;
                tmp2[1] = tmp4;
                tmp1[j] = tmp2;
            }
            population_Q.add(tmp1);
        }
        return population_Q;
    }

    /**
     * 计算适应度函数值
     * 将种群的量子列表转换为二进制列表
     * @param population_Q 种群的量子列表
     * @return population_Binary:种群的二进制列表
     */
    public List<double[][]> translation(List<double[][][]> population_Q){
        //种群的二进制列表
        List<double[][]> population_Binary   = new ArrayList<>();
        int size = population_Q.size();
        for (int i = 0; i < size; i++) {
            int length1 = population_Q.get(i).length;
            double[][] tmp1 = new double[length1][];
            for (int j = 0; j < length1 ; j++) {
                int length2 = population_Q.get(i)[j][0].length;
                double[] tmp2  = new double[length2];
                for (int k = 0; k < length2; k++) {
                    if(Math.pow(population_Q.get(i)[j][0][k],2)>Math.random()){
                        tmp2[k] = 1;
                    }else {
                        tmp2[k] = 0;
                    }
                }
                tmp1[j] = tmp2;
            }
            population_Binary.add(tmp1);
        }
        return population_Binary;
    }

    /**
     * 求适应度函数数值列表
     * @param population_Binary 种群的二进制列表
     * @return
     */
    public Map<String, Object> fitness(List<double[][]> population_Binary){
        int size = population_Binary.size();
        //1 . 对应寻优参数的列表,存储所有参数的可能取值
        //染色体的二进制表现形式转换为十进制并设置在[min_value,max_value]之间   解码
        double[][] parameters   = new double[size][];
        for (int i = 0; i <size ; i++) {
            int lenght1 = population_Binary.get(i).length;
            double[] tmp1 = new double[lenght1];
            for (int j = 0; j < lenght1; j++) {
                double total = 0.0;
                int lenght2 = population_Binary.get(i)[j].length;
                for (int k = 0; k < lenght2; k++) {
                    //计算二进制对应的十进制数值
                    total += population_Binary.get(i)[j][k] * Math.pow(2,k);
                }
                //将十进制数值坐落在[min_value,max_value]之间
                double value = (total*(max_value-min_value)) / Math.pow(2,lenght2) + min_value;
                tmp1[j] = value;
            }
            parameters[i] = tmp1;
        }
        int lenght3 = parameters[0].length;
        // 2 求适应度
        double[] fitness_value = new double[lenght3];
        for (int i = 0; i < lenght3; i++) {
            fitness_value[i] = Math.pow(Math.E, -0.001*parameters[0][i]) * Math.pow(0.8*parameters[0][i],2);
        }
        //3.找到最优的适应度函数值和对应的参数二进制表现形式
        double best_fitness = 0.0;
        int pb = population_Binary.get(0)[0].length;
        double[][] best_parameter_Binary = new double[size][];
        double[][] best_parameter = new double[size][];
        for (int i = 0; i <size ; i++) {
            best_parameter_Binary[i] = new double[pb];
            best_parameter[i] = new double[pb];
        }
        int len1 = population_Binary.get(0).length;
        for (int i = 0; i < len1; i++) {
            if(best_fitness<fitness_value[i]){
                best_fitness = fitness_value[i];
                for (int j = 0; j < size; j++) {
                    best_parameter_Binary[j] = population_Binary.get(j)[i];
                    best_parameter[j] = parameters[j];
                }
            }
        }
        Map<String , Object> map = new HashMap<>();
        map.put("parameters",parameters);
        map.put("fitness_value",fitness_value);
        map.put("best_parameter_Binary",best_parameter_Binary);
        map.put("best_fitness",best_fitness);
        map.put("best_parameter",best_parameter);
        return map;
    }

    /**
     * 全干扰交叉
     * 对种群量子角度列表进行全干扰交叉
     * @param population_Angle
     */
    public double[][][] crossover(List<double[][]> population_Angle){
        //初始化一个空列表，全干扰交叉后的量子角度列表
        double[][][] population_Angle_crossover = new double[population_Angle.size()][][];
        for (int i = 0; i < chromosome_num; i++) {
            double[][] tmp11 = new double[population_size][chromosome_length];
            for (int j = 0; j < population_size; j++) {
                double[] tmp12 = new double[chromosome_length];
                for (int k = 0; k < chromosome_length; k++) {
                    tmp12[k] = 0.0;
                }
                tmp11[j] = tmp12;
            }
            population_Angle_crossover[i] = tmp11;
        }
        int size = population_Angle.size();
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < population_Angle.get(i).length; j++) {
                for (int k = 0; k <population_Angle.get(i)[j].length ; k++) {
                    int ni = (j-k+population_Angle.get(i).length) % population_Angle.get(i).length;
                    population_Angle_crossover[i][j][k] = population_Angle.get(i)[ni][k];
                }
            }
        }
        return population_Angle_crossover;
    }

    /**
     * 采用量子门变换矩阵进行量子变异
     * @param population_Angle_crossover 全干扰交叉后的量子角度列表
     * @param population_Angle 种群的量子角度列表
     * @param best_parameter_Binary 种群的二进制列表
     * @param best_fitness 找到最优的适应度函数值和对应的参数二进制表现形式
     */
    public List<double[][]>  mutation(double[][][] population_Angle_crossover,List<double[][]> population_Angle,double[][] best_parameter_Binary,double best_fitness){
        List<double[][]> list = new ArrayList<>();
        for (int i = 0; i <population_Angle_crossover.length ; i++) {
            list.add(population_Angle_crossover[i]);
        }
        //交叉后的种群量子系数列表
        List<double[][][]> population_Q_crossover  = population_Q(list);
        //交叉后的种群二进制数列表
        List<double[][]> population_Binary_crossover  = translation(population_Q_crossover);
        Map<String , Object> map = fitness(population_Binary_crossover);
        //求出交叉后的适应度函数值列表
        double[][] parameters = (double[][])map.get("parameters");
        double[] fitness_crossover = (double[])map.get("fitness_value");
        double[][] best_parameter_Binary_crossover = (double[][])map.get("best_parameter_Binary");
        double best_fitness_crossover = (double)map.get("best_fitness");
        //初始化每一个量子位的旋转角度
        double[][][] Rotation_Angle = new double[population_Angle_crossover.length][][];
        for (int i = 0; i < population_Angle_crossover.length; i++) {
            int length = population_Angle_crossover[i].length;
            double[][] tmp1 = new double[length][];
            for (int j = 0; j < length; j++) {
                int length2 = population_Angle_crossover[i][j].length;
                double[] tmp2 = new double[length2];
                for (int k = 0; k < length2; k++) {
                    tmp2[k] = 0.0;
                }
                tmp1[j] = tmp2;
            }
            Rotation_Angle[i] = tmp1;
        }
        double deta2 = deta;
        //求每个量子位的旋转角度
        for (int i = 0; i < chromosome_num; i++) {
            for (int j = 0; j <population_size ; j++) {
                if(fitness_crossover[j] <= best_fitness){
                    for (int k = 0; k < chromosome_length; k++) {
                        int s1 = 0;
                        double a1 = population_Q_crossover.get(i)[j][0][k];
                        double b1 = population_Q_crossover.get(i)[j][1][k];
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==0 && a1*b1>0)
                            s1 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==0 && a1*b1<0)
                            s1 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==0 && a1*b1==0)
                            s1 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==1 && a1*b1>0)
                            s1 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==1 && a1*b1<0)
                            s1 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==1 && a1*b1==0)
                            s1 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==0 && a1*b1>0)
                            s1 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==0 && a1*b1<0)
                            s1 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==0 && a1*b1==0)
                            s1 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==1 && a1*b1>0)
                            s1 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==1 && a1*b1<0)
                            s1 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==1 && a1*b1==0)
                            s1 = 1;
                        Rotation_Angle[i][j][k] = deta2 * s1;
                    }
                }else {
                    for (int k = 0; k < chromosome_length; k++) {
                        int s2 = 0;
                        double a2 = population_Q_crossover.get(i)[j][0][k];
                        double b2 = population_Q_crossover.get(i)[j][1][k];
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==0 && a2*b2>0)
                            s2 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==0 && a2*b2<0)
                            s2 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==0 && a2*b2==0)
                            s2 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==1 && a2*b2>0)
                            s2 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==1 && a2*b2<0)
                            s2 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 0 && best_parameter_Binary[i][k]==1 && a2*b2==0)
                            s2 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==0 && a2*b2>0)
                            s2 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==0 && a2*b2<0)
                            s2 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==0 && a2*b2==0)
                            s2 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==1 && a2*b2>0)
                            s2 = 1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==1 && a2*b2<0)
                            s2 = -1;
                        if (population_Binary_crossover.get(i)[j][k] == 1 && best_parameter_Binary[i][k]==1 && a2*b2==0)
                            s2 = 1;
                        Rotation_Angle[i][j][k] = deta2 * s2;
                    }
                }
            }
        }
        //根据每个量子位的旋转角度，生成种群新的量子角度列表
        for (int i = 0; i < chromosome_num; i++) {
            for (int j = 0; j < population_size; j++) {
                for (int k = 0; k < chromosome_length; k++) {
                    population_Angle.get(i)[j][k] = population_Angle.get(i)[j][k] + Rotation_Angle[i][j][k];
                }
            }
        }
        return population_Angle;
    }

    public static void main(String[] args) {

        /**种群数**/
        int population_size = 20;
        /**染色体数，对应需要寻优的参数个数**/
        int chromosome_num = 10;
        /**染色体长度**/
        int chromosome_length = 10;
        /**染色体十进制数值最大值**/
        double max_value = 20;
        /**染色体十进制数值最小值**/
        double min_value = 1;
        /**迭代次数**/
        int iter_num = 50;
        /**量子旋转角度  **/
        double deta = 0.2;
        double[] results = new double[iter_num];
        double best_fitness = 0.0;
        double[][] best_parameter = new double[20][];
        QGA qga = new QGA(population_size,chromosome_num,chromosome_length,max_value,min_value,iter_num,deta);
        //种群初始化
        List<double[][]> population_Angle = qga.species_origin_angle();
        for (double[][] a:population_Angle) {
            System.err.println("【");
            for (int i = 0; i <a.length ; i++) {
                for (int j = 0; j < a[i].length; j++) {
                    System.err.print(a[i][j]+" ");
                }
            }
            System.err.println("】");
        }
        for (int i = 0; i < iter_num ; i++) {
            List<double[][][]> population_Q  = qga.population_Q(population_Angle);
            //将量子系数转换为二进制形式
            List<double[][]> population_Binary  = qga.translation(population_Q);
            //计算本次迭代的适应度函数值列表，最优适应度函数值及对应的参数
            Map<String , Object> map = qga.fitness(population_Binary);
            //求出交叉后的适应度函数值列表
            double[][] parameters = (double[][])map.get("parameters");
            double[] fitness_value = (double[])map.get("fitness_value");
            double[][] current_parameter_Binary = (double[][])map.get("best_parameter_Binary");
            double current_fitness = (double)map.get("best_fitness");
            double[][] current_parameter  = (double[][])map.get("best_parameter");
            if(current_fitness>best_fitness){
                best_fitness = current_fitness;
                best_parameter = current_parameter;
            }
            System.out.println("iteration is :"+i+1+";Best parameters:");
            for (int j = 0; j < best_parameter.length; j++) {
                System.out.print("【");
                for (int k = 0; k <best_parameter[j].length ; k++) {
                    System.out.print(best_parameter[j][k]+" ");
                }
                System.out.print("】");
            }
            System.out.println(";Best fitness:"+best_fitness);
            System.out.println();
            System.out.println();
            results[i] = best_fitness;
            //全干扰交叉
            double[][][] population_Angle_crossover  = qga.crossover(population_Angle);
            //量子旋转变异
            population_Angle  = qga.mutation(population_Angle_crossover,population_Angle,current_parameter_Binary,current_fitness);
        }
        System.out.println("Final results are :'"+ Arrays.toString(results));
        System.out.println("Final parameters are :'"+ Arrays.toString(best_parameter[best_parameter.length-1]));
    }
}

下面是程序运行产生的结果，我没有想转载的那位大佬用图画出来了
在这里插入图片描述
这篇文章理论讲的很好，可以看看学习学习 --------量子遗传算法详解

1024-iot-SaltIce
关注
专栏目录
QGA 量子遗传算法
06-18
完全可用的量子遗传算法, matlab语言
【超参数寻优】量子遗传算法（QGA） 超参数寻优的python实现
Luqiang_Shi的博客
12-01 9406
【寻优算法】量子遗传算法（QGA） 参数寻优的python实现：多参数寻优一、量子编码1、染色体量子编码2、量子编码转换为二进制编码二、量子进化1、全干扰交叉2、量子变异三、QGA多参数寻优的python实现1、训练模型及待寻优参数2、QGA算法的python代码参考资料 遗传算法用于模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，种群通过选择、交叉和变异操作使染色体的十进制数...
QGA_python-master_量子遗传算法_量子遗传_
09-29
量子原理和遗传算法结合的一种计算智能算法
a算法TSP旅行商java_模拟退火算法SA原理及python、java、php、c++语言代码实现TSP旅行商问题，智能优化算法，随机寻优算法，全局最短路径...
weixin_42558257的博客
02-26 402
模拟退火算法SA原理及python、java、php、c++语言代码实现TSP旅行商问题，智能优化算法，随机寻优算法，全局最短路径模拟退火算法(Simulated Annealing，SA)最早的思想是由N. Metropolis等人于1953年提出。1983 年,S. Kirkpatrick 等成功地将退火思想引入到组合优化领域。来源于固体退火原理，将固体加温至充分高，再让其徐徐冷却，加温时，固...
基于量子遗传算法的函数寻优算法
04-22
基于量子遗传算法的函数寻优算法。。。。。。。。。。。
QGA.rar_qga_寻优算法_量子遗传算法
07-15
量子遗传算法的matlab原程序，寻优精度高，收敛速度快
毕业设计项目源码-使用Matlab基于量子遗传算法的函数寻优算法实现.zip
最新发布
05-22
《基于量子遗传算法的函数寻优算法在Matlab中的实现》 毕业设计是学术生涯中的一个重要环节，它要求学生综合运用所学知识解决实际问题。本项目以“使用Matlab基于量子遗传算法的函数寻优算法实现”为主题，旨在探讨...
QuantumGeneticAlgorithms_量子遗传算法_量子_量子遗传_qga_遗传算法_
09-28
量子遗传算法(Quantum Genetic Algorithm, QGA)是一种结合了量子计算理论与传统遗传算法的优化技术，旨在解决复杂问题的全局寻优。在传统的遗传算法中，通过模拟自然选择、遗传、变异等过程来搜索解决方案空间。而...
量子遗传算法matlab程序,遗传算法matlab实现,matlab
09-10
首先，我们需要理解量子遗传算法（Quantum Genetic Algorithm, QGA）的基本原理。量子遗传算法源自遗传算法，后者是一种模拟生物进化过程的搜索算法，通过模拟“适者生存”的自然选择机制，不断优化种群中的个体，以...
量子遗传算法
09-16
量子是最近几年与智能算法结合的比较密切，可以用在不同场合，里面详细讲解量子与遗传算法结合的程序
java遗传算法寻找最优路径
01-01
该代码很好的实现了用遗传算法寻优最优路径问题
量子遗传算法代码
08-30
量子遗传算法，一步一步，注释详尽
【优化算法】量子遗传优化算法（QGA）【含Matlab源码 1123期】.zip
10-11
完整代码，可直接运行
基于量子遗传算法的函数寻优算法(matlab实现)
配电网和matlab的博客
05-27 2178
在每一次迭代中，首先对种群进行测量，以获得一组确定解P(t),然后计算每个解的适应度值，再根据当前的演化目标和事先确定的调整策略，利用量子旋转门对种群中的个体进行调整，获得更新后的种群，记录下当前的最优解，并与当前的目标值进行比较，如果大于当前目标值，则以新的最优解作为下一次迭代的目标值，否则保持当前的目标值不变。量子遗传算法建立在量子的态矢量表示的基础之上，将量子比特的几率幅表示应用于染色体的编码，使得一条染色体可以表达多个态的叠加，并利用量子逻辑门实现染色体的更新操作，从而实现了目标的优化求解。
贪心算法 - Java实现面值问题两种策略寻找最优
云梦归遥【qq_45834685】
05-21 433
贪心算法 - Java实现面值问题两种策略寻找最优
【优化算法】量子遗传优化算法（QGA）【含Matlab源码 1123期】
订阅2025年付费专栏Matlab（119.9元版），可赠送奶茶价版付费专栏任意代码1份；
07-15 1586
1 引言2 遗传算法理论2.1 遗传算法的生物学基础2.2 遗传算法的理论基础2.3 遗传算法的基本概念2.4 标准的遗传算法2.5 遗传算法的特点2.6 遗传算法的改进方向3 遗传算法流程4 关键参数说明。
Matlab量子遗传算法源码：函数寻优技术参考
量子遗传算法(QGA)是一种启发式搜索算法，借鉴量子计算和遗传算法的思想，旨在解决传统遗传算法在寻优过程中可能遇到的早熟收敛、局部搜索能力不足等问题。QGA利用量子比特的叠加态和量子纠缠特性，提高种群多样性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值