当前位置：首页 > news >正文

庙算兵棋推演AI开发初探（6-神经网络开发）

news 来源：原创 2025/6/28 5:59:06

碎碎念：

老师让我和同学组队参加10月底截止报名的庙算比赛，我俩走运进了64强，打的过程中发现了一个重要问题——为什么别人总能打我，但是我都看不见！就像玩dota被对面英雄莫名其妙单杀了但是他就一直隐身我都不知道怎么死的。还一个就是，步兵在这里非常厉害，在一个地方趴窝除了火炮集火，就像一个魔免英雄，坦克战车来了只能被步兵干死。

这些都源于一张规则表，但是打起来很离谱——环境和距离视野卡对了，这和不会玩的就是两个游戏！

（碎碎念，这个游戏移动过程中都没法更改目标位置，比星际魔兽操控起来死板，而且停止和冷却的cd太长了，75秒和120秒！什么RTS也不会设这么长的冷却时间……只能说这是一个不好玩的游戏）

——2024.12以上

一、神经网络简介

本质：不断求导找拟合，使得loss收敛，使得acc预测准确率变高

用法：编码映射到标签

结构：层级输入输出、loss函数设计、优化器

二、兵棋神经网络设计

参考alphaStar的星际2的监督学习-强化学习的构建道路，同时他们有强大算力来搞大规模的“联盟对抗”（不断的自己对战自己，利用强化学习然后挑选出更好的智能体）

1.明确实现目标

普通人都能叨叨两句“用AI就能实现”，“人工智能经过训练就可以实现”……这些都是不负责任的随口乱说，我十分讨厌这种空架子（好像当初我本科毕设就是讨厌空架子写的嗅图狗来帮我识图），我们得明确我们的任务是什么！

任务：经过挑选的样本的训练，得到可以准确预测敌方兵力运动方向的神经网络。（这一步还没到可以进行对战的智能体呢！）

2.明确输出、输入，构建数据集

既然输出是预测方位，那就按六边形构建行为空间。

兵棋是六边形的格子，每个格子有6个临边。

定义：0~5,0是正右侧,按逆时针递进，加上原地不同作为6

行为空间是[0,6]，即0123456共7个行为空间。

于是输出是一个动作向量,长度为7,分别代表7个行动的概率。

有因果关系的输入，我们可以定义各种行为作为输入

比如其他兵力的位置、兵力的血量状态、位置所处的地形……

位置是一个n*m的矩阵,可以作为一个张量输入

血量可以定义为离散的1、2、3、4,作为向量输入

……

最后将这些离散的状态组合到一起，变成一个大张量作为输入

3.数学理论基础

神经网络的数学原理本质上是一个非线性函数逼近器，它通过层层线性变换+非线性激活函数来学习数据中的复杂关系。

为什么神经网络能拟合复杂函数？

线性变换+非线性激活：单独的线性变换无法拟合复杂数据，但非线性激活函数（如 ReLU、Sigmoid）允许网络学到更复杂的映射。

通用逼近定理（Universal Approximation Theorem）：只要有足够的隐藏层和神经元，神经网络可以逼近任意连续函数。

完整的神经网络训练过程：

前向传播：计算神经网络输出（经过各个节点的函数得到最后的输出）

计算损失：衡量误差（预测值、真实值之间的差距，评估方式不同loss函数也可以不同）

反向传播：计算梯度（用链式法则（Chain Rule）传播误差，从输出层向输入层更新权重）

梯度下降更新权重

重复迭代，直到收敛

常见的神经网络的不同架构（Architecture）：

MLP（多层感知机）：如果输入足够丰富（如历史轨迹、环境状态），MLP 也能拟合出未来轨迹的函数关系。

RNN / LSTM / GRU：这些模型可以记住过去的信息，从而学会时间序列的依赖关系，对短期轨迹预测效果更好。

CNN（卷积神经网络）：如果数据是空间+时间序列（如战场局势随时间变化的热力图），CNN 也可以提取空间特征并用于未来位置预测。

三、编码及实践

1.onehot编码(独热编码）

对于离散的无关的，使用onehot编码。这里采用的都是没有前后关系的离散数据，于是就用0和1来表示一切的独热编码作为编码。

2.将数据转化为编码

.举一个简单的例子，将json中的占领状态定义成离散的四种独热编码（两个点的，所以是4位长度）

# eg. [1, 0, 1, 0]
def get_city_states(stepData):"""获取夺控点状态信息:param stepData: 样本中一帧的数据:return:  夺控点信息   2个夺控点共4个值 每两位对应一个夺控点, 如果红色方占领则10, 蓝色方01, 未占领00"""cities = stepData['cities'] # [{'coord': 3636, 'value': 80, 'flag': -1, 'name': '主要夺控点'}, {'coord': 3739, 'value': 50, 'flag': -1, 'name': '次要夺控点'}]cities_info = [0] * 4 # [0, 0, 0, 0]num = 0for loc in cities:if loc['flag'] == -1: # 未占领cities_info[num:num + 2] = [0, 0]elif loc['flag'] == 0: # 红方占领cities_info[num:num + 2] = [1, 0]else: # 蓝方占领cities_info[num:num + 2] = [0, 1]num += 2# print(cities_info) # eg. [1, 0, 1, 0]return cities_info

将1-1800的连续值，变成5位的离散01独热编码。（这里展示的是利用np.hstack(np.eye(n)函数创建n阶单位矩阵，np.eye(5)[m]是提取出矩阵中的第m行）

 cur_stage = np.hstack(np.eye(5)[int(cur_step / 400)]) # eg. [0. 1. 0. 0. 0.]

还一种，选取第m行的单位阵的值，这个方法速度上经试验与上述方法一样高效，更规范不容易出错。

def OneHotcode(self,curdata,list):onehot_encoded = [0]*len(list)if curdata in list:onehot_encoded[list.index(curdata)] = 1else:onehot_encoded = [-1] * len(list)return onehot_encodedOneHotcode(m, [x for x in range(0, 5)])

深度学习与传统特征工程的主要区别在于特征提取方式的不同。传统特征工程依赖人为经验，从数据中筛选出关键特征并输入数学模型以进行预测；而深度学习则由神经网络直接从原始数据中自动提取模式，并将其应用于新的数据，以得出预测结果。

在很多情况下，数据可能表面上看似无规律，但实际上隐藏着深层结构，神经网络可能能够提取出这些模式。如果数据中隐藏着某种模式，即使是复杂的、微弱的或者掺杂噪声的，神经网络可能仍然能够学习到某种有意义的特征。这正是深度学习强大的地方——它可以发现人类难以察觉的模式，但前提是数据本身确实存在某种可学习的结构。

3. nn.Module使用

3-1模型部分

在 PyTorch 中，所有的神经网络模型都建议继承自 nn.Module，这是因为 nn.Module 提供了许多构建和管理神经网络的基础功能。

import torch
import torch.nn as nnclass MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()# 定义模型的层self.fc1 = nn.Linear(10, 20)  # 全连接层self.relu = nn.ReLU()        # 激活函数self.fc2 = nn.Linear(20, 1)  # 输出层def forward(self, x):# 定义前向传播逻辑x = self.fc1(x)x = self.relu(x)x = self.fc2(x)return x

继承 nn.Module 后，需要在 __init__ 方法中定义模型的层或子模块，并在 forward 方法中定义前向传播逻辑（输入数据x如何穿过这些层训练，又如何把这些层的函数固化让输入穿过后得到期望的输出）。

3-2训练部分

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 模拟训练
for epoch in range(10):optimizer.zero_grad()  # 清空梯度output = model(input_data)  # 前向传播loss = criterion(output, torch.randn(5, 5))  # 计算损失loss.backward()  # 反向传播optimizer.step()  # 更新参数print(f"Epoch {epoch}, Loss: {loss.item()}")

可以通过 model.parameters() 或 model.state_dict() 访问模型的参数。

# 查看模型的参数
for name, param in model.named_parameters():print(name, param.shape)# 保存模型参数
torch.save(model.state_dict(), "model.pth")# 加载模型参数
model.load_state_dict(torch.load("model.pth"))

3-3调用部分

创建模型实例后，可以像调用函数一样调用模型，输入数据会自动经过 forward 方法。

model = MyModel()
input_data = torch.randn(5, 10)  # 假设输入是一个 (5, 10) 的张量
output = model(input_data)       # 前向传播
print(output)

4.我暂时的神经网络（仅预测兵力的移动方位）

这部分目前的实现，我考虑多层的决策处理，简单的方位预测我觉得还不够实用。

以后的通用RTS游戏智能体的自定义搭建我要更灵活通用。

# 通用兵力策略网络(坦克、战车、步兵)------输出是位置预测
class troopsNN(nn.Module): """输入：游戏状态、兵种特征、空间特征、位置嵌入"""def __init__(self):"""game_stats: torch.Size([batch_size, 10, 12]) bop_features: torch.Size([batch_size, 10, 12, 44])spatial_features:torch.Size([batch_size, 10, 14, 92, 77]) -> 送入cnn的形状应该是(b, n, h, w)bop_embeddings:torch.Size([batch_size, 10, 6, 92, 77])"""super(troopsNN, self).__init__()self.mlp_fg = torch.nn.Linear(12, 6)self.mlp_fb = torch.nn.Linear(44, 25)self.cnn_fs = nn.ModuleList() self.cnn_fs.append(self.conv_layer([17, 24], kernel=3))self.cnn_fs.append(self.conv_layer([24, 48], kernel=3))self.down_sampling = nn.MaxPool2d(kernel_size=2, stride=2)self.mlp_move_direction = self.mlp_layer(7)     # TODO: 这里用mask掩码机制，使得不同兵种的动作空间不同def conv_layer(self, channel, kernel):conv_block = nn.Sequential(nn.Conv2d(in_channels=channel[0], out_channels=channel[1], kernel_size=kernel, stride=2, padding=1),nn.BatchNorm2d(num_features=channel[1]),nn.ReLU(inplace=True),)return conv_blockdef mlp_layer(self, out_dim):mlp_block = nn.Sequential(nn.Linear(5430, 2048), # notemporal 5430; temporal 54300nn.ReLU(inplace=True),nn.Linear(2048, out_dim),) return mlp_blockdef forward(self, game_stats, bop_features, spatial_features, bop_embeddings):# 处理特征game_stats = game_stats.permute(1, 0, 2) # 1, b, 12bop_features = bop_features.permute(1, 2, 0, 3) # 1, 12, b, 44spatial_features = spatial_features.permute(1, 0, 2, 3, 4) # 1, b, 23, 92, 77bop_embeddings = bop_embeddings.permute(1, 0, 2, 3, 4) # 1, b, 3, 92, 77# final_feature_bop_frame = torch.zeros((6, 10, game_stats.shape[1], 2048), device=device) # (bop, frame, batch_size, length of final feature). too big?final_feature_frame = ([0] * 1)for i in range(1):final_feature_frame[i] = [0] * game_stats.shape[1]for i in range(1):for j in range(game_stats.shape[1]):final_feature_frame[i][j] = [0] * 2048# print(np.shape(final_feature_frame)) # (1, batch_size, 2048)for i in range(1):f_game = self.mlp_fg(game_stats[i]) # input (b, 12), output (b, 6)for j in range(6): # bops' features (our_info + enemy_info)fb_j_total = self.mlp_fb(bop_features[i][j]) # in (b, 44), out(b, 25)fb_j = fb_j_total[:, :-1] # (b, 24)if j == 0:f_bops = fb_jelse:f_bops = torch.cat((f_bops, fb_j), 1) # final f_bops: (b, 24*3=72)# basic网络中不需要区分算子的位置嵌入,直接把bop_embeddings与空间特征做concat。不再需要从共享特征池做att。f_spatial = torch.cat((spatial_features[i], bop_embeddings[i]), 1) # (b, 14+3, 92, 77)for u in range(len(self.cnn_fs)):f_spatial = self.cnn_fs[u](f_spatial)f_spatial = self.down_sampling(f_spatial)f_spatial = f_spatial.view(f_spatial.shape[0], -1) # 拉平成(b, )final_feature_frame[i] = torch.cat((f_game, f_bops, f_spatial), 1) # (b, )# print(final_feature_frame[i].shape) # torch.Size([8, 5430])pred_move_dir = self.mlp_move_direction(final_feature_frame[0])return pred_move_dir

——就像高中时悟到的那样，自己的笔记是一定要记的，就算别人的笔记再详细，也不是你所经历过的路，也有很多缺失的或多余的，所以不能依赖所谓的学霸笔记，要自己有自己的笔记，自己才能随时取用自己需要的知识。