Health/health_evalution_class.py

import numpy as np
import pandas as pd
from sklearn.neighbors import BallTree
from typing import Dict, List, Optional, Union
from functools import lru_cache


class HealthAssessor:
    def __init__(self):
        "八个子系统"
        self.subsystem_config = {
            # 偏航系统
            'YawSystem': {
                # 双馈
                'dfig': {
                    'fixed': ['yaw_ang_1','yaw_ang_2','twist_ang_1','twist_ang_2','yaw_err_1','yaw_err_2','wind_dir_1','wind_dir_2','wind_dir_3','yaw_to_wind_ang_1',
                              'yaw_to_wind_ang_2','yaw_to_wind_ang_3','total_yaw_cnt','untwist_cnt_1','untwist_cnt_2','yaw_sts_1','yaw_sts_2','cw_yaw_sts_1','ccw_yaw_sts_1',
                              'cw_yaw_sts_2','ccw_yaw_sts_2','yaw_sys_prs','yaw_brk_prs','yaw_motor_brk','yaw_hyd_brk','yaw_brk_valve_sts'],
                },
                # 直驱
                'direct': {
                    'fixed': ['yaw_ang_1','yaw_ang_2','twist_ang_1','twist_ang_2','yaw_err_1','yaw_err_2','wind_dir_1','wind_dir_2','wind_dir_3','yaw_to_wind_ang_1',
                              'yaw_to_wind_ang_2','yaw_to_wind_ang_3','total_yaw_cnt','untwist_cnt_1','untwist_cnt_2','yaw_sts_1','yaw_sts_2','cw_yaw_sts_1','ccw_yaw_sts_1',
                              'cw_yaw_sts_2','ccw_yaw_sts_2','yaw_sys_prs','yaw_brk_prs','yaw_motor_brk','yaw_hyd_brk','yaw_brk_valve_sts'],
                }
            },
            # 变桨系统
            'PicthSystem': {
                # 双馈
                'dfig': {
                    'fixed': ['pitch_ang_set_1','pitch_ang_set_2','pitch_ang_set_3','pitch_ang_set_4','pitch_ang_set_5','pitch_ang_set_6','pitch_ang_act_1','pitch_ang_act_2','pitch_ang_act_3','pitch_ang_act_4','pitch_ang_act_5','pitch_ang_act_16',
                              'pitch_ang_act_7','pitch_ang_act_7','pitch_ang_act_9','pitch_spd_1','pitch_spd_2','pitch_spd_3','pitch_spd_4','pitch_spd_5','pitch_spd_6','pitch_motor_pwr_1','pitch_motor_pwr_2',
                              'pitch_motor_pwr_3','pitch_motor_cur_1','pitch_motor_cur_2','pitch_motor_cur_3','pitch_motor_cur_4','pitch_motor_cur_5','pitch_motor_cur_6',
                              'pitch_motor_temp_1','pitch_motor_temp_2','pitch_motor_temp_3','pitch_motor_temp_4','pitch_motor_temp_5','pitch_motor_temp_6','pitch_cab_temp_1',
                              'pitch_cab_temp_2','pitch_cab_temp_3','pitch_cab_temp_4','pitch_cab_temp_5','pitch_cab_temp_6','pitch_bat_temp_1','pitch_bat_temp_2','pitch_bat_temp_3',
                              'pitch_bat_temp_4','pitch_bat_temp_5','pitch_bat_temp_6'],
                },
                # 直驱
                'direct': {
                    'fixed': ['pitch_ang_set_1','pitch_ang_set_2','pitch_ang_set_3','pitch_ang_set_4','pitch_ang_set_5','pitch_ang_set_6','pitch_ang_act_1','pitch_ang_act_2','pitch_ang_act_3','pitch_ang_act_4','pitch_ang_act_5','pitch_ang_act_16',
                              'pitch_ang_act_7','pitch_ang_act_7','pitch_ang_act_9','pitch_spd_1','pitch_spd_2','pitch_spd_3','pitch_spd_4','pitch_spd_5','pitch_spd_6','pitch_motor_pwr_1','pitch_motor_pwr_2',
                              'pitch_motor_pwr_3','pitch_motor_cur_1','pitch_motor_cur_2','pitch_motor_cur_3','pitch_motor_cur_4','pitch_motor_cur_5','pitch_motor_cur_6',
                              'pitch_motor_temp_1','pitch_motor_temp_2','pitch_motor_temp_3','pitch_motor_temp_4','pitch_motor_temp_5','pitch_motor_temp_6','pitch_cab_temp_1',
                              'pitch_cab_temp_2','pitch_cab_temp_3','pitch_cab_temp_4','pitch_cab_temp_5','pitch_cab_temp_6','pitch_bat_temp_1','pitch_bat_temp_2','pitch_bat_temp_3',
                              'pitch_bat_temp_4','pitch_bat_temp_5','pitch_bat_temp_6'],
                }
            },
            # 主轴
            'MainShaft': {
                # 双馈
                'dfig': {
                    'fixed': ['main_shaft_spd_1','main_shaft_spd_2','main_shaft_spd_3','main_brg_temp_1','main_brg_temp_2','main_brg_temp_3','main_brg_temp_4','lube_oil_temp',
                              'gen_lube_level_sts','gen_lube_pulse_sts','gen_lube_pump_act','gen_brg_lube_level_sig','oil_prs'],
                },
                # 直驱
                'direct': {
                    'fixed': ['main_shaft_spd_1','main_shaft_spd_2','main_shaft_spd_3','main_brg_temp_1','main_brg_temp_2','main_brg_temp_3','main_brg_temp_4','lube_oil_temp',
                              'gen_lube_level_sts','gen_lube_pulse_sts','gen_lube_pump_act','gen_brg_lube_level_sig','oil_prs'],
                }
            },   
            # 齿轮箱
            'Gearbox': {
                # 双馈
                'dfig': {
                    'fixed': ['gearbox_spd_1','gearbox_spd_2','gearbox_spd_3','hss_brg_temp_1','hss_brg_temp_2','hss_brg_temp_3','hss_brg_temp_4','hss_brg_temp_5','iss_brg_temp_1',
                              'iss_brg_temp_2','iss_brg_temp_3','iss_brg_temp_4','lss_brg_temp_1','lss_brg_temp_2','lss_brg_temp_3','lss_brg_temp_4','gearbox_oil_temp_1','gearbox_oil_temp_2',
                              'gearbox_oil_temp_3','gb_out_oil_prs_1','gb_out_oil_prs_2','gb_out_oil_prs_3','gb_in_oil_prs_1','gb_in_oil_prs_2','gb_cool_water_temp'],
                },
                # 直驱
                'direct': {
                    'fixed': ['gearbox_spd_1','gearbox_spd_2','gearbox_spd_3','hss_brg_temp_1','hss_brg_temp_2','hss_brg_temp_3','hss_brg_temp_4','hss_brg_temp_5','iss_brg_temp_1',
                              'iss_brg_temp_2','iss_brg_temp_3','iss_brg_temp_4','lss_brg_temp_1','lss_brg_temp_2','lss_brg_temp_3','lss_brg_temp_4','gearbox_oil_temp_1','gearbox_oil_temp_2',
                              'gearbox_oil_temp_3','gb_out_oil_prs_1','gb_out_oil_prs_2','gb_out_oil_prs_3','gb_in_oil_prs_1','gb_in_oil_prs_2','gb_cool_water_temp'],
                }
            },
            # 发电机
            'Generator': {
                # 双馈
                'dfig': {
                    'fixed': ['gen_spd_1','gen_spd_2','gen_spd_3','gen_spd_4','gen_de_brg_temp_1','gen_nde_brg_temp_1','gen_de_brg_temp_2','gen_nde_brg_temp_2','gen_de_brg_temp_3','gen_nde_brg_temp_3',
                              'rotor_brk_prs','rotor_temp_1','rotor_temp_2','rotor_temp_3','stator_cur','stator_temp','stator_wind_temp_1','stator_wind_temp_2','stator_wind_temp_3','stator_wind_temp_4',
                              'stator_wind_temp_5','stator_wind_temp_6','gen_in_water_temp','gen_out_water_temp_1','gen_out_water_temp_2','gen_in_air_temp_1','gen_in_air_temp_2','gen_out_air_temp_1','gen_out_air_temp_2'],
                },
                # 直驱
                'direct': {
                    'fixed': ['gen_spd_1','gen_spd_2','gen_spd_3','gen_spd_4','gen_de_brg_temp_1','gen_nde_brg_temp_1','gen_de_brg_temp_2','gen_nde_brg_temp_2','gen_de_brg_temp_3','gen_nde_brg_temp_3',
                              'rotor_brk_prs','rotor_temp_1','rotor_temp_2','rotor_temp_3','stator_cur','stator_temp','stator_wind_temp_1','stator_wind_temp_2','stator_wind_temp_3','stator_wind_temp_4',
                              'stator_wind_temp_5','stator_wind_temp_6','gen_in_water_temp','gen_out_water_temp_1','gen_out_water_temp_2','gen_in_air_temp_1','gen_in_air_temp_2','gen_out_air_temp_1','gen_out_air_temp_2'],
                }
            },
            # 变流器
            'Converter': {
                # 双馈
                'dfig': {
                    'fixed': ['grid_ia_1','grid_ib_1','grid_ic_1','grid_ia_2','grid_ib_2','grid_ic_2','grid_ua_1','grid_ub_1','grid_uc_1','grid_ua_2','grid_ub_2','grid_uc_2','phase_ang_a_1','phase_ang_b_1','phase_ang_c_1',
                              'phase_ang_a_2','phase_ang_b_2','phase_ang_c_2','conv_grid_freq_1','conv_grid_freq_2','conv_grid_freq_3','conv_spd_1','conv_spd_2','conv_mc_temp_1','conv_mc_temp_2','conv_mc_temp_3','conv_mc_temp_4',
                              'conv_mc_temp_5','conv_mc_temp_6','conv_mc_temp_7','conv_mc_temp_8','conv_mc_temp_9','conv_mc_temp_10','conv_gc_temp_1','conv_gc_temp_2','conv_gc_temp_3','conv_gc_temp_4','conv_gc_temp_5','conv_gc_temp_6',
                              'conv_gc_temp_7','conv_gc_temp_8','conv_gc_temp_9','conv_gc_temp_10','conv_fault_1','conv_fault_2','conv_fault_3','conv_fault_4','conv_err_1','conv_err_2','conv_alarm_1','conv_alarm_2','conv_cool_in_temp_1',
                              'conv_cool_in_temp_2','conv_cool_out_temp_1','conv_cool_out_temp_2','conv_in_air_temp','conv_out_air_temp' ],
                },
                # 直驱
                'direct': {
                    'fixed': ['grid_ia_1','grid_ib_1','grid_ic_1','grid_ia_2','grid_ib_2','grid_ic_2','grid_ua_1','grid_ub_1','grid_uc_1','grid_ua_2','grid_ub_2','grid_uc_2','phase_ang_a_1','phase_ang_b_1','phase_ang_c_1',
                              'phase_ang_a_2','phase_ang_b_2','phase_ang_c_2','conv_grid_freq_1','conv_grid_freq_2','conv_grid_freq_3','conv_spd_1','conv_spd_2','conv_mc_temp_1','conv_mc_temp_2','conv_mc_temp_3','conv_mc_temp_4',
                              'conv_mc_temp_5','conv_mc_temp_6','conv_mc_temp_7','conv_mc_temp_8','conv_mc_temp_9','conv_mc_temp_10','conv_gc_temp_1','conv_gc_temp_2','conv_gc_temp_3','conv_gc_temp_4','conv_gc_temp_5','conv_gc_temp_6',
                              'conv_gc_temp_7','conv_gc_temp_8','conv_gc_temp_9','conv_gc_temp_10','conv_fault_1','conv_fault_2','conv_fault_3','conv_fault_4','conv_err_1','conv_err_2','conv_alarm_1','conv_alarm_2','conv_cool_in_temp_1',
                              'conv_cool_in_temp_2','conv_cool_out_temp_1','conv_cool_out_temp_2','conv_in_air_temp','conv_out_air_temp' ],
                }
            },
            # 液压系统
            'HPU': {
                # 双馈
                'dfig': {
                    'fixed': ['hyd_sys_prs_1','hyd_sys_prs_2','hyd_sys_prs_3','hyd_pump_prs','hyd_pump_start_cnt','oil_pump_motor','hyd_tank_level','hyd_oil_temp','hyd_oil_prs','hyd_level_sts_1','hyd_level_sts_2','hyd_oil_temp_sts'],
                },
                # 直驱
                'direct': {
                    'fixed': ['hyd_sys_prs_1','hyd_sys_prs_2','hyd_sys_prs_3','hyd_pump_prs','hyd_pump_start_cnt','oil_pump_motor','hyd_tank_level','hyd_oil_temp','hyd_oil_prs','hyd_level_sts_1','hyd_level_sts_2','hyd_oil_temp_sts'],
                }
            },
            # 主控系统
            'MCS': {
                # 双馈
                'dfig': {
                    'fixed': ['wtg_sts_1','wtg_sts_2','wtg_sts_3','wtg_sts_4','wind_spd_1','wind_spd_2','wind_spd_3','wind_spd_4','p_active_1','p_active_2','p_active_3','p_active_4','p_reactive_1','p_reactive_2','p_reactive_3','rotor_spd_1',
                              'rotor_spd_2','rotor_spd_3','safety_chain_1','safety_chain_2','safety_chain_3','nacelle_estop_1','nacelle_estop_2','nacelle_estop_3','tower_estop_1','tower_estop_2','tower_estop_3','hand_estop','nacelle_in_temp_1',
                              'nacelle_in_temp_2','nacelle_out_temp_1','nacelle_out_temp_2','tower_fa_vib_1','tower_ss_vib_1','tower_fa_vib_2','tower_ss_vib_2','tower_fa_vib_3','tower_ss_vib_3','tower_env_temp_1','tower_env_temp_2','nacelle_cab_temp_1',
                              'nacelle_cab_temp_2','tower_cab_temp_1','tower_cab_temp_2','nacelle_ups_1','nacelle_ups_2','nacelle_ups_3','tower_ups_1','tower_ups_2','tower_ups_3','tower_ups_4' ],
                },
                # 直驱
                'direct': {
                    'fixed': ['wtg_sts_1','wtg_sts_2','wtg_sts_3','wtg_sts_4','wind_spd_1','wind_spd_2','wind_spd_3','wind_spd_4','p_active_1','p_active_2','p_active_3','p_active_4','p_reactive_1','p_reactive_2','p_reactive_3','rotor_spd_1',
                              'rotor_spd_2','rotor_spd_3','safety_chain_1','safety_chain_2','safety_chain_3','nacelle_estop_1','nacelle_estop_2','nacelle_estop_3','tower_estop_1','tower_estop_2','tower_estop_3','hand_estop','nacelle_in_temp_1',
                              'nacelle_in_temp_2','nacelle_out_temp_1','nacelle_out_temp_2','tower_fa_vib_1','tower_ss_vib_1','tower_fa_vib_2','tower_ss_vib_2','tower_fa_vib_3','tower_ss_vib_3','tower_env_temp_1','tower_env_temp_2','nacelle_cab_temp_1',
                              'nacelle_cab_temp_2','tower_cab_temp_1','tower_cab_temp_2','nacelle_ups_1','nacelle_ups_2','nacelle_ups_3','tower_ups_1','tower_ups_2','tower_ups_3','tower_ups_4' ],
                }
            },
                               
        }

        # 嵌入源代码的MSET实现
        self.mset = self._create_mset_core()

    def _create_mset_core(self):
        """创建MSET核心计算模块"""
        class MSETCore:
            def __init__(self):
                self.matrixD = None
                self.normalDataBallTree = None
                self.healthyResidual = None

            def calcSimilarity(self, x, y):
                """优化后的相似度计算"""
                diff = np.array(x) - np.array(y)
                return 1 / (1 + np.sqrt(np.sum(diff ** 2)))

            def genDLMatrix(self, trainDataset, dataSize4D=15, dataSize4L=5):
                """优化矩阵生成过程"""
                m, n = trainDataset.shape

                # 快速选择极值点
                min_indices = np.argmin(trainDataset, axis=0)
                max_indices = np.argmax(trainDataset, axis=0)
                unique_indices = np.unique(np.concatenate([min_indices, max_indices]))
                self.matrixD = trainDataset[unique_indices].copy()

                # 快速填充剩余点
                remaining_indices = np.setdiff1d(np.arange(m), unique_indices)
                np.random.shuffle(remaining_indices)
                needed = max(0, dataSize4D - len(unique_indices))
                if needed > 0:
                    self.matrixD = np.vstack([self.matrixD, trainDataset[remaining_indices[:needed]]])

                # 使用与源代码一致的BallTree参数
                self.normalDataBallTree = BallTree(
                    self.matrixD,
                    leaf_size=40,
                    metric=lambda i, j: 1 - self.calcSimilarity(i, j)  # 自定义相似度
                )

                # 使用所有数据计算残差
                self.healthyResidual = self.calcResidualByLocallyWeightedLR(trainDataset)
                return 0

            def calcResidualByLocallyWeightedLR(self, newStates):
                """优化残差计算"""
                if len(newStates.shape) == 1:
                    newStates = newStates.reshape(-1, 1)

                dist, iList = self.normalDataBallTree.query(
                    newStates,
                    k=min(10, len(self.matrixD)),
                    return_distance=True
                )
                weights = 1 / (dist + 1e-5)
                weights /= weights.sum(axis=1)[:, np.newaxis]

                est_X = np.sum(weights[:, :, np.newaxis] * self.matrixD[iList[0]], axis=1)
                return est_X - newStates

            def calcSPRT(self, newsStates, feature_weight, alpha=0.1, beta=0.1, decisionGroup=1):
                """优化SPRT计算"""
                stateResidual = self.calcResidualByLocallyWeightedLR(newsStates)
                weightedStateResidual = np.dot(stateResidual, feature_weight)
                weightedHealthyResidual = np.dot(self.healthyResidual, feature_weight)

                mu0 = np.mean(weightedHealthyResidual)
                sigma0 = np.std(weightedHealthyResidual)

                # 向量化计算
                n = len(newsStates)
                if n < decisionGroup:
                    return [50]  # 中性值

                rolling_mean = np.convolve(weightedStateResidual, np.ones(decisionGroup) / decisionGroup, 'valid')
                si = (rolling_mean - mu0) * (rolling_mean + mu0 - 2 * mu0) / (2 * sigma0 ** 2)

                lowThres = np.log(beta / (1 - alpha))
                highThres = np.log((1 - beta) / alpha)

                si = np.clip(si, lowThres, highThres)
                si = np.where(si > 0, si / highThres, si / lowThres)
                flag = 100 - si * 100

                # 填充不足的部分
                if len(flag) < n:
                    flag = np.pad(flag, (0, n - len(flag)), mode='edge')

                return flag.tolist()

            def CRITIC_prepare(self, data, flag=1):
                """标准化处理"""
                data = data.astype(float)
                numeric_cols = data.select_dtypes(include=[np.number]).columns
                negative_cols = [col for col in numeric_cols
                                 if any(kw in col for kw in ['temperature'])]
                positive_cols = list(set(numeric_cols) - set(negative_cols))

                # 负向标准化
                if negative_cols:
                    max_val = data[negative_cols].max()
                    min_val = data[negative_cols].min()
                    data[negative_cols] = (max_val - data[negative_cols]) / (max_val - min_val).replace(0, 1e-5)

                # 正向标准化
                if positive_cols:
                    max_val = data[positive_cols].max()
                    min_val = data[positive_cols].min()
                    data[positive_cols] = (data[positive_cols] - min_val) / (max_val - min_val).replace(0, 1e-5)

                return data

            def CRITIC(self, data):
                """CRITIC权重计算(支持单特征)"""
                try:
                    # 处理单特征情况
                    if len(data.columns) == 1:
                        return pd.Series([1.0], index=data.columns)
                        
                    data_norm = self.CRITIC_prepare(data.copy())
                    std = data_norm.std(ddof=0).clip(lower=0.01)
                    
                    # 计算相关系数矩阵(添加异常处理)
                    try:
                        corr = np.abs(np.corrcoef(data_norm.T))
                        np.fill_diagonal(corr, 0)
                        conflict = np.sum(1 - corr, axis=1)
                    except:
                        # 如果计算相关系数失败，使用等权重
                        return pd.Series(np.ones(len(data.columns))/len(data.columns))
                        
                    info = std * conflict
                    weights = info / info.sum()
                    return pd.Series(weights, index=data.columns)
                except Exception as e:
                    print(f"CRITIC计算失败: {str(e)}")
                    return pd.Series(np.ones(len(data.columns))/len(data.columns))

            def ahp(self, matrix):
                """AHP权重计算"""
                eigenvalue, eigenvector = np.linalg.eig(matrix)
                max_idx = np.argmax(eigenvalue)
                weight = eigenvector[:, max_idx].real
                return weight / weight.sum(), eigenvalue[max_idx].real

        return MSETCore()

    def assess_turbine(self, engine_code, data, mill_type, wind_turbine_name):
        """评估单个风机"""
        results = {
            "engine_code": engine_code,
            "wind_turbine_name": wind_turbine_name,
            "mill_type": mill_type,
            "total_health_score": None,
            "subsystems": {},
            "assessed_subsystems": []
        }

        # 各子系统评估
        subsystems_to_assess = [
            ('YawSystem', self.subsystem_config['YawSystem'], 2),
            ('PicthSystem', self.subsystem_config['PicthSystem'], 2),            
            ('MainShaft', self.subsystem_config['MainShaft'], 2),
            ('Gearbox', self.subsystem_config['Gearbox'] if mill_type == 'dfig' else None, 2),
            ('Generator', self.subsystem_config['Generator'], 2),
            ('Converter', self.subsystem_config['Converter'], 2),
            ('HPU', self.subsystem_config['HPU'], 2),
            ('MCS', self.subsystem_config['MCS'], 2),
        ]

        for subsystem, config, min_features in subsystems_to_assess:
            if config is None:
                continue

            features = self._get_subsystem_features(config, data)

            # 功能1：无论特征数量是否足够都输出结果
            if len(features) >= min_features:
                assessment = self._assess_subsystem(data[features])
            else:
                assessment = {
                    'health_score': -1,  # 特征不足时输出'-'
                    'weights': {},
                    'message': f'Insufficient features (required {min_features}, got {len(features)})'
                }
            print('结果打印',assessment)
            # 功能3：删除features内容
            if 'features' in assessment:
                del assessment['features']

            # 最终清理：确保没有NaN值
            for sys, result in results["subsystems"].items():
                if isinstance(result['health_score'], float) and np.isnan(result['health_score']):
                    result['health_score'] = -1
                    result['message'] = (result.get('message') or '') + '; NaN detected'
            
            if isinstance(results["total_health_score"], float) and np.isnan(results["total_health_score"]):
                results["total_health_score"] = -1               
            results["subsystems"][subsystem] = assessment

        # 计算整机健康度（使用新字段名）
        if results["subsystems"]:
            # 只计算健康值为数字的子系统
            valid_subsystems = [
                k for k, v in results["subsystems"].items()
                if isinstance(v['health_score'], (int, float)) and v['health_score'] >= 0
            ]

            if valid_subsystems:
                weights = self._get_subsystem_weights(valid_subsystems)
                health_scores = [results["subsystems"][sys]['health_score'] for sys in valid_subsystems]
                results["total_health_score"] = float(np.dot(health_scores, weights))
                results["assessed_subsystems"] = valid_subsystems

        return results

    def _get_all_possible_features(self, mill_type, available_columns):
        """
        获取所有可能的特征列
        
        参数:
            mill_type: 机型类型
            available_columns: 数据库实际存在的列名列表
        """
        features = []
        available_columns_lower = [col.lower() for col in available_columns]  # 不区分大小写匹配
        # for subsys_name, subsys_config in assessor.subsystem_config.items():
        for subsys_name, subsys_config in self.subsystem_config.items():
            # 处理子系统配置
            if subsys_name == 'generator':
                config = subsys_config.get(mill_type, {})
            elif subsys_name == 'drive_train' and mill_type != 'dfig':
                continue
            else:
                config = subsys_config

            # 处理固定特征
            if 'fixed' in config:
                for f in config['fixed']:
                    if f in available_columns:
                        features.append(f)

            # 处理关键词特征
            if 'keywords' in config:
                for rule in config['keywords']:
                    matched = []
                    include_kws = [kw.lower() for kw in rule['include']]
                    exclude_kws = [ex.lower() for ex in rule.get('exclude', [])]

                    for col in available_columns:
                        col_lower = col.lower()
                        # 检查包含关键词
                        include_ok = all(kw in col_lower for kw in include_kws)
                        # 检查排除关键词
                        exclude_ok = not any(ex in col_lower for ex in exclude_kws)

                        if include_ok and exclude_ok:
                            matched.append(col)

                    if len(matched) >= rule.get('min_count', 1):
                        features.extend(matched)

        return list(set(features))  # 去重

    def _get_subsystem_features(self, config: Dict, data: pd.DataFrame) -> List[str]:
        """最终版特征获取方法"""
        available_features = []

        # 固定特征检查（要求至少10%非空）
        if 'fixed' in config:
            for f in config['fixed']:
                if f in data.columns and data[f].notna().mean() > 0.1:
                    available_features.append(f)
        print(f"匹配到的固定特征: {available_features}")
        # 关键词特征检查
        if 'keywords' in config:
            for rule in config['keywords']:
                matched = [
                    col for col in data.columns
                    if all(kw.lower() in col.lower() for kw in rule['include'])
                    and not any(ex.lower() in col.lower() for ex in rule.get('exclude', []))
                    and data[col].notna().mean() > 0.1  # 数据有效性检查
                ]
                if len(matched) >= rule.get('min_count', 1):
                    available_features.extend(matched)
        print(f"匹配到的关键词特征: {available_features}")
        return list(set(available_features))
    
    def _assess_subsystem(self, data: pd.DataFrame) -> Dict:
        """评估子系统(支持单特征)"""
        # 数据清洗
        clean_data = data.dropna()
        if len(clean_data) < 10:  # 降低最小样本量要求(原为20)
            return {'health_score': -1, 'weights': {}, 'features': list(data.columns), 'message': 'Insufficient data'}

        try:
            # 标准化
            normalized_data = self.mset.CRITIC_prepare(clean_data)

            # 计算权重 - 处理单特征情况
            if len(normalized_data.columns) == 1:
                weights = pd.Series([1.0], index=normalized_data.columns)
            else:
                weights = self.mset.CRITIC(normalized_data)

            # MSET评估
            health_score = self._run_mset_assessment(normalized_data.values, weights.values)

            bins = [0, 10, 20, 30, 40, 50, 60, 70, 80]
            adjust_values = [87, 77, 67, 57, 47, 37, 27, 17, 7]

            # def adjust_score(score):
            #     for i in range(len(bins)):
            #         if score < bins[i]:
            #             return score + adjust_values[i-1]
            #     return score  #

            # adjusted_score = adjust_score(health_score)  #
            # if adjusted_score >= 100:
            #     adjusted_score = 92.8

            return {
                'health_score': float(health_score),
                'weights': weights.to_dict(),
                'features': list(data.columns)
            }
        except Exception as e:
            return {'health_score': -1, 'weights': {}, 'features': list(data.columns), 'message': str(e)}
        
    @lru_cache(maxsize=10)
    def _get_mset_model(self, train_data: tuple):
        """缓存MSET模型"""
        # 注意：由于lru_cache需要可哈希参数，这里使用元组
        arr = np.array(train_data)
        model = self._create_mset_core()
        model.genDLMatrix(arr)
        return model

    def _run_mset_assessment(self, data: np.ndarray, weights: np.ndarray) -> float:
        """执行MSET评估"""
        # 检查权重有效性
        if np.isnan(weights).any() or np.isinf(weights).any():
            weights = np.ones_like(weights) / len(weights)  # 重置为等权重 

        # 分割训练集和测试集
        split_idx = len(data) // 2
        train_data = data[:split_idx]
        test_data = data[split_idx:]

        # 使用缓存模型
        try:
            model = self._get_mset_model(tuple(map(tuple, train_data)))
            flags = model.calcSPRT(test_data, weights)
            
            # 过滤NaN值并计算均值
            valid_flags = [x for x in flags if not np.isnan(x)]
            if not valid_flags:
                return 50.0  # 默认中性值
                
            return float(np.mean(valid_flags))
        except Exception as e:
            print(f"MSET评估失败: {str(e)}")
            return 50.0  # 默认中性值
    
    def _get_subsystem_weights(self, subsystems: List[str]) -> np.ndarray:
        """生成等权重的子系统权重向量"""
        n = len(subsystems)
        if n == 0:
            return np.array([])

        # 直接返回等权重向量
        return np.ones(n) / n