基于神经网络的弹弹堂类游戏弹道快速预测

图 1 relu训练损失曲线

图 2 relu测试数据集结果图

图 3 tanh训练损失曲线

图 4 tanh测试数据集结果图

import numpy as np

import torch

import torch.nn as nn

import torch.optim as optim

from sklearn.preprocessing import MinMaxScaler

import matplotlib.pyplot as plt

import scipy.io

# 加载 .mat 文件（替换为实际的路径）

data = scipy.io.loadmat('E:\\Learn Project\\matlab_pjt\\data.mat')

# 获取数据

data = data['data']

# 输入和输出数据

inputs = data[:, :4]  # 输入特征

outputs = data[:, 4:]  # 输出标签

# 随机分割数据为训练集和测试集

test_size = 50  # 测试集大小

indices = np.random.permutation(len(inputs))

train_indices = indices[test_size:]

test_indices = indices[:test_size]

input_train = inputs[train_indices]

output_train = outputs[train_indices]

input_test = inputs[test_indices]

output_test = outputs[test_indices]

# 数据归一化

scaler_input = MinMaxScaler()

scaler_output = MinMaxScaler()

input_train_scaled = scaler_input.fit_transform(input_train)

output_train_scaled = scaler_output.fit_transform(output_train)

input_test_scaled = scaler_input.transform(input_test)

output_test_scaled = scaler_output.transform(output_test)

# 转换为 PyTorch 张量

X_train_tensor = torch.tensor(input_train_scaled, dtype=torch.float32)

y_train_tensor = torch.tensor(output_train_scaled, dtype=torch.float32)

X_test_tensor = torch.tensor(input_test_scaled, dtype=torch.float32)

y_test_tensor = torch.tensor(output_test_scaled, dtype=torch.float32)

# 定义简单的神经网络

class SimpleNN(nn.Module):

    def __init__(self, input_size, hidden_size, output_size):

        super(SimpleNN, self).__init__()

        self.layer1 = nn.Linear(input_size, hidden_size)

        self.layer2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):

        x = torch.relu(self.layer1(x))  # 激活函数 ReLU

        x = self.layer2(x)  # 输出层

        return x

# 网络参数

input_size = input_train.shape[1]

hidden_size = 10

output_size = output_train.shape[1]

# 创建模型

model = SimpleNN(input_size, hidden_size, output_size)

# 损失函数和优化器

criterion = nn.MSELoss()  # 均方误差损失

optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型

epochs = 3000

loss_history = []  # 保存损失变化

for epoch in range(epochs):

    optimizer.zero_grad()  # 清空梯度

    output = model(X_train_tensor)  # 前向传播

    loss = criterion(output, y_train_tensor)  # 计算损失

    loss.backward()  # 反向传播

    optimizer.step()  # 更新参数

    # 记录损失

    loss_history.append(loss.item())

    # 停止条件

    if loss.item() < 1e-14:

        print(f"训练提前停止，当前迭代：{epoch}")

        break

# 绘制训练损失图

plt.plot(loss_history)

plt.xlabel('Epoch')

plt.ylabel('Loss (MSE)')

plt.title('Training Loss History')

plt.show()

# 测试模型

with torch.no_grad():

    model.eval()  # 设置模型为评估模式

    y_test_pred_scaled = model(X_test_tensor)  # 预测

    y_test_pred = scaler_output.inverse_transform(y_test_pred_scaled.numpy())  # 反归一化

# 计算每个样本的偏差

deviation = np.sqrt(np.sum((output_test - y_test_pred) ** 2, axis=1))  # 欧几里得距离

# 绘制偏差图

plt.plot(deviation, marker='o', color='red')

plt.xlabel('Sample Index')

plt.ylabel('Deviation')

plt.title('Test Deviation')

plt.show()