生成基于栅格地图的bilstm改进的A*算法的路径规划python代码

以下是基于栅格地图的BiLSTM改进的A*算法的路径规划Python代码：

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

# 定义BiLSTM模型
class BiLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, num_classes):
        super(BiLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, bidirectional=True)
        self.fc = nn.Linear(hidden_size*2, num_classes)
        
    def forward(self, x):
        h0 = torch.zeros(self.num_layers*2, x.size(0), self.hidden_size).to(device)
        c0 = torch.zeros(self.num_layers*2, x.size(0), self.hidden_size).to(device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

# 定义A*算法类
class AStar:
    def __init__(self, map_size, start, end):
        self.map_size = map_size
        self.start = start
        self.end = end
        self.open_list = []
        self.close_list = []
        self.father = {}
        self.g_score = {}
        self.h_score = {}
        self.f_score = {}
        self.bi_lstm = None
        
    # 定义启发函数
    def heuristic(self, a, b):
        return np.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)
    
    # 定义判断点是否在地图内
    def in_map(self, point):
        return point[0]>=0 and point[0]<self.map_size[0] and point[1]>=0 and point[1]<self.map_size[1]
    
    # 定义判断点是否可通过
    def passable(self, point, map):
        return map[point[0]][point[1]]==0
    
    # 定义获取相邻点列表
    def get_neighbors(self, point, map):
        neighbors = []
        for i in [-1, 0, 1]:
            for j in [-1, 0, 1]:
                if i==0 and j==0:
                    continue
                neighbor = (point[0]+i, point[1]+j)
                if self.in_map(neighbor) and self.passable(neighbor, map):
                    neighbors.append(neighbor)
        return neighbors
    
    # 定义获取路径
    def get_path(self, current):
        path = []
        while current:
            path.append(current)
            current = self.father.get(current)
        path.reverse()
        return path
    
    # 定义A*算法函数
    def astar(self, map):
        self.open_list.append(self.start)
        self.g_score[self.start] = 0
        self.h_score[self.start] = self.heuristic(self.start, self.end)
        self.f_score[self.start] = self.h_score[self.start]
        
        while self.open_list:
            current = min(self.open_list, key=lambda x:self.f_score[x])
            
            if current == self.end:
                return self.get_path(current)
            
            self.open_list.remove(current)
            self.close_list.append(current)
            
            for neighbor in self.get_neighbors(current, map):
                if neighbor in self.close_list:
                    continue
                
                g = self.g_score[current] + self.heuristic(current, neighbor)
                
                if neighbor not in self.open_list:
                    self.open_list.append(neighbor)
                    self.h_score[neighbor] = self.heuristic(neighbor, self.end)
                    self.g_score[neighbor] = g
                    self.f_score[neighbor] = self.g_score[neighbor] + self.h_score[neighbor]
                    self.father[neighbor] = current
                elif g < self.g_score[neighbor]:
                    self.g_score[neighbor] = g
                    self.f_score[neighbor] = self.g_score[neighbor] + self.h_score[neighbor]
                    self.father[neighbor] = current
                    
        return None
    
    # 定义训练BiLSTM模型函数
    def train(self, x_train, y_train, num_epochs=100, learning_rate=0.001):
        self.bi_lstm = BiLSTM(2, 128, 2, 2).to(device)
        criterion = nn.CrossEntropyLoss()
        optimizer = optim.Adam(self.bi_lstm.parameters(), lr=learning_rate)
        
        for epoch in range(num_epochs):
            inputs = torch.Tensor(x_train).to(device)
            targets = torch.Tensor(y_train).long().to(device)
            
            optimizer.zero_grad()
            
            outputs = self.bi_lstm(inputs)
            loss = criterion(outputs, targets)
            loss.backward()
            optimizer.step()
            
            if (epoch+1) % 10 == 0:
                print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
    
    # 定义预测函数
    def predict(self, x):
        inputs = torch.Tensor(x).to(device)
        outputs = self.bi_lstm(inputs)
        _, predicted = torch.max(outputs.data, 1)
        return predicted.cpu().numpy()[0]
    
    # 定义路径规划函数
    def path_planning(self, map, smooth=False):
        x_train = []
        y_train = []
        for i in range(self.map_size[0]):
            for j in range(self.map_size[1]):
                if (i,j) == self.start or (i,j) == self.end:
                    continue
                x_train.append([i,j])
                y_train.append(int(map[i][j]))
        self.train(x_train, y_train)
        
        current = self.start
        path = [current]
        while current != self.end:
            neighbors = self.get_neighbors(current, map)
            if not neighbors:
                return None
            
            features = []
            for neighbor in neighbors:
                feature = [neighbor[0], neighbor[1], self.heuristic(neighbor, self.end)]
                feature.append(self.predict([feature]))
                features.append(feature)
                
            features = np.array(features)
            index = np.argmin(features[:,2] + features[:,3]*0.5)
            next = tuple(features[index][:2].astype(int))
            path.append(next)
            current = next
            
        if smooth:
            return self.smooth_path(path, map)
        else:
            return path
    
    # 定义路径平滑函数
    def smooth_path(self, path, map):
        smooth_path = [path[0]]
        i = 0
        while i < len(path)-1:
            j = i+1
            while j < len(path)-1:
                if not self.passable(path[i], path[j], map):
                    break
                j += 1
            smooth_path.append(path[j-1])
            i = j-1
        smooth_path.append(path[-1])
        return smooth_path

使用方法：

# 定义地图大小、起点、终点
map_size = (10, 10)
start = (1, 1)
end = (8, 8)

# 定义地图
map = np.zeros(map_size)
map[3:7, 4:8] = 1

# 定义A*算法对象
astar = AStar(map_size, start, end)

# 进行路径规划
path = astar.path_planning(map, smooth=True)
print(path)

其中，`map_size`为地图大小，`start`为起点坐标，`end`为终点坐标，`map`为地图，0表示可通过的点，1表示障碍物。`path_planning`函数的第二个参数`smooth`表示是否对路径进行平滑处理。