MASLD

# train.py - 本地训练LightGBM模型
# 核心: 用本地收集的临床数据从头训练,不依赖任何预训练模型

import lightgbm as lgb
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

# ============================================
# 1. 定义训练特征 (排除泄漏字段)
# ============================================

# 47个基础字段 + 派生特征, 排除会影响标签生成的字段
# 这些泄漏字段如果进入训练, 模型会"偷看"标签
LEAKAGE_EXCLUDE = {
    'pdff_percent',           # 直接影响case判定 (PDFF>=5% → case)
    'masld_icd_code',         # 直接影响case判定 (ICD编码 → case)
    'masld_icd_flag',         # 直接影响case判定
    'cardiometabolic_flag',   # 直接影响case判定
    'patient_id',             # 标识列, 不参与预测
    'assessment_time',        # 标识列
    'masld_score',            # 标签本身
    'fib4_label',             # 标签本身
}

# ============================================
# 2. 准备训练数据
# ============================================

# 读取经过字段映射和派生特征计算后的训练表
train_df = pd.read_csv("data/training_data.csv")

# 特征: 所有列减去泄漏字段
X = train_df.drop(columns=LEAKAGE_EXCLUDE, errors='ignore')

# 标签: FIB-4分层后的0-3分数
# 0=非MASLD, 1=低风险(FIB-4<1.3), 2=中风险(1.3-2.67), 3=高风险(>2.67)
y = train_df['fib4_label']

# 训练/验证/测试集划分 (8:1:1)
# random_state=42 保证结果可复现
X_train, X_temp, y_train, y_temp = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
X_val, X_test, y_val, y_test = train_test_split(
    X_temp, y_temp, test_size=0.5, random_state=42, stratify=y_temp
)

# ============================================
# 3. 训练LightGBM模型
# ============================================

# LightGBM回归模型参数
# objective='regression': 回归任务, 预测连续值
# num_leaves=31: 每棵树最多31个叶子, 控制复杂度
# learning_rate=0.05: 学习率, 每棵树的贡献权重
# n_estimators=1000: 最大迭代次数, 配合early stopping
# min_child_samples=20: 叶子节点最少样本数, 防止过拟合
# feature_fraction=0.8: 每棵树随机使用80%特征
# bagging_fraction=0.8: 每棵树随机使用80%样本
model = lgb.LGBMRegressor(
    objective='regression',
    num_leaves=31,
    learning_rate=0.05,
    n_estimators=1000,
    min_child_samples=20,
    feature_fraction=0.8,
    bagging_fraction=0.8,
    bagging_freq=5,
    random_state=42,
    verbose=-1
)

# 训练模型
# eval_set: 用于early stopping的验证集
# callbacks: 当验证集loss不再下降时提前停止
model.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],
    callbacks=[lgb.early_stopping(50), lgb.log_evaluation(100)]
)

# ============================================
# 4. 评估模型性能
# ============================================

# 在测试集上评估
y_pred = model.predict(X_test)

# 计算评价指标
from sklearn.metrics import mean_squared_error, r2_score
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)

print(f"测试集 RMSE: {rmse:.4f}")
print(f"测试集 R²: {r2:.4f}")

# ============================================
# 5. 保存模型
# ============================================

# 保存训练好的模型, 用于后续推理
model.booster_.save_model("models/lgbm_trained.txt")

# model_matrix.py - 多模型训练和比较
# 所有模型使用同一数据切分, 同一评价指标, 公平比较

from sklearn.linear_model import LinearRegression, ElasticNet
from sklearn.ensemble import RandomForestRegressor, HistGradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
import lightgbm as lgb
# XGBoost, CatBoost 在安装后可选启用
# import xgboost as xgb
# import catboost as cb

# 定义模型矩阵: 所有候选模型及其参数
MODEL_MATRIX = {
    # ===== 透明统计模型 =====
    # 系数可解释, 用于验证复杂模型是否真正带来增益
    "linear": LinearRegression(),
    "elastic_net": ElasticNet(
        alpha=0.1,         # 正则化强度
        l1_ratio=0.5,      # L1/L2混合比例
        max_iter=1000      # 最大迭代
    ),
    
    # ===== 树模型 =====
    # 处理非线性关系和变量交互
    "random_forest": RandomForestRegressor(
        n_estimators=500,   # 500棵树
        max_depth=10,       # 最大深度10
        min_samples_leaf=5, # 叶子最少5个样本
        random_state=42
    ),
    "hist_gbm": HistGradientBoostingRegressor(
        max_iter=500,       # 最大迭代500
        learning_rate=0.05, # 学习率
        max_depth=6         # 最大深度
    ),
    "lightgbm": lgb.LGBMRegressor(
        n_estimators=1000,
        num_leaves=31,
        learning_rate=0.05,
        min_child_samples=20,
        random_state=42,
        verbose=-1
    ),
    
    # ===== 可选模型 (需要额外安装) =====
    # "xgboost": xgb.XGBRegressor(...),
    # "catboost": cb.CatBoostRegressor(...),
}

# 训练所有模型并记录性能
results = {}
for name, model in MODEL_MATRIX.items():
    # 训练
    model.fit(X_train, y_train)
    
    # 预测
    y_pred = model.predict(X_test)
    
    # 评估
    rmse = np.sqrt(mean_squared_error(y_test, y_pred))
    r2 = r2_score(y_test, y_pred)
    
    results[name] = {'rmse': rmse, 'r2': r2}
    print(f"{name:15s} RMSE={rmse:.4f}  R²={r2:.4f}")

# 选择最优模型
best_model = min(results, key=lambda x: results[x]['rmse'])
print(f"\n最优模型: {best_model}")

# LightGBM 核心代码
import lightgbm as lgb

# 定义模型参数
params = {
    'objective': 'regression',    # 回归任务, 输出连续值
    'metric': 'rmse',             # 评价指标: 均方根误差
    'num_leaves': 31,             # 每棵树最多31个叶子
    'learning_rate': 0.05,        # 学习率: 每棵树的贡献权重
    'feature_fraction': 0.8,      # 每棵树随机使用80%特征
    'bagging_fraction': 0.8,      # 每棵树随机使用80%样本
    'min_child_samples': 20,      # 叶子最少20个样本
}

# 训练模型
train_data = lgb.Dataset(X_train, label=y_train)
valid_data = lgb.Dataset(X_val, label=y_val)

model = lgb.train(
    params,
    train_data,
    num_boost_round=1000,       # 最多1000棵树
    valid_sets=[valid_data],
    callbacks=[lgb.early_stopping(50)]  # 50轮不改善就停
)

# 预测
y_pred = model.predict(X_test)  # 输出0-100连续分数

# XGBoost 核心代码
# import xgboost as xgb

# params = {
#     'objective': 'reg:squarederror',  # 回归任务
#     'max_depth': 6,                    # 最大深度
#     'learning_rate': 0.05,             # 学习率
#     'reg_alpha': 0.1,                  # L1正则化
#     'reg_lambda': 1.0,                 # L2正则化
#     'n_estimators': 1000,              # 最大树数
# }

# Random Forest 核心代码
from sklearn.ensemble import RandomForestRegressor

model = RandomForestRegressor(
    n_estimators=500,     # 500棵树
    max_depth=10,         # 最大深度10
    min_samples_leaf=5,   # 叶子最少5个样本
    max_features=0.3,     # 每棵树随机使用30%特征
    random_state=42
)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Elastic Net 核心代码
from sklearn.linear_model import ElasticNet

model = ElasticNet(
    alpha=0.1,         # 正则化强度
    l1_ratio=0.5,      # L1和L2的混合比例
    max_iter=1000
)
model.fit(X_train, y_train)

# 查看每个特征的权重
for name, coef in zip(feature_names, model.coef_):
    if coef != 0:
        print(f"{name}: {coef:.4f}")

# CatBoost 核心代码
# import catboost as cb

# model = cb.CatBoostRegressor(
#     iterations=1000,           # 最大迭代次数
#     learning_rate=0.05,        # 学习率
#     depth=6,                   # 树深度
#     l2_leaf_reg=3,             # L2正则化
#     verbose=100                # 每100轮输出日志
# )
# model.fit(X_train, y_train, cat_features=cat_cols)

# HistGradientBoosting 核心代码
from sklearn.ensemble import HistGradientBoostingRegressor

model = HistGradientBoostingRegressor(
    max_iter=500,         # 最大迭代500
    learning_rate=0.05,   # 学习率
    max_depth=6,          # 最大深度
    min_samples_leaf=20   # 叶子最少20个样本
)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Logistic Regression 核心代码
from sklearn.linear_model import LogisticRegression

model = LogisticRegression(
    C=1.0,              # 正则化强度的倒数
    max_iter=1000,
    random_state=42
)
model.fit(X_train, y_train)

# 查看每个特征的权重系数
for name, coef in zip(feature_names, model.coef_[0]):
    print(f"{name}: {coef:.4f}")

# MLP 核心代码
from sklearn.neural_network import MLPRegressor

model = MLPRegressor(
    hidden_layer_sizes=(128, 64),  # 两个隐藏层: 128和64个神经元
    activation='relu',             # ReLU激活函数
    max_iter=500,                  # 最大迭代500次
    early_stopping=True,           # 早停: 验证集不改善就停
    random_state=42
)
model.fit(X_train_scaled, y_train)  # 注意: 需要标准化输入
y_pred = model.predict(X_test_scaled)

# Stacking 核心代码
from sklearn.ensemble import StackingRegressor
from sklearn.linear_model import Ridge

estimators = [
    ('lgbm', lgb.LGBMRegressor(n_estimators=500)),
    ('rf', RandomForestRegressor(n_estimators=500)),
    ('hist', HistGradientBoostingRegressor(n_estimators=500)),
]

model = StackingRegressor(
    estimators=estimators,
    final_estimator=Ridge(alpha=1.0),  # 元模型: 岭回归
    cv=5                               # 5折交叉验证
)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# explain.py - 使用TreeSHAP解释每个特征的贡献
# 原理: TreeSHAP可以精确计算每个特征对预测值的贡献
# 正值 = 推高评分, 负值 = 降低评分

import shap

def explain_patient(model, patient_row, feature_cols):
    """
    计算单个患者的特征贡献
    
    参数:
        model: 训练好的LightGBM模型
        patient_row: 单个患者的数据行
        feature_cols: 特征列名列表
    
    返回:
        contributions: 字典,每个特征的贡献值
    """
    
    # 使用pred_contrib=True参数获取TreeSHAP值
    # 这是LightGBM内置的SHAP实现,速度很快
    shap_values = model.predict(
        patient_row[feature_cols],
        pred_contrib=True  # 启用TreeSHAP
    )
    
    # shap_values的形状: (n_samples, n_features + 1)
    # 最后一列是bias项,需要排除
    contributions = dict(zip(feature_cols, shap_values[0][:-1]))
    
    return contributions

# 示例输出
# {
#   "AST":        +0.35,  # AST偏高,推高评分
#   "platelet":   +0.28,  # 血小板偏低,推高评分
#   "bmi":        -0.12,  # BMI正常,降低评分
#   "HbA1c":      +0.18,  # 糖化偏高,推高评分
#   "lsm_kpa":    +0.42,  # 肝硬度偏高,推高评分
#   ...
# }

# train.py - 防止标签信息泄漏到训练特征
# 原理: 某些字段直接影响标签生成,如果进入训练特征,
# 模型会"偷看"标签,导致验证指标虚高

# 需要排除的泄漏字段集合
LEAKAGE_EXCLUDE_FROM_X = {
    'pdff_percent',           # 直接影响case判定 (PDFF>=5% → case)
    'masld_icd_code',         # 直接影响case判定 (ICD编码 → case)
    'masld_icd_flag',         # 直接影响case判定 (诊断标记 → case)
    'cardiometabolic_flag',   # 直接影响case判定 (代谢标记 → case)
    'patient_id',             # 标识列,不参与预测
    'assessment_time',        # 标识列,不参与预测
    'masld_score',            # 标签本身,不能作为特征
    'fib4_label',             # 标签本身,不能作为特征
}

# 训练时只用安全特征
# 从所有列中删除泄漏字段,剩余的作为训练特征X
X_train = train_df.drop(
    columns=LEAKAGE_EXCLUDE_FROM_X,
    errors='ignore'  # 如果列不存在也不报错
)

# 标签: FIB-4分层后的0-3分数
y_train = train_df['fib4_label']

# 训练LightGBM回归模型
# objective='regression': 回归任务,预测连续值
# num_leaves=31: 控制树的复杂度
# learning_rate=0.05: 学习率,控制每棵树的贡献
# n_estimators=1000: 最大树数,配合early stopping
model = lgb.LGBMRegressor(
    objective='regression',
    num_leaves=31,
    learning_rate=0.05,
    n_estimators=1000,
    random_state=42
)
model.fit(X_train, y_train)

# risk_assessment.py - MASLD状态判定逻辑
# 判定依据: 中国2024版指南 + EASL 2024指南
# 核心逻辑: 脂肪变证据 + 代谢异常证据 = MASLD成立

def _masld_status(row):
    """
    判定患者的MASLD状态
    
    返回值:
        "成立" - 同时满足脂肪变和代谢异常
        "不成立" - 有脂肪变但无代谢异常
        "证据不足" - 关键字段缺失
        "合并其他病因" - 有病毒性肝炎等其他病因
    """
    
    # 第1步: 排除其他病因
    # 如果有病毒性肝炎、肿瘤史等,标记为合并其他病因
    if _has_other_etiology(row):
        return "合并其他病因"
    
    # 第2步: 检查脂肪变证据 (满足任一即可)
    steatosis_evidence = (
        row.get('pdff_percent', 0) >= 5          # MRI-PDFF >= 5%
        or row.get('cap_db_m', 0) >= 248          # FibroScan CAP >= 248 dB/m
        or '脂肪肝' in str(row.get('ultrasound_raw_text', ''))  # 超声提示
        or row.get('masld_icd_flag', False)      # ICD编码阳性
    )
    
    # 第3步: 检查代谢异常证据 (满足任一即可)
    metabolic_evidence = _has_metabolic_evidence(row)
    # 检查项目:
    # - cardiometabolic_flag: 系统标记的代谢异常
    # - diabetes_history: 糖尿病病史
    # - hypertension_history: 高血压病史
    # - gout_history: 痛风病史
    # - bmi >= 23: 超重 (中国标准)
    # - HbA1c >= 5.7: 糖代谢异常
    # - triglycerides >= 1.7: 甘油三酯升高
    # - HDL < 1.0(男)/1.3(女): 高密度脂蛋白降低
    
    # 第4步: 综合判定
    if steatosis_evidence and metabolic_evidence:
        return "成立"        # 脂肪变 + 代谢异常 = MASLD
    elif steatosis_evidence and not metabolic_evidence:
        return "不成立"      # 有脂肪变但无代谢异常
    else:
        return "证据不足"    # 关键字段缺失

# risk_assessment.py - 脂肪变分级逻辑
# 按优先级使用三个数据源: PDFF > CAP > 超声文本
# PDFF是金标准,CAP是FibroScan输出,超声是文本匹配

def _steatosis_grade(row):
    """
    脂肪变分级: S0(无) / S1(轻度) / S2(中度) / S3(重度)
    
    数据源优先级:
        1. MRI-PDFF (金标准)
        2. FibroScan CAP
        3. 超声文本关键词
    """
    
    # 优先级1: PDFF (最准确)
    # PDFF = MRI质子密度脂肪分数,是脂肪变定量金标准
    pdff = row.get('pdff_percent')
    if pdff is not None:
        if pdff < 5:    return "S0"   # < 5%: 无脂肪变
        if pdff < 16:   return "S1"   # 5-16%: 轻度
        if pdff < 22:   return "S2"   # 16-22%: 中度
        return "S3"               # >= 22%: 重度
    
    # 优先级2: CAP (FibroScan输出)
    # CAP = 受控衰减参数,与肝脂肪变程度相关
    cap = row.get('cap_db_m')
    if cap is not None:
        if cap < 248:   return "S0"   # < 248 dB/m: 无脂肪变
        if cap < 268:   return "S1"   # 248-268: 轻度
        if cap < 280:   return "S2"   # 268-280: 中度
        return "S3"               # >= 280: 重度
    
    # 优先级3: 超声文本关键词匹配
    text = str(row.get('ultrasound_raw_text', ''))
    if '重度脂肪' in text: return "S3"
    if '中度脂肪' in text: return "S2"
    if '轻度脂肪' in text: return "S1"
    
    return "未知"  # 所有数据源都没有

# risk_assessment.py - 纤维化风险判定逻辑
# 按优先级使用三个数据源: 病理 > LSM > FIB-4
# 病理是金标准,LSM是FibroScan肝硬度,FIB-4是血清指标

def _fibrosis_risk(row):
    """
    纤维化风险: 低 / 中间 / 高
    
    数据源优先级:
        1. 肝活检病理文本 (金标准)
        2. FibroScan LSM (肝硬度值)
        3. FIB-4 (血清纤维化评分)
    """
    
    # 优先级1: 病理文本 (最准确)
    path = str(row.get('pathology_raw_text', ''))
    if 'F4' in path or '肝硬化' in path:
        return "高"       # F4 = 肝硬化
    if 'F3' in path:
        return "高"       # F3 = 严重纤维化
    if 'F2' in path:
        return "中间"     # F2 = 显著纤维化
    
    # 优先级2: LSM (FibroScan肝硬度值)
    # 单位: kPa (千帕)
    lsm = row.get('lsm_kpa')
    if lsm is not None:
        if lsm >= 12:   return "高"       # >= 12 kPa: 显著纤维化
        if lsm >= 8:    return "中间"     # 8-12 kPa: 轻度纤维化
        return "低"                   # < 8 kPa: 无/轻微纤维化
    
    # 优先级3: FIB-4 (血清纤维化评分)
    fib4 = row.get('fib4')
    if fib4 is not None:
        if fib4 > 2.67:  return "高"       # > 2.67: 高风险
        if fib4 >= 1.30: return "中间"     # 1.30-2.67: 中间风险
        return "低"                   # < 1.30: 低风险
    
    return "未知"  # 所有数据源都没有