pip install pandas numpy scikit-learn xgboost scipy

# src/data_simulation.py
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def simulate_wearable_data(nights=50):
    """
    为多个夜晚生成合成可穿戴数据集。
    
    每晚包含 8 小时的数据，频率为 1 秒。
    特征：heart_rate（心率 bpm）、acceleration（加速度 g）。
    """
    data_frames = []
    
    for night in range(nights):
        # 为这个夜晚分配随机睡眠质量
        quality = np.random.choice(['差', '一般', '好'], p=[0.25, 0.45, 0.3])
        start_time = datetime(2025, 1, 1, 22, 0, 0) + timedelta(days=night)
        
        # 基于睡眠质量的基础参数
        if quality == '好':
            hr_base, hr_var = 60, 3
            acc_base, acc_var = 0.01, 0.005
            num_awakenings = np.random.randint(0, 2)
        elif quality == '一般':
            hr_base, hr_var = 68, 5
            acc_base, acc_var = 0.02, 0.01
            num_awakenings = np.random.randint(2, 5)
        else: # 差
            hr_base, hr_var = 75, 8
            acc_base, acc_var = 0.04, 0.02
            num_awakenings = np.random.randint(5, 10)
            
        # 生成 8 小时数据（28800 秒）
        timestamps = pd.to_datetime([start_time + timedelta(seconds=i) for i in range(28800)])
        
        # 模拟数据
        hr = hr_base + np.random.randn(28800) * hr_var
        acc = np.abs(acc_base + np.random.randn(28800) * acc_var)
        
        # 为觉醒/不安添加一些尖峰
        for _ in range(num_awakenings):
            idx = np.random.randint(0, 28800)
            spike_duration = np.random.randint(60, 300)
            hr[idx:idx+spike_duration] += np.random.uniform(5, 15)
            acc[idx:idx+spike_duration] += np.random.uniform(0.1, 0.5)

        night_df = pd.DataFrame({
            'timestamp': timestamps,
            'heart_rate': hr,
            'acceleration': acc,
            'night_id': night,
            'sleep_quality': quality
        })
        data_frames.append(night_df)
        
    return pd.concat(data_frames, ignore_index=True)

# 生成并保存数据
raw_data = simulate_wearable_data(nights=100)
raw_data.to_csv('wearable_sleep_data.csv', index=False)

print("已生成 wearable_sleep_data.csv，包含 100 个夜晚的数据。")
print(raw_data.head())

# src/feature_engineering.py
import pandas as pd
import numpy as np
from scipy.stats import iqr

def calculate_hrv(hr_series):
    """从心率序列计算心率变异性（RMSSD）。"""
    # 计算 RR 间期（心跳间隔），单位毫秒
    rr_intervals = 60000 / hr_series
    # 计算连续差值
    successive_diffs = np.diff(rr_intervals)
    # 计算 RMSSD（连续差值的均方根）
    if len(successive_diffs) > 0:
        rmssd = np.sqrt(np.mean(successive_diffs ** 2))
    else:
        rmssd = 0
    return rmssd

def engineer_features(df):
    """
    从原始可穿戴数据工程化特征，按夜晚分组。
    """
    # 按夜晚分组
    grouped = df.groupby('night_id')
    
    feature_list = []
    for night_id, group in grouped:
        features = {'night_id': night_id}
        
        # 基本心率特征
        features['hr_mean'] = group['heart_rate'].mean()
        features['hr_std'] = group['heart_rate'].std()
        features['hr_min'] = group['heart_rate'].min()
        features['hr_max'] = group['heart_rate'].max()
        
        # 心率变异性（HRV）
        features['hrv_rmssd'] = calculate_hrv(group['heart_rate'])
        
        # 加速度特征（运动）
        features['acc_mean'] = group['acceleration'].mean()
        features['acc_std'] = group['acceleration'].std()
        features['acc_max'] = group['acceleration'].max()
        features['restless_moments'] = (group['acceleration'] > 0.1).sum() # 计算高运动时刻
        
        # 睡眠阶段时长（简化）
        # 深睡：低心率、低运动
        deep_sleep_mask = (group['heart_rate'] < (features['hr_mean'] * 0.9)) & (group['acceleration'] ＜ 0.05)
        features['deep_sleep_duration_pct'] = deep_sleep_mask.sum() / len(group)
        
        # 浅睡：中等一切
        light_sleep_mask = ~deep_sleep_mask
        features['light_sleep_duration_pct'] = light_sleep_mask.sum() / len(group)
        
        # 目标变量
        features['sleep_quality'] = group['sleep_quality'].iloc[0]
        
        feature_list.append(features)
        
    return pd.DataFrame(feature_list)

# 加载原始数据并工程化特征
raw_data = pd.read_csv('wearable_sleep_data.csv')
featured_data = engineer_features(raw_data)
featured_data.to_csv('featured_sleep_data.csv', index=False)

print("已完成特征工程并保存到 featured_sleep_data.csv")
print(featured_data.head())

# src/train_model.py
import pandas as pd
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, accuracy_score
from sklearn.preprocessing import LabelEncoder

# 加载特征数据
df = pd.read_csv('featured_sleep_data.csv')

# 为 XGBoost 准备数据
X = df.drop(['night_id', 'sleep_quality'], axis=1)
y = df['sleep_quality']

# 编码目标变量（如 '差' -> 0, '一般' -> 1, '好' -> 2）
le = LabelEncoder()
y_encoded = le.fit_transform(y)

# 分割为训练和测试集
X_train, X_test, y_train, y_test = train_test_split(
    X, y_encoded, test_size=0.2, random_state=42, stratify=y_encoded
)

# 初始化并训练 XGBoost 分类器
model = xgb.XGBClassifier(
    objective='multi:softmax', # 多类分类
    num_class=len(le.classes_),
    eval_metric='mlogloss',
    use_label_encoder=False,
    seed=42
)

model.fit(X_train, y_train)

# 进行预测
y_pred = model.predict(X_test)

# 评估模型
accuracy = accuracy_score(y_test, y_pred)
print(f"模型准确率: {accuracy * 100:.2f}%")

# 打印详细分类报告
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=le.classes_))

# 在 train_model.py 末尾添加
import matplotlib.pyplot as plt

# 绘制特征重要性
feature_importances = pd.DataFrame(
    {'feature': X.columns, 'importance': model.feature_importances_}
).sort_values('importance', ascending=False)

print("\n特征重要性:")
print(feature_importances)