2025年MathorCup数学应用挑战赛【A题解题思路第二版】|附可运行代码（无偿分享）

注：该内容由“数模加油站”原创，无偿分享，可以领取参考但不要利用该内容倒卖，谢谢！

2025年第十五届MathorCup数学应用挑战赛A题参考思路

A题聚焦于科学机器学习（SciML）中的算子学习，要求通过深度学习模型预测三维车辆几何形状下的空气阻力。核心挑战在于处理高维物理场数据（如压力场、速度场），并满足Navier-Stokes方程的物理约束。传统CFD仿真计算耗时，需构建端到端的算子网络实现秒级预测，同时确保模型在几何拓扑变化时的泛化能力。该问题涉及微分方程求解、高维数据建模与泛化性优化，属于交叉学科难题。

针对问题1：目标损失函数的最小化求解 

这一问难度其实是最小的，这个问题的核心就是通过优化算法找到让目标函数值达到最小的参数。由于目标函数结构复杂，包含指数项和自然对数项，当参数初始值较大的时候（比如100）时，函数的变化会非常剧烈，呈现高度非线性特征。这种情况下，直接通过数学公式推导求出解析解几乎不可能，必须依靠数值优化方法。首先要分析函数的单调性和极值分布，因为指数项会让函数在参数较大时迅速增长或下降，自然对数项可能导致梯度在局部区域出现剧烈波动。如果使用固定学习率的梯度下降法，很容易因为步长控制不当出现问题，当参数更新的步长太大，可能会在函数曲面上来回震荡，甚至远离极值点，就像走路时步幅太大容易错过目标位置。解决这个问题更适合采用自适应学习率的优化算法，比如Adam算法。这类算法能根据历史梯度的均值和方差动态调整学习率，在函数平缓的区域让参数更新的步幅大一些，快速接近极值点；在函数陡峭的区域让步幅小一些，避免错过极值点。另外，确定极值点的性质也很重要：找到一阶导数为零的临界点后，需要计算二阶导数（Hessian矩阵），如果二阶导数在该点是正定的，才能确定这是一个局部极小值点。实际求解时，要通过不断迭代来调整参数，每次迭代都根据当前的梯度方向和大小更新参数，并实时监控损失值的变化。如果损失值长时间不再明显下降，或者出现波动，就要考虑是否陷入了局部极小值，可以通过调整初始参数、引入动量项等方法，提高收敛到全局最优解的可能性。最后需要通过多次独立实验来验证结果的稳定性，排除数值计算误差对结论的影响。

针对问题2：数据读取与处理 

这项任务需要从复杂的三维仿真数据中提取有用信息，并构建高效的数据加载流程。核心就是从仿真文件中提取汽车表面几何特征和压力场标签，构建飞桨数据加载器。数据中包含两部分关键内容：一是车辆表面的几何信息，包括节点的坐标数据和单元之间的连接关系，这些信息描述了车辆的形状；二是物理场数据，比如每个节点上的压力分布，反映了流体在车辆表面的作用情况。在提取几何特征时，可以采用传统方法，比如计算曲率来描述表面的弯曲程度，或者用主成分分析（PCA）对高维坐标数据进行降维，保留最能反映形状差异的主要成分；也可以使用现代方法，比如自动编码器，通过神经网络自动学习低维的特征表示，这种方法在处理复杂曲面时能捕捉到更隐蔽的形状特征。一定要注意去量纲，因为不同物理量的量纲差异很大，比如坐标的单位是米，压力的单位是帕斯卡，如果不进行归一化处理，模型训练时可能会更关注量纲大的特征，忽略量纲小的特征，导致训练不稳定。对于坐标和压力等不同类型的数据，需要分别进行标准化或归一化处理，比如减去均值再除以标准差，或者缩放到0到1的区间。在飞桨框架中实现数据加载时，针对大规模数据集，要采用多进程异步读取技术，让多个进程同时读取数据，避免单个进程因为输入输出操作阻塞而浪费计算资源。同时，通过预加载技术提前将数据存入内存缓冲区，再将多个样本打包成批次进行处理，可以提高数据的加载速度和处理效率。此外，还需要优化内存管理，避免频繁申请和释放内存造成性能损耗，确保数据管道高效稳定地为模型训练提供支持。 

针对问题3：算子神经网络构建与训练 

这道题的核心任务就是设计基于深度学习的偏微分方程求解器，实现几何到压力场的快速预测，构建能够快速预测风阻的神经网络，需要让模型同时融合几何信息和物理规律。傅里叶神经算子（FNO）可以将输入数据转换到频域进行处理，利用傅里叶变换的全局特性来捕捉湍流等复杂流场的特征，这种方法在处理具有周期性或多尺度特征的物理场时非常有效。物理信息神经网络（PINN）则是将流体力学中的控制方程，比如纳维-斯托克斯方程，作为约束条件嵌入到损失函数中，让模型的预测结果不仅符合数据驱动的规律，还能满足质量守恒、动量守恒等物理定律，提高预测的合理性。 

如果使用Transformer模型，需要设计三维位置编码，将空间中的x、y、z坐标通过正弦余弦函数等方式编码成模型能够识别的特征，让自注意力机制可以感知不同位置之间的依赖关系，从而建模长距离的空间关联，比如车头形状对车尾压力分布的影响。损失函数的设计要兼顾两个方面：一是数据驱动的误差，比如用均方误差来衡量预测压力场和真实压力场的差异；二是物理一致性误差，通过计算控制方程的残差来确保预测结果符合物理规律。在训练策略上，可以分阶段进行：第一阶段先以数据驱动的损失为主，让模型学习几何信息和压力场之间的映射关系；第二阶段逐步引入物理约束，让模型在满足物理规律的前提下优化预测结果。考虑到显存和计算资源的限制，还可以采用混合精度训练技术，使用半精度浮点数进行计算，减少显存占用；或者采用模型并行技术，将网络的不同层分配到不同的GPU上，提高计算效率，确保在有限资源下完成大规模的参数更新。 

针对问题4：算法特性分析与实验验证 

这道题的难度稍微比2、3题难一些，比第五问要简单，因为分析算法特性需要从多个角度展开。在计算复杂度方面，我们既要从理论上统计模型的参数量、浮点运算次数等指标，指标反映了模型的理论复杂度；而且还要在实际运行中测量单次推理时间，了解模型在实际应用中的效率。显存占用情况需要在训练过程中进行监控，特别是在反向传播阶段，此时显存的使用量达到峰值，避免因为显存溢出导致训练中断。  实验设计要覆盖不同的数据稀疏场景，比如使用10%、50%的采样数据，通过插值或补全方法处理缺失数据，测试模型在输入信息不完整时的适应能力，这能反映模型的鲁棒性。超参数调优需要系统地探索网络深度、激活函数类型、批量大小等参数对模型精度的影响，可以采用网格搜索或随机搜索等方法。为了防止过拟合，还需要结合早停策略，当验证集上的误差连续多轮不再下降时，提前终止训练，避免模型在训练集上过拟合。最终，要在全量数据上验证两个核心指标：一是压力场预测的误差是否满足要求，比如说均方根误差是否低于预设阈值；二是阻力系数的预测误差是否在工程可接受的范围内。通过实验总结不同模型配置下精度、速度和显存占用之间的权衡关系，为模型的实际部署提供参考依据。 

针对问题5：注意力机制与神经算子的理论联系 

这一问难度是最大的，从数学理论的角度来看，神经算子的核心是将输入函数映射到输出函数，它通过基函数展开或积分核近似的方法，来建模无限维函数空间中的映射关系。注意力机制则是通过计算查询向量和键向量之间的相似度，生成注意力权重，然后对值向量进行加权求和，实现对输入特征的动态聚合。这两种方法在本质上存在联系：可以将注意力权重看作神经算子中的积分核，值向量看作基函数在不同点的表示，那么注意力机制的输出就相当于神经算子中的积分运算结果。 

具体来说，神经算子的输出可以表示为对输入函数在不同点的加权积分，而注意力机制通过动态计算权重，实现了对输入特征的自适应加权组合，这相当于在函数空间中定义了一个动态的局部关联算子。通过数学推导可以证明，当注意力头的数量和维度足够时，标准自注意力层能够逼近特定类型的神经算子，说明注意力机制是神经算子在离散化、参数化场景下的一种特例。在实验中，可以通过固定神经算子的基函数，对比注意力机制在相同任务中的表现，验证两者在理论上的一致性，为结合使用这两种方法提供理论支持，帮助理解它们在建模函数映射时的内在联系。

参考代码：

1. 傅里叶神经算子（FNO）核心代码：

import torch
import torch.nn as nn
import torch.nn.functional as F

class FNO2d(nn.Module):
    """二维傅里叶神经算子层"""
    def __init__(self, in_channels, out_channels, modes1, modes2):
        super(FNO2d, self).__init__()
        
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.modes1 = modes1  # 第一个维度的傅里叶模态数
        self.modes2 = modes2  # 第二个维度的傅里叶模态数
        
        # 定义可学习的频域权重
        self.weights1 = nn.Parameter(torch.randn(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))
        self.weights2 = nn.Parameter(torch.randn(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))

    def forward(self, x):
        batchsize = x.shape[0]
        size_x, size_y = x.shape[2], x.shape[3]
        
        # 对输入进行二维傅里叶变换
        x_ft = torch.fft.rfft2(x, s=(size_x, size_y))
        
        # 提取频域中的低秩模态
        x_ft = x_ft[:, :, :self.modes1, :self.modes2]
        
        # 频域卷积操作（逐通道相乘后累加）
        out_ft = torch.zeros(batchsize, self.out_channels, self.modes1, self.modes2, dtype=torch.cfloat, device=x.device)
        for i in range(self.in_channels):
            out_ft += x_ft[:, i:i+1] * self.weights1[i] + x_ft[:, i:i+1] * self.weights2[i]  # 示例中的双权重结构
        
        # 逆傅里叶变换回空间域
        out = torch.fft.irfft2(out_ft, s=(size_x, size_y))
        
        return out

class FNOModel(nn.Module):
    """完整的傅里叶神经算子模型"""
    def __init__(self, in_channels, hidden_channels, out_channels, modes1, modes2, layers=3):
        super(FNOModel, self).__init__()
        self.layers = layers
        self.in_channels = in_channels
        self.hidden_channels = hidden_channels
        
        # 输入层：将输入映射到隐藏空间
        self.fc0 = nn.Linear(in_channels, hidden_channels)
        
        # 构建多个FNO层和非线性激活层
        self.fno_layers = nn.ModuleList()
        for _ in range(layers):
            self.fno_layers.append(FNO2d(hidden_channels, hidden_channels, modes1, modes2))
            self.activation = nn.GELU()  # 选择光滑的激活函数
        
        # 输出层：从隐藏空间映射到输出
        self.fc1 = nn.Linear(hidden_channels, hidden_channels)
        self.fc2 = nn.Linear(hidden_channels, out_channels)

    def forward(self, x):
        # 输入形状假设：(batch, channels, x_dim, y_dim)
        batchsize = x.shape[0]
        size_x, size_y = x.shape[2], x.shape[3]
        
        # 展平空间维度以便全连接层处理
        x = x.view(batchsize, self.in_channels, -1)
        x = self.fc0(x)  # 输入层映射
        x = x.view(batchsize, self.hidden_channels, size_x, size_y)
        
        # 多层FNO处理
        for fno_layer in self.fno_layers:
            x = fno_layer(x)
            x = self.activation(x)
        
        # 输出处理
        x = x.view(batchsize, self.hidden_channels, -1)
        x = self.fc1(x)
        x = self.activation(x)
        x = self.fc2(x)
        x = x.view(batchsize, -1, size_x, size_y)  # 恢复空间维度
        
        return x

2. 物理信息神经网络（PINN）核心代码：

import torch
import torch.nn as nn

class PINN(nn.Module):
    """物理信息神经网络基类，支持任意维度微分方程约束"""
    def __init__(self, input_dim, hidden_dim, output_dim, layers=3):
        super(PINN, self).__init__()
        self.layers = layers
        self.fc = nn.ModuleList()
        self.fc.append(nn.Linear(input_dim, hidden_dim))
        for _ in range(layers-1):
            self.fc.append(nn.Linear(hidden_dim, hidden_dim))
        self.fc.append(nn.Linear(hidden_dim, output_dim))
        
    def forward(self, x):
        """前向传播函数"""
        for i, layer in enumerate(self.fc):
            x = layer(x)
            if i < self.layers:  # 避免最后一层激活
                x = torch.tanh(x)  # 选择平滑激活函数便于微分
        return x
    
    def get_derivatives(self, x, output, order=1):
        """计算指定阶数的空间导数（支持多维）"""
        grads = [output]
        for _ in range(order):
            grads.append(torch.autograd.grad(
                grads[-1], x, grad_outputs=torch.ones_like(grads[-1]), 
                create_graph=True, retain_graph=True
            )[0])
        return grads[1:order+1]  # 返回1阶到n阶导数

def pinn_loss(pred, true, physics_residual, data_weight=1.0, physics_weight=1.0):
    """组合数据损失与物理约束损失"""
    data_loss = torch.mean((pred - true)**2)
    physics_loss = torch.mean(physics_residual**2)
    return data_weight * data_loss + physics_weight * physics_weight

# 示例：泊松方程PINN实现（-∇²u = f(x,y)）
class PoissonPINN(PINN):
    def __init__(self, hidden_dim=64, layers=4):
        super(PoissonPINN, self).__init__(input_dim=2, hidden_dim=hidden_dim, output_dim=1, layers=layers)
    
    def forward(self, x):
        return super(PoissonPINN, self).forward(x)
    
    def physics_equation(self, x):
        """计算泊松方程残差：-∂²u/∂x² - ∂²u/∂y² - f(x,y)"""
        u = self(x)
        du_dx, du_dy = self.get_derivatives(x, u, order=1)
        d2u_dx2, _ = self.get_derivatives(x, du_dx, order=1)
        _, d2u_dy2 = self.get_derivatives(x, du_dy, order=1)
        f = 10 * torch.sin(torch.pi * x[:,0:1]) * torch.sin(torch.pi * x[:,1:2])  # 示例源项
        residual = -d2u_dx2 - d2u_dy2 - f
        return residual

# 训练流程示例
if __name__ == "__main__":
    # 生成数据：边界条件+内部残差点
    x_boundary = torch.randn(100, 2)  # 边界点坐标
    u_boundary = torch.sin(torch.pi * x_boundary[:,0:1]) * torch.sin(torch.pi * x_boundary[:,1:2])  # 解析解
    
    x_interior = torch.randn(1000, 2)  # 内部残差点
    
    model = PoissonPINN()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    
    for epoch in range(1000):
        optimizer.zero_grad()
        
        # 计算边界损失
        u_pred = model(x_boundary)
        data_loss = torch.mean((u_pred - u_boundary)**2)
        
        # 计算物理损失
        residual = model.physics_equation(x_interior)
        physics_loss = torch.mean(residual**2)
        
        total_loss = data_loss + 0.1 * physics_loss
        total_loss.backward()
        optimizer.step()
        
        if epoch % 100 == 0:
            print(f"Epoch {epoch}, Total Loss: {total_loss.item():.6f}")
    
3. Transformer模型核心算法：
import torch
import torch.nn as nn
import torch.nn.functional as F

class PositionalEncoding(nn.Module):
    """位置编码层（正弦余弦函数生成）"""
    def __init__(self, d_model, max_len=5000):
        super(PositionalEncoding, self).__init__()
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        self.register_buffer('pe', pe.unsqueeze(0))  # 形状: [1, max_len, d_model]

    def forward(self, x):
        """输入形状: [batch_size, seq_len, d_model]"""
        x = x + self.pe[:, :x.size(1)]
        return x

class MultiHeadAttention(nn.Module):
    """多头自注意力机制"""
    def __init__(self, d_model, n_heads):
        super(MultiHeadAttention, self).__init__()
        self.d_model = d_model
        self.n_heads = n_heads
        self.head_dim = d_model // n_heads
        
        # 线性变换层
        self.q_linear = nn.Linear(d_model, d_model)
        self.k_linear = nn.Linear(d_model, d_model)
        self.v_linear = nn.Linear(d_model, d_model)
        self.out_linear = nn.Linear(d_model, d_model)
        
    def forward(self, q, k, v, mask=None):
        batch_size = q.size(0)
        
        # 分割多头: [batch_size, seq_len, n_heads, head_dim]
        q = self.q_linear(q).view(batch_size, -1, self.n_heads, self.head_dim).transpose(1, 2)
        k = self.k_linear(k).view(batch_size, -1, self.n_heads, self.head_dim).transpose(1, 2)
        v = self.v_linear(v).view(batch_size, -1, self.n_heads, self.head_dim).transpose(1, 2)
        
        # 计算注意力分数: [batch_size, n_heads, seq_len, seq_len]
        scores = (q @ k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float))
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        attention = F.softmax(scores, dim=-1)
        
        # 加权求和: [batch_size, n_heads, seq_len, head_dim]
        context = attention @ v
        # 合并多头: [batch_size, seq_len, d_model]
        context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        return self.out_linear(context)

class EncoderLayer(nn.Module):
    """编码器层（自注意力+前馈网络）"""
    def __init__(self, d_model, n_heads, d_ff=2048, dropout=0.1):
        super(EncoderLayer, self).__init__()
        self.self_attn = MultiHeadAttention(d_model, n_heads)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Linear(d_ff, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, x, mask=None):
        # 自注意力层
        attn_output = self.self_attn(x, x, x, mask)
        x = self.norm1(x + self.dropout(attn_output))
        
        # 前馈网络层
        ffn_output = self.ffn(x)
        x = self.norm2(x + self.dropout(ffn_output))
        return x

class DecoderLayer(nn.Module):
    """解码器层（自注意力+编码器-解码器注意力+前馈网络）"""
    def __init__(self, d_model, n_heads, d_ff=2048, dropout=0.1):
        super(DecoderLayer, self).__init__()
        self.self_attn = MultiHeadAttention(d_model, n_heads)
        self.src_attn = MultiHeadAttention(d_model, n_heads)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Linear(d_ff, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.norm3 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, x, memory, src_mask=None, tgt_mask=None):
        # 目标序列自注意力（带掩码防止看到未来信息）
        attn_output = self.self_attn(x, x, x, tgt_mask)
        x = self.norm1(x + self.dropout(attn_output))
        
        # 编码器-解码器注意力
        attn_output = self.src_attn(x, memory, memory, src_mask)
        x = self.norm2(x + self.dropout(attn_output))
        
        # 前馈网络
        ffn_output = self.ffn(x)
        x = self.norm3(x + self.dropout(ffn_output))
        return x

class Transformer(nn.Module):
    """完整Transformer模型"""
    def __init__(self, src_vocab_size, tgt_vocab_size, d_model=512, n_heads=8, n_layers=6, d_ff=2048, dropout=0.1):
        super(Transformer, self).__init__()
        self.encoder_embed = nn.Embedding(src_vocab_size, d_model)
        self.decoder_embed = nn.Embedding(tgt_vocab_size, d_model)
        self.pos_encoder = PositionalEncoding(d_model)
        self.pos_decoder = PositionalEncoding(d_model)
        
        self.encoder_layers = nn.ModuleList([
            EncoderLayer(d_model, n_heads, d_ff, dropout) for _ in range(n_layers)
        ])
        self.decoder_layers = nn.ModuleList([
            DecoderLayer(d_model, n_heads, d_ff, dropout) for _ in range(n_layers)
        ])
        self.out_linear = nn.Linear(d_model, tgt_vocab_size)
        
        self.dropout = nn.Dropout(dropout)
        self.d_model = d_model
        
    def encode(self, src, src_mask):
        """编码器流程"""
        src = self.encoder_embed(src) * torch.sqrt(torch.tensor(self.d_model, dtype=torch.float))
        src = self.pos_encoder(self.dropout(src))
        for layer in self.encoder_layers:
            src = layer(src, src_mask)
        return src
        
    def decode(self, tgt, memory, src_mask, tgt_mask):
        """解码器流程"""
        tgt = self.decoder_embed(tgt) * torch.sqrt(torch.tensor(self.d_model, dtype=torch.float))
        tgt = self.pos_decoder(self.dropout(tgt))
        for layer in self.decoder_layers:
            tgt = layer(tgt, memory, src_mask, tgt_mask)
        return tgt
        
    def forward(self, src, tgt, src_mask, tgt_mask):
        """完整前向传播"""
        memory = self.encode(src, src_mask)
        output = self.decode(tgt, memory, src_mask, tgt_mask)
        return self.out_linear(output)

# 示例用法
if __name__ == "__main__":
    # 超参数设置
    d_model = 512
    n_heads = 8
    n_layers = 6
    src_vocab_size = 1000
    tgt_vocab_size = 1000
    max_seq_len = 100
    
    # 初始化模型
    model = Transformer(
        src_vocab_size=src_vocab_size,
        tgt_vocab_size=tgt_vocab_size,
        d_model=d_model,
        n_heads=n_heads,
        n_layers=n_layers
    )
    
    # 输入数据（批次大小=2，源序列长度=20，目标序列长度=15）
    src = torch.randint(0, src_vocab_size, (2, 20))
    tgt = torch.randint(0, tgt_vocab_size, (2, 15))
    
    # 生成掩码（填充位置为0，有效位置为1）
    src_mask = (src != 0).unsqueeze(1).unsqueeze(2)
    tgt_mask = (tgt != 0).unsqueeze(1).unsqueeze(2) & \
               torch.triu(torch.ones(tgt.size(1), tgt.size(1)), diagonal=1).bool().unsqueeze(0).unsqueeze(1)
    
    # 前向传播
    output = model(src, tgt, src_mask, tgt_mask)
    print(f"Output Shape: {output.shape}")  # 应输出: [2, 15, tgt_vocab_size]

参考链接：

1.Fourier Neural Operator (FNO)：在频域学习微分算子，适合高雷诺数湍流场的全局特征捕捉:

DeepONet & FNO 开源项目教程-CSDN博客

2. Physics-Informed Neural Network (PINN): 将N-S方程作为软约束加入损失函数，增强物理一致性。

物理信息神经网络PINNs : Physics Informed Neural Networks 详解-CSDN博客

3. Transformer：通过自注意力机制建模长程依赖，需引入位置编码处理三维坐标。

【NLP解析】多头注意力+掩码机制+位置编码：Transformer三大核心技术详解-CSDN博客

参考文献：

[1]陈凯,李佳琳,王朋波,等.基于几何信息神经算子的参数化汽车几何风阻预测模型[C]//中国汽车工程学会汽车空气动力学分会.2024中国汽车工程学会汽车空气动力学分会学术年会论文集.百度公司;北京汽车研究总院;清华大学自动化系;,2024:2-11.DOI:10.26914/c.cnkihy.2024.023235.

[2]王刚,张瑞昊,刘学龙,等.融合稀疏八叉树与卷积神经网络的汽车风阻系数预测[J].计算力学学报,2024,41(01):58-65.

[3]唐经添.基于灵敏度与中心组合设计的商用车风阻研究及优化[D].桂林电子科技大学,2023.DOI:10.27049/d.cnki.ggldc.2023.000076.

[4]廖洪.车轮结构参数及其气动套件对整车风阻的影响分析[D].西南交通大学,2022.DOI:10.27414/d.cnki.gxnju.2022.001659.

[5]杨易,高骏,谷正气,等.基于GA-BP的汽车风振噪声声品质预测模型[J].机械工程学报,2021,57(24):241-249.

[6]王正炬.某MPV车型整车风阻预测模型的研究[D].武汉理工大学,2021.DOI:10.27381/d.cnki.gwlgu.2021.000251.

[7]张全周.汽车风振噪声预测方法与优化控制研究[D].重庆大学,2020.DOI:10.27670/d.cnki.gcqdu.2020.000333.

[8]尹善斌.汽车风振噪声声品质预测与空气射流优化[D].湖南大学,2019.DOI:10.27135/d.cnki.ghudu.2019.001646.

[9]闫坤,徐飞,侯志旭.基于BP神经网络的暖风散热器传热和风阻性能预测[C]//河南省科学技术协会.第十四届河南省汽车工程科技学术研讨会论文集.豫新汽车空调股份有限公司;,2017:155-158.