Ant Colony Algorithm of Intelligent Algorithm Series (Detailed Supplementary Version)

insert image description here

The cover of this blog ChatGPT + DALL·E 2was co-authored.

Article directory

foreword

This article is the sixth article of the Intelligent Algorithm (Python Reproduction) column, which is mainly a supplement to the ant colony algorithm.
In the previous blog, the principle of the ant colony algorithm was briefly introduced, and the pythonapplication of the ant colony algorithm in finding the extreme value of the function was realized, but after careful study, it was found that the key points were not highlighted, and it was different from TSPthe ant colony in the original problem. The algorithm is quite different, and it feels that it only involves the shell of the ant colony algorithm, and does not touch the soul.
Therefore, in this article, a detailed supplement is made to the application of the ant colony algorithm in finding the extreme value of the function, and the soul of the ant colony algorithm is touched as much as possible.

Paper Reference: Applying Ant Colony Algorithm to Solve All Extreme Values of a Function ( HowNet )

1. Improvement method

Let the one-dimensional function $y =$ The domain of $f$ $($ $x$ $)$ $[a, b]$ .
(1)the interval $[a, b]$ is divided into several subintervals of equal length, these subintervals are recorded as ${I_1,I_2,...,I_n\}$ , interval $I_i$ The midpoint of xi is denoted as $x_i$ ;
(2)Let and interval $I_i$ The adjacent interval is $I_{i+1}$ , $I_i$ Sum $I_{i+1}$ There is a virtual edge $e(I_{i+1}, I_{i+1})$ , the weight of the edge (virtual distance) and $f(x_i) - f(x_{i+1})$ , $f(x_i) - f(x_{i+1})$ is bigger, the ant from the interval $I_i$ Shift to interval $I_{i+1}$ The greater the possibility;
(3)the ant from the interval $I_i$ Shift to interval $I_{i+1}$ Finally, to leave the pheromone, the size of the pheromone left is the same as $f(x_i) - f(x_{i+1})$ related quantity, interval $I_{i+1}$ The more pheromones there are, the more ants in the adjacent intervals are attracted to transfer to it;
(4)after the ants have transferred many times, some intervals contain many ants, while some intervals do not contain ants. The intervals containing ants are exactly the intervals containing extreme points, and the intervals without ants are unlikely to contain extreme points;
(5)take out the intervals containing ants and refine them again, repeat the above search process until the refinement interval is small enough.
In the end, the ants stayed near the extreme point, and the midpoint of the interval where the ants were located was exactly the position of the extreme point.

2. Ant colony initialization

First, the domain of the problem $[a, b]$ for $n$ equal division, the length of each interval after equal division is $\sigma = \frac {ba} {n}$ Each interval is written as ${I_1,I_2,...,I_n\}$ , ), where $I_i(i=1,2,..,n)$ means the $i$ 个区间，则 $I_i=[a+(i-1)\sigma, a+i\sigma]$ , display interval $I_i$ The left and right endpoints of the interval $I_i$ The midpoint position of is denoted as $x_i$ ，则 $x_i=a+(i-\frac {1} {2})\sigma$ in the ant colony $m$ ants, recorded as ${a_1,a_2,...,a_n\}$ In general, $\geq n$ . At the beginning, an interval is randomly assigned to each ant, and the position of the ant is the midpoint of the interval. $\tau _i(t)$ meansSubinterval $at time t$ $For the pheromone on i$ , the pheromone concentration of each subinterval is the same at the beginning, and the default is1.0; $\Delta \tau _i(t)$ meansSubinterval $at time t$ $The pheromone increment on i$ , the initial pheromone increment of each subinterval is also the same, the default is0.

3. Ant mobile strategy

假设 $neighbor(I_i)$ display interval $I_i$ Neighboring interval set, function $neighbor(I_i) = \begin{cases} \{I_{i+1}\}, & i=1\\ \{I_{i-1}, I_{ i+1}\}, & i=2,3,...,n-1\\ \{I_{i-1}\}, & i=n \end{cases}$ in interval $I_i$ The ants of the adjacent interval $I_j$ transfer, assuming $I_i$ Sum $I_j$ There is a virtual edge $e(I_i,I_j)$ , the weight of this edge is $f(x_i) - f(x_j) \bigg|$ , then the heuristic function $\eta_{ij} = \bigg| f(x_i) - f(x_j) \bigg|$ Let ant $a_k$ Currently in interval $I_i$ ，若 $f(x_i) - f(x_j) > 0$ ，The interval before display $I_i$ The value above is larger, the ant $a_k$ can be transferred to its adjacent interval $I_j$ ; Otherwise, the ants will not transfer to it. Let $allow_k$ means ant $a_k$ A collection of subintervals that can be transferred in the next step.
Use $p_{ij}^k(t)$ means the $t$ cycle ant $a_k$ From child section $I_i$ Transfer to subinterval $I_j$ The probability of imitating the basic ant colony algorithm, defining ant $a_k$ Derive the functions: $p_{ij}^k(t). ) = \begin{cases}\frac {\tau_j^{\alpha}(t) \\eta_{ij}^{\beta}} {\sum_{h\in allowed_k} \tau_j^{\alpha}(t ) \\eta_{ih}^{\beta}}, &j \in allowed_k\\\\0, &j \notin allowed_k\end{cases}$ Among them, $\alpha$ is the information heuristic factor (pheromone importance factor), $\beta$ is the expected heuristic factor (heuristic function importance factor), $\tau _j$ Toshi interval ${I_i}$ pheromone concentration.

4. Pheromone update

if ant $a_k$ From subinterval $I_i according to probability$ transferred to the subinterval $I_j$ , then the ant $a_k$ It will leave pheromone in the interval, and the amount of pheromone left is expressed by $\Delta \tau_j^{k}(t)$ 表示，则 $\Delta \tau_j^{k}(t) = C\bigg( f(x_i) - f(x_j) \bigg)$ Among them, $C$ represents a constant, $f(x_i) - f(x_j)$ is bigger, it means ant $a_k$ The more pheromone left, the more it attracts other ants to the interval $I_j$ transfer.
All transfers to interval $I_j$ The ants of all must leave corresponding pheromones, assuming that at $t$ cycles, with $b$ ants moved to interval $I_j$ , then this $b$ ants are in the interval $I_j$ The sum of pheromone left on is $\Delta \tau_j(t) = \sum_{c=1} ^{b} \Delta \tau_j^{ c}(t)$ After all ants complete a neighboring interval transfer, they need to update the pheromone
. Interval $I_j$ The pheromone concentration of $\tau_j$ 手机的 $\tau_j(t+1) = (1-1\rho)\tau_j(t) + \ Delta \tau_j(t)$ where, $\rho$ represents the pheromone volatilization coefficient.

5. Reducing the search space of ant colony

The interval with smaller function value will contain more pheromone, which is more likely to attract ants to transfer to it. After some cycles, when all the ants stop transferring, the ant colony distribution will have such characteristics: all ants are distributed in the interval with smaller extreme points, while there are no ants in other intervals, that is, the interval containing ants contains extreme points. small value point.
Take out these intervals containing ants, and refine these intervals again, and let the ant colony search for the minimum point in these intervals in the next cycle. If this cycle continues, the search range of the ant colony will become smaller and smaller. When the refined interval is small enough, all ants will stay near the extreme point, and the midpoint of the interval where the ant stays is the extreme value point location.
A threshold is set in the paper. After all, it is impossible to subdivide indefinitely. When the step size of the interval is smaller than the threshold, the subdivision of the interval is stopped and the search ends. In the implementation of this paper, the operation in the paper is not adopted, but a small interval step is directly adopted at the beginning, so that the optimal solution searched is very close to the theoretical optimal value.

6. Code implementation

# -*- coding:utf-8 -*-
# Author:   xiayouran
# Email:    [email protected]
# Datetime: 2023/5/6 14:59
# Filename: ant_colony_optimization.py
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

from base_algorithm import BaseAlgorithm


__all__ = ['AntColonyOptimization']


class Ant:
    def __init__(self):
        self.id = None          # 蚂蚁所在区间的id
        self.eta = None         # 启发式信息, 存放本区间与其左右两个区间的函数差值
        self.tran_prob = None   # 状态转移概率


class Interval:
    def __init__(self):
        self.position = None    # 该区间上的中点
        self.tau = 1.           # 信息素浓度值
        self.delta_tau = 0.     # 信息素浓度增量
        self.count = 0          # 此区间上蚂蚁的数量


class AntColonyOptimization(BaseAlgorithm):
    def __init__(self, population_size=100, max_iter=200, alpha=1.5, beta=0.8, rho=0.3, epsilon=1e-4,
                 q=1.0, step=0.01, x_range=(0, 5), seed=10086):
        super(AntColonyOptimization, self).__init__()
        self.__population_size = population_size  # 蚂蚁种群大小
        self.__max_iter = max_iter  # 最大迭代次数
        self.__alpha = alpha        # 信息素重要程度因子
        self.__beta = beta          # 启发函数重要程度因子
        self.__rho = rho            # 信息素蒸发系数
        self.__epsilon = epsilon    # 停止搜索门限
        self.__q = q                # 信息素释放增量系数, 常量C
        self.__step = step          # 子区间间隔
        self.__x_range = x_range    # 变量x的定义域
        self.__population = []      # 蚁群
        self.__interval_set = []    # 区间集合(对应TSP问题中的city)
        self.__tabu = []            # 禁忌表
        self.__seed = seed
        self.optimal_solution = None

        np.random.seed(seed)

    def init_interval_set(self):
        for left_point in np.arange(*self.__x_range, self.__step):
            interval = Interval()
            interval.position = left_point + self.__step / 2  # 区间中点
            self.__interval_set.append(interval)

        if len(self.__interval_set) > self.__population_size:
            tmp_size = self.__population_size
            self.__population_size = int(np.ceil(len(self.__interval_set) / self.__population_size) * self.__population_size)
            print("Suggest a larger value for population_size, the value for population_size has been "
                  "changed from {} to {}".format(tmp_size, self.__population_size))

    def init_tabu(self):
        self.__tabu = np.zeros(shape=(len(self.__interval_set), 2))   # 初始禁忌表, 当前点与左右两坐标
        # TSP中的禁忌表的shape是(m, n), 其中m为蚂蚁数量, n为城市数量, 确保每只蚂蚁仅能访问城市一次

    def update_eta(self, ant):
        index = ant.id
        interval = self.__interval_set[index]
        ant.eta = []

        if index == 0:
            ant.eta.append(0)
            ant.eta.append(self.problem_function(interval.position) - self.problem_function(
                interval.position + self.__step))
        elif index == len(self.__interval_set) - 1:
            ant.eta.append(self.problem_function(interval.position) - self.problem_function(
                interval.position - self.__step))
            ant.eta.append(0)
        else:
            ant.eta.append(self.problem_function(interval.position) - self.problem_function(
                interval.position - self.__step))  # 当前区间(中点)与左邻居区间(中点)的差值
            ant.eta.append(self.problem_function(interval.position) - self.problem_function(
                interval.position + self.__step))  # 当前区间(中点)与右邻居区间(中点)的差值

    def update_tabu(self, ant):
        index = ant.id
        if ant.eta[0] > 0:
            self.__tabu[index, 0] = 1  # 表示左子区间值较小, 可以跳转
        if ant.eta[1] > 0:
            self.__tabu[index, 1] = 1  # 表示右子区间值较小, 可以跳转

    def init_population(self):
        # 初始化区间集合
        self.init_interval_set()

        # 初始化禁忌表
        self.init_tabu()

        for i in range(self.__population_size):
            index = np.random.choice(range(len(self.__interval_set)))   # 随机选择一个区间
            # index = i
            interval = self.__interval_set[index]
            interval.count += 1

            ant = Ant()
            ant.id = index

            # 更新eta
            self.update_eta(ant)

            # 更新禁忌表tabu
            self.update_tabu(ant)

            # 更新蚂蚁的状态转移概率
            ant.tran_prob = interval.tau * ant.eta[0] / (interval.tau * ant.eta[0] + interval.tau * ant.eta[1])  # 蚂蚁向左区间跳转概率

            self.__population.append(ant)

    def skip_left(self, ant):
        index = ant.id

        interval = self.__interval_set[index]
        interval.count -= 1  # 此区间蚂蚁数-1
        left_interval = self.__interval_set[index - 1]
        left_interval.count += 1  # 左区间蚂蚁数+1
        ant.id -= 1  # 蚂蚁跳转至左区间
        left_interval.delta_tau = left_interval.delta_tau + self.__q * ant.eta[0]

    def skip_right(self, ant):
        index = ant.id

        interval = self.__interval_set[index]
        interval.count -= 1  # 此区间蚂蚁数-1
        right_interval = self.__interval_set[index + 1]
        right_interval.count += 1  # 右区间蚂蚁数+1
        ant.id += 1  # 蚂蚁跳转至右区间
        right_interval.delta_tau = right_interval.delta_tau + self.__q * ant.eta[1]

    def search_local_optimal_solution(self):
        flag = np.ones(self.__population_size)
        while np.sum(flag):
            for i, ant in enumerate(self.__population):
                index = ant.id
                if self.__tabu[index, 0] and not self.__tabu[index, 1]:
                    # 蚂蚁可以向左区间跳转
                    self.skip_left(ant)
                elif not self.__tabu[index, 0] and self.__tabu[index, 1]:
                    # 蚂蚁可以向右区间跳转
                    self.skip_right(ant)
                elif self.__tabu[index, 0] and self.__tabu[index, 1]:
                    # 两个区间都可以跳转, 计算一下蚂蚁的状态转移概率
                    if ant.tran_prob > np.random.rand():
                        # 蚂蚁向左区间跳转
                        self.skip_left(ant)
                    else:
                        # 蚂蚁向右区间跳转
                        self.skip_right(ant)
                else:
                    flag[i] = 0     # 表示此蚂蚁不再进行跳转了

                self.update_eta(ant)    # 更新eta
                self.update_tabu(ant)   # 更新禁忌表

            for interval in self.__interval_set:
                # 更新区间上的信息素
                interval.tau = (1 - self.__rho) * interval.tau + interval.delta_tau

    def print_local_optimal_solution(self):
        print('local optimal solution:')
        local_optimal_solution = {
    
    }
        best_point = np.inf
        for ant in self.__population:
            index = ant.id
            if not local_optimal_solution.get(index, ''):
                local_optimal_solution[index] = (self.__interval_set[index].position,
                                                 self.problem_function(self.__interval_set[index].position))
                print(local_optimal_solution[index])
                if best_point > local_optimal_solution[index][1]:
                    best_point = local_optimal_solution[index][1]
                    self.optimal_solution = local_optimal_solution[index]

    def solution(self):
        self.init_population()
        self.search_local_optimal_solution()
        self.print_local_optimal_solution()

        print('the optimal solution is', self.optimal_solution)


if __name__ == "__main__":
	algo = AntColonyOptimization()
	algo.solution()

The visualization effect of the ant colony algorithm is as follows:

insert image description here

Code repository: IALib[GitHub]

The code of this article has been synchronized to Pythonthe exclusive warehouse of the [Smart Algorithm (Recurrence)] column: Algorithms in the IALib
runtime library:IALibACO

git clone [email protected]:xiayouran/IALib.git
cd examples
python main.py -algo aco