java两阶段混合蚁群算法蚁群算法java实现

转载

mob6454cc74e2cb 2024-08-09 12:08:18

文章标签 java两阶段混合蚁群算法算法 java 优化 distance 文章分类 Java 后端开发

蚁群算法简介

蚁群算法是群智能算法的一种，所谓的群智能是一种由无智能或简单智能的个体通过任何形式的聚集协同而表现出智能行为，它为在没有集中控制且不提供全局模型的前提下寻找复杂的分布式问题求解方案提供了基础，比如常见的蚂蚁觅食，大雁南飞等行为。蚁群算法是模拟自然界中蚂蚁觅食的一种随机搜索算法，由Dorigo等人于1991年在第一届欧洲人工生命会议上提出^[1] 。

蚁群算法的生物原理

通过观察发现，蚁群在觅食的时候，总能找到一条从蚁巢到食物之间的一条最短的路径。这个现象引起了生物学家的注意，根据研究，原来是蚂蚁在行进的过程中，会分泌一种化学物质——信息素，而蚂蚁在行进时，总是倾向于选择信息素浓度比较高的路线。这样，在蚁巢和食物之间假如有多条路径，初始的时候，每条路径上都会有蚂蚁爬过，但是随着时间的推迟，单位时间内最短的那条路上爬过的蚂蚁数量会比较多，释放的信息素就相对来说比较多，那么以后蚂蚁选择的时候会大部分都选择信息素比较多的路径，从而会把最短路径找出来。

蚁群算法正是模拟这种蚁群觅食的原理，构造人工蚂蚁，用来求解许多组合优化问题。

有关蚁群算法的详细信息，可参考[2]——[5]。

蚁群算法的JAVA实现

我个人认为利用JAVA编写一些计算密集型的算法不是一个好的选择。本身一些算法是要要求高效率的，但是我感觉JAVA语言的性能不够，所以编写算法最好用c，其次也可以用c++。当然，这仅是一家之言，欢迎拍砖。

此处使用JAVA的原因是为了演示算法的框架，给出一种思路，如果需要c++的参考，可以参考 http://fashionxu.blogchina.com,如果需要c的代码，可以上 http://iridia.ulb.ac.be/~mdorigo/ACO/ACO.html, 这个可以看作是ACO的官方网站了，里面的内容比较多。

算法说明

算法以求解TSP问题为例，用来演示ACO的框架。

算法设定了两个类，一个是ACO，用来处理文件信息的读入，信息素的更新，路径的计算等；另一个是ant，即蚂蚁的信息。

算法中用到的数据，可以从TSPLib 上面下载，使用的是对称TSP数据，为了简化算法的代码，下载下来的数据需要做一个简单处理，即把TSP文件中除去城市节点信息部分之外的内容都删除掉，然后在文件首插入一行，写入此文件包含的城市的数目，以att48.tsp为例，下载下来的文件内容如下：

NAME : att48
 COMMENT : 48 capitals of the US (Padberg/Rinaldi)
 TYPE : TSP
 DIMENSION : 48
 EDGE_WEIGHT_TYPE : ATT
 NODE_COORD_SECTION
 1 6734 1453
 2 2233 10
 3 5530 1424
 4 401 841
 5 3082 1644
 6 7608 4458
 7 7573 3716
 8 7265 1268
 9 6898 1885
 10 1112 2049
 11 5468 2606
 12 5989 2873
 13 4706 2674
 14 4612 2035
 15 6347 2683
 16 6107 669
 17 7611 5184
 18 7462 3590
 19 7732 4723
 20 5900 3561
 21 4483 3369
 22 6101 1110
 23 5199 2182
 24 1633 2809
 25 4307 2322
 26 675 1006
 27 7555 4819
 28 7541 3981
 29 3177 756
 30 7352 4506
 31 7545 2801
 32 3245 3305
 33 6426 3173
 34 4608 1198
 35 23 2216
 36 7248 3779
 37 7762 4595
 38 7392 2244
 39 3484 2829
 40 6271 2135
 41 4985 140
 42 1916 1569
 43 7280 4899
 44 7509 3239
 45 10 2676
 46 6807 2993
 47 5185 3258
 48 3023 1942
 EOF修改之后，内容变为如下：
 
48
 1 6734 1453
 2 2233 10
 3 5530 1424
 4 401 841
 5 3082 1644
 6 7608 4458
 7 7573 3716
 8 7265 1268
 9 6898 1885
 10 1112 2049
 11 5468 2606
 12 5989 2873
 13 4706 2674
 14 4612 2035
 15 6347 2683
 16 6107 669
 17 7611 5184
 18 7462 3590
 19 7732 4723
 20 5900 3561
 21 4483 3369
 22 6101 1110
 23 5199 2182
 24 1633 2809
 25 4307 2322
 26 675 1006
 27 7555 4819
 28 7541 3981
 29 3177 756
 30 7352 4506
 31 7545 2801
 32 3245 3305
 33 6426 3173
 34 4608 1198
 35 23 2216
 36 7248 3779
 37 7762 4595
 38 7392 2244
 39 3484 2829
 40 6271 2135
 41 4985 140
 42 1916 1569
 43 7280 4899
 44 7509 3239
 45 10 2676
 46 6807 2993
 47 5185 3258
 48 3023 1942

这么做仅是为了方便处理，也可以根据TSPLib给出的文件格式而自己写代码读取。

算法流程图

此处实现的算法应该是AS（Ant System），其算法流程如下：

算法代码

package tspsolver;
import java.util.Random;
/**
 *蚂蚁类
 * @author FashionXu
 */
public class ant {
    /**
     * 蚂蚁获得的路径
     */
    public int[]tour;
    //unvisitedcity 取值是0或1，
    //1表示没有访问过，0表示访问过
    int[] unvisitedcity;
    /**
     * 蚂蚁获得的路径长度
     */
    public int tourlength;
    int citys;
/**
 * 随机分配蚂蚁到某个城市中
 * 同时完成蚂蚁包含字段的初始化工作
 * @param citycount 总的城市数量
 */
    public void RandomSelectCity(int citycount){
        citys=citycount;
        unvisitedcity=new int[citycount];
        tour=new int[citycount+1];
        tourlength=0;
        for(int i=0;i<citycount;i++){
            tour[i]=-1;
            unvisitedcity[i]=1;
        }
        long r1 = System.currentTimeMillis();
        Random rnd=new Random(r1);
        int firstcity=rnd.nextInt(citycount);
        unvisitedcity[firstcity]=0;
        tour[0]=firstcity;
    }
    /**
     * 选择下一个城市
     * @param index 需要选择第index个城市了
     * @param tao   全局的信息素信息
     * @param distance  全局的距离矩阵信息
     */
    public void SelectNextCity(int index,double[][]tao,int[][]distance){
        double []p;
        p=new double[citys];
        double alpha=1.0;
        double beta=2.0;
        double sum=0;
        int currentcity=tour[index-1];
        //计算公式中的分母部分
        for(int i=0;i<citys;i++){
            if(unvisitedcity[i]==1)
                sum+=(Math.pow(tao[currentcity][i], alpha)*
                        Math.pow(1.0/distance[currentcity][i], beta));
        }
        //计算每个城市被选中的概率
        for(int i=0;i<citys;i++){
            if(unvisitedcity[i]==0)
                p[i]=0.0;
            else{
                p[i]=(Math.pow(tao[currentcity][i], alpha)*
                        Math.pow(1.0/distance[currentcity][i], beta))/sum;
            }
        }
        long r1 = System.currentTimeMillis();
        Random rnd=new Random(r1);
        double selectp=rnd.nextDouble();
        //轮盘赌选择一个城市；
        double sumselect=0;
        int selectcity=-1;
        for(int i=0;i<citys;i++){
            sumselect+=p[i];
            if(sumselect>=selectp){
                selectcity=i;
                break;
            }
        }
        if (selectcity==-1)
            System.out.println();
        tour[index]=selectcity;
        unvisitedcity[selectcity]=0;
    }
    /**
     * 计算蚂蚁获得的路径的长度
     * @param distance  全局的距离矩阵信息
     */
    public void CalTourLength(int [][]distance){
        tourlength=0;
        tour[citys]=tour[0];
        for(int i=0;i<citys;i++){
            tourlength+=distance[tour[i]][tour[i+1]];
        }    
    }
}

package tspsolver;
import java.io.*;
/**
 *蚁群优化算法，用来求解TSP问题
 * @author FashionXu
 */
public class ACO {
    //定义蚂蚁群
    ant []ants;
    int antcount;//蚂蚁的数量
    int [][]distance;//表示城市间距离
    double [][]tao;//信息素矩阵
    int citycount;//城市数量
    int[]besttour;//求解的最佳路径
    int bestlength;//求的最优解的长度
    /** 初始化函数
     *@param filename tsp数据文件
     *@param antnum 系统用到蚂蚁的数量
     *@throws 如果文件不存在则抛出异常
    */
    public void init(String filename,int antnum) throws FileNotFoundException, IOException{
        antcount=antnum;
        ants=new ant[antcount];
        //读取数据
        int[] x;
        int[] y;
        String strbuff;
        BufferedReader tspdata = new BufferedReader(new InputStreamReader(new FileInputStream(filename)));
        strbuff = tspdata.readLine();
        citycount = Integer.valueOf(strbuff);
        distance = new int[citycount][citycount];
        x = new int[citycount];
        y = new int[citycount];
        for (int citys = 0; citys < citycount; citys++) {
            strbuff = tspdata.readLine();
            String[] strcol = strbuff.split(" ");
            x[citys] = Integer.valueOf(strcol[1]);
            y[citys] = Integer.valueOf(strcol[2]);
        }
        //计算距离矩阵
        for (int city1 = 0; city1 < citycount - 1; city1++) {
            distance[city1][city1] = 0;
            for (int city2 = city1 + 1; city2 < citycount; city2++) {
                distance[city1][city2] = (int) (Math.sqrt((x[city1] - x[city2]) * (x[city1] - x[city2])
                        + (y[city1] - y[city2]) * (y[city1] - y[city2])) + 0.5);
                distance[city2][city1] = distance[city1][city2];
            }
        }
        distance[citycount - 1][citycount - 1] = 0;
        //初始化信息素矩阵
        tao=new double[citycount][citycount];
        for(int i=0;i<citycount;i++)
        {
            for(int j=0;j<citycount;j++){
                tao[i][j]=0.1;
            }
        }
        bestlength=Integer.MAX_VALUE;
        besttour=new int[citycount+1];
        //随机放置蚂蚁
        for(int i=0;i<antcount;i++){
            ants[i]=new ant();
            ants[i].RandomSelectCity(citycount);
        }
    }
    /**
     * ACO的运行过程
     * @param maxgen ACO的最多循环次数
     * 
     */
    public void run(int maxgen){
        for(int runtimes=0;runtimes<maxgen;runtimes++){
            //每一只蚂蚁移动的过程
            for(int i=0;i<antcount;i++){
                for(int j=1;j<citycount;j++){
                    ants[i].SelectNextCity(j,tao,distance);
                }
                //计算蚂蚁获得的路径长度
                ants[i].CalTourLength(distance);
                if(ants[i].tourlength<bestlength){
                    //保留最优路径
                    bestlength=ants[i].tourlength;
                    System.out.println("第"+runtimes+"代，发现新的解"+bestlength);
                    for(int j=0;j<citycount+1;j++)
                        besttour[j]=ants[i].tour[j];
                }
            }
            //更新信息素矩阵
            UpdateTao();
            //重新随机设置蚂蚁
            for(int i=0;i<antcount;i++){
                ants[i].RandomSelectCity(citycount);
            }
        }
       }
    /**
     * 更新信息素矩阵
     */
    private void UpdateTao(){
        double rou=0.5;
        //信息素挥发
        for(int i=0;i<citycount;i++)
            for(int j=0;j<citycount;j++)
                tao[i][j]=tao[i][j]*(1-rou);
        //信息素更新
        for(int i=0;i<antcount;i++){
            for(int j=0;j<citycount;j++){
                tao[ants[i].tour[j]][ants[i].tour[j+1]]+=1.0/ants[i].tourlength;
            }
        }
    }
    /**
     * 输出程序运行结果
     */
    public void ReportResult(){
        System.out.println("最优路径长度是"+bestlength);
    }
}

package tspsolver;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *主程序 调用ACO求解问题
 * @author FashionXu
 */
public class Main {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        ACO aco;
        aco=new ACO();
        try {
            aco.init("e://eil51.tsp", 50);
            aco.run(2000);
            aco.ReportResult();
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

一些额外说明

算法只是提供了一个框架，没有对算法做优化处理，也没有做一些错误检查之类的，因此在实际运行时难免可能会有出错的时候，请使用者注意。

参考文献

[1]M. Dorigo, V. Maniezzo and A. Colorni, Positive Feedback as a Search Strategy. Technical Report No. 91-016, Politecnico di Milano, Italy, 1991. Later published as Optimization by a colony of cooperating agents, IEEE Transactions on Systems, Man, and Cybernetics-Part B, 26(1):29-41,1996. TR.01-ANTS-91-016.ps.gz , IJ.10-SMC96.pdf

[2]M. Dorigo, V. Maniezzo & A. Colorni, Ant System: Optimization by a colony of cooperating agents. IEEE Transactions on Systems, Man, and Cybernetics-Part B, 26(1):29-41,1996. IJ.10-SMC96.pdf

o [3]Dorigo, Stutzle M. T.,张军译.蚁群优化.北京：清华大学出版社,2007
[4]http://www.aco-metaheuristic.org/
[5]http://iridia.ulb.ac.be/~mdorigo/HomePageDorigo/

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。