✅博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。
✅成品或者定制，扫描文章底部微信二维码。
(1) 基于注意力增强卷积网络的车辆轴承智能故障诊断方法
混合动力车辆在运行过程中承受着复杂多变的工况载荷，其传动系统中的滚动轴承作为关键支撑部件，长期处于高转速、变载荷和多应力耦合的工作环境中，故障发生率较高。及时准确地诊断轴承故障状态对于保障车辆安全运行和制定合理维护策略具有重要意义。然而在实际工业场景中，轴承振动信号采集过程中会混入大量与故障无关的冗余信息，包括路面激励传递的低频振动、发动机和电机产生的周期性干扰以及测量系统引入的随机噪声等，这些因素严重影响了故障特征的可辨识度。传统的深度学习诊断模型将所有输入特征同等对待，缺乏对关键故障信息的选择性关注能力，导致在复杂工况下的诊断准确率不够理想。针对这一问题，本研究提出一种融合卷积神经网络与自适应注意力机制的混合诊断框架。在特征提取阶段，设计多尺度卷积模块并行提取不同感受野范围内的局部特征，短核卷积捕捉高频细节信息，长核卷积获取低频趋势特征，两者互补形成更加全面的特征表示。在特征筛选阶段，引入动态注意力权重生成模块，该模块通过学习输入特征的全局上下文信息自动计算各通道和各空间位置的重要性权重，对包含故障敏感信息的特征图区域进行自适应增强，同时抑制冗余干扰成分的影响。为了进一步提升模型的训练效率和泛化性能，设计了一种自适应软阈值参数优化策略，将可学习的阈值参数嵌入网络结构中实现特征的自动稀疏化，在保留主要故障特征的同时过滤掉噪声和冗余信息。
(2) 基于多任务剖面的复杂系统可靠性建模与评估方法
混合动力车辆装备是由动力系统、传动系统、控制系统和辅助系统等多个子系统组成的复杂机电系统，各子系统之间存在紧密的功能耦合和信息交互关系。在实际使用过程中，车辆需要执行多种不同的任务剖面，如城市工况行驶、高速巡航、坡道爬升和制动能量回收等，不同任务对各子系统的负载要求和工作模式存在显著差异，这种多任务耦合特性给系统可靠性分析带来了特殊挑战。本研究提出一种基于目标导向方法论的多任务可靠性建模方法，该方法能够有效处理复杂系统中功能流、信息流和能量流的传递关系以及多任务环境下的可靠性耦合问题。首先根据车辆装备的功能层次结构建立系统的目标导向模型图，将系统分解为若干个具有明确输入输出关系的操作单元，每个操作单元对应特定的功能实现或状态转换。然后针对每种任务剖面分析各操作单元的工作状态和故障模式，根据任务持续时间、环境应力强度和负载特性等因素为每个单元分配相应的故障率参数。针对多任务环境下的可靠性耦合问题，引入任务权重因子建立任务类型与故障模式之间的动态关联模型，同一部件在不同任务下的等效故障率根据其实际工作强度进行调整。利用目标导向模型的结构特点可以方便地计算系统在各任务剖面下的可靠度以及整个任务序列的综合可靠度，同时还能够识别出对系统可靠性影响最大的关键路径和薄弱环节。
(3) 基于蒙特卡洛仿真与故障树融合的多阶段系统可靠性评估框架
当车辆装备需要连续执行多个具有时序依赖关系的任务阶段时，前序阶段的运行状态和累积损伤会对后续阶段的可靠性产生影响，这种阶段间的耦合效应使得传统的单阶段可靠性分析方法不再适用。本研究提出一种融合蒙特卡洛仿真与故障树分析的多阶段可靠性评估框架，能够同时考虑任务阶段内的故障逻辑关系和任务阶段间的状态依赖关系。首先针对每个任务阶段建立相应的故障树模型，确定导致该阶段任务失败的顶层事件以及与之关联的中间事件和底层基本事件，通过逻辑与门和或门描述事件之间的因果传递关系。故障树模型可以清晰地展示系统故障的演化路径并支持定性的最小割集分析，识别出能够单独导致系统失效的关键部件组合。在此基础上，采用蒙特卡洛仿真方法对多阶段任务系统进行定量可靠性评估。仿真过程中为每个基本事件生成符合其寿命分布的随机失效时间样本，按照任务时序逐阶段推进系统状态，在每个阶段结束时根据部件状态和故障树逻辑判断任务是否成功。
import numpy as np import torch import torch.nn as nn from torch.utils.data import DataLoader, TensorDataset from sklearn.model_selection import train_test_split from collections import defaultdict class ChannelAttentionModule(nn.Module): def __init__(self, channels, reduction=16): super(ChannelAttentionModule, self).__init__() self.avg_pool = nn.AdaptiveAvgPool1d(1) self.max_pool = nn.AdaptiveMaxPool1d(1) self.fc = nn.Sequential( nn.Linear(channels, channels // reduction, bias=False), nn.ReLU(inplace=True), nn.Linear(channels // reduction, channels, bias=False) ) self.sigmoid = nn.Sigmoid() def forward(self, x): b, c, _ = x.size() avg_out = self.fc(self.avg_pool(x).view(b, c)) max_out = self.fc(self.max_pool(x).view(b, c)) attention = self.sigmoid(avg_out + max_out).view(b, c, 1) return x * attention class SoftThresholdLayer(nn.Module): def __init__(self, channels): super(SoftThresholdLayer, self).__init__() self.threshold = nn.Parameter(torch.ones(1, channels, 1) * 0.1) def forward(self, x): mask = torch.abs(x) - self.threshold mask = torch.clamp(mask, min=0) return torch.sign(x) * mask class MultiScaleConvBlock(nn.Module): def __init__(self, in_channels, out_channels): super(MultiScaleConvBlock, self).__init__() self.conv1 = nn.Conv1d(in_channels, out_channels // 3, kernel_size=3, padding=1) self.conv2 = nn.Conv1d(in_channels, out_channels // 3, kernel_size=5, padding=2) self.conv3 = nn.Conv1d(in_channels, out_channels - 2 * (out_channels // 3), kernel_size=7, padding=3) self.bn = nn.BatchNorm1d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x): out1 = self.conv1(x) out2 = self.conv2(x) out3 = self.conv3(x) out = torch.cat([out1, out2, out3], dim=1) return self.relu(self.bn(out)) class AttentionEnhancedCNN(nn.Module): def __init__(self, input_length, num_classes): super(AttentionEnhancedCNN, self).__init__() self.conv1 = MultiScaleConvBlock(1, 64) self.attention1 = ChannelAttentionModule(64) self.threshold1 = SoftThresholdLayer(64) self.pool1 = nn.MaxPool1d(2) self.conv2 = MultiScaleConvBlock(64, 128) self.attention2 = ChannelAttentionModule(128) self.threshold2 = SoftThresholdLayer(128) self.pool2 = nn.MaxPool1d(2) self.conv3 = MultiScaleConvBlock(128, 256) self.attention3 = ChannelAttentionModule(256) self.global_pool = nn.AdaptiveAvgPool1d(1) self.fc = nn.Sequential( nn.Linear(256, 128), nn.ReLU(), nn.Dropout(0.5), nn.Linear(128, num_classes) ) def forward(self, x): if x.dim() == 2: x = x.unsqueeze(1) x = self.conv1(x) x = self.attention1(x) x = self.threshold1(x) x = self.pool1(x) x = self.conv2(x) x = self.attention2(x) x = self.threshold2(x) x = self.pool2(x) x = self.conv3(x) x = self.attention3(x) x = self.global_pool(x).squeeze(-1) return self.fc(x) class GOMethodOperator: def __init__(self, operator_id, operator_type, failure_rate): self.id = operator_id self.type = operator_type self.base_failure_rate = failure_rate self.inputs = [] self.output = None def compute_reliability(self, input_reliabilities, mission_duration, stress_factor=1.0): effective_failure_rate = self.base_failure_rate * stress_factor if self.type == 'series': R_self = np.exp(-effective_failure_rate * mission_duration) return R_self * np.prod(input_reliabilities) elif self.type == 'parallel': R_self = np.exp(-effective_failure_rate * mission_duration) return R_self * (1 - np.prod(1 - np.array(input_reliabilities))) elif self.type == 'standby': R_self = np.exp(-effective_failure_rate * mission_duration) return R_self * (np.sum(input_reliabilities) / len(input_reliabilities)) return np.exp(-effective_failure_rate * mission_duration) class MultiTaskGOModel: def __init__(self): self.operators = {} self.topology = {} self.task_profiles = {} def add_operator(self, operator): self.operators[operator.id] = operator def define_topology(self, connections): self.topology = connections def define_task_profile(self, task_name, stress_factors, duration): self.task_profiles[task_name] = { 'stress_factors': stress_factors, 'duration': duration } def compute_system_reliability(self, task_name): profile = self.task_profiles[task_name] operator_reliabilities = {} sorted_operators = self._topological_sort() for op_id in sorted_operators: op = self.operators[op_id] input_rels = [operator_reliabilities[inp] for inp in self.topology.get(op_id, [])] if len(input_rels) == 0: input_rels = [1.0] stress = profile['stress_factors'].get(op_id, 1.0) operator_reliabilities[op_id] = op.compute_reliability( input_rels, profile['duration'], stress ) return operator_reliabilities[sorted_operators[-1]] def _topological_sort(self): visited = set() order = [] def dfs(node): if node in visited: return visited.add(node) for inp in self.topology.get(node, []): dfs(inp) order.append(node) for op_id in self.operators: dfs(op_id) return order class FaultTreeNode: def __init__(self, name, node_type, failure_prob=None): self.name = name self.node_type = node_type self.failure_prob = failure_prob self.children = [] def add_child(self, child): self.children.append(child) def compute_probability(self): if self.node_type == 'basic': return self.failure_prob child_probs = [c.compute_probability() for c in self.children] if self.node_type == 'AND': return np.prod(child_probs) elif self.node_type == 'OR': return 1 - np.prod([1 - p for p in child_probs]) return 0 class MonteCarloFTASimulator: def __init__(self, fault_tree, num_simulations=10000): self.fault_tree = fault_tree self.num_simulations = num_simulations self.basic_events = self._collect_basic_events(fault_tree) def _collect_basic_events(self, node): events = [] if node.node_type == 'basic': events.append(node) for child in node.children: events.extend(self._collect_basic_events(child)) return events def simulate_single_phase(self, duration, previous_failures=None): if previous_failures is None: previous_failures = set() current_failures = previous_failures.copy() for event in self.basic_events: if event.name in current_failures: continue failure_rate = -np.log(1 - event.failure_prob) ttf = np.random.exponential(1 / failure_rate) if ttf < duration: current_failures.add(event.name) return current_failures def evaluate_system_state(self, failures, node=None): if node is None: node = self.fault_tree if node.node_type == 'basic': return node.name in failures child_states = [self.evaluate_system_state(failures, c) for c in node.children] if node.node_type == 'AND': return all(child_states) elif node.node_type == 'OR': return any(child_states) return False def run_multiphase_simulation(self, phase_durations): phase_reliabilities = [] system_successes = 0 for _ in range(self.num_simulations): failures = set() all_phases_success = True for duration in phase_durations: failures = self.simulate_single_phase(duration, failures) if self.evaluate_system_state(failures): all_phases_success = False break if all_phases_success: system_successes += 1 return system_successes / self.num_simulations def compute_importance_measures(self, duration): base_unreliability = 1 - self.run_multiphase_simulation([duration]) importance = {} for event in self.basic_events: original_prob = event.failure_prob event.failure_prob = 1.0 unreliability_with_failure = 1 - self.run_multiphase_simulation([duration]) event.failure_prob = 0.0 unreliability_without_failure = 1 - self.run_multiphase_simulation([duration]) event.failure_prob = original_prob importance[event.name] = unreliability_with_failure - unreliability_without_failure return importance class VehicleDiagnosisAndReliabilityPlatform: def __init__(self): self.diagnosis_model = AttentionEnhancedCNN(2048, 4) self.go_model = self._build_go_model() self.fault_tree = self._build_fault_tree() self.mc_simulator = MonteCarloFTASimulator(self.fault_tree) def _build_go_model(self): model = MultiTaskGOModel() model.add_operator(GOMethodOperator('engine', 'series', 0.0001)) model.add_operator(GOMethodOperator('motor', 'series', 0.00005)) model.add_operator(GOMethodOperator('battery', 'series', 0.00008)) model.add_operator(GOMethodOperator('transmission', 'series', 0.00006)) model.add_operator(GOMethodOperator('system', 'series', 0.00001)) model.define_topology({ 'motor': ['battery'], 'transmission': ['engine', 'motor'], 'system': ['transmission'] }) model.define_task_profile('city', {'engine': 0.8, 'motor': 1.2, 'battery': 1.1}, 2.0) model.define_task_profile('highway', {'engine': 1.5, 'motor': 0.6, 'battery': 0.8}, 4.0) return model def _build_fault_tree(self): top = FaultTreeNode('system_failure', 'OR') power_fail = FaultTreeNode('power_failure', 'AND') power_fail.add_child(FaultTreeNode('engine_fail', 'basic', 0.02)) power_fail.add_child(FaultTreeNode('motor_fail', 'basic', 0.01)) top.add_child(power_fail) top.add_child(FaultTreeNode('battery_fail', 'basic', 0.015)) top.add_child(FaultTreeNode('transmission_fail', 'basic', 0.012)) return top def diagnose_bearing(self, vibration_signal): self.diagnosis_model.eval() with torch.no_grad(): x = torch.FloatTensor(vibration_signal).unsqueeze(0) output = self.diagnosis_model(x) pred = torch.argmax(output, dim=1).item() fault_types = ['normal', 'inner_race', 'outer_race', 'ball'] return fault_types[pred] def evaluate_mission_reliability(self, task_sequence): phase_durations = [self.go_model.task_profiles[t]['duration'] for t in task_sequence] mc_reliability = self.mc_simulator.run_multiphase_simulation(phase_durations) go_reliabilities = [self.go_model.compute_system_reliability(t) for t in task_sequence] go_total = np.prod(go_reliabilities) return {'monte_carlo': mc_reliability, 'go_method': go_total} def compute_critical_components(self, duration=10.0): return self.mc_simulator.compute_importance_measures(duration)如有问题，可以直接沟通
👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇
