20：《死亡笔记》自然死亡伪装算法：心梗/事故概率模型与随机化生成

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler

# 模拟生理指标数据
def generate_physiological_data(age, gender, blood_pressure, cholesterol, smoking):
    # 生成基础生理指标
    heart_rate = np.random.normal(75, 10)
    blood_oxygen = np.random.normal(98, 1.5)
    blood_sugar = np.random.normal(5.5, 1.0)
    
    # 生成心电图数据
    ecg_data = generate_ecg_data()
    
    # 生成心肌酶谱数据
    cardiac_enzymes = generate_cardiac_enzymes()
    
    # 组合数据
    data = {
        'age': age,
        'gender': gender,
        'blood_pressure': blood_pressure,
        'cholesterol': cholesterol,
        'smoking': smoking,
        'heart_rate': heart_rate,
        'blood_oxygen': blood_oxygen,
        'blood_sugar': blood_sugar,
        'ecg_data': ecg_data,
        'cardiac_enzymes': cardiac_enzymes
    }
    
    return data

# 生成心电图数据
def generate_ecg_data():
    # 生成正常心电图
    time = np.linspace(0, 10, 1000)
    ecg = np.zeros_like(time)
    
    # P波
    for i, t in enumerate(time):
        if 0.1 < t < 0.2:
            ecg[i] = 0.2 * np.sin(2 * np.pi * 10 * (t - 0.1))
    
    # QRS波群
    for i, t in enumerate(time):
        if 0.2 < t < 0.25:
            ecg[i] = -0.5 * np.sin(2 * np.pi * 20 * (t - 0.2))
        elif 0.25 < t < 0.3:
            ecg[i] = 1.0 * np.sin(2 * np.pi * 20 * (t - 0.25))
        elif 0.3 < t < 0.35:
            ecg[i] = -0.3 * np.sin(2 * np.pi * 20 * (t - 0.3))
    
    # T波
    for i, t in enumerate(time):
        if 0.4 < t < 0.6:
            ecg[i] = 0.3 * np.sin(2 * np.pi * 5 * (t - 0.4))
    
    return ecg.tolist()

# 生成心肌酶谱数据
def generate_cardiac_enzymes():
    return {
        'troponin': np.random.normal(0.03, 0.01),
        'ck_mb': np.random.normal(5.0, 2.0),
        'myoglobin': np.random.normal(50.0, 15.0)
    }

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 构建心梗预测模型
def build_mi_model():
    # 加载训练数据
    # 这里使用模拟数据，实际应用中应使用真实医疗数据
    X = np.random.rand(1000, 8)  # 8个特征
    y = np.random.randint(0, 2, 1000)  # 0: 正常, 1: 心梗
    
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # 训练模型
    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    
    # 评估模型
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"模型准确率: {accuracy}")
    
    return model

# 计算心梗概率
def calculate_mi_probability(model, patient_data):
    # 提取特征
    features = [
        patient_data['age'],
        1 if patient_data['gender'] == 'male' else 0,
        patient_data['blood_pressure'],
        patient_data['cholesterol'],
        1 if patient_data['smoking'] else 0,
        patient_data['heart_rate'],
        patient_data['blood_oxygen'],
        patient_data['blood_sugar']
    ]
    
    # 预测概率
    prob = model.predict_proba([features])[0][1]
    
    return prob

# 构建事故概率模型
def build_accident_model():
    # 环境因素权重
    environment_weights = {
        'weather': 0.3,
        'road_condition': 0.25,
        'time_of_day': 0.2,
        'traffic_density': 0.25
    }
    
    # 人为因素权重
    human_weights = {
        'fatigue': 0.3,
        'distraction': 0.25,
        'impairment': 0.25,
        'inexperience': 0.2
    }
    
    # 车辆因素权重
    vehicle_weights = {
        'brake_condition': 0.3,
        'tire_condition': 0.25,
        'visibility': 0.25,
        'mechanical_issues': 0.2
    }
    
    return {
        'environment': environment_weights,
        'human': human_weights,
        'vehicle': vehicle_weights
    }

# 计算事故概率
def calculate_accident_probability(model, scenario):
    # 环境因素评分
    env_score = (
        scenario['weather'] * model['environment']['weather'] +
        scenario['road_condition'] * model['environment']['road_condition'] +
        scenario['time_of_day'] * model['environment']['time_of_day'] +
        scenario['traffic_density'] * model['environment']['traffic_density']
    )
    
    # 人为因素评分
    human_score = (
        scenario['fatigue'] * model['human']['fatigue'] +
        scenario['distraction'] * model['human']['distraction'] +
        scenario['impairment'] * model['human']['impairment'] +
        scenario['inexperience'] * model['human']['inexperience']
    )
    
    # 车辆因素评分
    vehicle_score = (
        scenario['brake_condition'] * model['vehicle']['brake_condition'] +
        scenario['tire_condition'] * model['vehicle']['tire_condition'] +
        scenario['visibility'] * model['vehicle']['visibility'] +
        scenario['mechanical_issues'] * model['vehicle']['mechanical_issues']
    )
    
    # 总概率
    total_prob = 0.3 * env_score + 0.4 * human_score + 0.3 * vehicle_score
    
    return total_prob

import random
from datetime import datetime, timedelta

# 生成自然死亡场景
def generate_natural_death_scenario(target_profile, death_type='mi'):
    if death_type == 'mi':
        return generate_mi_scenario(target_profile)
    elif death_type == 'accident':
        return generate_accident_scenario(target_profile)
    else:
        raise ValueError("Invalid death type")

# 生成心梗场景
def generate_mi_scenario(target_profile):
    # 生成发作时间
    now = datetime.now()
    # 心梗通常在清晨或运动后发作
    hour = random.choice([6, 7, 8, 17, 18, 19])
    minute = random.randint(0, 59)
    attack_time = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
    
    # 生成发作地点
    locations = ['家中', '办公室', '健身房', '餐厅', '公园']
    location = random.choice(locations)
    
    # 生成前驱症状
    symptoms = ['胸痛', '胸闷', '呼吸困难', '出汗', '恶心']
    num_symptoms = random.randint(2, 4)
    selected_symptoms = random.sample(symptoms, num_symptoms)
    
    # 生成死亡时间（心梗发作后30分钟到2小时）
    death_delay = timedelta(minutes=random.randint(30, 120))
    death_time = attack_time + death_delay
    
    return {
        'type': '心梗',
        'attack_time': attack_time.strftime('%Y-%m-%d %H:%M:%S'),
        'death_time': death_time.strftime('%Y-%m-%d %H:%M:%S'),
        'location': location,
        'symptoms': selected_symptoms,
        'description': f"{target_profile['name']}在{location}突然感到{', '.join(selected_symptoms)}，随后失去意识，经抢救无效死亡。医学诊断为急性心肌梗死。"
    }

# 生成事故场景
def generate_accident_scenario(target_profile):
    # 生成事故时间
    now = datetime.now()
    # 事故通常在早晚高峰或夜间发生
    hour = random.choice([7, 8, 17, 18, 22, 23, 0, 1])
    minute = random.randint(0, 59)
    accident_time = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
    
    # 生成事故类型
    accident_types = ['车祸', '跌倒', '溺水', '火灾']
    accident_type = random.choice(accident_types)
    
    # 生成事故地点
    if accident_type == '车祸':
        locations = ['高速公路', '城市道路', '乡村公路', '停车场']
    elif accident_type == '跌倒':
        locations = ['楼梯', '浴室', '户外台阶', '山坡']
    elif accident_type == '溺水':
        locations = ['游泳池', '湖泊', '河流', '海边']
    else:  # 火灾
        locations = ['家中', '办公室', '餐厅', '旅馆']
    location = random.choice(locations)
    
    # 生成事故原因
    if accident_type == '车祸':
        causes = ['疲劳驾驶', '酒驾', '超速', '注意力分散']
    elif accident_type == '跌倒':
        causes = ['地面湿滑', '光线不足', '身体不适', '障碍物']
    elif accident_type == '溺水':
        causes = ['游泳技能不足', '突发疾病', '水流湍急', '天气突变']
    else:  # 火灾
        causes = ['电器故障', '用火不慎', '烟雾报警器失效', '易燃物堆积']
    cause = random.choice(causes)
    
    # 生成死亡时间（事故发生后立即或短时间内）
    death_delay = timedelta(minutes=random.randint(0, 30))
    death_time = accident_time + death_delay
    
    return {
        'type': accident_type,
        'accident_time': accident_time.strftime('%Y-%m-%d %H:%M:%S'),
        'death_time': death_time.strftime('%Y-%m-%d %H:%M:%S'),
        'location': location,
        'cause': cause,
        'description': f"{target_profile['name']}在{location}发生{accident_type}，原因是{cause}，经抢救无效死亡。"
    }

# 自适应生成算法
def adaptive_generate_scenario(target_profile):
    # 分析目标特征
    age = target_profile.get('age', 40)
    health_status = target_profile.get('health_status', 'good')
    lifestyle = target_profile.get('lifestyle', 'sedentary')
    
    # 根据特征调整概率
    if age > 60 or health_status == 'poor' or lifestyle == 'unhealthy':
        # 心梗概率更高
        mi_prob = 0.7
        accident_prob = 0.3
    else:
        # 事故概率更高
        mi_prob = 0.3
        accident_prob = 0.7
    
    # 随机选择死亡类型
    death_type = 'mi' if random.random() < mi_prob else 'accident'
    
    # 生成场景
    return generate_natural_death_scenario(target_profile, death_type)