[Algoritmo] Algoritmo tabú + problema TSP código python

1. El concepto de algoritmo tabú

La búsqueda tabú es un algoritmo de optimización que simula la inteligencia humana.Imita la función de la memoria humana., en el proceso de resolución del problema se utiliza la técnica del tabú,Marcar la solución óptima local que se ha buscado, y tratar de iterarEvita repetir la misma búsqueda(pero no completamente eliminada), para obtener un intervalo de búsqueda más amplio, lo que conduce a encontrar la solución óptima global.

2. Explicación de los términos relacionados

1. Objeto Tabú (Objeto Tabú, TO)

Se refiere a aquellos elementos variables que están prohibidos en la lista tabú.
Por ejemplo, en el problema del viajante de comercio (TSP), los pares de ciudades intercambiados se pueden usar como objetos tabú, y la longitud total de la ruta también se puede usar como objeto tabú.

2. Lista Tabú (Lista Tabú, TL)

Una mesa utilizada para almacenar (recordar) objetos tabú. Es la premisa básica para llevar a cabo la búsqueda tabú. La tabla tabú en sí tiene una capacidad limitada y su tamaño afecta la cantidad de objetos tabú almacenados y afecta el rendimiento del algoritmo.

3. Tenencia tabú (TT)

También llamada duración tabú, se refiere al período durante el cual no se pueden seleccionar objetos tabú.
Si el período tabú es demasiado corto, es fácil tener un ciclo y es imposible saltar fuera del óptimo local.
Plazos de urgencia excesivamente largos pueden resultar en tiempos de cálculo excesivamente largos.

4. Criterios de Aspiración (CA)

También conocida como la regla de amnistía. Cuando todos los objetos son tabú, se puede desbanear el objeto prohibido con el mejor rendimiento , o también se puede usar la regla de amnistía cuando desbanear un objeto traerá una gran mejora en el valor objetivo.

5. Criterios de terminación

tres métodos:

1. Dado el número máximo de pasos de iteración.

2. Establece la frecuencia tabú máxima para un objeto.

3. Establezca el rango de desviación del valor de ajuste.

3. Flujo básico del algoritmo

4. Problema TSP

Se sabe que el problema de un viajante de comercio es un problema de cuatro ciudades (a, b, c, d), y la distancia entre ciudades se muestra en la matriz D. Por conveniencia, se supone que el mapa de vecindario se define como el intercambio de dos ciudades, y el punto de partida y Las ciudades de destino son todas a. Analice el proceso y los pasos principales de las tres generaciones anteriores para resolver este problema utilizando el algoritmo de búsqueda tabú.

Los pasos principales:

código pitón

1. Importe el paquete.

import time
import numpy as np
import random

2. Establezca el valor del parámetro del algoritmo tabú.
La longitud tabú es 2.

# m城市个数  best全局最优  tl初始禁忌长度
# time 迭代次数, spe特赦值
# tabu禁忌表
# best_way 最优解 now_way当前解
# dis两点距离
global m, best, tl
global time, spe
best = 4.0
m= 4
tl = 2
spe= 2
time = 100
tabu = [[0] * (m) for i in range(m)]
best_way =[0] * m
now_way = [0] * m
dis = [[0] * (m) for i in range(m)]

3. Generar una solución inicial.

def rand(g):
    vis = [0]*m
    for i in range(m):
        vis[i] = 0;
    g[0] = 0  # 必定要从第一个城市a出发
    vis[0] = 1
    on = 1
    while on < m:
        te = random.randint(1, m - 1) # 随机选择一个城市
        if(vis[te] == 0):
            vis[te] = 1
            g[on] = te
            on += 1

4. Calcular la longitud de la ruta de la solución t.

def get_value(t):
    ans = 0.0
    for i in range(1, m):
        ans += dis[t[i-1]][t[i]]
    ans += dis[t[i-1]][t[i]]
    return ans

5. Copie la solución actual a la matriz de solución óptima.

def cop(a,b):
    for i in range(m):
        a[i] = b[i]

6. Inicialice la tabla tabú y calcule el valor de ruta de la solución inicial.

def init():
    global best
    for i in range(m):
        for j in range(m):
            tabu[i][j] = 0  #初始化禁忌表
    rand(now_way)           #生成初始解作为当前解
    now = get_value(now_way)
    cop(best_way, now_way)
    best = now

7. Algoritmo tabú.

def slove():
    global best, now
    temp = [0] * m       # 中间变量记录交换结果
    a = 0                # 记录交换城市下标
    b = 0
    ob_way = [0] * m
    cop(ob_way, now_way)
    ob_value = get_value(now_way)    # 暂存邻域最优解
    for i in range(1, m):            # 搜索所有邻域
        for j in range(1, m):
            if(i + j >= m): break;
            if(i == j): continue;
            cop(temp, now_way)
            temp[i], temp[i + j] = temp[i + j], temp[i]
            value = get_value(temp)
            if(value <= best and tabu[i][i + j] < spe): # 如果优于全局最优且禁忌长度小于特赦值
                cop(best_way, temp)
                best = value
                a = i
                b = i + j         #更新全局最优且接受新解

                cop(ob_way, temp)
                ob_value = value
            elif(tabu[i][i + j] == 0 and value < ob_value): # 如果优于邻域中的最优解则接受新解
                cop(ob_way, temp)
                ob_value = value
                a = i
                b = i + j
    cop(now_way, ob_way)  # 更新当前解
    for i in range(m):    # 更新禁忌表
        for j in range(m):
            if(tabu[i][j] > 0):
                tabu[i][j] -= 1
    tabu[a][b] = tl  #重置a，b两个交换城市的禁忌值

8. Función principal:

if __name__ == '__main__':
    dis = np.array([[0, 1, 0.5, 1],
                    [1, 0, 1, 1],
                    [1.5, 5, 0, 1],
                    [1, 1, 1, 0]])
    init()                                # 数据初始化
    for i in range(time):                 # 控制迭代次数
        slove()
    print("路线总长度： ", round(best,3))   # 打印最优解距离保留三位小数
    print("具体路线： ", best_way)

9. Resultado de ejecución:

FIN