Python NetworkX threshold_accepting_tsp用法及代码示例

返回旅行商问题的近似解。

该函数使用阈值接受方法来近似通过节点的最小成本循环。从次优解决方案开始，阈值接受方法会扰乱该解决方案，接受使解决方案不比增加阈值量更差的任何更改。成本的改进是可以接受的，但导致成本小幅增加的变化也是如此。这允许解决方案在解决方案空间中留下次优的局部最小值。随着迭代的进行，阈值会缓慢降低，以帮助确保最佳状态。总之，该函数返回一个从source 开始的循环，其中总成本最小化。

参数：

G：图形

G 应该是一个完整的加权无向图。应包括所有节点对之间的距离。

init_cycle：列表或“greedy”

初始解决方案(循环所有节点返回起点)。这个论点没有默认让你思考。如果“greedy”，请使用greedy_tsp(G, weight)。其他常见的起始周期是 list(G) + [next(iter(G))] 或执行 threshold_accepting_tsp 时 simulated_annealing_tsp 的最终结果。

weight：字符串，可选(默认=”weight”)

边权重对应的边数据键。如果任何边不具有此属性，则权重设置为 1。

source：节点，可选(默认：列表(G)中的第一个节点)

起始节点。如果没有，默认为next(iter(G))

threshold：int，可选(默认=1)

算法的阈值参数。它代表初始阈值的值

move：“1-1” 或 “1-0” 或函数，可选(默认 =”1-1”)

在寻找新的试验解决方案时使用什么移动的指标。字符串表示两个特殊的内置移动：

• “1-1”：1-1 交换，它转置了当前解决方案的两个元素的位置。调用的函数是 swap_two_nodes() 。例如，如果我们在解决方案A = [3, 2, 1, 4, 3]中应用1-1交换，我们可以通过1和4元素的转置得到以下内容：A' = [3, 2, 4, 1, 3]
• “1-0”：1-0 交换，将解决方案中的节点移动到新位置。调用的函数是 move_one_node() 。例如，如果我们在解决方案A = [3, 2, 1, 4, 3] 中应用 1-0 交换，我们可以将第四个元素转移到第二个位置：A' = [3, 4, 2, 1, 3]

您可以提供自己的函数来制定从一个解决方案到相邻解决方案的转变。该函数必须将解作为输入以及 seed 输入来控制随机数生成(请参阅此处的 seed 输入)。您的函数应该将解决方案维护为一个循环，其中第一个和最后一个节点相等，所有其他节点都出现一次。您的函数应该返回新的解决方案。

max_iterations：int，可选(默认=10)

当外部循环的此数量的连续迭代发生而最佳成本解决方案没有任何变化时声明完成。

N_inner：int，可选(默认=100)

内循环的迭代次数。

alpha：在 (0, 1) 之间浮点数，可选(默认 = 0.1)

当至少有一个邻居解决方案被接受时，阈值降低的百分比。如果没有接受内循环移动，则阈值保持不变。

seed：整数、random_state 或无(默认)

随机数生成状态的指示符。请参阅随机性。

返回：

cycle：节点列表

返回推销员可以遵循的循环(节点列表)以最小化行程的总重量。

抛出：

NetworkXError

如果G 未完成，算法将引发异常。

注意：

阈值接受是一种元启发式局部搜索算法。该算法的主要特点是它接受偶数解，从而导致成本增加，以逃避低质量的局部最优解。

该算法需要一个初始解。这个解决方案可以通过一个简单的贪心算法来构建。在每次迭代中，它都会仔细选择一个邻居解决方案。考虑当前解决方案的\(c(x)\) 成本和邻居解决方案的\(c(x')\) 成本。如果\(c(x') - c(x) <= threshold\) 则邻居解成为下一次迭代的当前解，其中阈值被命名为阈值。

与模拟退火算法相比，阈值接受算法不接受质量非常低的解决方案(由于存在阈值)。在模拟退火的情况下，即使是非常低质量的解决方案也可以以概率 \(p\) 被接受。

时间复杂度：它有一个运行时间\(O(m * n * |V|)\)，其中\(m\)和\(n\)分别是外循环和内循环运行的次数。

有关更多信息以及如何启发算法，请参阅：https://doi.org/10.1016/0021-9991(90)90201-B

例子：

>>> from networkx.algorithms import approximation as approx
>>> G = nx.DiGraph()
>>> G.add_weighted_edges_from({
...     ("A", "B", 3), ("A", "C", 17), ("A", "D", 14), ("B", "A", 3),
...     ("B", "C", 12), ("B", "D", 16), ("C", "A", 13),("C", "B", 12),
...     ("C", "D", 4), ("D", "A", 14), ("D", "B", 15), ("D", "C", 2)
... })
>>> cycle = approx.threshold_accepting_tsp(G, "greedy", source="D")
>>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
>>> cycle
['D', 'C', 'B', 'A', 'D']
>>> cost
31
>>> incycle = ["D", "B", "A", "C", "D"]
>>> cycle = approx.threshold_accepting_tsp(G, incycle, source="D")
>>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
>>> cycle
['D', 'C', 'B', 'A', 'D']
>>> cost
31