模拟退火不会返回（一个）最优解

Question

我决定学习模拟退火作为攻击this problem 的新方法。它本质上询问如何用 -1、0 或 1 填充网格，以便每一行和每一列的总和都是唯一的。作为一个测试用例，我使用了一个 6x6 的网格，Neil 给出的肯定有一个最优解：

1  1  1  1  1  1  6
1  1  1  1  1 -1  4
1  1  1  1 -1 -1  2
1  1  0 -1 -1 -1 -1
1  0 -1 -1 -1 -1 -3
0 -1 -1 -1 -1 -1 -5
5  3  1  0 -2 -4

我的代码在大多数运行时通常不会达到最佳情况，甚至返回错误的网格成本（old_cost 应该匹配 count_conflict(grid)）。是我的参数设置不正确，是我执行不正确，还是模拟退火在这里不是一种可行的方法？

import random
from math import exp

G_SIZE = 6
grid = [[1]*G_SIZE for i in range(G_SIZE)]

def count_conflict(grid):
    cnt = [0]*(2*G_SIZE+1)
    conflicts = 0
    for row in grid:
        cnt[sum(row)] += 1
    for col in zip(*grid):
        cnt[sum(col)] += 1

    #print(cnt)
    for c in cnt:
        if c == 0: conflicts += 1
        if c > 1: conflicts += c-1
    return conflicts

def neighbor(grid):
    new_grid = grid[:]

    i = random.choice(range(G_SIZE))
    j = random.choice(range(G_SIZE))
    new_cells = [-1, 0, 1]
    new_cells.remove(new_grid[i][j])
    new_grid[i][j] = random.choice(new_cells)

    return new_grid

def acceptance_probability(old_cost, new_cost, T):
    if new_cost < old_cost: return 1.0
    return exp(-(new_cost - old_cost) / T)


# Initial guess
for i in range(1, G_SIZE):
    for j in range(0, i):
        grid[i][j] = -1

#print(grid)

old_cost = count_conflict(grid)
T = 10.0
T_min = 0.1
alpha = 0.99
while T > T_min:
    for i in range(1000):
        new_sol = neighbor(grid)
        new_cost = count_conflict(new_sol)
        ap = acceptance_probability(old_cost, new_cost, T)
        print(old_cost, new_cost, ap, T)
        if ap > random.random():
            grid = new_sol
            old_cost = new_cost

    T *= alpha

for row in grid:
    print(row)

print(count_conflict(grid))

Answer 1

首先要做一些事情，这可能会很快引导您找到可行的解决方案，而无需执行任何其他操作（例如，交换启发式）：

• 在主迭代循环的顶部附近添加一行，以 计算你的 t0 状态的成本（即你的起始 配置）；

• 在主循环中，在 计算当前迭代成本的行——写 到文件，成本函数返回的值 迭代；在其下方添加一行，每 20 次打印一次该值 迭代或类似的东西（例如，大约每秒一次 与我们理解滚动数据一样快）

  如果 n % 10 == 0：打印（what_cost_fn_returned_this_iteration）

• 不要调用acceptance_probability；没有自然收敛 组合优化问题的准则；通常的做法 是在发生这些情况时跳出主循环：

  已达到最大迭代次数

  成本函数的当前最小值 过去 __ 次迭代的变化小于 __%；例如 如果在过去 100 次迭代中，成本（通过比较 min 和 max 使用移动窗口）变化小于 1%

  在迭代过程中达到最小值后，现在的成本是 随着迭代次数不断增加

---

其他一些观察：

• 有了诊断程序（见上文），您将能够 确定：（i）从一些初始成本，我的求解器在做什么？ IE， 它是否正朝着越来越低的价值或多或少的直接路径移动？ 是不是在震荡？是在增加吗？ （如果是后者，解决方法是 通常你有一个向后的标志）

• 一个 6 x 6 的矩阵非常非常小——不会留下太多的
  使用的成本函数

• 重新编写成本函数，以便“完美”的解决方案返回一个
  零成本，其他都有更高的价值

• 1000 次迭代并不多；尝试将其增加到 50,000

Answer 2

new_grid = grid[:] 进行浅拷贝。深层复制或修改网格并恢复为原始网格可以解决问题。