Python programming implementation Ant Colony Algorithm details, python algorithm details
Introduction
Ant colony optimization (ACO), also known as ant colony algorithm, is a probability algorithm used to find the optimal path in the figure. It was proposed by Marco Dorigo in his doctoral thesis in 1992 that it was inspired by the behavior of ant financial in searching for food. Ant Colony Algorithm is a simulated evolutionary algorithm. Preliminary research shows that the algorithm has many excellent properties. For PID controller parameter optimization design problems, the ant colony algorithm design results are compared with the genetic algorithm design results. Numerical simulation results show that, ant Colony Algorithm has the validity and application value of a new method for simulating Evolutionary Optimization.
Definition
Each ant starts searching for food without telling them where it is. After a food is found, it will release a volatile secretion pheromone (called the sex loose) to the environment, which will gradually evaporate over time, the size of the information element concentration represents the distance of the path) to attract other ants, so that more and more ants will find food. Some ants do not always repeat the same path as other ants. They will take a different path. If the other path is shorter than the other one, then gradually, more ant financial is attracted to this shorter road. Finally, after a period of operation, a shortest path may be repeated by most ants.
Solved problems
In 3D terrain, the starting point and focus are given to find the optimal path.
Source code:
from mpl_toolkits.mplot3d import proj3dfrom mpl_toolkits.mplot3d import Axes3Dimport numpy as npheight3d = np.array([[2000,1400,800,650,500,750,1000,950,900,800,700,900,1100,1050,1000,1150,1300,1250,1200,1350,1500], [1100,900,700,625,550,825,1100,1150,1200,925,650,750,850,950,1050,1175,1300,1350,1400,1425,1450], [200,400,600,600,600,900,1200,1350,1500,1050,600,600,600,850,1100,1200,1300,1450,1600,1500,1400], [450,500,550,575,600,725,850,875,900,750,600,600,600,725,850,900,950,1150,1350,1400,1450], [700,600,500,550,600,550,500,400,300,450,600,600,600,600,600,600,600,850,1100,1300,1500], [500,525,550,575,600,575,550,450,350,475,600,650,700,650,600,600,600,725,850,1150,1450], [300,450,600,600,600,600,600,500,400,500,600,700,800,700,600,600,600,600,600,1000,1400], [550,525,500,550,600,875,1150,900,650,725,800,700,600,875,1150,1175,1200,975,750,875,1000], [800,600,400,500,600,1150,1700,1300,900,950,1000,700,400,1050,1700,1750,1800,1350,900,750,600], [650,600,550,625,700,1175,1650,1275,900,1100,1300,1275,1250,1475,1700,1525,1350,1200,1050,950,850], [500,600,700,750,800,1200,1600,1250,900,1250,1600,1850,2100,1900,1700,1300,900,1050,1200,1150,1100], [400,375,350,600,850,1200,1550,1250,950,1225,1500,1750,2000,1950,1900,1475,1050,975,900,1175,1450], [300,150,0,450,900,1200,1500,1250,1000,1200,1400,1650,1900,2000,2100,1650,1200,900,600,1200,1800], [600,575,550,750,950,1275,1600,1450,1300,1300,1300,1525,1750,1625,1500,1450,1400,1125,850,1200,1550], [900,1000,1100,1050,1000,1350,1700,1650,1600,1400,1200,1400,1600,1250,900,1250,1600,1350,1100,1200,1300], [750,850,950,900,850,1000,1150,1175,1200,1300,1400,1325,1250,1125,1000,1150,1300,1075,850,975,1100], [600,700,800,750,700,650,600,700,800,1200,1600,1250,900,1000,1100,1050,1000,800,600,750,900], [750,775,800,725,650,700,750,775,800,1000,1200,1025,850,975,1100,950,800,900,1000,1050,1100], [900,850,800,700,600,750,900,850,800,800,800,800,800,950,1100,850,600,1000,1400,1350,1300], [750,800,850,850,850,850,850,825,800,750,700,775,850,1000,1150,875,600,925,1250,1100,950], [600,750,900,1000,1100,950,800,800,800,700,600,750,900,1050,1200,900,600,850,1100,850,600]])fig = figure()ax = Axes3D(fig)X = np.arange(21)Y = np.arange(21)X, Y = np.meshgrid(X, Y)Z = -20*np.exp(-0.2*np.sqrt(np.sqrt(((X-10)**2+(Y-10)**2)/2)))+20+np.e-np.exp((np.cos(2*np.pi*X)+np.sin(2*np.pi*Y))/2)ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='cool')ax.set_xlabel('X axis')ax.set_ylabel('Y axis')ax.set_zlabel('Z')ax.set_title('3D map')point0 = [0,9,Z[0][9]] point1 = [20,7,Z[20][7]]ax.plot([point0[0]],[point0[1]],[point0[2]],'r',marker = u'o',markersize = 15)ax.plot([point1[0]],[point1[1]],[point1[2]],'r',marker = u'o',markersize = 15)x0,y0,_ = proj3d.proj_transform(point0[0],point0[1],point0[2], ax.get_proj())x1,y1,_ = proj3d.proj_transform(point1[0],point1[1],point1[2], ax.get_proj())label = pylab.annotate( "start", xy = (x0, y0), xytext = (-20, 20), textcoords = 'offset points', ha = 'right', va = 'bottom', bbox = dict(boxstyle = 'round,pad=0.5', fc = 'yellow', alpha = 1), arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'),fontsize=15)label2 = pylab.annotate( "end", xy = (x1, y1), xytext = (-20, 20), textcoords = 'offset points', ha = 'right', va = 'bottom', bbox = dict(boxstyle = 'round,pad=0.5', fc = 'yellow', alpha = 1), arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'),fontsize=15)def update_position(e): x2, y2, _ = proj3d.proj_transform(point0[0],point0[1],point0[2],ax.get_proj()) label.xy = x2,y2 label.update_positions(fig.canvas.renderer) x1,y1,_ = proj3d.proj_transform(point1[0],point1[1],point1[2],ax.get_proj()) label2.xy = x1,y1 label2.update_positions(fig.canvas.renderer) fig.canvas.draw()fig.canvas.mpl_connect('button_release_event', update_position)
Basic Principles
Ant k decides the next access City Based on the concentration of information elements in the Link path between cities. Pkij (t) indicates the probability that ant k will transfer from city I to matrix j at the t moment, the formula is as follows:
After calculating the transfer probability between cities, select the next city to be accessed using the same round-robin method as in the genetic algorithm.
After all the ant Financial completes a cycle, the concentration of information elements in the Link paths between cities needs to be updated. The formula is as follows:
Where, △tau kij indicates the concentration of information elements released by k ant on the connection path between city I and city j; △tau ij indicates the sum of the concentration of information elements released by all ant financial on the connection path between city I and city j.
Ant financial releases the information element model
Program code:
Import numpy as npimport matplotlib. pyplot as plt % pylabcoordinates = np. array ([[565.0, 575.0], [25.0, 185.0], [345.0, 750.0], [945.0, 685.0], [845.0, 655.0], [880.0, 660.0], [25.0, 230.0], [525.0, 1000.0], [580.0, 1175.0], [650.0, 1130.0], [1605.0, 620.0], [1220.0, 580.0, 200.0], [1530.0, 5.0], [845.0, 680.0], [725.0, 370.0], [145.0, 665.0], [415.0, 635.0], [560.0, 365.0], [300.0, 465.0], [520.0, 585.0], [480.0, 415.0], [835.0, 625.0], [975.0, 580.0, 245.0], [1320.0, 315.0], [1250.0, 400.0], [660.0, 180.0], [410.0, 250.0], [420.0, 555.0], [1150.0, 1160.0], [700.0, 580.0], [685.0, 595.0], [685.0, 610.0], [770.0, 610.0], [795.0, 645.0, 635.0], [760.0, 650.0], [475.0, 960.0], [95.0, 260.0], [875.0, 920.0], [700.0, 500.0], [830.0, 485.0], [1170.0, 65.0], [830.0, 610.0], [605.0, 625.0], [595.0, 360.0], [1340.0, 725.0, 245.0]) def getdistmat (coordinates): num = coordinates. shape [0] distmat = np. zeros (52,52) for I in range (num): for j in range (I, num ): distmat [I] [j] = distmat [j] [I] = np. linalg. norm (coordinates [I]-coordinates [j]) return distmatdistmat = getdistmat (coordinates) numant = 40 # Number of ants numcity = coordinates. shape [0] # Number of cities alpha = 1 # elemental importance factor beta = 5 # heuristic function importance factor rock = 0.1 # The volatile speed of the information elements Q = 1 iter = 0 itermax = 250 etatable = 1.0/(distmat + np. diag ([1e10] * numcity) # inspires the function matrix, indicating the degree of expectation for ant financial to transfer from city I to matrix j. pheromonetable = np. ones (numcity, numcity) # Information Element Matrix pathtable = np. zeros (numant, numcity )). astype (int) # path record table distmat = getdistmat (coordinates) # city distance matrix lengthaver = np. zeros (itermax) # average length of each generation path lengthbest = np. zeros (itermax) # The optimal path length pathbest = np for each generation and before. zeros (itermax, numcity) # The optimal path length of each generation and before it, while iter <itermax: # randomly generate the starting city of each ant if numant <= numcity: # The number of cities is more than the number of ants. pathtable [:, 0] = np. random. permutation (range (0, numcity) [: numant] else: # The number of ants is more than the number of cities. Make up pathtable [: numcity, 0] = np. random. permutation (range (0, numcity) [:] pathtable [numcity:, 0] = np. random. permutation (range (0, numcity) [: numant-numcity] length = np. zeros (numant) # Calculate the Path Distance of each ant for I in range (numant): visiting = pathtable [I, 0] # current city # visited = set () # existing cities to prevent duplication # visited. add (visiting) # add element unvisited = set (range (numcity) # inaccessible city unvisited. remove (visiting) # Delete the element for j in range (1, numcity): # loop numcity-1 times, access to the remaining numcity-1 cities # Use the wheel method each time to select the next city to be accessed listunvisited = list (unvisited) probtrans = np. zeros (len (listunvisited) for k in range (len (listunvisited): probtrans [k] = np. power (pheromonetable [visiting] [listunvisited [k], alpha) \ * np. power (etatable [visiting] [listunvisited [k], alpha) cumsumprobtrans = (probtrans/sum (probtrans )). cumsum () cumsumprobtrans-= np. random. rand () k = listunvisited [find (cumsumprobtrans> 0) [0] # Next city pathtable [I, j] = k unvisited. remove (k) # visited. add (k) length [I] + = distmat [visiting] [k] visiting = k length [I] + = distmat [visiting] [pathtable [I, 0] # The Path Distance of ant financial includes the distance between the last city and the first city # print length # after an iteration of all ant financial, counts several statistical parameters of this iteration, lengthaver [iter] = length. mean () if iter = 0: lengthbest [iter] = length. min () pathbest [iter] = pathtable [length. argmin ()]. copy () else: if length. min ()> lengthbest [iter-1]: lengthbest [iter] = lengthbest [iter-1] pathbest [iter] = pathbest [iter-1]. copy () else: lengthbest [iter] = length. min () pathbest [iter] = pathtable [length. argmin ()]. copy () # update the information element changepheromonetable = np. zeros (numcity, numcity) for I in range (numant): for j in range (numcity-1): changepheromonetable [pathtable [I, j] [pathtable [I, j + 1] + = Q/distmat [pathtable [I, j] [pathtable [I, j + 1] changepheromonetable [pathtable [I, j + 1] [pathtable [I, 0] + = Q/distmat [pathtable [I, j + 1] [pathtable [I, 0] pheromonetable = (1-ROV) * pheromonetable + changepheromonetable iter + = 1 # iterations indicator + 1 # observe program execution progress, this function is not required if (iter-1) % 20 = 0: print iter-1 # make average path length and optimal path length fig, axes = plt. subplots (nrows = 2, ncols = 1, figsize = (12, 10) axes [0]. plot (lengthaver, 'k', marker = u'') axes [0]. set_title ('average length') axes [0]. set_xlabel (u 'iteration') axes [1]. plot (lengthbest, 'k', marker = u'') axes [1]. set_title ('best length'%axes%1%.set_xlabel(u'iteration'%fig.savefig('average_best.png ', dpi = 500, bbox_inches = 'tight') plt. close () # create the Optimal Path Graph bestpath = pathbest [-1] plt. plot (coordinates [:, 0], coordinates [:, 1], 'R. ', marker = U' $ \ cdot $') plt. xlim ([-100,2000]) plt. ylim ([-]) for I in range (numcity-1): # m, n = bestpath [I], bestpath [I + 1] print m, n plt. plot ([coordinates [m] [0], coordinates [n] [0], [coordinates [m] [1], coordinates [n] [1], 'k') plt. plot ([coordinates [bestpath [0] [0], coordinates [n] [0], [coordinates [bestpath [0] [1], coordinates [n] [1], 'B') ax = plt. gca () ax. set_title ("Best Path") ax. set_xlabel ('x axis ') ax. set_ylabel ('y _ axis ') plt. savefig ('best Path.png ', dpi = 500, bbox_inches = 'tid') plt. close ()
Summary
The above is all the details about how to implement the ant colony algorithm through Python programming. I hope it will be helpful to you. For more information about image processing and Feature Extraction in python, common operations on python images, and binary tree traversal in python, you can leave a message if you have any questions, the editor will reply to you in a timely manner. Thank you for your support!