帮我看一下我的代码对吗
def swap(permutation, i, j):
"""
Return a new permutation where the elements at indices i and j are swapped.
Parameters:
permutation (list or np.ndarray): Current assignment.
i, j (int): Indices to swap.
Returns:
(list or np.ndarray): New permutation with i and j exchanged.
"""
# create a copy or modify in place to swap positions i and j
new_permutation=permutation
new_permutation[i]=permutation[j]
new_permutation[j]=permutation[i]
return new_permutation
def delta_i_j(permutation, i, j, weights, distance):
"""
Compute the change in objective value if we swap facilities i and j.
Parameters:
permutation (list or np.ndarray): Current assignment.
i, j (int): Indices of facilities to swap.
weights (np.ndarray): Flow matrix.
distance (np.ndarray): Distance matrix.
Returns:
float: Change in cost after swapping i and j.
"""
# compute the fitness difference directly or with the O(n) delta formula
old_cost=fitness(permutation,weights,distance)
new_permutation=swap(permutation,i,j)
new_cost=fitness(new_permutation,weights,distance)
return new_cost-old_cost
def best_swap(weights, distance, permutation, current_fitness, best_fitness, tabu_matrix, itr):
"""
Identify the best neighbor of the current solution
while respecting Tabu Search rules.
Parameters:
weights (np.ndarray) : Flow matrix of the QAP.
distance (np.ndarray) : Distance matrix of the QAP.
permutation (list or np.ndarray) : Current assignment of facilities to locations.
current_fitness (float) : Cost of the current solution.
best_fitness (float) : Best cost found so far (global best).
tabu_matrix (np.ndarray) : Matrix that stores, for each possible swap, the iteration number until which it is tabu.
itr (int) : Current iteration index.
Returns:
i, j (int): Indices of the selected swap.
delta (float): Change in cost for the swap.
is_best (bool): True if this move improves the global best solution.
"""
# iterate over all pairs (i, j)
# compute delta for each swap
# skip tabu moves unless aspiration criterion is met
# keep track of the best candidate
n=len(permutation)
best_delta=float('inf')
best_i, best_j = 0, 0
is_best=False
for i in range(n):
for j in range(i+1,n):
if tabu_matrix[i][j]<itr:
if current_fitness+delta_i_j(permutation,i,j,weights,distance)<best_fitness:
new_permutation=swap(permutation,i,j)
delta=delta_i_j(permutation,i,j,weights,distance)
return i,j,delta,True
else:
delta=delta_i_j(permutation,i,j,weights,distance)
if delta<best_delta:
best_delta=delta
best_i, best_j=i,j
return best_i,best_j,best_delta,is_best
def tabu_search(weights, distance, tabu_tenure, tmax, diversification, u):
"""
Main Tabu Search routine.
Parameters:
weights (np.ndarray): Flow between locations.
distance (np.ndarray): Distance between locations.
tabu_tenure (int): Number of iterations a move remains tabu.
tmax (int): Total number of iterations.
diversification (bool): Enable diversification strategy.
u (int): Number of iterations after which diversification triggers.
Returns:
best_fitness (float): Best objective value found.
best_permutation (list or np.ndarray): Best assignment found.
fitness_history (list): Cost of each visited solution.
best_history (list): Best cost at each iteration.
"""
# initialize permutation and tabu matrix
# initialize diversification structures if enabled
# repeat for tmax iterations:
# choose move (best swap or diversification)
# apply move and update current fitness
# update best solution if improved
# update tabu matrix
# update diversification bookkeeping if enabled
# initialize permutation and tabu matrix
n = len(weights)
permutation = np.random.permutation(n)
# 计算当前适应度
current_fitness = fitness(permutation,weights,distance)
# 初始化最佳适应度
best_fitness = current_fitness
# 初始化最佳排列
best_permutation = permutation.copy()
# 初始化禁忌矩阵
tabu_matrix = np.zeros((n, n), dtype=int)
for itr in range(tmax):
# 找到最佳交换
i, j, delta, is_best = best_swap(weights, distance, permutation, current_fitness, best_fitness, tabu_matrix, itr)
# 更新排列
permutation = swap(permutation, i, j)
# 更新当前适应度
current_fitness += delta
# 更新禁忌矩阵
tabu_matrix[i][j] = itr + tabu_tenure
tabu_matrix[j][i] = itr + tabu_tenure
# 更新最佳适应度和最佳排列
if is_best:
best_fitness = current_fitness
best_permutation = permutation.copy()
# 多样化策略
if diversification and itr % u == 0:
np.random.shuffle(permutation)
current_fitness = fitness(permutation,weights, distance )
return best_permutation, best_fitness,
# return final best solution and histories
# ------------------------------------------------
# Diversification:
# implement a mechanism that forces rarely-used
# swaps to be tried after u iterations
# ------------------------------------------------
最新发布