蚁群算法及蚂蚁系统的原理（js实现版）

蚁群算法
旅行商问题
蚁群系统
代码实现

蚁群算法

蚁群算法是著名的启发式算法，常用于解决最短路径问题

蚁群算法的来源

蚁群算法来源于对蚂蚁寻找食物行为的观察，蚂蚁个体并不存在太高的智慧，但蚁群整体却可以通过信息素来找到通往食物的最短路径

蚁群算法的原理

假设从a点到b点存在2条路径，而第一条路径l短，第二条路径m长。
刚开始时走l和m是随机的，但是由于l更短，所以重复频率也就更高，而留下的信息素浓度也就更高。
最终，大部分蚂蚁都会走l而不走m，这样也就是找到了最短路径。

旅行商问题

假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。这就是TSP，属于NPC问题。

使用图论来描述TSP问题

已知有n个点的完全图，每条边都有一个长度，求总长度最短的经过每个顶点正好一次的封闭回路

蚁群系统

蚁群系统是第一个满足蚁群算法框架的算法

使用蚁群系统来解决TSP问题，其伪代码如下

function AntSystem () {Init()// 初始化 蚂蚁、图、信息素while(!isConvergence()) {// 如果未收敛或不满足其他停止条件则继续ContructSolution()// 对每个蚂蚁构造解PheromoneUpdate()// 信息素更新}
}

初始化

1.初始化节点与路径，并根据节点与路径生成图
2.初始化信息素，每条路径上的信息素都相等
3.随机化蚂蚁，使其分布于某一节点中，也可以不使用随机化。每个蚂蚁都会存储走过的路径与剩下可走的路径

蚂蚁抉择

对于每个蚂蚁，会从接下来可走的路径中进行选择，选择按照概率进行。
选择其中一条路径的计算公式为

p = 所选路径信息素*能见度 / 求和(每个路径的信息素*每个路径的能见度)

其中能见度为:
能见度 = 1/路径距离

选择其中一条路径后将该路径从未走路径加入到已走路径

信息素更新

在每个蚂蚁都走完后将更新信息素

每个路径上的信息素 = 原信息素*信息素挥发率 + 求和(1/每个经过该路径上的蚂蚁其行走总路径长度)

其中的信息素挥发率为0到1之间的常数，如果过低则难以收敛，过高则容易陷入局部最优解

终止条件

如果某一路径信息素要明显大于其余所有边的信息素的和则可以认定该路径满足收敛条件。
如果循环的次数超出最大则判断收敛失败。

代码实现

生成图代码

function Graph() {}Graph.prototype.setNode = (nodeArr, nodeMatrix) => {this.nodeArr = nodeArr;// 邻接矩阵// 矩阵中为null则代表该方向没有边this.nodeMatrix = nodeMatrix;};Graph.prototype.setValue = (start, end, value) => {const startNodeIndex = getNodeIndex(start, this.nodeArr);const endNodeIndex = getNodeIndex(end, this.nodeArr);if (startNodeIndex === -1 || endNodeIndex === -1) return;this.nodeMatrix[startNodeIndex][endNodeIndex] = value;};Graph.prototype.getValue = (start, end) => {const startNodeIndex = getNodeIndex(start, this.nodeArr);const endNodeIndex = getNodeIndex(end, this.nodeArr);if (startNodeIndex === -1 || endNodeIndex === -1) {debuggerreturn;}return this.nodeMatrix[startNodeIndex][endNodeIndex];};Graph.prototype.addValue = (start, end, value) => {const startNodeIndex = getNodeIndex(start, this.nodeArr);const endNodeIndex = getNodeIndex(end, this.nodeArr);if (startNodeIndex === -1 || endNodeIndex === -1) return;this.nodeMatrix[startNodeIndex][endNodeIndex] += value;};Graph.prototype.each = cb => {this.nodeMatrix.forEach((item, x) => {item.forEach((ite, y) => {if (ite !== null) {cb && cb(ite, x, y);}})})};Graph.prototype.xEach = cb => {this.nodeMatrix.forEach(cb);};Graph.prototype.getXArr = index => {if (index < 0) throw new Error('index不可小于0');return this.nodeMatrix[index];};const getNodeIndex = (node, nodeArr) => {return nodeArr.findIndex(x => x === node);};

蚁群系统代码

function AntSystem(nodeArr, nodeMatrix) {this.nodeArr = nodeArr;this.nodeMatrix = nodeMatrix;}AntSystem.prototype.init = function(theta) {this.theta = theta;this.graph = new Graph();this.nodeMatrix.forEach(item => {item.forEach((ite, i) => {// l: 距离// w: 信息素const l = ite;if (l !== null) {const w = 10;item[i] = {l, w}}})});this.graph.setNode(this.nodeArr, this.nodeMatrix);const ant = [];this.nodeArr.forEach(x => {ant.push({road: [x],});});this.ant = ant;};AntSystem.prototype.math = function() {// 计算最大迭代次数const antLen = this.ant.length;const nodeLen = this.nodeLen = this.nodeArr.length;const n = nodeLen - 1;const lineNum = this.lineNum = (n*n + n) / 2; // 路径的数量const maxNum = lineNum*lineNum; // 最大迭代次数let i = 0;let result;for (; i < maxNum; i++) {for (let j = 0; j < n; j++) {for (let k = 0; k < antLen; k++) {const nowAnt = this.ant[k];this.antChoice(nowAnt);}}this.systemUpdate();// 收敛判断result = this.isConvergence();if (result.success){break;}}result.twice = i;return result;};AntSystem.prototype.antChoice = function(ant) {const antRoad = ant.road;const antNowNode = antRoad[antRoad.length - 1];// 获取接下来可选的行走路径let roadList = this.nodeArr.filter(x=>antRoad.indexOf(x) === -1);if (roadList.length === 1) {antRoad.push(roadList[0]);return;}if (roadList.length === 0) {throw new Error('获取路径列表错误')}// 获取可行走路径的权重let weightList = [];roadList.forEach(x => {const obj = this.graph.getValue(antNowNode, x);let value = obj.w*(1/obj.l);if (!value) {value = 0;}weightList.push(value);});// 获取权重总和，以及根据根据修改后的权重以及随机数来判断走哪条路let total = 0;weightList.forEach((x, i) => {total += x;weightList[i] = total;});const random = Math.random() * total;// 根据随机数计算下一步走哪const weightIndex = weightList.findIndex(x => random < x);if (weightIndex === -1) {throw new Error('权重计算错误');} else {antRoad.push(roadList[weightIndex]);}};AntSystem.prototype.systemUpdate = function() {// 信息发挥率const theta = this.theta;// 根据挥发率重新计算权重this.graph.each(item => {item.w *= theta*1;});// 根据每个蚂蚁的行走路径计算总行走距离 lconst totalWalkList = this.ant.map(x => {let road = x.road;road.push(road[0]);let len = 0;for (let i = 1; i < road.length; i++) {const obj = this.graph.getValue(road[i-1], road[i]);len += obj.l;}return len;});// 根据距离为每条路径重新计算权重this.ant.forEach((x, i) => {const road = x.road;// 计算当前蚂蚁产生的信息素const thisAntWalkLen = totalWalkList[i];const pheromone = 1/thisAntWalkLen;for (let i = 1; i < road.length; i++) {const obj = this.graph.getValue(road[i-1], road[i]);obj.w += pheromone;}});// 重置当前蚁群的路径this.ant.forEach(item => {item.road.length = 1;});};AntSystem.prototype.isConvergence = function() {// 如果某条路径的信息素占比信息素总和一定概率则判断收敛let pheromoneTotal = 0;// 计算信息素总和this.graph.each(item => {const weight = item.w;pheromoneTotal += weight;});// 从第一个点开始选择，走信息素最高的道路然后计算该道路的信息素总和let roadPheromone = 0;let road = [];let arr = this.graph.getXArr(0);while (road.length < this.nodeArr.length) {let max = 0;let maxIndex = -1;arr.forEach((item,i) => {if (item === null) return;if (road.indexOf(i) === -1) {if (item.w > max) {max = item.w;maxIndex = i;}}});road.push(maxIndex);arr = this.graph.getXArr(maxIndex);roadPheromone += max;}// 当选择的路径信息素占比超过一定值时就算收敛const proportion = 0.95;const result = roadPheromone / pheromoneTotal;return {result,road,success: result > proportion}};

使用js实现的缺陷

js计算容易有偏差，且当数值过低时计算出的值容易出错，并且js计算效率并不高。

蚁群系统的局限

蚁群系统在节点过多时性能下降严重，目前已有很多基于蚁群系统的优化，这些优化后的算法效率更高，更不容易陷于局部最优解。