From a375832b6c519cbb16518b587d9b423279ce7e4d Mon Sep 17 00:00:00 2001
From: weixin_46229132 <weixin_46229132@noreply.gitcode.com>
Date: Fri, 28 Mar 2025 10:53:41 +0800
Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0q-learning=20TSP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Q_learning/TSP.py     |  71 +++++++----
 Q_learning/mTSP.py    | 278 ++++++++++++++++++++++++++++++++++++++++++
 Q_learning/test.ipynb | 277 +++++++++++++++++++++++++++++++++++++++++
 Q_learning/tsp.png    | Bin 0 -> 45648 bytes
 4 files changed, 601 insertions(+), 25 deletions(-)
 create mode 100644 Q_learning/mTSP.py
 create mode 100644 Q_learning/test.ipynb
 create mode 100644 Q_learning/tsp.png

diff --git a/Q_learning/TSP.py b/Q_learning/TSP.py
index 2d4507b..587f21c 100644
--- a/Q_learning/TSP.py
+++ b/Q_learning/TSP.py
@@ -1,22 +1,22 @@
-%matplotlib inline
 import pylab as plt
-from IPython.display import clear_output
 import numpy as np
 import asyncio
 
+
 class TSP(object):
     '''
     用 Q-Learning 求解 TSP 问题
     作者 Surfer Zen @ https://www.zhihu.com/people/surfer-zen
     '''
-    def __init__(self, 
-                 num_cities=15, 
-                 map_size=(800.0, 600.0), 
-                 alpha=2, 
+
+    def __init__(self,
+                 num_cities=15,
+                 map_size=(800.0, 600.0),
+                 alpha=2,
                  beta=1,
                  learning_rate=0.001,
                  eps=0.1,
-                ):
+                 ):
         '''
         Args:
             num_cities (int): 城市数目
@@ -26,7 +26,7 @@ class TSP(object):
             learning_rate (float)： 学习率
             eps (float): 探索率，值越大，探索性越强，但越难收敛 
         '''
-        self.num_cities =num_cities
+        self.num_cities = num_cities
         self.map_size = map_size
         self.alpha = alpha
         self.beta = beta
@@ -40,7 +40,6 @@ class TSP(object):
         self.best_path = None
         self.best_path_length = np.inf
 
-
     def generate_cities(self):
         '''
         随机生成城市（坐标）
@@ -77,7 +76,8 @@ class TSP(object):
         current_city_id = start_city_id
         cities_visited.append(current_city_id)
         while len(cities_visited) < self.num_cities:
-            current_city_id, action_prob = self.choose_next_city(cities_visited)
+            current_city_id, action_prob = self.choose_next_city(
+                cities_visited)
             cities_visited.append(current_city_id)
             action_probs.append(action_prob)
         cities_visited.append(cities_visited[0])
@@ -95,7 +95,7 @@ class TSP(object):
         根据策略选择下一个城市
         '''
         current_city_id = cities_visited[-1]
-        
+
         # 对 quality 取指数，计算 softmax 概率用
         probabilities = np.exp(self.qualities[current_city_id])
 
@@ -105,10 +105,11 @@ class TSP(object):
 
         # 计算 softmax 概率
         probabilities = probabilities/probabilities.sum()
-        
+
         if np.random.random() < self.eps:
             # 以 eps 概率按softmax概率密度进行随机采样
-            next_city_id = np.random.choice(range(len(probabilities)), p=probabilities)
+            next_city_id = np.random.choice(
+                range(len(probabilities)), p=probabilities)
         else:
             # 以 (1 - eps) 概率选择当前最优策略
             next_city_id = probabilities.argmax()
@@ -118,7 +119,7 @@ class TSP(object):
             action_prob = probabilities[next_city_id]*self.eps + (1-self.eps)
         else:
             action_prob = probabilities[next_city_id]*self.eps
-            
+
         return next_city_id, action_prob
 
     def calc_path_rewards(self, path, path_length):
@@ -146,7 +147,7 @@ class TSP(object):
         for fr, to in zip(path[:-1], path[1:]):
             path_length += self.distances[fr, to]
         return path_length
-    
+
     def calc_updates_for_one_rollout(self, path, action_probs, rewards):
         '''
         对于给定的一次 rollout 的结果，计算其对应的 qualities 和 normalizers 
@@ -165,16 +166,19 @@ class TSP(object):
         '''
         lr = self.learning_rate
         for fr, to, new_quality, new_normalizer in zip(
-            path[:-1], path[1:], new_qualities, new_normalizers):
-            self.normalizers[fr] = (1-lr)*self.normalizers[fr] + lr*new_normalizer
-            self.qualities[fr, to] = (1-lr)*self.qualities[fr, to] + lr*new_quality
-    
+                path[:-1], path[1:], new_qualities, new_normalizers):
+            self.normalizers[fr] = (
+                1-lr)*self.normalizers[fr] + lr*new_normalizer
+            self.qualities[fr, to] = (
+                1-lr)*self.qualities[fr, to] + lr*new_quality
+
     async def train_for_one_rollout(self, start_city_id):
         '''
         对一次 rollout 的结果进行训练的流程
         '''
         path, action_probs, rewards = self.rollout(start_city_id=start_city_id)
-        new_qualities, new_normalizers = self.calc_updates_for_one_rollout(path, action_probs, rewards)
+        new_qualities, new_normalizers = self.calc_updates_for_one_rollout(
+            path, action_probs, rewards)
         self.update(path, new_qualities, new_normalizers)
 
     async def train_for_one_epoch(self):
@@ -182,7 +186,8 @@ class TSP(object):
         对一个 epoch 的结果进行训练的流程，
         一个 epoch 对应于从每个 city 出发进行一次 rollout
         '''
-        tasks = [self.train_for_one_rollout(start_city_id) for start_city_id in range(self.num_cities)]
+        tasks = [self.train_for_one_rollout(
+            start_city_id) for start_city_id in range(self.num_cities)]
         await asyncio.gather(*tasks)
 
     async def train(self, num_epochs=1000, display=True):
@@ -203,14 +208,30 @@ class TSP(object):
             x1, y1 = self.cities[:, fr]
             x2, y2 = self.cities[:, to]
             dx, dy = x2-x1, y2-y1
-            plt.arrow(x1, y1, dx, dy, width=0.01*min(self.map_size), 
-                      edgecolor='orange', facecolor='white', animated=True, 
+            plt.arrow(x1, y1, dx, dy, width=0.01*min(self.map_size),
+                      edgecolor='orange', facecolor='white', animated=True,
                       length_includes_head=True)
         nrs = np.exp(self.qualities)
         for i in range(self.num_cities):
             nrs[i, i] = 0
         gap = np.abs(np.exp(self.normalizers) - nrs.sum(-1)).mean()
-        plt.title(f'epoch {epoch}: path length = {self.best_path_length:.2f}, normalizer error = {gap:.3f}')
+        plt.title(
+            f'epoch {epoch}: path length = {self.best_path_length:.2f}, normalizer error = {gap:.3f}')
         plt.savefig('tsp.png')
         plt.show()
-        clear_output(wait=True)
\ No newline at end of file
+
+async def main():
+    # 创建TSP实例
+    tsp = TSP()
+
+    # 训练模型
+    await tsp.train(200, display=False)
+
+    # 输出最终路径
+    print(f"最优路径: {tsp.best_path}")
+    print(f"路径长度: {tsp.best_path_length:.2f}")
+
+
+if __name__ == '__main__':
+    # 使用asyncio.run()运行异步主函数
+    asyncio.run(main())
diff --git a/Q_learning/mTSP.py b/Q_learning/mTSP.py
new file mode 100644
index 0000000..ef5db8c
--- /dev/null
+++ b/Q_learning/mTSP.py
@@ -0,0 +1,278 @@
+import pylab as plt
+import numpy as np
+import asyncio
+from typing import List, Tuple, Dict, Any
+import yaml
+
+class mTSP:
+    '''
+    用 Q-Learning 求解多旅行商问题
+    基于TSP.py修改，增加了多旅行商的支持
+    '''
+    def __init__(self, 
+                 num_cities: int = 15,
+                 num_drones: int = 3,
+                 map_size: Tuple[float, float] = (800.0, 600.0),
+                 alpha: float = 2,
+                 beta: float = 1,
+                 learning_rate: float = 0.001,
+                 eps: float = 0.1,
+                 params_file: str = 'params2.yml'):
+        '''
+        Args:
+            num_cities (int): 实际城市数目（不包括虚拟起点）
+            num_drones (int): 无人机数量
+            map_size (int, int): 地图尺寸（宽，高）
+            alpha (float): 一个超参，值越大，越优先探索最近的点
+            beta (float): 一个超参，值越大，越优先探索可能导向总距离最优的点
+            learning_rate (float)： 学习率
+            eps (float): 探索率，值越大，探索性越强，但越难收敛
+            params_file (str): 参数文件路径
+        '''
+        self.num_cities = num_cities
+        self.num_drones = num_drones
+        self.map_size = map_size
+        self.alpha = alpha
+        self.beta = beta
+        self.eps = eps
+        self.learning_rate = learning_rate
+        
+        # 加载参数
+        with open(params_file, 'r', encoding='utf-8') as file:
+            self.params = yaml.safe_load(file)
+            
+        # 生成城市和虚拟起点
+        self.cities = self.generate_cities()
+        self.to_process_idx = self.generate_start_points()
+        
+        # 计算距离矩阵
+        self.distances = self.get_dist_matrix()
+        self.mean_distance = self.distances.mean()
+        
+        # Q-learning相关
+        self.qualities = np.zeros([self.total_cities, self.total_cities])
+        self.normalizers = np.zeros(self.total_cities)
+        self.best_path = None
+        self.best_path_length = np.inf
+        
+        # 计算每个点的飞行时间和基站时间
+        self.rectangles = self.calculate_rectangles()
+
+    @property
+    def total_cities(self) -> int:
+        """总城市数（包括虚拟起点）"""
+        return self.num_cities + self.num_drones - 1
+
+    def generate_cities(self) -> np.ndarray:
+        '''生成城市坐标'''
+        max_width, max_height = self.map_size
+        cities = np.random.random([2, self.num_cities]) \
+            * np.array([max_width, max_height]).reshape(2, -1)
+        return cities
+
+    def generate_start_points(self) -> List[int]:
+        '''生成起点索引列表'''
+        # 添加虚拟起点
+        virtual_starts = np.zeros([2, self.num_drones - 1])
+        self.cities = np.hstack([self.cities, virtual_starts])
+        return list(range(self.num_cities, self.total_cities))
+
+    def get_dist_matrix(self) -> np.ndarray:
+        '''计算距离矩阵'''
+        dist_matrix = np.zeros([self.total_cities, self.total_cities])
+        for i in range(self.total_cities):
+            for j in range(self.total_cities):
+                if i == j:
+                    dist_matrix[i, j] = np.inf
+                    continue
+                xi, xj = self.cities[0, i], self.cities[0, j]
+                yi, yj = self.cities[1, i], self.cities[1, j]
+                dist_matrix[i, j] = np.sqrt((xi-xj)**2 + (yi-yj)**2)
+        
+        # 设置起点之间的距离为无穷大
+        for i in self.to_process_idx:
+            for j in self.to_process_idx:
+                if i != j:
+                    dist_matrix[i, j] = np.inf
+                    
+        return dist_matrix
+
+    def calculate_rectangles(self) -> List[Dict[str, Any]]:
+        '''计算每个点的飞行时间和基站时间'''
+        rectangles = []
+        for i in range(self.num_cities):
+            d = 1.0  # 这里简化处理，实际应该根据区域大小计算
+            rho_time_limit = (self.params['flight_time_factor'] - self.params['trans_time_factor']) / \
+                (self.params['comp_time_factor'] - self.params['trans_time_factor'])
+            rho_energy_limit = (self.params['battery_energy_capacity'] - 
+                              self.params['flight_energy_factor'] * d - 
+                              self.params['trans_energy_factor'] * d) / \
+                (self.params['comp_energy_factor'] * d - 
+                 self.params['trans_energy_factor'] * d)
+            rho = min(rho_time_limit, rho_energy_limit)
+            
+            flight_time = self.params['flight_time_factor'] * d
+            bs_time = self.params['bs_time_factor'] * (1 - rho) * d
+            
+            rectangles.append({
+                'flight_time': flight_time,
+                'bs_time': bs_time,
+                'center': (self.cities[0, i], self.cities[1, i])
+            })
+        return rectangles
+
+    def rollout(self, start_city_id: int = None) -> Tuple[List[int], List[float], List[float]]:
+        '''执行一次路径探索'''
+        cities_visited = []
+        action_probs = []
+        
+        if start_city_id is None:
+            start_city_id = np.random.choice(self.to_process_idx)
+        current_city_id = start_city_id
+        cities_visited.append(current_city_id)
+        
+        while len(cities_visited) < self.total_cities:
+            current_city_id, action_prob = self.choose_next_city(cities_visited)
+            cities_visited.append(current_city_id)
+            action_probs.append(action_prob)
+            
+        # 返回起点
+        cities_visited.append(cities_visited[0])
+        action_probs.append(1.0)
+        
+        path_length = self.calc_path_length(cities_visited)
+        if path_length < self.best_path_length:
+            self.best_path = cities_visited
+            self.best_path_length = path_length
+            
+        rewards = self.calc_path_rewards(cities_visited, path_length)
+        return cities_visited, action_probs, rewards
+
+    def choose_next_city(self, cities_visited: List[int]) -> Tuple[int, float]:
+        '''选择下一个城市'''
+        current_city_id = cities_visited[-1]
+        probabilities = np.exp(self.qualities[current_city_id])
+        
+        # 将已访问的城市概率设为0
+        for city_visited in cities_visited:
+            probabilities[city_visited] = 0
+            
+        # 计算softmax概率
+        probabilities = probabilities/probabilities.sum()
+        
+        if np.random.random() < self.eps:
+            next_city_id = np.random.choice(range(len(probabilities)), p=probabilities)
+        else:
+            next_city_id = probabilities.argmax()
+            
+        if probabilities.argmax() == next_city_id:
+            action_prob = probabilities[next_city_id]*self.eps + (1-self.eps)
+        else:
+            action_prob = probabilities[next_city_id]*self.eps
+            
+        return next_city_id, action_prob
+
+    def calc_path_length(self, path: List[int]) -> float:
+        '''计算路径长度'''
+        # 将路径分成多个子路径
+        car_paths = []
+        found_start_points = []
+        
+        # 找到所有起点
+        for i, city in enumerate(path):
+            if city in self.to_process_idx:
+                found_start_points.append(i)
+                
+        # 根据起点分割路径
+        for i in range(len(found_start_points)-1):
+            start_idx = found_start_points[i]
+            end_idx = found_start_points[i+1]
+            car_paths.append(path[start_idx:end_idx+1])
+            
+        # 计算每个子路径的时间
+        T_k_list = []
+        for car_path in car_paths:
+            flight_time = 0
+            bs_time = 0
+            car_time = 0
+            
+            # 计算飞行时间和基站时间
+            for point in car_path:
+                if point not in self.to_process_idx:
+                    flight_time += self.rectangles[point]['flight_time']
+                    bs_time += self.rectangles[point]['bs_time']
+                    
+            # 计算车辆时间
+            for i in range(len(car_path)-1):
+                if car_path[i] not in self.to_process_idx and car_path[i+1] not in self.to_process_idx:
+                    car_time += self.distances[car_path[i], car_path[i+1]] * self.params['car_time_factor']
+                    
+            # 计算总时间
+            system_time = max(flight_time + car_time, bs_time)
+            T_k_list.append(system_time)
+            
+        return max(T_k_list)
+
+    def calc_path_rewards(self, path: List[int], path_length: float) -> List[float]:
+        '''计算路径奖励'''
+        rewards = []
+        for fr, to in zip(path[:-1], path[1:]):
+            dist = self.distances[fr, to]
+            reward = (self.mean_distance/path_length)**self.beta
+            reward = reward*(self.mean_distance/dist)**self.alpha
+            rewards.append(np.log(reward))
+        return rewards
+
+    def calc_updates_for_one_rollout(self, path: List[int], action_probs: List[float], 
+                                   rewards: List[float]) -> Tuple[List[float], List[float]]:
+        '''计算一次rollout的更新值'''
+        qualities = []
+        normalizers = []
+        for fr, to, reward, action_prob in zip(path[:-1], path[1:], rewards, action_probs):
+            log_action_probability = np.log(action_prob)
+            qualities.append(- reward*log_action_probability)
+            normalizers.append(- (reward + 1)*log_action_probability)
+        return qualities, normalizers
+
+    def update(self, path: List[int], new_qualities: List[float], 
+               new_normalizers: List[float]) -> None:
+        '''更新Q值和normalizer'''
+        lr = self.learning_rate
+        for fr, to, new_quality, new_normalizer in zip(
+                path[:-1], path[1:], new_qualities, new_normalizers):
+            self.normalizers[fr] = (1-lr)*self.normalizers[fr] + lr*new_normalizer
+            self.qualities[fr, to] = (1-lr)*self.qualities[fr, to] + lr*new_quality
+
+    async def train_for_one_rollout(self, start_city_id: int) -> None:
+        '''训练一次rollout'''
+        path, action_probs, rewards = self.rollout(start_city_id)
+        new_qualities, new_normalizers = self.calc_updates_for_one_rollout(
+            path, action_probs, rewards)
+        self.update(path, new_qualities, new_normalizers)
+
+    async def train_for_one_epoch(self) -> None:
+        '''训练一个epoch'''
+        tasks = [self.train_for_one_rollout(start_city_id) 
+                for start_city_id in self.to_process_idx]
+        await asyncio.gather(*tasks)
+
+    async def train(self, num_epochs: int = 1000, display: bool = True) -> None:
+        '''训练过程'''
+        for epoch in range(num_epochs):
+            await self.train_for_one_epoch()
+            if display and epoch % 100 == 0:
+                print(f"Epoch {epoch}: Best path length = {self.best_path_length:.2f}")
+
+async def main():
+    # 创建mTSP实例
+    mtsp = mTSP(num_cities=12, num_drones=3)
+    
+    # 训练模型
+    await mtsp.train(200, display=True)
+    
+    # 输出最终路径
+    print(f"\n最优路径: {mtsp.best_path}")
+    print(f"路径长度: {mtsp.best_path_length:.2f}")
+
+if __name__ == '__main__':
+    asyncio.run(main()) 
\ No newline at end of file
diff --git a/Q_learning/test.ipynb b/Q_learning/test.ipynb
new file mode 100644
index 0000000..d887e60
--- /dev/null
+++ b/Q_learning/test.ipynb
@@ -0,0 +1,277 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import pylab as plt\n",
+    "from IPython.display import clear_output\n",
+    "import numpy as np\n",
+    "import asyncio\n",
+    "\n",
+    "class TSP(object):\n",
+    "    '''\n",
+    "    用 Q-Learning 求解 TSP 问题\n",
+    "    作者 Surfer Zen @ https://www.zhihu.com/people/surfer-zen\n",
+    "    '''\n",
+    "    def __init__(self, \n",
+    "                 num_cities=15, \n",
+    "                 map_size=(800.0, 600.0), \n",
+    "                 alpha=2, \n",
+    "                 beta=1,\n",
+    "                 learning_rate=0.001,\n",
+    "                 eps=0.1,\n",
+    "                ):\n",
+    "        '''\n",
+    "        Args:\n",
+    "            num_cities (int): 城市数目\n",
+    "            map_size (int, int): 地图尺寸（宽，高）\n",
+    "            alpha (float): 一个超参，值越大，越优先探索最近的点\n",
+    "            beta (float): 一个超参，值越大，越优先探索可能导向总距离最优的点\n",
+    "            learning_rate (float)： 学习率\n",
+    "            eps (float): 探索率，值越大，探索性越强，但越难收敛 \n",
+    "        '''\n",
+    "        self.num_cities =num_cities\n",
+    "        self.map_size = map_size\n",
+    "        self.alpha = alpha\n",
+    "        self.beta = beta\n",
+    "        self.eps = eps\n",
+    "        self.learning_rate = learning_rate\n",
+    "        self.cities = self.generate_cities()\n",
+    "        self.distances = self.get_dist_matrix()\n",
+    "        self.mean_distance = self.distances.mean()\n",
+    "        self.qualities = np.zeros([num_cities, num_cities])\n",
+    "        self.normalizers = np.zeros(num_cities)\n",
+    "        self.best_path = None\n",
+    "        self.best_path_length = np.inf\n",
+    "\n",
+    "\n",
+    "    def generate_cities(self):\n",
+    "        '''\n",
+    "        随机生成城市（坐标）\n",
+    "        Returns:\n",
+    "            cities: [[x1, x2, x3...], [y1, y2, y3...]] 城市坐标\n",
+    "        '''\n",
+    "        max_width, max_height = self.map_size\n",
+    "        cities = np.random.random([2, self.num_cities]) \\\n",
+    "            * np.array([max_width, max_height]).reshape(2, -1)\n",
+    "        return cities\n",
+    "\n",
+    "    def get_dist_matrix(self):\n",
+    "        '''\n",
+    "        根据城市坐标，计算距离矩阵\n",
+    "        '''\n",
+    "        dist_matrix = np.zeros([self.num_cities, self.num_cities])\n",
+    "        for i in range(self.num_cities):\n",
+    "            for j in range(self.num_cities):\n",
+    "                if i == j:\n",
+    "                    continue\n",
+    "                xi, xj = self.cities[0, i], self.cities[0, j]\n",
+    "                yi, yj = self.cities[1, i], self.cities[1, j]\n",
+    "                dist_matrix[i, j] = np.sqrt((xi-xj)**2 + (yi-yj)**2)\n",
+    "        return dist_matrix\n",
+    "\n",
+    "    def rollout(self, start_city_id=None):\n",
+    "        '''\n",
+    "        从 start_city 出发，根据策略，在城市间游走，直到所有城市都走了一遍\n",
+    "        '''\n",
+    "        cities_visited = []\n",
+    "        action_probs = []\n",
+    "        if start_city_id is None:\n",
+    "            start_city_id = np.random.randint(self.num_cities)\n",
+    "        current_city_id = start_city_id\n",
+    "        cities_visited.append(current_city_id)\n",
+    "        while len(cities_visited) < self.num_cities:\n",
+    "            current_city_id, action_prob = self.choose_next_city(cities_visited)\n",
+    "            cities_visited.append(current_city_id)\n",
+    "            action_probs.append(action_prob)\n",
+    "        cities_visited.append(cities_visited[0])\n",
+    "        action_probs.append(1.0)\n",
+    "\n",
+    "        path_length = self.calc_path_length(cities_visited)\n",
+    "        if path_length < self.best_path_length:\n",
+    "            self.best_path = cities_visited\n",
+    "            self.best_path_length = path_length\n",
+    "        rewards = self.calc_path_rewards(cities_visited, path_length)\n",
+    "        return cities_visited, action_probs, rewards\n",
+    "\n",
+    "    def choose_next_city(self, cities_visited):\n",
+    "        '''\n",
+    "        根据策略选择下一个城市\n",
+    "        '''\n",
+    "        current_city_id = cities_visited[-1]\n",
+    "        \n",
+    "        # 对 quality 取指数，计算 softmax 概率用\n",
+    "        probabilities = np.exp(self.qualities[current_city_id])\n",
+    "\n",
+    "        # 将已经走过的城市概率设置为零\n",
+    "        for city_visited in cities_visited:\n",
+    "            probabilities[city_visited] = 0\n",
+    "\n",
+    "        # 计算 softmax 概率\n",
+    "        probabilities = probabilities/probabilities.sum()\n",
+    "        \n",
+    "        if np.random.random() < self.eps:\n",
+    "            # 以 eps 概率按softmax概率密度进行随机采样\n",
+    "            next_city_id = np.random.choice(range(len(probabilities)), p=probabilities)\n",
+    "        else:\n",
+    "            # 以 (1 - eps) 概率选择当前最优策略\n",
+    "            next_city_id = probabilities.argmax()\n",
+    "\n",
+    "        # 计算当前决策/action 的概率\n",
+    "        if probabilities.argmax() == next_city_id:\n",
+    "            action_prob = probabilities[next_city_id]*self.eps + (1-self.eps)\n",
+    "        else:\n",
+    "            action_prob = probabilities[next_city_id]*self.eps\n",
+    "            \n",
+    "        return next_city_id, action_prob\n",
+    "\n",
+    "    def calc_path_rewards(self, path, path_length):\n",
+    "        '''\n",
+    "        计算给定路径的奖励/rewards\n",
+    "        Args:\n",
+    "            path (list[int]): 路径，每个元素代表城市的 id\n",
+    "            path_length (float): 路径长路\n",
+    "        Returns:\n",
+    "            rewards: 每一步的奖励，总距离以及当前这一步的距离越大，奖励越小\n",
+    "        '''\n",
+    "        rewards = []\n",
+    "        for fr, to in zip(path[:-1], path[1:]):\n",
+    "            dist = self.distances[fr, to]\n",
+    "            reward = (self.mean_distance/path_length)**self.beta\n",
+    "            reward = reward*(self.mean_distance/dist)**self.alpha\n",
+    "            rewards.append(np.log(reward))\n",
+    "        return rewards\n",
+    "\n",
+    "    def calc_path_length(self, path):\n",
+    "        '''\n",
+    "        计算路径长度\n",
+    "        '''\n",
+    "        path_length = 0\n",
+    "        for fr, to in zip(path[:-1], path[1:]):\n",
+    "            path_length += self.distances[fr, to]\n",
+    "        return path_length\n",
+    "    \n",
+    "    def calc_updates_for_one_rollout(self, path, action_probs, rewards):\n",
+    "        '''\n",
+    "        对于给定的一次 rollout 的结果，计算其对应的 qualities 和 normalizers \n",
+    "        '''\n",
+    "        qualities = []\n",
+    "        normalizers = []\n",
+    "        for fr, to, reward, action_prob in zip(path[:-1], path[1:], rewards, action_probs):\n",
+    "            log_action_probability = np.log(action_prob)\n",
+    "            qualities.append(- reward*log_action_probability)\n",
+    "            normalizers.append(- (reward + 1)*log_action_probability)\n",
+    "        return qualities, normalizers\n",
+    "\n",
+    "    def update(self, path, new_qualities, new_normalizers):\n",
+    "        '''\n",
+    "        用渐近平均的思想，对 qualities 和 normalizers 进行更新\n",
+    "        '''\n",
+    "        lr = self.learning_rate\n",
+    "        for fr, to, new_quality, new_normalizer in zip(\n",
+    "            path[:-1], path[1:], new_qualities, new_normalizers):\n",
+    "            self.normalizers[fr] = (1-lr)*self.normalizers[fr] + lr*new_normalizer\n",
+    "            self.qualities[fr, to] = (1-lr)*self.qualities[fr, to] + lr*new_quality\n",
+    "    \n",
+    "    async def train_for_one_rollout(self, start_city_id):\n",
+    "        '''\n",
+    "        对一次 rollout 的结果进行训练的流程\n",
+    "        '''\n",
+    "        path, action_probs, rewards = self.rollout(start_city_id=start_city_id)\n",
+    "        new_qualities, new_normalizers = self.calc_updates_for_one_rollout(path, action_probs, rewards)\n",
+    "        self.update(path, new_qualities, new_normalizers)\n",
+    "\n",
+    "    async def train_for_one_epoch(self):\n",
+    "        '''\n",
+    "        对一个 epoch 的结果进行训练的流程，\n",
+    "        一个 epoch 对应于从每个 city 出发进行一次 rollout\n",
+    "        '''\n",
+    "        tasks = [self.train_for_one_rollout(start_city_id) for start_city_id in range(self.num_cities)]\n",
+    "        await asyncio.gather(*tasks)\n",
+    "\n",
+    "    async def train(self, num_epochs=1000, display=True):\n",
+    "        '''\n",
+    "        总训练流程\n",
+    "        '''\n",
+    "        for epoch in range(num_epochs):\n",
+    "            await self.train_for_one_epoch()\n",
+    "            if display:\n",
+    "                self.draw(epoch)\n",
+    "\n",
+    "    def draw(self, epoch):\n",
+    "        '''\n",
+    "        绘图\n",
+    "        '''\n",
+    "        _ = plt.scatter(*self.cities)\n",
+    "        for fr, to in zip(self.best_path[:-1], self.best_path[1:]):\n",
+    "            x1, y1 = self.cities[:, fr]\n",
+    "            x2, y2 = self.cities[:, to]\n",
+    "            dx, dy = x2-x1, y2-y1\n",
+    "            plt.arrow(x1, y1, dx, dy, width=0.01*min(self.map_size), \n",
+    "                      edgecolor='orange', facecolor='white', animated=True, \n",
+    "                      length_includes_head=True)\n",
+    "        nrs = np.exp(self.qualities)\n",
+    "        for i in range(self.num_cities):\n",
+    "            nrs[i, i] = 0\n",
+    "        gap = np.abs(np.exp(self.normalizers) - nrs.sum(-1)).mean()\n",
+    "        plt.title(f'epoch {epoch}: path length = {self.best_path_length:.2f}, normalizer error = {gap:.3f}')\n",
+    "        plt.savefig('tsp.png')\n",
+    "        plt.show()\n",
+    "        clear_output(wait=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "tsp = TSP()\n",
+    "await tsp.train(200)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "PPO2",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Q_learning/tsp.png b/Q_learning/tsp.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce984c79aa21892a0076e9915cfb850e7ca43787
GIT binary patch
literal 45648
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

literal 0
HcmV?d00001