Python NetworkX simulated_annealing_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))

temp：int，可選(默認=100)

算法的溫度參數。它代表溫度的初始值

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.01)

外循環每次迭代的溫度下降百分比

seed：整數、random_state 或無(默認)

隨機數生成狀態的指示符。請參閱隨機性。

返回：

cycle：節點列表

返回推銷員可以遵循的循環(節點列表)以最小化行程的總重量。

拋出：

NetworkXError

如果G 未完成，算法將引發異常。

注意：

模擬退火是一種元啟發式局部搜索算法。該算法的主要特點是它接受偶數解，從而導致成本增加，以逃避低質量的局部最優解。

該算法需要一個初始解。如果未提供，則由簡單的貪心算法構造。在每次迭代中，算法都會仔細選擇一個鄰居解決方案。考慮當前解決方案的\(c(x)\) 成本和鄰居解決方案的\(c(x')\) 成本。如果\(c(x') - c(x) <= 0\) 則相鄰解成為下一次迭代的當前解。否則，算法接受概率為 \(p = exp - ([c(x') - c(x)] / temp)\) 的鄰居解。否則，將保留當前解決方案。

temp是算法的參數，代表溫度。

時間複雜度：對於內循環的\(N_i\)迭代和外循環的\(N_o\)迭代，該算法具有運行時間\(O(N_i * N_o * |V|)\)。

有關更多信息以及該算法的靈感來源，請參閱：http://en.wikipedia.org/wiki/Simulated_annealing

例子：

>>> 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.simulated_annealing_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.simulated_annealing_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