人工智能A*算法与CNN结合- CNN 增加卷积层的数量，并对卷积核大小进行调整

以下是一个增强版的将 A* 算法与卷积神经网络（CNN）结合的代码实现，其中 CNN 增加了卷积层的数量，并对卷积核大小进行了调整。整体思路依然是先利用 A* 算法生成训练数据，再用这些数据训练 CNN 模型，最后使用训练好的模型进行路径规划。

import numpy as np
import heapq
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader# A* 算法实现
class Node:def __init__(self, x, y, g=float('inf'), h=float('inf'), parent=None):self.x = xself.y = yself.g = gself.h = hself.f = g + hself.parent = parentdef __lt__(self, other):return self.f < other.fdef heuristic(current, goal):return abs(current[0] - goal[0]) + abs(current[1] - goal[1])def astar(grid, start, goal):rows, cols = grid.shapeopen_list = []closed_set = set()start_node = Node(start[0], start[1], g=0, h=heuristic(start, goal))heapq.heappush(open_list, start_node)while open_list:current_node = heapq.heappop(open_list)if (current_node.x, current_node.y) == goal:path = []while current_node:path.append((current_node.x, current_node.y))current_node = current_node.parentreturn path[::-1]closed_set.add((current_node.x, current_node.y))neighbors = [(0, 1), (0, -1), (1, 0), (-1, 0)]for dx, dy in neighbors:new_x, new_y = current_node.x + dx, current_node.y + dyif 0 <= new_x < rows and 0 <= new_y < cols and grid[new_x][new_y] == 0 and (new_x, new_y) not in closed_set:new_g = current_node.g + 1new_h = heuristic((new_x, new_y), goal)new_node = Node(new_x, new_y, g=new_g, h=new_h, parent=current_node)found = Falsefor i, node in enumerate(open_list):if node.x == new_x and node.y == new_y:if new_g < node.g:open_list[i] = new_nodeheapq.heapify(open_list)found = Truebreakif not found:heapq.heappush(open_list, new_node)return None# 生成训练数据
def generate_training_data(grid, num_samples):rows, cols = grid.shapeinputs = []outputs = []for _ in range(num_samples):start = (np.random.randint(0, rows), np.random.randint(0, cols))goal = (np.random.randint(0, rows), np.random.randint(0, cols))path = astar(grid, start, goal)if path:input_data = np.zeros((1, rows, cols))input_data[0, start[0], start[1]] = 1input_data[0, goal[0], goal[1]] = 2output_data = np.zeros((1, rows, cols))for point in path:output_data[0, point[0], point[1]] = 1inputs.append(input_data)outputs.append(output_data)return np.array(inputs), np.array(outputs)# 自定义数据集类
class PathDataset(Dataset):def __init__(self, inputs, outputs):self.inputs = torch.tensor(inputs, dtype=torch.float32)self.outputs = torch.tensor(outputs, dtype=torch.float32)def __len__(self):return len(self.inputs)def __getitem__(self, idx):return self.inputs[idx], self.outputs[idx]# 定义增强版卷积神经网络模型
class EnhancedPathCNN(nn.Module):def __init__(self):super(EnhancedPathCNN, self).__init__()self.conv1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)self.relu1 = nn.ReLU()self.conv2 = nn.Conv2d(32, 64, kernel_size=5, padding=2)self.relu2 = nn.ReLU()self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)self.relu3 = nn.ReLU()self.conv4 = nn.Conv2d(128, 64, kernel_size=3, padding=1)self.relu4 = nn.ReLU()self.conv5 = nn.Conv2d(64, 1, kernel_size=3, padding=1)def forward(self, x):x = self.relu1(self.conv1(x))x = self.relu2(self.conv2(x))x = self.relu3(self.conv3(x))x = self.relu4(self.conv4(x))x = self.conv5(x)return x# 训练神经网络
def train_model(model, dataloader, criterion, optimizer, epochs):for epoch in range(epochs):running_loss = 0.0for inputs, labels in dataloader:optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()print(f'Epoch {epoch + 1}, Loss: {running_loss / len(dataloader)}')# 主程序
if __name__ == "__main__":# 示例地图map_grid = np.array([[0, 0, 0, 0, 0],[0, 1, 1, 0, 0],[0, 0, 0, 0, 0],[0, 0, 1, 1, 0],[0, 0, 0, 0, 0]])# 生成训练数据num_samples = 1000inputs, outputs = generate_training_data(map_grid, num_samples)# 创建数据集和数据加载器dataset = PathDataset(inputs, outputs)dataloader = DataLoader(dataset, batch_size=32, shuffle=True)# 初始化增强版 CNN 模型model = EnhancedPathCNN()# 定义损失函数和优化器criterion = nn.MSELoss()optimizer = optim.Adam(model.parameters(), lr=0.001)# 训练模型epochs = 10train_model(model, dataloader, criterion, optimizer, epochs)# 使用训练好的模型进行路径规划start = (0, 0)goal = (4, 4)input_data = np.zeros((1, 1, map_grid.shape[0], map_grid.shape[1]))input_data[0, 0, start[0], start[1]] = 1input_data[0, 0, goal[0], goal[1]] = 2input_tensor = torch.tensor(input_data, dtype=torch.float32)output = model(input_tensor)output_path = output.detach().numpy()[0, 0]path_points = np.argwhere(output_path > 0.5)print("增强版 CNN 预测的路径点:", path_points)

代码解释

1. A* 算法部分

这部分和之前的实现基本一致，Node 类用于表示地图中的节点，heuristic 函数计算启发式代价，astar 函数通过维护开放列表和关闭列表来搜索从起点到终点的最短路径。

2. 数据生成部分

generate_training_data 函数随机生成起点和终点，调用 A* 算法计算路径，将起点、终点信息作为输入，路径信息作为输出，生成训练数据。

3. 数据集和数据加载器部分

PathDataset 类继承自 torch.utils.data.Dataset，用于封装训练数据，DataLoader 用于批量加载数据并支持随机打乱。

4. 增强版卷积神经网络部分

EnhancedPathCNN 类定义了一个更复杂的 CNN 模型，增加了卷积层的数量，同时调整了卷积核的大小。具体来说，前两层使用 5x5 的卷积核，后三层使用 3x3 的卷积核，每层卷积后都接一个 ReLU 激活函数，最后一层卷积输出单通道的预测路径。
train_model 函数使用均方误差损失函数（nn.MSELoss）和 Adam 优化器对模型进行训练，在多个 epoch 中不断更新模型参数。