[Algoritmo] Algoritmo tabu + código python do problema TSP

1. O conceito de algoritmo tabu

A busca tabu é um algoritmo de otimização que simula a inteligência humana.Imita a função da memória humana, no processo de resolução do problema, é utilizada a técnica do tabu,Marque a solução ótima local que foi pesquisada, e tente iterarEvite repetir a mesma pesquisa(mas não completamente eliminados), de modo a obter um intervalo de busca mais amplo, o que é propício para encontrar a solução ótima global.

2. Explicação dos termos relacionados

1. Objeto Tabu (Objeto Tabu, TO)

Refere-se aos elementos variáveis ​​que são proibidos na lista de tabus.
Por exemplo, no problema do caixeiro viajante (TSP), os pares de cidades trocadas podem ser usados ​​como objetos tabus, e o comprimento total do caminho também pode ser usado como objetos tabus.

2. Lista de tabus (lista de tabus, TL)

Uma mesa usada para armazenar (lembrar) objetos tabu. É a premissa básica para que a busca tabu seja realizada. A própria tabela tabu é limitada em capacidade e seu tamanho afeta o número de objetos tabu armazenados e afeta o desempenho do algoritmo.

3. Posse Tabu (TT)

Também chamado de comprimento do tabu, refere-se ao período durante o qual os objetos do tabu não podem ser selecionados.
Se o período tabu for muito curto, é fácil ter um ciclo e é impossível pular fora do ótimo local.
Prazos de urgência excessivamente longos podem resultar em tempos de cálculo excessivamente longos.

4. Critérios de Aspiração (AC)

Também conhecida como regra da anistia. Quando todos os objetos são tabus, o objeto proibido de melhor desempenho pode ser desbanido , ou a regra de anistia também pode ser usada quando desbanir um objeto levará a uma grande melhoria no valor alvo.

5. Critérios de rescisão

três métodos:

1. Dado o número máximo de etapas de iteração.

2. Define a frequência tabu máxima para um objeto.

3. Defina a faixa de desvio do valor de ajuste.

3. Fluxo básico do algoritmo

4. Problema TSP

Sabe-se que o problema do caixeiro viajante é um problema de quatro cidades (a, b, c, d), e a distância entre as cidades é mostrada na matriz D. Por conveniência, assume-se que o mapa da vizinhança é definido como o troca de duas cidades, e o ponto de partida e as cidades finais são todas a. Analise o processo e as principais etapas das três gerações anteriores para resolver esse problema usando o algoritmo de pesquisa tabu.

As principais etapas:

código python

1. Importe o pacote.

import time
import numpy as np
import random

2. Defina o valor do parâmetro do algoritmo tabu.
O comprimento do tabu é 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. Gere uma solução 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. Calcule o comprimento da rota da solução 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 a solução atual para o array de solução ideal.

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

6. Inicialize a tabela tabu e calcule o valor do caminho da solução 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 tabu.

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. Função 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 da execução:

FIM