多目标优化下的智能交通自适应路径规划研究

import numpy as np
import random

# 定义交通网络（邻接矩阵表示）
# 0表示无连接，其他值为行驶时间
graph = np.array([
    [0, 2, 4, 0, 0],
    [2, 0, 1, 7, 0],
    [4, 1, 0, 3, 2],
    [0, 7, 3, 0, 1],
    [0, 0, 2, 1, 0]
])

n_states = graph.shape[0]
Q = np.zeros((n_states, n_states))  # 初始化Q表
gamma = 0.8  # 折扣因子
alpha = 0.5  # 学习率
episodes = 500

# 奖励矩阵：负的行驶时间（时间越短奖励越高）
R = np.where(graph > 0, -graph, -1000)

def choose_action(state):
    possible_actions = np.where(graph[state] > 0)[0]
    return random.choice(possible_actions)

for _ in range(episodes):
    state = random.randint(0, n_states-1)
    while state != n_states-1:  # 目标是到达最后一个节点
        action = choose_action(state)
        reward = R[state, action]
        Q[state, action] = Q[state, action] + alpha * (
            reward + gamma * np.max(Q[action]) - Q[state, action]
        )
        state = action

# 打印学习到的Q表
print("学习到的Q表：")
print(Q)

# 测试最优路径
def get_optimal_path(start, end):
    path = [start]
    current = start
    while current != end:
        current = np.argmax(Q[current])
        path.append(current)
    return path

print("从节点0到节点4的最优路径：", get_optimal_path(0, 4))

# 假设实时流量数据 traffic_flow 为节点流量字典
traffic_flow = {0:5, 1:10, 2:3, 3:8, 4:2}

# 更新奖励函数，根据流量调整
for i in range(n_states):
    for j in range(n_states):
        if graph[i,j] > 0:
            R[i,j] = -graph[i,j] * (1 + 0.1 * traffic_flow[j])

# 简化示例：两个智能体共享Q表信息
Q_agent1 = np.copy(Q)
Q_agent2 = np.copy(Q)

# 更新时考虑平均值作为共享知识
Q_shared = (Q_agent1 + Q_agent2) / 2

import torch
import torch.nn as nn
import torch.optim as optim
import random
import numpy as np

# 定义DQN网络
class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_dim, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, action_dim)
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

state_dim = n_states  # 状态维度
action_dim = n_states # 动作维度
dqn = DQN(state_dim, action_dim)
optimizer = optim.Adam(dqn.parameters(), lr=0.001)
criterion = nn.MSELoss()

# 训练示例（简化）
for episode in range(500):
    state = np.zeros(state_dim)
    state[random.randint(0, n_states-1)] = 1  # 独热编码初始节点
    done = False
    while not done:
        state_tensor = torch.FloatTensor(state)
        q_values = dqn(state_tensor)
        action = torch.argmax(q_values).item()
        reward = R[np.argmax(state), action]
        next_state = np.zeros(state_dim)
        next_state[action] = 1
        next_q = dqn(torch.FloatTensor(next_state)).max().item()
        target = reward + gamma * next_q
        loss = criterion(q_values[action], torch.tensor(target))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        state = next_state
        if action == n_states-1:
            done = True