Upload folder using huggingface_hub

README.md

@@ -1,12 +1,558 @@
 ---
-title: Wearable TimeSeries Health Monitor
-emoji: ⚡
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 6.0.1
-app_file: app.py
-pinned: false
+library_name: pytorch
+pipeline_tag: time-series-forecasting
+language:
+  - zh
+  - en
+tags:
+  - anomaly-detection
+  - time-series
+  - wearable
+  - health
+  - lstm
+  - transformer
+  - physiological-monitoring
+  - hrv
+  - heart-rate
+  - real-time
+  - multi-user
+  - personalized
+  - sensor-fusion
+  - healthcare
+  - continuous-monitoring
+license: apache-2.0
+pretty_name: Wearable TimeSeries Health Monitor
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div align="center">
+
+**Language / 语言**: [中文](#中文版本) | [English](#english-version)
+
+</div>
+
+---
+
+<a id="中文版本"></a>
+# Wearable_TimeSeries_Health_Monitor
+
+面向可穿戴设备的多用户健康监控方案：一份模型、一个配置，就能为不同用户构建个性化异常检测。模型基于 **Phased LSTM + Temporal Fusion Transformer (TFT)**，并整合自适应基线、因子特征以及单位秒级的数据滑窗能力，适合当作 HuggingFace 模型或企业内部服务快速接入。
+
+---
+
+## 🌟 模型应用亮点
+
+| 能力 | 说明 |
+| --- | --- |
+| **即插即用** | 内置 `WearableAnomalyDetector` 封装，加载模型即可预测，一次初始化后可持续监控多个用户 |
+| **配置驱动特征** | `configs/features_config.json` 描述所有特征、缺省值、类别映射，新增/删减血氧、呼吸率等只需改配置 |
+| **多用户实时服务** | `FeatureCalculator` + 轻量级 `data_storage` 缓存，实现用户历史管理、基线演化、批量推理 |
+| **真实数据验证** | README 内置“真实数据测试”操作说明，可一键模拟正常/异常用户、基线更新与多天模式检测 |
+| **自适应基线支持** | 可扩展 `UserDataManager` 将个人/分组基线接入推理流程，持续改善个体敏感度 |
+
+---
+
+## ⚡ 核心特点与技术优势
+
+### 🎯 自适应基线：个人与群体智能融合
+
+模型采用**自适应基线策略**，根据用户历史数据量动态选择最优基线：
+
+- **个人基线优先**：当用户有足够历史数据（如 ≥7 天）时，使用个人 HRV 均值/标准差作为基线，捕捉个体生理节律差异
+- **群体基线兜底**：新用户或数据稀疏时，自动切换到群体统计基线，确保冷启动也能稳定检测
+- **平滑过渡机制**：通过加权混合（如 `final_mean = α × personal_mean + (1-α) × group_mean`）实现从群体到个人的渐进式适应
+- **实时基线更新**：推理过程中持续累积用户数据，基线随用户状态演化而动态调整，提升长期监控精度
+
+**优势**：相比固定阈值或纯群体基线，自适应基线能同时兼顾**个性化敏感度**（减少误报）和**冷启动鲁棒性**（新用户可用），特别适合多用户、长周期监控场景。
+
+### ⏱️ 灵活的时间窗口与周期
+
+- **5 分钟级粒度**：每条数据点代表 5 分钟聚合，支持秒级到小时级的灵活时间尺度
+- **可配置窗口大小**：默认 12 点（1 小时），可根据业务需求调整为 6 点（30 分钟）或 24 点（2 小时）
+- **不等间隔容错**：Phased LSTM 架构天然处理缺失数据点，即使数据稀疏（如夜间传感器断开）也能稳定推理
+- **多时间尺度特征**：同时提取短期波动（RMSSD）、中期趋势（滑动均值）和长期模式（日/周周期），捕捉不同时间尺度的异常信号
+
+**优势**：适应不同设备采样频率、用户佩戴习惯，无需强制对齐时间戳，降低数据预处理复杂度。
+
+### 🔄 多通道数据协同作用
+
+模型整合**4 大类特征通道**，通过因子特征与注意力机制实现跨通道信息融合：
+
+1. **生理通道**（HR、HRV 系列、呼吸率、血氧）
+   - 直接反映心血管与呼吸系统状态
+   - 因子特征：`physiological_mean`, `physiological_std`, `physiological_max`, `physiological_min`
+
+2. **活动通道**（步数、距离、能量消耗、加速度、陀螺仪）
+   - 捕捉运动强度与身体负荷
+   - 因子特征：`activity_mean`, `activity_std` 等
+
+3. **环境通道**（光线、时间周期、数据质量）
+   - 提供上下文信息，区分运动性心率升高 vs 静息异常
+   - 类别特征：`time_period_primary`（morning/day/evening/night）
+
+4. **基线通道**（自适应基线均值/标准差、偏差特征）
+   - 提供个性化参考基准，计算 `hrv_deviation_abs`, `hrv_z_score` 等相对异常指标
+
+**协同机制**：
+- **因子特征聚合**：将同类通道的统计量（均值/标准差/最值）作为高层特征，让模型学习通道间的关联模式
+- **TFT 注意力**：Temporal Fusion Transformer 的变量选择网络自动识别哪些通道在特定时间点最重要
+- **已知未来特征**：时间特征（小时、星期、是否周末）帮��模型理解周期性，区分正常波动与异常
+
+**优势**：多通道协同能显著降低**单一指标误报**（如运动导致心率升高），提升**异常检测的上下文感知能力**，特别适合可穿戴设备的多传感器融合场景。
+
+---
+
+## 📊 核心指标（短期窗口）
+
+- **F1**: 0.2819
+- **Precision**: 0.1769
+- **Recall**: 0.6941
+- **最佳阈值**: 0.53
+- **窗口定义**: 12 条 5 分钟数据（1小时时间窗，预测未来 0.5 小时）
+
+> 模型偏向召回，适合“异常先提醒、人机协同复核”的场景。可通过阈值/采样策略调节精度与召回。
+
+---
+
+## 🚀 快速体验
+
+### 1. 克隆或下载模型仓库
+
+```bash
+git clone https://huggingface.co/oscarzhang/Wearable_TimeSeries_Health_Monitor
+cd Wearable_TimeSeries_Health_Monitor
+pip install -r requirements.txt
+```
+
+### 2. 在业务代码中调用
+
+```python
+from wearable_anomaly_detector import WearableAnomalyDetector
+
+detector = WearableAnomalyDetector(
+    model_dir="checkpoints/phase2/exp_factor_balanced",
+    threshold=0.53,
+)
+
+result = detector.predict(data_points, return_score=True, return_details=True)
+print(result)
+```
+
+> `data_points` 为 12 条最新的 5 分钟记录；若缺静态特征/设备信息，系统会自动从配置/缓存补齐。
+
+### 3. 快速体验真实数据模拟
+
+```python
+from datetime import datetime, timedelta
+from wearable_anomaly_detector import WearableAnomalyDetector
+
+detector = WearableAnomalyDetector("checkpoints/phase2/exp_factor_balanced", device="cpu")
+
+def make_point(ts, hrv, hr):
+    return {
+        "timestamp": ts.isoformat(),
+        "deviceId": "demo_user",
+        "features": {
+            "hr": hr,
+            "hr_resting": 65,
+            "hrv_rmssd": hrv,
+            "time_period_primary": "day",
+            "data_quality": "high",
+            "baseline_hrv_mean": 75.0,
+            "baseline_hrv_std": 5.0
+        },
+        "static_features": {
+            "age_group": 2,
+            "sex": 0,
+            "exercise": 1
+        }
+    }
+
+start = datetime.now() - timedelta(hours=1)
+window = [make_point(start + timedelta(minutes=5*i), 75 - i*0.5, 70 + i*0.2) for i in range(12)]
+print(detector.detect_realtime(window))
+```
+
+以上脚本会自动构造 12 条 5 分钟数据，完成一次实时检测。可自行调节 HRV、HR 或窗口大小模拟不同场景。
+
+---
+
+## 🧪 真实数据测试
+
+> 以下结果来自 README 中的示例脚本（模拟正常/异常用户、基线更新、多天模式）。全部在 CPU 上完成。
+
+| 场景 | 数据概况 | 结果 |
+| --- | --- | --- |
+| 实时检测（正常） | HRV≈76ms，HR≈68 bpm，12 条数据 | 异常分数 0.5393，阈值 0.53（轻微触发，模型对边缘异常敏感） |
+| 实时检测（异常） | HRV≈69ms，HR≈74 bpm，12 条数据 | 异常分数 0.4764，未超阈值，需结合多天模式进一步观察 |
+| 模式聚合（7 天） | 前 3 天正常，后 4 天逐渐下行 | 正确识别持续 3 天的异常模式，趋势为 stable |
+| 基线存储/更新 | 初始基线 75±5，记录 30 条 | 存储成功；新值 70ms 后均值更新为 74.84，记录数 31 |
+| 完整流程 | 实时检测 → 基线更新 → LLM 文本 | 全流程执行成功，生成 114 字符的结构化异常摘要 |
+
+复制上文的“真实数据模拟”代码，按需调整 HRV/HR、窗口长度或异常强度即可复现同样的流程。
+
+---
+
+## 🔧 输入与输出
+
+### 输入（单个数据点）
+
+```python
+{
+  "timestamp": "2024-01-01T08:00:00",
+  "deviceId": "ab60",            # 可选，缺失时会自动创建匿名 ID
+  "features": {
+    "hr": 72.0,
+    "hrv_rmssd": 30.0,
+    "time_period_primary": "morning",
+    "data_quality": "high",
+    ...
+  }
+}
+```
+
+- 每个窗口需 12 条数据（默认 1 小时）
+- 特征是否必填由 `configs/features_config.json` 控制
+- 缺失值会自动回落到 default 或 category_mapping 定义值
+
+### 输出
+
+```python
+{
+  "is_anomaly": True,
+  "anomaly_score": 0.5760,
+  "threshold": 0.5300,
+  "details": {
+     "window_size": 12,
+     "model_output": 0.5760,
+     "prediction_confidence": 0.0460
+  }
+}
+```
+
+---
+
+## 🧱 模型架构与训练
+
+- **模型骨干**：Phased LSTM 处理不等间隔序列 + Temporal Fusion Transformer 聚合时间上下文
+- **异常检测头**：增强注意力、多层 MLP、可选对比学习/类型辅助头
+- **特征体系**：
+  - 生理：HR、HRV（RMSSD/SDNN/PNN50…）
+  - 活动：步数、距离、能量消耗、加速度、陀螺仪
+  - 环境：光线、昼夜标签、数据质量
+  - 基线：自适应基线均值/标准差 + 偏差特征
+- **标签来源**：问卷高置信度标签 + 自适应基线低置信度标签
+- **训练流程**：Stage1/2/3 数据加工 ➜ Phase1 自监督预训练 ➜ Phase2 监督微调 ➜ 阈值/案例校正
+
+---
+
+## 📦 仓库结构（部分）
+
+```
+├─ configs/
+│   └─ features_config.json     # 特征定义 & 归一化策��
+├─ wearable_anomaly_detector.py # 核心封装：加载、预测、批处理
+├─ feature_calculator.py        # 配置驱动的特征构建 + 用户历史缓存
+└─ checkpoints/phase2/...       # 模型权重 & summary
+```
+
+---
+
+## 📚 数据来源与许可证
+
+- 训练数据基于 **“A continuous real-world dataset comprising wearable-based heart rate variability alongside sleep diaries”**（Baigutanova *et al.*, Scientific Data, 2025）以及其 Figshare 数据集 [doi:10.1038/s41597-025-05801-3](https://www.nature.com/articles/s41597-025-05801-3) / [dataset link](https://springernature.figshare.com/articles/dataset/In-situ_wearable-based_dataset_of_continuous_heart_rate_variability_monitoring_accompanied_by_sleep_diaries/28509740)。
+- 该数据集以 **Creative Commons Attribution 4.0 (CC BY 4.0)** 许可发布，可自由使用、修改、分发，但必须保留署名并附上许可证链接。
+- 本仓库沿用 CC BY 4.0 对原始数据的要求；若你在此基础上再加工或发布，请继续保留上述署名与许可证说明。
+- 代码/模型可根据需要使用 MIT/Apache 等许可证，但凡涉及数据的部分，仍需遵循 CC BY 4.0。
+
+---
+
+## 🤝 贡献与扩展
+
+欢迎：
+1. 新增特征或数据源 ⇒ 更新 `features_config.json` + 提交 PR
+2. 接入新的用户数据管理/基线策略 ⇒ 扩展 `FeatureCalculator` 或贡献 `UserDataManager`
+3. 反馈案例或真实部署经验 ⇒ 提 Issue 或 Discussion
+
+---
+
+## 📄 许可证
+
+- **模型与代码**：Apache-2.0。可在保留版权与许可证声明的前提下任意使用/修改/分发。
+- **训练数据**：原始可穿戴 HRV 数据集使用 CC BY 4.0，复用时请继续保留作者署名与许可信息。
+
+---
+
+## 🔖 引用
+
+```bibtex
+@software{Wearable_TimeSeries_Health_Monitor,
+  title  = {Wearable\_TimeSeries\_Health\_Monitor},
+  author = {oscarzhang},
+  year   = {2025},
+  url    = {https://huggingface.co/oscarzhang/Wearable_TimeSeries_Health_Monitor}
+}
+```
+
+---
+
+<a id="english-version"></a>
+# Wearable_TimeSeries_Health_Monitor
+
+A multi-user health monitoring solution for wearable devices: one model, one configuration, enabling personalized anomaly detection for different users. The model is based on **Phased LSTM + Temporal Fusion Transformer (TFT)**, integrating adaptive baselines, factor features, and second-level data sliding window capabilities, suitable for deployment as a HuggingFace model or rapid integration into enterprise services.
+
+---
+
+## 🌟 Model Highlights
+
+| Capability | Description |
+| --- | --- |
+| **Plug-and-Play** | Built-in `WearableAnomalyDetector` wrapper, load the model and start predicting, supports continuous monitoring of multiple users after a single initialization |
+| **Configuration-Driven Features** | `configs/features_config.json` defines all features, default values, and category mappings; adding/removing features like blood oxygen or respiratory rate only requires configuration changes |
+| **Multi-User Real-Time Service** | `FeatureCalculator` + lightweight `data_storage` cache enables user history management, baseline evolution, and batch inference |
+| **Real-World Validation** | README ships with a “Real Data Tests” section plus sample simulation code so you can mimic normal/abnormal users in minutes |
+| **Adaptive Baseline Support** | Extensible `UserDataManager` integrates personal/group baselines into the inference pipeline, continuously improving individual sensitivity |
+
+---
+
+## ⚡ Core Features & Technical Advantages
+
+### 🎯 Adaptive Baseline: Intelligent Fusion of Personal and Group
+
+The model employs an **adaptive baseline strategy** that dynamically selects the optimal baseline based on user historical data volume:
+
+- **Personal Baseline Priority**: When users have sufficient historical data (e.g., ≥7 days), use personal HRV mean/std as baseline to capture individual physiological rhythm differences
+- **Group Baseline Fallback**: For new users or sparse data, automatically switch to group statistical baseline, ensuring stable detection even during cold start
+- **Smooth Transition Mechanism**: Achieve gradual adaptation from group to personal through weighted mixing (e.g., `final_mean = α × personal_mean + (1-α) × group_mean`)
+- **Real-Time Baseline Updates**: Continuously accumulate user data during inference, baseline dynamically adjusts as user state evolves, improving long-term monitoring accuracy
+
+**Advantage**: Compared to fixed thresholds or pure group baselines, adaptive baselines balance **personalized sensitivity** (reducing false positives) and **cold-start robustness** (usable for new users), especially suitable for multi-user, long-term monitoring scenarios.
+
+### ⏱️ Flexible Time Windows & Periods
+
+- **5-Minute Granularity**: Each data point represents 5-minute aggregation, supporting flexible time scales from seconds to hours
+- **Configurable Window Size**: Default 12 points (1 hour), adjustable to 6 points (30 minutes) or 24 points (2 hours) based on business needs
+- **Uneven Interval Tolerance**: Phased LSTM architecture naturally handles missing data points, stable inference even with sparse data (e.g., sensor disconnection at night)
+- **Multi-Time-Scale Features**: Simultaneously extract short-term fluctuations (RMSSD), medium-term trends (rolling mean), and long-term patterns (daily/weekly cycles), capturing anomaly signals at different time scales
+
+**Advantage**: Adapts to different device sampling frequencies and user wearing habits, no need to force timestamp alignment, reducing data preprocessing complexity.
+
+### 🔄 Multi-Channel Data Synergy
+
+The model integrates **4 major feature channels**, achieving cross-channel information fusion through factor features and attention mechanisms:
+
+1. **Physiological Channel** (HR, HRV series, respiratory rate, blood oxygen)
+   - Directly reflects cardiovascular and respiratory system status
+   - Factor features: `physiological_mean`, `physiological_std`, `physiological_max`, `physiological_min`
+
+2. **Activity Channel** (steps, distance, energy consumption, acceleration, gyroscope)
+   - Captures exercise intensity and body load
+   - Factor features: `activity_mean`, `activity_std`, etc.
+
+3. **Environmental Channel** (light, time period, data quality)
+   - Provides contextual information, distinguishing exercise-induced heart rate elevation vs. resting anomalies
+   - Categorical features: `time_period_primary` (morning/day/evening/night)
+
+4. **Baseline Channel** (adaptive baseline mean/std, deviation features)
+   - Provides personalized reference baseline, calculating relative anomaly indicators like `hrv_deviation_abs`, `hrv_z_score`
+
+**Synergy Mechanism**:
+- **Factor Feature Aggregation**: Use statistical measures (mean/std/max/min) of similar channels as high-level features, enabling the model to learn association patterns between channels
+- **TFT Attention**: Temporal Fusion Transformer's variable selection network automatically identifies which channels are most important at specific time points
+- **Known Future Features**: Time features (hour, day of week, is_weekend) help the model understand periodicity, distinguishing normal fluctuations from anomalies
+
+**Advantage**: Multi-channel synergy significantly reduces **single-indicator false positives** (e.g., exercise-induced heart rate elevation) and improves **context-aware anomaly detection**, especially suitable for multi-sensor fusion scenarios in wearable devices.
+
+---
+
+## 📊 Core Metrics (Short-Term Window)
+
+- **F1**: 0.2819
+- **Precision**: 0.1769
+- **Recall**: 0.6941
+- **Optimal Threshold**: 0.53
+- **Window Definition**: 12 data points of 5-minute intervals (1-hour time window, predicting 0.5 hours ahead)
+
+> The model favors recall, suitable for "anomaly-first alert, human-machine collaborative review" scenarios. Precision and recall can be adjusted through threshold/sampling strategies.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Clone or Download the Model Repository
+
+```bash
+git clone https://huggingface.co/oscarzhang/Wearable_TimeSeries_Health_Monitor
+cd Wearable_TimeSeries_Health_Monitor
+pip install -r requirements.txt
+```
+
+### 2. Run the Official Inference Script
+
+```bash
+python run_official_inference.py \
+  --window-file test_data/example_window.json \
+  --model-dir checkpoints/phase2/exp_factor_balanced
+```
+
+脚本会：
+- 读取 `test_data/example_window.json`（12 条真实格式的窗口数据）
+- 调用 `WearableAnomalyDetector.detect_realtime`
+- 打印完整 JSON 结果
+- 使用 `AnomalyFormatter` 输出 LLM 可直接消费的 Markdown 文本
+
+想测试自己的窗口，只需替换 `--window-file` 路径；该脚本不会注入随机噪声，输出与正式 API 一致。
+
+### 3. Call in Business Code
+
+```python
+from wearable_anomaly_detector import WearableAnomalyDetector
+
+detector = WearableAnomalyDetector(
+    model_dir="checkpoints/phase2/exp_factor_balanced",
+    threshold=0.53,
+)
+
+result = detector.predict(data_points, return_score=True, return_details=True)
+print(result)
+```
+
+> `data_points` should be 12 latest 5-minute records; if static features/device information are missing, the system will automatically fill from configuration/cache.
+
+### 4. Quick Simulation Script（Optional）
+
+```bash
+python test_quickstart.py
+```
+
+该脚本包含更多演示场景（随机噪声、7 天显著异常、缺失/低质量数据）。日志会先跑一遍示例文件推理，然后输出正常/异常窗口、模式聚合与容错样例。**注意**：脚本为了观察边界，会临时把阈值调至 0.50，并引入随机扰动，仅用于体验。
+
+---
+
+## 🧪 Real Data Tests
+
+> The following results were reproduced with the sample code above (normal vs. abnormal users, multi-day trend, baseline update, end-to-end workflow). All tests ran on CPU; the first scenario直接加载 `test_data/example_window.json`.
+
+| Scenario | Data Snapshot | Outcome |
+| --- | --- | --- |
+| Real-time (sample file) | HRV≈72 ms, HR≈71 bpm, 12 points | Score ≈0.526 vs. threshold 0.50（演示用阈值） |
+| Real-time (normal) | HRV≈76 ms, HR≈68 bpm, 12 points | Score 0.5393 vs. threshold 0.53 (marginal trigger) |
+| Real-time (abnormal) | HRV≈69 ms, HR≈74 bpm | Score 0.4764 < threshold, requires multi-day confirmation |
+| Pattern aggregation | 7 days, last 3 days gradually down | Detected 3-day continuous anomaly, trend `stable` |
+| Baseline storage/update | Start 75 ± 5, 30 records | After new value 70 ms ⇒ mean 74.84, records 31 |
+| Missing data tolerance | 40% features removed + static info missing | Still flags anomaly (score ≈0.50) thanks to fallback defaults |
+| Full workflow | Detect → Baseline update → LLM text | Completed successfully; 114-char structured summary |
+
+Feel free to adapt `test_data/example_window.json` 或脚本内的模拟逻辑，调整 HRV/HR 曲线、窗口大小或缺失比例，观察输出变化。
+
+---
+
+> Quickstart 脚本默认把阈值临时调至 0.50，以便观测边界场景。实际部署时可根据业务重新设置。
+
+## 🔧 Input & Output
+
+### Input (Single Data Point)
+
+```python
+{
+  "timestamp": "2024-01-01T08:00:00",
+  "deviceId": "ab60",            # Optional, anonymous ID will be created if missing
+  "features": {
+    "hr": 72.0,
+    "hrv_rmssd": 30.0,
+    "time_period_primary": "morning",
+    "data_quality": "high",
+    ...
+  }
+}
+```
+
+- Each window requires 12 data points (default 1 hour)
+- Whether features are required is controlled by `configs/features_config.json`
+- Missing values automatically fall back to default or category_mapping defined values
+
+### Output
+
+```python
+{
+  "is_anomaly": True,
+  "anomaly_score": 0.5760,
+  "threshold": 0.5300,
+  "details": {
+     "window_size": 12,
+     "model_output": 0.5760,
+     "prediction_confidence": 0.0460
+  }
+}
+```
+
+---
+
+## 🧱 Model Architecture & Training
+
+- **Model Backbone**: Phased LSTM handles unevenly-spaced sequences + Temporal Fusion Transformer aggregates temporal context
+- **Anomaly Detection Head**: Enhanced attention, multi-layer MLP, optional contrastive learning/type auxiliary head
+- **Feature System**:
+  - Physiological: HR, HRV (RMSSD/SDNN/PNN50…)
+  - Activity: Steps, distance, energy consumption, acceleration, gyroscope
+  - Environmental: Light, day/night labels, data quality
+  - Baseline: Adaptive baseline mean/std + deviation features
+- **Label Source**: High-confidence questionnaire labels + low-confidence adaptive baseline labels
+- **Training Pipeline**: Stage1/2/3 data processing ➜ Phase1 self-supervised pre-training ➜ Phase2 supervised fine-tuning ➜ Threshold/case calibration
+
+---
+
+## 📦 Repository Structure (Partial)
+
+```
+├─ configs/
+│   └─ features_config.json     # Feature definitions & normalization strategies
+├─ wearable_anomaly_detector.py # Core wrapper: loading, prediction, batch processing
+├─ feature_calculator.py        # Configuration-driven feature construction + user history cache
+└─ checkpoints/phase2/...       # Model weights & summary
+```
+
+---
+
+## 🧾 API 文档
+
+- `API_USAGE.md`：列出 `WearableAnomalyDetector`、`AnomalyFormatter`、`BaselineStorage` 等核心接口的参数、输入输出示例。
+- `test_quickstart.py`：可直接运行的自检脚本，便于验证接口行为。
+
+---
+
+## 📚 Data Source & License
+
+- Training data is based on **"A continuous real-world dataset comprising wearable-based heart rate variability alongside sleep diaries"** (Baigutanova *et al.*, Scientific Data, 2025) and its Figshare dataset [doi:10.1038/s41597-025-05801-3](https://www.nature.com/articles/s41597-025-05801-3) / [dataset link](https://springernature.figshare.com/articles/dataset/In-situ_wearable-based_dataset_of_continuous_heart_rate_variability_monitoring_accompanied_by_sleep_diaries/28509740).
+- This dataset is released under **Creative Commons Attribution 4.0 (CC BY 4.0)** license, allowing free use, modification, and distribution, but attribution and license link must be retained.
+- This repository follows CC BY 4.0 requirements for original data; if you further process or publish based on this, please continue to retain the above attribution and license information.
+- Code/models can use MIT/Apache or other licenses as needed, but any parts involving data must still follow CC BY 4.0.
+
+---
+
+## 🤝 Contributions & Extensions
+
+Welcome to:
+1. Add new features or data sources ⇒ Update `features_config.json` + submit PR
+2. Integrate new user data management/baseline strategies ⇒ Extend `FeatureCalculator` or contribute `UserDataManager`
+3. Provide feedback on cases or real deployment experiences ⇒ Open Issues or Discussions
+
+---
+
+## 📄 License
+
+- **Model & Code**: Apache-2.0. Can be used/modified/distributed freely while retaining copyright and license notices.
+- **Training Data**: Original wearable HRV dataset uses CC BY 4.0; please continue to retain author attribution and license information when reusing.
+
+---
+
+## 🔖 Citation
+
+```bibtex
+@software{Wearable_TimeSeries_Health_Monitor,
+  title  = {Wearable\_TimeSeries\_Health\_Monitor},
+  author = {oscarzhang},
+  year   = {2025},
+  url    = {https://huggingface.co/oscarzhang/Wearable_TimeSeries_Health_Monitor}
+}
+```
+

checkpoints/phase2/exp_factor_balanced/best_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f2f056ea3cec48902ffda2399e905189dce62826034470bb6514f8739eba9ff
+size 27270610

configs/api_config.json

@@ -0,0 +1,31 @@
+{
+  "historical_data_platform": {
+    "base_url": "",
+    "api_key": "",
+    "timeout": 30,
+    "retry_times": 3,
+    "endpoints": {
+      "raw_data": "/api/raw-data/{deviceId}",
+      "user_profile": "/api/user-profile/{deviceId}",
+      "historical_results": "/api/historical-results/{deviceId}"
+    }
+  },
+  "baseline": {
+    "storage_type": "file",
+    "file_path": "data_storage/baselines.json",
+    "database": {
+      "enabled": false,
+      "type": "sqlite",
+      "connection_string": "sqlite:///data_storage/baselines.db"
+    },
+    "auto_update": true,
+    "update_on_detect": true,
+    "import_from_csv": true,
+    "csv_path": "processed_data/stage1/adaptive_baselines.csv"
+  },
+  "cache": {
+    "user_profile_ttl": 86400,
+    "baseline_ttl": 3600
+  }
+}
+

configs/detector_config.json

@@ -0,0 +1,18 @@
+{
+  "detection": {
+    "window_size": 12,
+    "window_interval_minutes": 5,
+    "min_duration_days": 3,
+    "default_threshold": 0.53
+  },
+  "baseline": {
+    "update_on_detect": true,
+    "update_interval_hours": 1,
+    "sliding_window_days": 30
+  },
+  "pattern_detection": {
+    "min_duration_days": 3,
+    "trend_threshold": 0.01
+  }
+}
+

configs/features_config.json

@@ -0,0 +1,108 @@
+{
+  "metadata": {
+    "version": "1.0",
+    "description": "Wearable anomaly detection feature configuration"
+  },
+  "time_series": [
+    {"name": "hr", "enabled": true, "default": 70.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "hr_resting", "enabled": true, "default": 65.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "hrv_rmssd", "enabled": true, "default": 30.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "hrv_sdnn", "enabled": true, "default": 40.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "hrv_pnn50", "enabled": true, "default": 15.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "sdnn", "enabled": true, "default": 35.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "sdsd", "enabled": true, "default": 25.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "rmssd", "enabled": true, "default": 30.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "pnn20", "enabled": true, "default": 25.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "pnn50", "enabled": true, "default": 12.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "ibi", "enabled": true, "default": 0.86, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "lf/hf", "enabled": true, "default": 1.8, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "steps", "enabled": true, "default": 20.0, "normalization": {"type": "minmax", "min": 0.0, "max": 500.0}},
+    {"name": "distance", "enabled": true, "default": 10.0, "normalization": {"type": "minmax", "min": 0.0, "max": 2000.0}},
+    {"name": "calories", "enabled": true, "default": 1.5, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "acc_x_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "acc_y_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "acc_z_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "grv_x_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "grv_y_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "grv_z_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "grv_w_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "gyr_x_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "gyr_y_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "gyr_z_avg", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "light_avg", "enabled": true, "default": 100.0, "normalization": {"type": "minmax", "min": 0.0, "max": 1000.0}},
+    {
+      "name": "time_period_primary",
+      "enabled": true,
+      "default": 2.0,
+      "normalization": {"type": "none"},
+      "category_mapping": {
+        "night": 0,
+        "morning": 1,
+        "day": 2,
+        "evening": 3,
+        "unknown": 4
+      }
+    },
+    {
+      "name": "time_period_secondary",
+      "enabled": true,
+      "default": 7.0,
+      "normalization": {"type": "none"},
+      "category_mapping": {
+        "commute_morning": 0,
+        "breakfast": 1,
+        "work_morning": 2,
+        "lunch": 3,
+        "work_afternoon": 4,
+        "commute_evening": 5,
+        "dinner": 6,
+        "rest_evening": 7,
+        "rest_night": 8,
+        "exercise": 9,
+        "unknown": 10
+      }
+    },
+    {"name": "is_weekend", "enabled": true, "default": 0.0, "normalization": {"type": "none"}},
+    {
+      "name": "data_quality",
+      "enabled": true,
+      "default": 0.9,
+      "normalization": {"type": "minmax", "min": 0.0, "max": 1.0},
+      "category_mapping": {
+        "low": 0.3,
+        "medium": 0.6,
+        "high": 1.0
+      }
+    },
+    {"name": "missingness_score", "enabled": true, "default": 0.0, "normalization": {"type": "minmax", "min": 0.0, "max": 1.0}},
+    {"name": "baseline_hrv_mean", "enabled": true, "default": 30.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "baseline_hrv_std", "enabled": true, "default": 5.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "hrv_deviation_abs", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "hrv_deviation_pct", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}},
+    {"name": "hrv_z_score", "enabled": true, "default": 0.0, "normalization": {"type": "zscore", "use_norm_params": true}}
+  ],
+  "static": [
+    {"name": "age_group", "enabled": true, "default": -1},
+    {"name": "age_normalized", "enabled": true, "default": 0.5},
+    {"name": "sex", "enabled": true, "default": 0.5},
+    {"name": "marriage", "enabled": true, "default": -1},
+    {"name": "exercise", "enabled": true, "default": -1},
+    {"name": "coffee", "enabled": true, "default": -1},
+    {"name": "smoking", "enabled": true, "default": -1},
+    {"name": "drinking", "enabled": true, "default": -1},
+    {"name": "MEQ", "enabled": true, "default": 0.0},
+    {"name": "baseline_commute_morning_mean", "enabled": true, "default": 30.0},
+    {"name": "baseline_commute_morning_std", "enabled": true, "default": 5.0}
+  ],
+  "factor_features": {
+    "enabled": true,
+    "factor_names": ["physio", "activity", "context"],
+    "factor_dim": 4
+  },
+  "known_future": [
+    {"name": "hour_of_day", "enabled": true},
+    {"name": "day_of_week", "enabled": true},
+    {"name": "is_weekend", "enabled": true}
+  ]
+}
+

configs/formatter_config.json

@@ -0,0 +1,189 @@
+{
+  "sections": {
+    "anomaly_overview": {
+      "enabled": true,
+      "title": "异常概览",
+      "fields": {
+        "anomaly_type": {
+          "label": "异常类型",
+          "format": "string",
+          "default": "未知"
+        },
+        "duration_days": {
+          "label": "持续天数",
+          "format": "integer",
+          "suffix": "天"
+        },
+        "trend": {
+          "label": "异常趋势",
+          "format": "string",
+          "default": "未知",
+          "mapping": {
+            "worsening": "持续恶化",
+            "stable": "稳定异常",
+            "improving": "逐渐改善"
+          }
+        },
+        "is_anomaly": {
+          "label": "是否异常",
+          "format": "boolean",
+          "true_text": "是",
+          "false_text": "否"
+        },
+        "anomaly_score": {
+          "label": "异常分数",
+          "format": "float",
+          "decimal_places": 4
+        },
+        "threshold": {
+          "label": "阈值",
+          "format": "float",
+          "decimal_places": 4
+        }
+      }
+    },
+    "core_indicators": {
+      "enabled": true,
+      "title": "核心指标",
+      "fields": {
+        "hrv_rmssd": {
+          "label": "HRV RMSSD",
+          "format": "float",
+          "decimal_places": 2,
+          "suffix": " ms"
+        },
+        "baseline_mean": {
+          "label": "基线值",
+          "format": "float",
+          "decimal_places": 2,
+          "suffix": " ms"
+        },
+        "deviation_pct": {
+          "label": "偏离基线",
+          "format": "float",
+          "decimal_places": 2,
+          "suffix": "%"
+        }
+      }
+    },
+    "historical_trend": {
+      "enabled": true,
+      "title": "历史趋势",
+      "fields": {
+        "date": {
+          "label": "日期",
+          "format": "string"
+        },
+        "hrv_rmssd": {
+          "label": "HRV",
+          "format": "float",
+          "decimal_places": 2,
+          "prefix": "HRV=",
+          "suffix": " ms"
+        },
+        "hr": {
+          "label": "心率",
+          "format": "float",
+          "decimal_places": 1,
+          "prefix": "心率=",
+          "suffix": " bpm"
+        },
+        "anomaly_score": {
+          "label": "异常分数",
+          "format": "float",
+          "decimal_places": 4,
+          "prefix": "异常分数="
+        }
+      }
+    },
+    "related_indicators": {
+      "enabled": true,
+      "title": "相关健康指标",
+      "fields": {
+        "activity_level": {
+          "label": "活动水平",
+          "format": "nested",
+          "sub_fields": {
+            "level": {
+              "label": "水平",
+              "format": "string"
+            },
+            "avg_steps": {
+              "label": "平均步数",
+              "format": "float",
+              "decimal_places": 1,
+              "prefix": "（平均步数=",
+              "suffix": "）"
+            }
+          }
+        },
+        "sleep_quality": {
+          "label": "睡眠质量",
+          "format": "nested",
+          "sub_fields": {
+            "quality": {
+              "label": "质量",
+              "format": "string"
+            },
+            "available": {
+              "label": "可用性",
+              "format": "boolean",
+              "true_text": "数据可用",
+              "false_text": "数据不可用"
+            }
+          }
+        },
+        "stress_indicators": {
+          "label": "压力指标",
+          "format": "nested",
+          "sub_fields": {
+            "level": {
+              "label": "水平",
+              "format": "string"
+            }
+          }
+        }
+      }
+    },
+    "user_profile": {
+      "enabled": true,
+      "title": "用户背景信息",
+      "fields": {
+        "estimated_age": {
+          "label": "年龄",
+          "format": "string_or_nested",
+          "fallback": "age_group"
+        },
+        "sex": {
+          "label": "性别",
+          "format": "string"
+        },
+        "exercise": {
+          "label": "运动频率",
+          "format": "string"
+        },
+        "coffee": {
+          "label": "咖啡消费",
+          "format": "string"
+        },
+        "drinking": {
+          "label": "饮酒状况",
+          "format": "string"
+        },
+        "MEQ_type": {
+          "label": "MEQ类型",
+          "format": "string"
+        }
+      }
+    }
+  },
+  "formatting": {
+    "section_prefix": "## ",
+    "section_suffix": "\n",
+    "field_prefix": "- ",
+    "field_suffix": "\n",
+    "line_separator": "\n",
+    "header": "# 健康异常检测结果\n"
+  }
+}
+

data_storage/baselines.json

@@ -0,0 +1,31 @@
+[
+  {
+    "device_id": "test_user",
+    "feature_name": "hrv_rmssd",
+    "baseline_type": "personal",
+    "baseline_mean": 75.45454545454545,
+    "baseline_std": 5.0,
+    "personal_mean": 75.0,
+    "personal_std": 5.0,
+    "data_count": 11,
+    "time_period_primary": "morning",
+    "time_period_secondary": "",
+    "is_weekend": 0,
+    "last_updated": "2025-11-27T14:24:45.274978"
+  },
+  {
+    "device_id": "test_user_003",
+    "feature_name": "hrv_rmssd",
+    "baseline_type": "personal",
+    "baseline_mean": 74.83870967741936,
+    "baseline_std": 5.0,
+    "personal_mean": 75.0,
+    "personal_std": 5.0,
+    "group_mean": 75.0,
+    "data_count": 31,
+    "time_period_primary": "",
+    "time_period_secondary": "",
+    "is_weekend": 0,
+    "last_updated": "2025-11-27T14:34:26.141050"
+  }
+]

demo_llm_inputs/case_am77_full.json

@@ -0,0 +1,30 @@
+{
+  "case_id": "case_am77_full",
+  "summary": {
+    "anomaly_type": "continuous_anomaly",
+    "duration_days": 7,
+    "trend": "stable",
+    "description": "检测到持续7天的异常模式，趋势：稳定异常，异常分数范围：0.4827 - 0.4890，平均分数：0.4871"
+  },
+  "user_profile": {
+    "age_group": "30-35岁",
+    "estimated_age": 32,
+    "sex": "男性",
+    "exercise": "每周5次以上",
+    "coffee": "不喝咖啡",
+    "smoking": "不吸烟",
+    "drinking": "经常饮酒",
+    "MEQ": 64.0,
+    "MEQ_type": "晨型"
+  },
+  "messages": [
+    {
+      "role": "system",
+      "content": "请阅读以下健康异常检测输入描述，生成符合P3与PROCEED框架的个性化健康干预方案，需列出异常点、推理过程、误报判断、紧急处理、长期方案及用户特征说明，且所有建议需为个人可执行。"
+    },
+    {
+      "role": "user",
+      "content": "# 健康异常检测案例报告\n\n## 异常概览\n\n**异常类型**：持续性异常  \n**持续时间**：7天  \n**异常趋势**：稳定型  \n**严重程度**：轻度异常  \n**状态确认**：**真实异常**（非误报案例）\n\n### 异常评分分析\n- **异常分数范围**：0.4827 - 0.4890\n- **平均异常分数**：0.4871\n- **检测阈值**：0.4800\n- **异常状态**：持续超过阈值但幅度有限\n\n## 核心指标状态\n\n### 心率变异性（HRV）分析\n| 指标 | 当前值 | 偏离基线 | 基线值 | Z-score |\n|------|--------|----------|--------|---------|\n| HRV RMSSD | 68.11 ms | +1.0% | 67.46 ms | 0.02 |\n\n**基线特征**：\n- 基线类型：个人主要基线\n- 基线可靠性：高\n- 个人基线：68.31 ms（标准差：32.86 ms，基于63次历史记录）\n- 群体基线：59.85 ms\n\n## 历史趋势分析\n\n### 关键指标监测数据\n| 日期 | HRV (ms) | 心率 (bpm) | 异常分数 |\n|------|----------|------------|----------|\n| 2021-03-07 | 67.14 | 80.2 | 0.4827 |\n| 2021-03-09 | 84.74 | 71.5 | 0.4869 |\n| 2021-03-14 | 77.41 | 68.6 | 0.4869 |\n| 2021-03-17 | 75.94 | 75.5 | 0.4884 |\n| 2021-03-20 | 66.86 | 68.7 | 0.4875 |\n| 2021-03-27 | 92.36 | 74.8 | 0.4884 |\n| 2021-03-28 | 68.11 | 67.6 | 0.4890 |\n\n## 相关健康指标\n\n### 活动水平分析\n- **总体状态**：低活动水平\n- **平均步数**：3.1步/日\n- **平均卡路里消耗**：0.1千卡/日\n- **趋势特征**：持续下降模式\n\n### 其他健康指标\n- **睡眠质量**：数据不可用\n- **压力指标**：无显著压力表现\n\n## 用户背景信息\n\n### 人口统计学特征\n- **年龄**：约32岁（30-35岁区间）\n- **性别**：男性\n- **昼夜节律类型**：MEQ得分64.0（晨型人格）\n\n### 生活习惯特征\n- **运动频率**：每周5次以上（高频率）\n- **咖啡消费**：不喝咖啡\n- **吸烟状况**：不吸烟\n- **饮酒状况**：经常饮酒\n\n## 临床意义评估\n\n### 异常特征总结\n该异常表现为持续7天的稳定型轻度异常，具有以下特征：\n- HRV指标仅轻微偏离个人基线（+1.0%）\n- Z-score为0.02，表明偏离程度在统计学上不显著\n- 异常分数持续但稳定，无明显恶化趋势\n\n### 风险评估与建议\n考虑到用户的高运动频率和良好的生活习惯基础，此异常更可能属于生理性波动范畴。建议：\n- 继续定期监测相关指标\n- 关注活动水平下降的潜在影响\n- 现阶段无需紧急医疗干预\n- 如异常持续或加重，建议进一步评估"
+    }
+  ]
+}

demo_llm_inputs/case_ba30_full.json

@@ -0,0 +1,30 @@
+{
+  "case_id": "case_ba30_full",
+  "summary": {
+    "anomaly_type": "continuous_anomaly",
+    "duration_days": 24,
+    "trend": "stable",
+    "description": "检测到持续24天的异常模式，趋势：稳定异常，异常分数范围：0.4866 - 0.4888，平均分数：0.4881"
+  },
+  "user_profile": {
+    "age_group": "25-30岁",
+    "estimated_age": 27,
+    "sex": "男性",
+    "exercise": "很少运动",
+    "coffee": "每天2-3杯",
+    "smoking": "不吸烟",
+    "drinking": "经常饮酒",
+    "MEQ": 62.0,
+    "MEQ_type": "晨型"
+  },
+  "messages": [
+    {
+      "role": "system",
+      "content": "请阅读以下健康异常检测输入描述，生成符合P3与PROCEED框架的个性化健康干预方案，需列出异常点、推理过程、误报判断、紧急处理、长期方案及用户特征说明，且所有建议需为个人可执行。"
+    },
+    {
+      "role": "user",
+      "content": "# 健康异常检测分析报告\n\n## 异常概况\n\n**异常类型**：持续性异常  \n**持续时间**：24天  \n**异常趋势**：稳定型  \n**严重程度**：轻度异常  \n**状态确认**：确认真实异常（非误报）\n\n## 关键指标分析\n\n### 异常评分特征\n- **异常分数范围**：0.4866 - 0.4888\n- **平均异常分数**：0.4881\n- **检测阈值**：0.4800\n- **异常持续性**：所有检测点均超过阈值\n\n### 当前生理状态\n- **HRV RMSSD当前值**：102.50 ms\n- **相对于基线偏离**：+7.5%\n- **个人基线值**：95.32 ms\n- **Z-score统计值**：0.27（轻度偏离）\n- **基线可靠性**：高可靠性（基于348条个人历史记录）\n\n## 历史趋势数据\n\n| 日期 | HRV (ms) | 心率 (bpm) | 异常分数 |\n|------|----------|------------|----------|\n| 2021-03-11 | 71.07 | 62.4 | 0.4881 |\n| 2021-03-13 | 87.16 | 57.0 | 0.4888 |\n| 2021-03-14 | 107.80 | 56.7 | 0.4876 |\n| 2021-03-16 | 93.93 | 61.1 | 0.4882 |\n| 2021-03-17 | 96.05 | 61.3 | 0.4881 |\n| 2021-03-18 | 82.32 | 64.0 | 0.4882 |\n| 2021-03-19 | 92.42 | 59.8 | 0.4866 |\n| 2021-03-20 | 91.41 | 56.7 | 0.4887 |\n| 2021-03-21 | 84.49 | 59.8 | 0.4882 |\n| 2021-03-23 | 94.86 | 61.7 | 0.4882 |\n| 2021-03-24 | 100.66 | 58.6 | 0.4882 |\n| 2021-03-25 | 102.66 | 62.7 | 0.4882 |\n| 2021-03-26 | 95.19 | 58.2 | 0.4882 |\n| 2021-03-27 | 96.99 | 57.0 | 0.4888 |\n| 2021-03-28 | 77.60 | 58.2 | 0.4876 |\n| 2021-03-29 | 104.94 | 59.4 | 0.4881 |\n| 2021-03-30 | 95.22 | 62.1 | 0.4878 |\n| 2021-03-31 | 95.29 | 59.7 | 0.4882 |\n| 2021-04-01 | 96.67 | 59.8 | 0.4882 |\n| 2021-04-02 | 123.00 | 56.5 | 0.4876 |\n| 2021-04-03 | 93.23 | 67.5 | 0.4883 |\n| 2021-04-05 | 102.81 | 56.0 | 0.4882 |\n| 2021-04-06 | 96.31 | 59.8 | 0.4881 |\n| 2021-04-07 | 102.50 | 61.2 | 0.4878 |\n\n## 相关健康指标\n\n### 活动水平\n- **总体状态**：低水平\n- **平均步数**：13.4步\n- **平均卡路里消耗**：0.6千卡\n- **趋势特征**：缓慢增加\n\n### 其他指标\n- **睡眠质量**：数据不可用\n- **压力指标**：未检测到明显压力信号\n\n## 基线参考信息\n\n### 个人基线\n- **HRV基线值**：96.79 ms\n- **标准差**：26.79 ms\n- **数据基础**：基于348条历史记录\n\n### 群体比较\n- **群体基线**：82.08 ms\n- **个人相对群体**：高于群体平均水平\n\n## 用户个性化档案\n\n### 基本信息\n- **性别**：男性\n- **年龄**：约27岁（25-30岁）\n- **昼夜节律**：MEQ得分62.0（晨型人格）\n\n### 生活习惯\n- **运动习惯**：很少运动\n- **咖啡消费**：每天2-3杯\n- **吸烟状况**：不吸烟\n- **饮酒状况**：经常饮酒\n\n## 临床评估与建议\n\n### 异常特征总结\n该案例显示持续24天的稳定型HRV轻度异常，异常分数持续略高于检测阈值（0.4800）。HRV RMSSD值在监测期间呈现波动，但整体维持在个人基线水平附近。\n\n### 影响因素分析\n考虑到用户的活动水平极低（平均步数13.4步）、经常饮酒的生活习惯，以及相对稳定的心率表现，此异常可能反映了自主神经系统的轻微调节变化。\n\n### 监测建议\n1. 持续监测HRV趋势变化\n2. 结合更多生理参数进行综合评估\n3. 关注生活方式因素对自主神经系统的影响\n4. 建议记录饮酒与活动水平的相关性\n\n**重要提示**：此为真实异常案例，非误报情况，建议保持定期监测。"
+    }
+  ]
+}

demo_llm_inputs/case_ej27_full.json

@@ -0,0 +1,30 @@
+{
+  "case_id": "case_ej27_full",
+  "summary": {
+    "anomaly_type": "continuous_anomaly",
+    "duration_days": 27,
+    "trend": "stable",
+    "description": "检测到持续27天的异常模式，趋势：稳定异常，异常分数范围：0.4846 - 0.4895，平均分数：0.4878"
+  },
+  "user_profile": {
+    "age_group": "30-35岁",
+    "estimated_age": 30,
+    "sex": "女性",
+    "exercise": "每周1-2次",
+    "coffee": "每天1杯",
+    "smoking": "不吸烟",
+    "drinking": "不饮酒",
+    "MEQ": 49.0,
+    "MEQ_type": "中间型"
+  },
+  "messages": [
+    {
+      "role": "system",
+      "content": "请阅读以下健康异常检测输入描述，生成符合P3与PROCEED框架的个性化健康干预方案，需列出异常点、推理过程、误报判断、紧急处理、长期方案及用户特征说明，且所有建议需为个人可执行。"
+    },
+    {
+      "role": "user",
+      "content": "# 健康异常检测案例报告\n\n## 异常概况\n\n**异常类型**：持续性异常  \n**持续时间**：27天（2021年3月8日至4月3日）  \n**异常趋势**：稳定型异常  \n**严重程度**：轻度异常  \n\n## 异常评分分析\n\n**异常分数范围**：0.4846 - 0.4895  \n**平均异常分数**：0.4878  \n**检测阈值**：0.4800  \n**异常状态**：持续超过阈值水平  \n\n## 当前生理状态\n\n- **HRV RMSSD当前值**：89.09 ms\n- **相对于基线偏离**：3.4%（基线值：86.18 ms）\n- **统计显著性**：Z-score = 0.09（偏离程度轻微）\n- **基线可靠性**：高（基于个人主要基线）\n\n## 历史趋势分析\n\n### 每日生理指标变化\n\n| 日期 | HRV (ms) | 心率 (bpm) | 异常分数 |\n|------|----------|------------|----------|\n| 2021-03-08 | 85.27 | 86.6 | 0.4883 |\n| 2021-03-09 | 90.12 | 83.2 | 0.4877 |\n| 2021-03-10 | 85.98 | 79.2 | 0.4858 |\n| 2021-03-11 | 77.37 | 86.4 | 0.4884 |\n| 2021-03-12 | 75.68 | 83.7 | 0.4882 |\n| 2021-03-13 | 75.46 | 85.9 | 0.4895 |\n| 2021-03-14 | 77.03 | 82.9 | 0.4875 |\n| 2021-03-15 | 79.40 | 89.8 | 0.4883 |\n| 2021-03-16 | 72.56 | 91.8 | 0.4884 |\n| 2021-03-17 | 72.58 | 89.8 | 0.4885 |\n| 2021-03-18 | 73.32 | 79.4 | 0.4875 |\n| 2021-03-19 | 85.93 | 87.6 | 0.4883 |\n| 2021-03-20 | 83.36 | 78.7 | 0.4867 |\n| 2021-03-21 | 77.28 | 81.9 | 0.4876 |\n| 2021-03-22 | 93.25 | 92.6 | 0.4846 |\n| 2021-03-23 | 80.82 | 85.9 | 0.4884 |\n| 2021-03-24 | 77.66 | 88.3 | 0.4884 |\n| 2021-03-25 | 87.05 | 79.9 | 0.4883 |\n| 2021-03-26 | 94.50 | 75.1 | 0.4870 |\n| 2021-03-27 | 97.29 | 83.0 | 0.4860 |\n| 2021-03-28 | 97.68 | 73.7 | 0.4885 |\n| 2021-03-29 | 100.65 | 82.4 | 0.4884 |\n| 2021-03-30 | 75.52 | 86.9 | 0.4883 |\n| 2021-03-31 | 75.52 | 84.1 | 0.4875 |\n| 2021-04-01 | 89.34 | 83.4 | 0.4884 |\n| 2021-04-02 | 89.58 | 80.0 | 0.4881 |\n| 2021-04-03 | 89.09 | 75.0 | 0.4867 |\n\n## 相关健康指标\n\n- **睡眠质量**：数据不可用\n- **活动水平**：低\n  - 平均步数：16.0步\n  - 平均卡路里消耗：0.6千卡\n  - 趋势：下降中\n- **压力指标**：中等水平\n  - 具体表现：心率升高\n\n## 基线参考标准\n\n**个人基线**：\n- 均值：88.34 ms\n- 标准差：31.20 ms\n- 数据记录数：83条\n- 基线类型：个人主要基线\n\n**群体基线**：66.76 ms\n\n## 用户背景信息\n\n- **人口统计学**：\n  - 年龄：30-35岁女性\n  - MEQ得分：49.0（中间型昼夜节律）\n\n- **生活方式**：\n  - 运动频率：每周1-2次\n  - 咖啡消费：每天1杯\n  - 吸烟状况：不吸烟\n  - 饮酒状况：不饮酒\n\n## 临床评估\n\n**误报状态**：确认为真实异常（非误报）  \n**监测建议**：建议继续监测HRV变化趋势，关注活动水平下降与压力指标的关联性，考虑增加日常活动量以改善整体生理状态。"
+    }
+  ]
+}

demo_llm_inputs/manifest.json

@@ -0,0 +1,17 @@
+[
+  {
+    "case_id": "case_am77_full",
+    "title": "case_am77_full：continuous_anomaly (7天)",
+    "file": "case_am77_full.json"
+  },
+  {
+    "case_id": "case_ba30_full",
+    "title": "case_ba30_full：continuous_anomaly (24天)",
+    "file": "case_ba30_full.json"
+  },
+  {
+    "case_id": "case_ej27_full",
+    "title": "case_ej27_full：continuous_anomaly (27天)",
+    "file": "case_ej27_full.json"
+  }
+]

feature_calculator.py

@@ -0,0 +1,273 @@
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from collections import defaultdict
+
+import numpy as np
+import pandas as pd
+
+
+class FeatureCalculator:
+    """
+    统一从配置文件加载特征定义，构建推理/训练需要的窗口结构
+    """
+
+    def __init__(
+        self,
+        config_path: Optional[Path] = None,
+        norm_params_path: Optional[Path] = None,
+        static_features_path: Optional[Path] = None,
+        storage_dir: Optional[Path] = None,
+    ):
+        base_dir = Path(__file__).parent
+        self.config_path = Path(config_path or base_dir / "configs" / "features_config.json")
+        self.norm_params_path = Path(norm_params_path or base_dir / "processed_data" / "stage3" / "norm_params.json")
+        self.static_features_path = Path(static_features_path or base_dir / "processed_data" / "stage2" / "static_features.csv")
+        self.storage_dir = Path(storage_dir or base_dir / "data_storage")
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+
+        self.features_config = self._load_json(self.config_path)
+        self.norm_params = self._load_json(self.norm_params_path) if self.norm_params_path.exists() else {}
+        self.static_features_dict = self._load_static_features(self.static_features_path)
+
+        self.time_series_features = [f for f in self.features_config.get("time_series", []) if f.get("enabled", True)]
+        self.static_feature_defs = [f for f in self.features_config.get("static", []) if f.get("enabled", True)]
+        self.known_future_defs = [f for f in self.features_config.get("known_future", []) if f.get("enabled", True)]
+        factor_cfg = self.features_config.get("factor_features", {})
+        self.factor_enabled = factor_cfg.get("enabled", False)
+        self.factor_names = factor_cfg.get("factor_names", [])
+        self.factor_dim = factor_cfg.get("factor_dim", 0)
+
+        # 简单的内存级历史缓存，便于后续扩展个性化特征
+        self.user_histories: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+
+    @staticmethod
+    def _load_json(path: Path) -> Dict:
+        if not path.exists():
+            return {}
+        with open(path, "r") as f:
+            return json.load(f)
+
+    @staticmethod
+    def _load_static_features(static_file: Path) -> Dict[str, Dict]:
+        if not static_file.exists():
+            return {}
+        df = pd.read_csv(static_file)
+        static_dict = {}
+        for _, row in df.iterrows():
+            device_id = str(row.get("deviceId"))
+            if device_id:
+                static_dict[device_id] = {
+                    col: row[col]
+                    for col in df.columns
+                    if col != "deviceId"
+                }
+        return static_dict
+
+    @staticmethod
+    def _to_serializable(value):
+        import numpy as np
+        from datetime import datetime
+        if isinstance(value, (np.integer, )):
+            return int(value)
+        if isinstance(value, (np.floating, )):
+            return float(value)
+        if isinstance(value, (pd.Timestamp, datetime)):
+            return value.isoformat()
+        if isinstance(value, (np.ndarray, )):
+            return value.tolist()
+        raise TypeError(f"Object of type {type(value)} is not JSON serializable")
+
+    def register_data_points(self, user_id: str, data_points: List[Dict]):
+        """
+        轻量缓存用户数据，并写入 data_storage/users/{user_id}.jsonl
+        """
+        if not user_id:
+            return
+        user_dir = self.storage_dir / "users"
+        user_dir.mkdir(exist_ok=True, parents=True)
+        history_file = user_dir / f"{user_id}.jsonl"
+
+        with history_file.open("a", encoding="utf-8") as f:
+            for point in data_points:
+                serializable = dict(point)
+                ts = serializable.get('timestamp')
+                if isinstance(ts, (pd.Timestamp, )):
+                    serializable['timestamp'] = ts.isoformat()
+                elif hasattr(ts, "isoformat"):
+                    serializable['timestamp'] = ts.isoformat()
+                f.write(json.dumps(serializable, ensure_ascii=False, default=self._to_serializable) + "\n")
+
+        self.user_histories[user_id].extend(data_points)
+        # 只保留最近 5,000 条在内存，避免占用
+        if len(self.user_histories[user_id]) > 5000:
+            self.user_histories[user_id] = self.user_histories[user_id][-5000:]
+
+    def normalize_series(self, values: List[float], feature_name: str, cfg: Dict) -> List[float]:
+        arr = np.array(values, dtype=np.float32)
+        norm_cfg = cfg.get("normalization", {"type": "none"})
+        norm_type = norm_cfg.get("type", "none")
+
+        if norm_type == "zscore":
+            mean, std = self._get_norm_stats(feature_name, norm_cfg)
+            if std == 0:
+                std = 1.0
+            arr = (arr - mean) / std
+        elif norm_type == "minmax":
+            min_v = norm_cfg.get("min", 0.0)
+            max_v = norm_cfg.get("max", 1.0)
+            scale = max(max_v - min_v, 1e-6)
+            arr = (arr - min_v) / scale
+        else:
+            # none
+            pass
+
+        arr = np.nan_to_num(arr, nan=0.0, posinf=0.0, neginf=0.0)
+        return arr.tolist()
+
+    @staticmethod
+    def _coerce_value(value, feat_cfg):
+        default = feat_cfg.get("default", 0.0)
+        if value is None or pd.isna(value):
+            return default
+        category_mapping = feat_cfg.get("category_mapping")
+        if isinstance(value, str):
+            if category_mapping:
+                return category_mapping.get(value, default)
+            try:
+                return float(value)
+            except ValueError:
+                return default
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return default
+
+    def _get_norm_stats(self, feature_name: str, norm_cfg: Dict) -> (float, float):
+        if norm_cfg.get("use_norm_params") and feature_name in self.norm_params:
+            stats = self.norm_params[feature_name]
+            return stats.get("mean", 0.0), stats.get("std", 1.0)
+        return norm_cfg.get("mean", 0.0), norm_cfg.get("std", 1.0)
+
+    def build_window(self, data_points: List[Dict], user_id: Optional[str] = None) -> Dict:
+        if len(data_points) < 12:
+            raise ValueError("数据点不足，需要至少12个点构建短期窗口")
+
+        if user_id:
+            self.register_data_points(user_id, data_points)
+
+        timestamps = []
+        input_features = {feat["name"]: [] for feat in self.time_series_features}
+
+        for point in data_points:
+            ts = point.get("timestamp")
+            if isinstance(ts, str):
+                ts = pd.to_datetime(ts)
+            timestamps.append(ts)
+
+            feature_payload = point.get("features", {})
+            for feat_cfg in self.time_series_features:
+                name = feat_cfg["name"]
+                value = feature_payload.get(name)
+                value = self._coerce_value(value, feat_cfg)
+                input_features[name].append(value)
+
+        # delta_t
+        delta_t = [0.0]
+        for i in range(1, len(timestamps)):
+            diff = (timestamps[i] - timestamps[i - 1]).total_seconds()
+            delta_t.append(float(diff))
+
+        # 归一化
+        normalized_features = {}
+        for feat_cfg in self.time_series_features:
+            name = feat_cfg["name"]
+            normalized_features[name] = self.normalize_series(input_features[name], name, feat_cfg)
+
+        static_features = self._build_static_features(data_points[0], user_id)
+        factor_features = self._build_factor_features(normalized_features)
+        known_future = self._build_known_future(timestamps[-6:] if len(timestamps) >= 6 else timestamps)
+
+        return {
+            "input_timestamp": timestamps[:12],
+            "input_delta_t": delta_t[:12],
+            "input_features": normalized_features,
+            "target_timestamp": timestamps[12:] if len(timestamps) > 12 else [],
+            "target_delta_t": delta_t[12:] if len(delta_t) > 12 else [],
+            "static_features": static_features,
+            "known_future_features": known_future,
+            "factor_features": factor_features,
+        }
+
+    def _build_static_features(self, first_point: Dict, user_id: Optional[str]) -> Dict:
+        static_payload = dict(first_point.get("static_features", {}))
+        device_id = first_point.get("deviceId") or user_id
+
+        if device_id and str(device_id) in self.static_features_dict:
+            for key, value in self.static_features_dict[str(device_id)].items():
+                static_payload.setdefault(key, value)
+
+        result = {}
+        for feat_cfg in self.static_feature_defs:
+            name = feat_cfg["name"]
+            result[name] = static_payload.get(name, feat_cfg.get("default", 0.0))
+        return result
+
+    def _build_factor_features(self, normalized_features: Dict[str, List[float]]) -> Optional[Dict[str, List[float]]]:
+        if not self.factor_enabled or not self.factor_names:
+            return None
+
+        factor_vectors = {}
+        for factor_name in self.factor_names:
+            # 目前采用简单均值/最大值/最小值/最后值，方便后续替换
+            merged = []
+            for feat_name, values in normalized_features.items():
+                if factor_name == "physio" and feat_name.startswith("hrv"):
+                    merged.extend(values)
+                elif factor_name == "activity" and feat_name in {"steps", "distance", "calories"}:
+                    merged.extend(values)
+                elif factor_name == "context" and feat_name in {"time_period_primary", "time_period_secondary", "is_weekend"}:
+                    merged.extend(values)
+
+            if not merged:
+                factor_vectors[factor_name] = [0.0] * self.factor_dim
+            else:
+                arr = np.array(merged, dtype=np.float32)
+                stats = [
+                    float(arr.mean()),
+                    float(arr.std()),
+                    float(arr.max()),
+                    float(arr.min())
+                ]
+                factor_vectors[factor_name] = stats[: self.factor_dim] if len(stats) >= self.factor_dim else stats + [0.0] * (self.factor_dim - len(stats))
+        return factor_vectors
+
+    def _build_known_future(self, timestamps: List[pd.Timestamp]) -> Dict[str, List[float]]:
+        hours, days, weekends = [], [], []
+        for ts in timestamps:
+            if pd.isna(ts):
+                hours.append(12.0)
+                days.append(3.0)
+                weekends.append(0.0)
+            else:
+                hours.append(float(ts.hour))
+                days.append(float(ts.weekday()))
+                weekends.append(float(1 if ts.weekday() >= 5 else 0))
+
+        result = {}
+        for cfg in self.known_future_defs:
+            name = cfg["name"]
+            if name == "hour_of_day":
+                result[name] = hours
+            elif name == "day_of_week":
+                result[name] = days
+            elif name == "is_weekend":
+                result[name] = weekends
+        return result
+
+    def get_enabled_feature_names(self) -> List[str]:
+        return [feat["name"] for feat in self.time_series_features]
+
+
+__all__ = ["FeatureCalculator"]
+

processed_data/stage3/norm_params.json

@@ -0,0 +1,146 @@
+{
+  "hr_mean": {
+    "mean": 79.88385009765625,
+    "std": 15.546831130981445,
+    "min": 33.0,
+    "max": 200.2244873046875
+  },
+  "hr_std": {
+    "mean": 12.757049560546875,
+    "std": 3.9224278926849365,
+    "min": 0.0,
+    "max": 32.2431755065918
+  },
+  "hr_median": {
+    "mean": 76.4555892944336,
+    "std": 6.908801555633545,
+    "min": 48.0,
+    "max": 104.0
+  },
+  "hr_resting": {
+    "mean": 65.74867248535156,
+    "std": 7.843548774719238,
+    "min": 44.12284469604492,
+    "max": 86.0
+  },
+  "hr_nrem": {
+    "mean": 61.779720306396484,
+    "std": 11.666051864624023,
+    "min": 0.0,
+    "max": 92.5469970703125
+  },
+  "hrv_rmssd": {
+    "mean": 83.4627685546875,
+    "std": 62.30027389526367,
+    "min": 0.0,
+    "max": 855.8391723632812
+  },
+  "hrv_sdnn": {
+    "mean": 100.59049987792969,
+    "std": 43.545467376708984,
+    "min": 0.0,
+    "max": 393.35162353515625
+  },
+  "steps": {
+    "mean": 342.7657470703125,
+    "std": 823.3682861328125,
+    "min": 0.0,
+    "max": 27004.0
+  },
+  "distance": {
+    "mean": 225.4749755859375,
+    "std": 504.8075866699219,
+    "min": 0.0,
+    "max": 10460.2998046875
+  },
+  "calories": {
+    "mean": 104.05133819580078,
+    "std": 211.85128784179688,
+    "min": 0.0,
+    "max": 2962.070068359375
+  },
+  "sleep_duration_total": {
+    "mean": 418.6901550292969,
+    "std": 142.2774200439453,
+    "min": 0.0,
+    "max": 1110.0
+  },
+  "sleep_efficiency": {
+    "mean": 93.89789581298828,
+    "std": 7.327056884765625,
+    "min": 34.0,
+    "max": 100.0
+  },
+  "sleep_deep_ratio": {
+    "mean": 1.00419020652771,
+    "std": 0.3390481770038605,
+    "min": 0.0,
+    "max": 4.310344696044922
+  },
+  "sleep_rem_ratio": {
+    "mean": 1.00448739528656,
+    "std": 0.35869544744491577,
+    "min": 0.0,
+    "max": 3.9259259700775146
+  },
+  "sleep_light_ratio": {
+    "mean": 0.9923003315925598,
+    "std": 0.23265497386455536,
+    "min": 0.0,
+    "max": 3.034313678741455
+  },
+  "spo2": {
+    "mean": 95.9047622680664,
+    "std": 1.04403817653656,
+    "min": 92.4000015258789,
+    "max": 100.0
+  },
+  "stress_score": {
+    "mean": 65.94886779785156,
+    "std": 28.051528930664062,
+    "min": 0.0,
+    "max": 93.0
+  },
+  "ALERT": {
+    "mean": 0.07375683635473251,
+    "std": 0.2613747715950012,
+    "min": 0.0,
+    "max": 1.0
+  },
+  "HAPPY": {
+    "mean": 0.1726546734571457,
+    "std": 0.37794846296310425,
+    "min": 0.0,
+    "max": 1.0
+  },
+  "NEUTRAL": {
+    "mean": 0.1967589408159256,
+    "std": 0.3975485563278198,
+    "min": 0.0,
+    "max": 1.0
+  },
+  "RESTED/RELAXED": {
+    "mean": 0.23211927711963654,
+    "std": 0.42218467593193054,
+    "min": 0.0,
+    "max": 1.0
+  },
+  "SAD": {
+    "mean": 0.018068943172693253,
+    "std": 0.13320080935955048,
+    "min": 0.0,
+    "max": 1.0
+  },
+  "TENSE/ANXIOUS": {
+    "mean": 0.10590820014476776,
+    "std": 0.3077200949192047,
+    "min": 0.0,
+    "max": 1.0
+  },
+  "TIRED": {
+    "mean": 0.20073312520980835,
+    "std": 0.4005488157272339,
+    "min": 0.0,
+    "max": 1.0
+  }
+}

requirements.txt

@@ -0,0 +1,6 @@
+torch>=2.1.0
+numpy>=1.24
+pandas>=2.0
+huggingface_hub>=0.23
+scikit-learn>=1.3.0
+requests>=2.31.0

run_official_inference.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+run_official_inference.py
+
+最小化测试脚本：读取一个窗口 JSON 文件 -> 调用 WearableAnomalyDetector -> 打印模型输出及格式化文本。
+
+使用方式：
+    python run_official_inference.py \
+        --window-file test_data/example_window.json \
+        --model-dir checkpoints/phase2/exp_factor_balanced
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import List, Dict, Any
+
+import importlib.util
+
+from wearable_anomaly_detector import WearableAnomalyDetector
+
+
+def load_formatter():
+    formatter_path = Path(__file__).parent / "utils" / "formatter.py"
+    spec = importlib.util.spec_from_file_location("formatter", formatter_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.AnomalyFormatter
+
+
+def load_window(path: Path) -> List[Dict[str, Any]]:
+    if path.suffix == ".jsonl":
+        with open(path, "r", encoding="utf-8") as f:
+            data = [json.loads(line) for line in f if line.strip()]
+    else:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            data = data.get("records") or data.get("data") or [data]
+    if not isinstance(data, list) or not data:
+        raise ValueError("窗口文件必须是非空列表")
+    if len(data) < 12:
+        raise ValueError("窗口数据至少需要 12 条记录")
+    return data[-12:]
+
+
+def build_baseline_info(window: List[Dict[str, Any]]) -> Dict[str, float]:
+    # 优先使用输入中的 baseline 字段，否则简单按窗口平均值估算
+    for point in window:
+        baseline_mean = point["features"].get("baseline_hrv_mean")
+        baseline_std = point["features"].get("baseline_hrv_std")
+        if baseline_mean is not None and baseline_std is not None:
+            current = point["features"].get("hrv_rmssd")
+            deviation = 0.0
+            if current is not None:
+                deviation = (current - baseline_mean) / baseline_mean * 100
+            return {
+                "baseline_mean": float(baseline_mean),
+                "baseline_std": float(baseline_std),
+                "current_value": float(current or baseline_mean),
+                "deviation_pct": float(deviation),
+            }
+
+    avg_hrv = sum(pt["features"].get("hrv_rmssd", 0.0) for pt in window) / len(window)
+    return {
+        "baseline_mean": avg_hrv,
+        "baseline_std": 5.0,
+        "current_value": avg_hrv,
+        "deviation_pct": 0.0,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run wearable anomaly detector on a JSON window file.")
+    parser.add_argument(
+        "--window-file",
+        type=Path,
+        default=Path("test_data/example_window.json"),
+        help="包含 12 条数据点的 JSON 文件路径",
+    )
+    parser.add_argument(
+        "--model-dir",
+        type=Path,
+        default=Path("checkpoints/phase2/exp_factor_balanced"),
+        help="Phase2 最佳模型所在目录",
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default=None,
+        help="可选：cpu / cuda / cuda:0 等",
+    )
+    args = parser.parse_args()
+
+    if not args.window_file.exists():
+        raise FileNotFoundError(f"窗口文件不存在：{args.window_file}")
+
+    window = load_window(args.window_file)
+    detector = WearableAnomalyDetector(model_dir=args.model_dir, device=args.device)
+    result = detector.detect_realtime(window, update_baseline=False, return_details=True)
+
+    print("\n=== 模型输出（JSON）===")
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+    formatter_cls = load_formatter()
+    formatter = formatter_cls()
+    baseline_info = build_baseline_info(window)
+    formatted = formatter.format_for_llm(
+        anomaly_result=result,
+        baseline_info=baseline_info,
+        daily_results=None,
+    )
+
+    print("\n=== LLM 文本 ===")
+    print(formatted)
+
+
+if __name__ == "__main__":
+    main()
+

test_data/example_window.json

@@ -0,0 +1,291 @@
+[
+  {
+    "timestamp": "2025-01-15T08:00:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 68.5,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 78.5,
+      "hrv_sdnn": 94.2,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:05:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 69.0,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 77.3,
+      "hrv_sdnn": 92.7,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:10:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 69.4,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 76.1,
+      "hrv_sdnn": 91.3,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:15:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 69.8,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 74.2,
+      "hrv_sdnn": 89.0,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:20:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 70.2,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 73.8,
+      "hrv_sdnn": 88.6,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:25:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 70.7,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 72.1,
+      "hrv_sdnn": 86.5,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:30:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 71.1,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 71.8,
+      "hrv_sdnn": 86.1,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:35:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 71.6,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 70.5,
+      "hrv_sdnn": 84.6,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "high",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:40:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 72.0,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 69.4,
+      "hrv_sdnn": 83.3,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "medium",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:45:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 72.5,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 68.7,
+      "hrv_sdnn": 82.4,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "medium",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:50:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 72.9,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 68.1,
+      "hrv_sdnn": 81.7,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "medium",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  },
+  {
+    "timestamp": "2025-01-15T08:55:00",
+    "deviceId": "sample_user",
+    "features": {
+      "hr": 73.4,
+      "hr_resting": 64.0,
+      "hrv_rmssd": 67.5,
+      "hrv_sdnn": 81.0,
+      "time_period_primary": "morning",
+      "time_period_secondary": "weekday",
+      "is_weekend": 0,
+      "data_quality": "medium",
+      "baseline_hrv_mean": 76.0,
+      "baseline_hrv_std": 5.0
+    },
+    "static_features": {
+      "age_group": 2,
+      "sex": 0,
+      "exercise": 1,
+      "coffee": 1,
+      "drinking": 0,
+      "MEQ": 52.0
+    }
+  }
+]
+

test_quickstart.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""
+test_quickstart.py
+
+功能：
+1. 构造 1 小时窗口，演示实时异常检测（正常 / 异常两种场景）
+2. 构造 7 天数据，演示异常模式聚合
+3. 输出格式化的LLM文案，方便直接接入大模型
+
+运行方式：
+    python test_quickstart.py
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta
+import json
+import numpy as np
+import random
+import random
+
+ROOT_DIR = Path(__file__).parent.resolve()
+sys.path.insert(0, str(ROOT_DIR))
+
+from wearable_anomaly_detector import WearableAnomalyDetector
+import importlib.util
+
+# 动态导入 utils.formatter，避免相对路径问题
+formatter_spec = importlib.util.spec_from_file_location(
+    "formatter", ROOT_DIR / "utils" / "formatter.py"
+)
+formatter_module = importlib.util.module_from_spec(formatter_spec)
+formatter_spec.loader.exec_module(formatter_module)
+AnomalyFormatter = formatter_module.AnomalyFormatter
+FORMATTER = AnomalyFormatter()
+TEST_WINDOW_FILE = ROOT_DIR / "test_data" / "example_window.json"
+
+WINDOW_SIZE = 12          # 12 * 5 分钟 = 1 小时
+INTERVAL_MINUTES = 5
+
+
+def make_point(ts: datetime, device_id: str, hrv: float, hr: float, include_static: bool = True) -> dict:
+    """构造单个数据点"""
+    return {
+        "timestamp": ts.isoformat(),
+        "deviceId": device_id,
+        "features": {
+            "hr": float(hr),
+            "hr_resting": 65.0,
+            "hrv_rmssd": float(hrv),
+            "hrv_sdnn": float(hrv * 1.2),
+            "time_period_primary": "day",
+            "time_period_secondary": "workday",
+            "is_weekend": 0.0,
+            "data_quality": "high",
+            "baseline_hrv_mean": 75.0,
+            "baseline_hrv_std": 5.0,
+        },
+        "static_features": {
+            "age_group": 2,
+            "sex": 0,
+            "exercise": 1,
+            "coffee": 1,
+            "drinking": 0,
+            "MEQ": 50.0,
+        } if include_static else {},
+    }
+
+
+def generate_window(
+    device_id: str,
+    start: datetime,
+    base_hrv: float,
+    base_hr: float,
+    anomaly_level: float = 0.0,
+    include_static: bool = True,
+    missing_ratio: float = 0.0,
+) -> list:
+    """生成 1 小时窗口数据"""
+    data = []
+    base_hrv_for_day = max(30, base_hrv - 18 * anomaly_level)
+    base_hr_for_day = min(125, base_hr + 10 * anomaly_level)
+    for i in range(WINDOW_SIZE):
+        noise_hrv = np.random.normal(0, 3)
+        noise_hr = np.random.normal(0, 1.5)
+        decline = -15 * anomaly_level * (i / WINDOW_SIZE)
+        increase = 8 * anomaly_level * (i / WINDOW_SIZE)
+        hrv = max(25, base_hrv_for_day + noise_hrv + decline)
+        hr = min(125, base_hr_for_day + noise_hr + increase)
+        ts = start + timedelta(minutes=INTERVAL_MINUTES * i)
+        point = make_point(ts, device_id, hrv, hr, include_static=include_static)
+
+        if missing_ratio > 0 and random.random() < missing_ratio:
+            point["features"].pop("hr_resting", None)
+            point["features"].pop("baseline_hrv_mean", None)
+            point["features"].pop("baseline_hrv_std", None)
+            if random.random() < 0.5:
+                point["static_features"] = {}
+
+        data.append(point)
+    return data
+
+
+def load_window_from_file(path: Path) -> list | None:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        assert isinstance(data, list) and data, "JSON needs to be a non-empty list"
+        return data
+    except Exception as exc:
+        print(f"  ⚠️  读取 {path.name} 失败: {exc}")
+        return None
+
+
+def demo_from_file(detector: WearableAnomalyDetector) -> None:
+    print("\n" + "=" * 80)
+    print("示例文件推理（test_data/example_window.json）")
+    print("=" * 80)
+
+    if not TEST_WINDOW_FILE.exists():
+        print(f"  ⚠️  未找到 {TEST_WINDOW_FILE}, 请确认仓库中存在该文件")
+        return
+
+    window = load_window_from_file(TEST_WINDOW_FILE)
+    if not window:
+        return
+
+    avg_hrv = np.nanmean([pt["features"]["hrv_rmssd"] for pt in window])
+    avg_hr = np.nanmean([pt["features"]["hr"] for pt in window])
+    print(f"  - 数据点数: {len(window)}")
+    print(f"  - 平均 HRV: {avg_hrv:.2f} ms, 平均心率: {avg_hr:.1f} bpm")
+
+    result = detector.detect_realtime(window, update_baseline=False)
+    print(
+        f"  -> 是否异常: {'是 ⚠️' if result.get('is_anomaly') else '否'} | "
+        f"分数: {result.get('anomaly_score', 0):.4f} | 阈值: {result.get('threshold', 0):.4f}"
+    )
+
+    baseline_info = {
+        "baseline_mean": 76.0,
+        "baseline_std": 5.0,
+        "current_value": avg_hrv,
+        "deviation_pct": (avg_hrv - 76.0) / 76.0 * 100,
+    }
+    llm_text = FORMATTER.format_for_llm(result, baseline_info=baseline_info)
+    print("\n  LLM 文本片段（前 350 字符）:")
+    print("-" * 60)
+    print(llm_text[:350])
+    print("...")
+    print("-" * 60)
+
+
+def demo_realtime(detector: WearableAnomalyDetector) -> None:
+    print("\n" + "=" * 80)
+    print("实时检测示例")
+    print("=" * 80)
+
+    start = datetime.now() - timedelta(hours=1)
+    normal_window = generate_window("demo_normal", start, base_hrv=76, base_hr=68, anomaly_level=0.0)
+    anomaly_window = generate_window("demo_anomaly", start, base_hrv=74, base_hr=70, anomaly_level=0.7)
+
+    for title, window in [("正常窗口", normal_window), ("异常窗口", anomaly_window)]:
+        avg_hrv = np.mean([pt["features"]["hrv_rmssd"] for pt in window])
+        avg_hr = np.mean([pt["features"]["hr"] for pt in window])
+        print(f"\n[{title}] HRV≈{avg_hrv:.2f} ms, HR≈{avg_hr:.1f} bpm")
+        result = detector.detect_realtime(window, update_baseline=False)
+        print(
+            f"  -> 是否异常: {'是 ⚠️' if result.get('is_anomaly') else '否'} | "
+            f"分数: {result.get('anomaly_score', 0):.4f} | 阈值: {result.get('threshold', 0):.4f}"
+        )
+
+
+def demo_pattern(detector: WearableAnomalyDetector) -> None:
+    print("\n" + "=" * 80)
+    print("7 天异常模式聚合示例")
+    print("=" * 80)
+
+    base_date = datetime.now() - timedelta(days=7)
+    daily_data = []
+    anomaly_plan = [0.0, 0.1, 0.3, 1.0, 1.4, 1.8, 1.8]
+    avg_hrv_per_day = []
+
+    for day, anomaly_level in enumerate(anomaly_plan):
+        day_start = base_date + timedelta(days=day)
+        window = generate_window(
+            device_id="demo_pattern",
+            start=day_start.replace(hour=8, minute=0, second=0, microsecond=0),
+            base_hrv=75,
+            base_hr=69,
+            anomaly_level=anomaly_level,
+        )
+        daily_data.append(window)
+        avg_hrv_per_day.append(np.mean([pt["features"]["hrv_rmssd"] for pt in window]))
+
+    print("  日均HRV轨迹: " + ", ".join(f"{val:.1f}" for val in avg_hrv_per_day))
+
+    result = detector.detect_pattern(
+        daily_data,
+        days=len(daily_data),
+        min_duration_days=2,
+        format_for_llm=True
+    )
+    pattern = result.get("anomaly_pattern", {})
+    print(
+        f"  -> 是否有模式: {'是' if pattern.get('has_pattern') else '否'} | "
+        f"持续天数: {pattern.get('duration_days', 0)} | 趋势: {pattern.get('trend', '未知')}"
+    )
+
+    if "formatted_for_llm" in result:
+        print("\n格式化输出（前 400 字符）:")
+        print("-" * 60)
+        print(result["formatted_for_llm"][:400])
+        print("...")
+        print("-" * 60)
+
+
+def demo_missing_data(detector: WearableAnomalyDetector) -> None:
+    print("\n" + "=" * 80)
+    print("数据缺失 / 质量下降示例")
+    print("=" * 80)
+
+    start = datetime.now() - timedelta(hours=1)
+    incomplete_window = generate_window(
+        device_id="demo_missing",
+        start=start,
+        base_hrv=74,
+        base_hr=71,
+        anomaly_level=0.5,
+        include_static=True,
+        missing_ratio=0.4,
+    )
+
+    # 模拟传感器丢包：移除 2 个时间点 & 降低数据质量
+    for idx in (3, 7):
+        incomplete_window[idx]["features"]["data_quality"] = "low"
+        incomplete_window[idx]["features"]["hr"] = float("nan")
+
+    avg_hrv = np.nanmean([pt["features"].get("hrv_rmssd", np.nan) for pt in incomplete_window])
+    available_static = sum(bool(pt["static_features"]) for pt in incomplete_window)
+    print(f"  - 有效静态特征点数: {available_static}/{len(incomplete_window)}")
+    print(f"  - 平均 HRV（忽略缺失）: {avg_hrv:.2f} ms")
+
+    result = detector.detect_realtime(incomplete_window, update_baseline=False)
+    print(
+        f"  -> 是否异常: {'是' if result.get('is_anomaly') else '否'} | "
+        f"分数: {result.get('anomaly_score', 0):.4f} | 阈值: {result.get('threshold', 0):.4f}"
+    )
+
+
+def main() -> None:
+    model_dir = ROOT_DIR / "checkpoints" / "phase2" / "exp_factor_balanced"
+    detector = WearableAnomalyDetector(model_dir=model_dir, device="cpu")
+    detector.update_threshold(0.50)
+    demo_from_file(detector)
+    demo_realtime(detector)
+    demo_pattern(detector)
+    demo_missing_data(detector)
+
+
+if __name__ == "__main__":
+    main()
+

utils/__init__.py

@@ -0,0 +1,10 @@
+"""
+工具模块
+"""
+
+from .baseline_storage import BaselineStorage
+from .api_client import HistoricalDataPlatformClient
+from .formatter import AnomalyFormatter
+
+__all__ = ['BaselineStorage', 'HistoricalDataPlatformClient', 'AnomalyFormatter']
+

utils/api_client.py

@@ -0,0 +1,158 @@
+"""
+历史数据平台API客户端
+最小化实现，只包含必要的功能
+"""
+
+import json
+import requests
+from pathlib import Path
+from typing import Dict, List, Optional
+from datetime import datetime, timedelta
+
+
+class HistoricalDataPlatformClient:
+    """
+    历史数据平台API客户端
+    """
+    
+    def __init__(
+        self,
+        base_url: str = "",
+        api_key: Optional[str] = None,
+        timeout: int = 30,
+        retry_times: int = 3
+    ):
+        """
+        初始化API客户端
+        
+        参数:
+            base_url: API基础URL
+            api_key: API密钥（可选）
+            timeout: 超时时间（秒）
+            retry_times: 重试次数
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.timeout = timeout
+        self.retry_times = retry_times
+        
+        # 从配置文件加载（如果base_url为空）
+        if not self.base_url:
+            self._load_config()
+    
+    def _load_config(self):
+        """从配置文件加载API配置"""
+        try:
+            config_path = Path(__file__).parent.parent / "configs" / "api_config.json"
+            if config_path.exists():
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                    api_config = config.get('historical_data_platform', {})
+                    self.base_url = api_config.get('base_url', '')
+                    self.api_key = api_config.get('api_key') or self.api_key
+                    self.timeout = api_config.get('timeout', 30)
+                    self.retry_times = api_config.get('retry_times', 3)
+        except Exception as e:
+            print(f"⚠️  加载API配置失败: {e}")
+    
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict] = None,
+        data: Optional[Dict] = None
+    ) -> Optional[Dict]:
+        """发送HTTP请求"""
+        if not self.base_url:
+            print("⚠️  API base_url未配置")
+            return None
+        
+        url = f"{self.base_url}{endpoint}"
+        headers = {'Content-Type': 'application/json'}
+        if self.api_key:
+            headers['Authorization'] = f'Bearer {self.api_key}'
+        
+        for attempt in range(self.retry_times):
+            try:
+                if method.upper() == 'GET':
+                    response = requests.get(url, params=params, headers=headers, timeout=self.timeout)
+                else:
+                    response = requests.post(url, json=data, params=params, headers=headers, timeout=self.timeout)
+                
+                response.raise_for_status()
+                return response.json()
+            except requests.exceptions.RequestException as e:
+                if attempt == self.retry_times - 1:
+                    print(f"⚠️  API请求失败: {e}")
+                    return None
+                continue
+        
+        return None
+    
+    def get_raw_data(
+        self,
+        device_id: str,
+        days: int = 7,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None
+    ) -> Optional[Dict]:
+        """
+        获取用户原始数据
+        
+        参数:
+            device_id: 用户ID
+            days: 过去N天（如果start_date和end_date未提供）
+            start_date: 开始日期（YYYY-MM-DD格式）
+            end_date: 结束日期（YYYY-MM-DD格式）
+        
+        返回:
+            {
+                "deviceId": "user123",
+                "data_points": [...],
+                "total_count": 100
+            }
+        """
+        endpoint = f"/api/raw-data/{device_id}"
+        params = {}
+        
+        if start_date and end_date:
+            params['start_date'] = start_date
+            params['end_date'] = end_date
+        else:
+            params['days'] = days
+        
+        return self._request('GET', endpoint, params=params)
+    
+    def get_user_profile(self, device_id: str) -> Optional[Dict]:
+        """
+        获取用户个性化信息
+        
+        返回:
+            {
+                "deviceId": "user123",
+                "age_group": "30-35岁",
+                "sex": "男性",
+                ...
+            }
+        """
+        endpoint = f"/api/user-profile/{device_id}"
+        return self._request('GET', endpoint)
+    
+    def get_historical_results(
+        self,
+        device_id: str,
+        days: int = 7
+    ) -> Optional[Dict]:
+        """
+        获取历史检测结果
+        
+        返回:
+            {
+                "deviceId": "user123",
+                "daily_results": [...]
+            }
+        """
+        endpoint = f"/api/historical-results/{device_id}"
+        params = {'days': days}
+        return self._request('GET', endpoint, params=params)
+

utils/baseline_storage.py

@@ -0,0 +1,348 @@
+"""
+基线存储模块 - 支持文件存储和增量更新
+最小化改动，复用现有的FeatureCalculator.get_baseline_info()
+"""
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Dict, Optional, List
+from datetime import datetime
+import pandas as pd
+
+
+class BaselineStorage:
+    """
+    基线存储管理器
+    - 支持文件存储（JSON格式，兼容现有）
+    - 支持数据库存储（SQLite，可选）
+    - 支持增量更新基线
+    - 支持从现有CSV文件导入
+    """
+    
+    def __init__(
+        self,
+        storage_type: str = "file",
+        file_path: Optional[Path] = None,
+        database_path: Optional[str] = None,
+        import_from_csv: bool = True,
+        csv_path: Optional[Path] = None
+    ):
+        """
+        初始化基线存储
+        
+        参数:
+            storage_type: 存储类型 ("file" 或 "database")
+            file_path: 文件存储路径（JSON格式）
+            database_path: 数据库连接字符串（SQLite）
+            import_from_csv: 是否从现有CSV文件导入
+            csv_path: CSV文件路径（adaptive_baselines.csv）
+        """
+        self.storage_type = storage_type
+        base_dir = Path(__file__).parent.parent
+        
+        # 文件存储
+        if file_path is None:
+            file_path = base_dir / "data_storage" / "baselines.json"
+        self.file_path = Path(file_path)
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # 数据库存储
+        if database_path is None:
+            database_path = str(base_dir / "data_storage" / "baselines.db")
+        self.database_path = database_path
+        
+        # CSV导入路径
+        if csv_path is None:
+            csv_path = base_dir / "processed_data" / "stage1" / "adaptive_baselines.csv"
+        self.csv_path = Path(csv_path)
+        
+        # 初始化存储
+        if storage_type == "database":
+            self._init_database()
+        
+        # 从CSV导入（如果启用且文件存在）
+        if import_from_csv and self.csv_path.exists():
+            self._import_from_csv()
+    
+    def _init_database(self):
+        """初始化数据库表"""
+        conn = sqlite3.connect(self.database_path)
+        cursor = conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS baselines (
+                device_id TEXT,
+                feature_name TEXT,
+                baseline_type TEXT,
+                baseline_mean REAL,
+                baseline_std REAL,
+                personal_mean REAL,
+                personal_std REAL,
+                group_mean REAL,
+                data_count INTEGER,
+                time_period_primary TEXT,
+                time_period_secondary TEXT,
+                is_weekend INTEGER,
+                last_updated TEXT,
+                PRIMARY KEY (device_id, feature_name, time_period_primary, time_period_secondary, is_weekend)
+            )
+        """)
+        conn.commit()
+        conn.close()
+    
+    def _import_from_csv(self):
+        """从现有CSV文件导入基线数据"""
+        try:
+            if not self.csv_path.exists():
+                return
+            
+            df = pd.read_csv(self.csv_path)
+            
+            # 转换为存储格式
+            baselines = []
+            for _, row in df.iterrows():
+                baseline = {
+                    'device_id': str(row.get('deviceId', '')),
+                    'feature_name': 'hrv_rmssd',  # 默认特征
+                    'baseline_type': row.get('baseline_type', 'unknown'),
+                    'baseline_mean': float(row.get('final_mean', 0.0)),
+                    'baseline_std': float(row.get('final_std', 1.0)),
+                    'personal_mean': float(row.get('personal_mean', 0.0)) if pd.notna(row.get('personal_mean')) else None,
+                    'personal_std': float(row.get('personal_std', 0.0)) if pd.notna(row.get('personal_std')) else None,
+                    'group_mean': float(row.get('group_mean', 0.0)) if pd.notna(row.get('group_mean')) else None,
+                    'data_count': int(row.get('personal_record_count', 0)),
+                    'time_period_primary': row.get('time_period_primary', ''),
+                    'time_period_secondary': row.get('time_period_secondary', ''),
+                    'is_weekend': int(row.get('is_weekend', 0)),
+                    'last_updated': datetime.now().isoformat()
+                }
+                baselines.append(baseline)
+            
+            # 批量保存
+            for baseline in baselines:
+                self.save_baseline(baseline)
+            
+            print(f"✅ 已从CSV导入 {len(baselines)} 条基线数据")
+        except Exception as e:
+            print(f"⚠️  从CSV导入基线失败: {e}")
+    
+    def get_baseline(
+        self,
+        device_id: str,
+        feature_name: str = "hrv_rmssd",
+        time_period_primary: Optional[str] = None,
+        time_period_secondary: Optional[str] = None,
+        is_weekend: Optional[bool] = None
+    ) -> Optional[Dict]:
+        """
+        获取基线信息
+        
+        返回:
+            基线信息字典，如果不存在返回None
+        """
+        if self.storage_type == "database":
+            return self._get_from_database(device_id, feature_name, time_period_primary, time_period_secondary, is_weekend)
+        else:
+            return self._get_from_file(device_id, feature_name, time_period_primary, time_period_secondary, is_weekend)
+    
+    def _get_from_file(self, device_id: str, feature_name: str, 
+                      time_period_primary: Optional[str], 
+                      time_period_secondary: Optional[str],
+                      is_weekend: Optional[bool]) -> Optional[Dict]:
+        """从文件获取基线"""
+        if not self.file_path.exists():
+            return None
+        
+        try:
+            with open(self.file_path, 'r', encoding='utf-8') as f:
+                all_baselines = json.load(f)
+            
+            # 查找匹配的基线
+            for baseline in all_baselines:
+                if (baseline.get('device_id') == device_id and
+                    baseline.get('feature_name') == feature_name):
+                    # 匹配时间段（如果提供）
+                    if time_period_primary and baseline.get('time_period_primary') != time_period_primary:
+                        continue
+                    if time_period_secondary and baseline.get('time_period_secondary') != time_period_secondary:
+                        continue
+                    if is_weekend is not None and baseline.get('is_weekend') != (1 if is_weekend else 0):
+                        continue
+                    return baseline
+            return None
+        except Exception as e:
+            print(f"⚠️  从文件读取基线失败: {e}")
+            return None
+    
+    def _get_from_database(self, device_id: str, feature_name: str,
+                          time_period_primary: Optional[str],
+                          time_period_secondary: Optional[str],
+                          is_weekend: Optional[bool]) -> Optional[Dict]:
+        """从数据库获取基线"""
+        try:
+            conn = sqlite3.connect(self.database_path)
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+            
+            query = """
+                SELECT * FROM baselines 
+                WHERE device_id = ? AND feature_name = ?
+            """
+            params = [device_id, feature_name]
+            
+            if time_period_primary:
+                query += " AND time_period_primary = ?"
+                params.append(time_period_primary)
+            if time_period_secondary:
+                query += " AND time_period_secondary = ?"
+                params.append(time_period_secondary)
+            if is_weekend is not None:
+                query += " AND is_weekend = ?"
+                params.append(1 if is_weekend else 0)
+            
+            cursor.execute(query, params)
+            row = cursor.fetchone()
+            conn.close()
+            
+            if row:
+                return dict(row)
+            return None
+        except Exception as e:
+            print(f"⚠️  从数据库读取基线失败: {e}")
+            return None
+    
+    def save_baseline(self, baseline: Dict):
+        """保存基线信息"""
+        if self.storage_type == "database":
+            self._save_to_database(baseline)
+        else:
+            self._save_to_file(baseline)
+    
+    def _save_to_file(self, baseline: Dict):
+        """保存到文件"""
+        try:
+            # 读取现有数据
+            if self.file_path.exists():
+                with open(self.file_path, 'r', encoding='utf-8') as f:
+                    all_baselines = json.load(f)
+            else:
+                all_baselines = []
+            
+            # 查找是否已存在
+            key = (
+                baseline.get('device_id'),
+                baseline.get('feature_name'),
+                baseline.get('time_period_primary'),
+                baseline.get('time_period_secondary'),
+                baseline.get('is_weekend')
+            )
+            
+            found = False
+            for i, existing in enumerate(all_baselines):
+                existing_key = (
+                    existing.get('device_id'),
+                    existing.get('feature_name'),
+                    existing.get('time_period_primary'),
+                    existing.get('time_period_secondary'),
+                    existing.get('is_weekend')
+                )
+                if existing_key == key:
+                    all_baselines[i] = baseline
+                    found = True
+                    break
+            
+            if not found:
+                all_baselines.append(baseline)
+            
+            # 保存
+            with open(self.file_path, 'w', encoding='utf-8') as f:
+                json.dump(all_baselines, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"⚠️  保存基线到文件失败: {e}")
+    
+    def _save_to_database(self, baseline: Dict):
+        """保存到数据库"""
+        try:
+            conn = sqlite3.connect(self.database_path)
+            cursor = conn.cursor()
+            
+            cursor.execute("""
+                INSERT OR REPLACE INTO baselines 
+                (device_id, feature_name, baseline_type, baseline_mean, baseline_std,
+                 personal_mean, personal_std, group_mean, data_count,
+                 time_period_primary, time_period_secondary, is_weekend, last_updated)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                baseline.get('device_id'),
+                baseline.get('feature_name'),
+                baseline.get('baseline_type'),
+                baseline.get('baseline_mean'),
+                baseline.get('baseline_std'),
+                baseline.get('personal_mean'),
+                baseline.get('personal_std'),
+                baseline.get('group_mean'),
+                baseline.get('data_count', 0),
+                baseline.get('time_period_primary'),
+                baseline.get('time_period_secondary'),
+                baseline.get('is_weekend', 0),
+                baseline.get('last_updated', datetime.now().isoformat())
+            ))
+            
+            conn.commit()
+            conn.close()
+        except Exception as e:
+            print(f"⚠️  保存基线到数据库失败: {e}")
+    
+    def update_baseline_incremental(
+        self,
+        device_id: str,
+        feature_name: str,
+        new_value: float,
+        data_count: int,
+        time_period_primary: Optional[str] = None,
+        time_period_secondary: Optional[str] = None,
+        is_weekend: Optional[bool] = None
+    ):
+        """
+        增量更新基线
+        
+        使用公式：新基线 = 旧基线 + (新值 - 旧值) / 数据量
+        """
+        # 获取现有基线
+        existing = self.get_baseline(device_id, feature_name, time_period_primary, time_period_secondary, is_weekend)
+        
+        if existing:
+            # 增量更新
+            old_mean = existing.get('baseline_mean', 0.0)
+            old_count = existing.get('data_count', 0)
+            
+            # 计算新均值（简化版：滑动平均）
+            if old_count > 0:
+                new_mean = (old_mean * old_count + new_value) / (old_count + 1)
+            else:
+                new_mean = new_value
+            
+            # 更新基线
+            existing['baseline_mean'] = new_mean
+            existing['data_count'] = old_count + 1
+            existing['last_updated'] = datetime.now().isoformat()
+            
+            self.save_baseline(existing)
+        else:
+            # 创建新基线
+            new_baseline = {
+                'device_id': device_id,
+                'feature_name': feature_name,
+                'baseline_type': 'personal',
+                'baseline_mean': new_value,
+                'baseline_std': 1.0,  # 默认标准差
+                'personal_mean': new_value,
+                'personal_std': 1.0,
+                'data_count': 1,
+                'time_period_primary': time_period_primary or '',
+                'time_period_secondary': time_period_secondary or '',
+                'is_weekend': 1 if is_weekend else 0,
+                'last_updated': datetime.now().isoformat()
+            }
+            self.save_baseline(new_baseline)
+

utils/formatter.py

@@ -0,0 +1,277 @@
+"""
+异常检测结果格式化器
+将检测结果格式化为LLM需要的文本格式
+完全基于配置文件，方便扩展和定制
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+
+class AnomalyFormatter:
+    """
+    异常检测结果格式化器
+    所有格式都从配置文件读取，支持完全自定义
+    """
+    
+    def __init__(self, config_path: Optional[Path] = None):
+        """
+        初始化格式化器
+        
+        参数:
+            config_path: 配置文件路径，如果为None则使用默认配置
+        """
+        if config_path is None:
+            config_path = Path(__file__).parent.parent / "configs" / "formatter_config.json"
+        
+        self.config_path = Path(config_path)
+        self.config = self._load_config()
+    
+    def _load_config(self) -> Dict:
+        """加载配置文件"""
+        if self.config_path.exists():
+            try:
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"⚠️  加载格式化配置失败: {e}，使用默认配置")
+        
+        # 返回默认配置
+        return self._get_default_config()
+    
+    def _get_default_config(self) -> Dict:
+        """获取默认配置（向后兼容）"""
+        return {
+            "sections": {
+                "anomaly_overview": {"enabled": True, "title": "异常概览"},
+                "core_indicators": {"enabled": True, "title": "核心指标"},
+                "historical_trend": {"enabled": True, "title": "历史趋势"},
+                "related_indicators": {"enabled": True, "title": "相关健康指标"},
+                "user_profile": {"enabled": True, "title": "用户背景信息"}
+            },
+            "formatting": {
+                "section_prefix": "## ",
+                "section_suffix": "\n",
+                "field_prefix": "- ",
+                "field_suffix": "\n",
+                "line_separator": "\n",
+                "header": "# 健康异常检测结果\n"
+            }
+        }
+    
+    def _format_value(self, value: Any, field_config: Dict) -> str:
+        """格式化单个字段值（完全基于配置）"""
+        if value is None:
+            default = field_config.get("default", "")
+            return default if default else ""
+        
+        format_type = field_config.get("format", "string")
+        decimal_places = field_config.get("decimal_places", 2)
+        prefix = field_config.get("prefix", "")
+        suffix = field_config.get("suffix", "")
+        default = field_config.get("default", "")
+        mapping = field_config.get("mapping", {})
+        
+        # 处理映射（如trend: "worsening" -> "持续恶化"）
+        if mapping and str(value) in mapping:
+            value = mapping[str(value)]
+        
+        # 格式化
+        try:
+            if format_type == "float":
+                formatted = f"{float(value):.{decimal_places}f}"
+            elif format_type == "integer":
+                formatted = f"{int(value)}"
+            elif format_type == "boolean":
+                true_text = field_config.get("true_text", "是")
+                false_text = field_config.get("false_text", "否")
+                formatted = true_text if value else false_text
+            else:
+                formatted = str(value) if value else default
+        except (ValueError, TypeError):
+            formatted = default if default else ""
+        
+        return f"{prefix}{formatted}{suffix}"
+    
+    def _format_section(
+        self,
+        section_key: str,
+        data: Dict,
+        section_config: Dict
+    ) -> List[str]:
+        """格式化一个章节（完全基于配置）"""
+        lines = []
+        
+        if not section_config.get("enabled", True):
+            return lines
+        
+        formatting = self.config.get("formatting", {})
+        section_prefix = formatting.get("section_prefix", "## ")
+        section_suffix = formatting.get("section_suffix", "\n")
+        field_prefix = formatting.get("field_prefix", "- ")
+        field_suffix = formatting.get("field_suffix", "\n")
+        
+        # 添加章节标题
+        title = section_config.get("title", section_key)
+        lines.append(f"{section_prefix}{title}{section_suffix}")
+        
+        # 格式化字段
+        fields_config = section_config.get("fields", {})
+        for field_key, field_config in fields_config.items():
+            if not field_config.get("enabled", True):
+                continue
+            
+            field_label = field_config.get("label", field_key)
+            format_type = field_config.get("format", "string")
+            
+            if format_type == "nested":
+                # 嵌套字段（如activity_level.level）
+                nested_data = data.get(field_key, {})
+                if nested_data:
+                    sub_fields = field_config.get("sub_fields", {})
+                    sub_values = []
+                    for sub_key, sub_config in sub_fields.items():
+                        if not sub_config.get("enabled", True):
+                            continue
+                        sub_value = nested_data.get(sub_key)
+                        if sub_value is not None:
+                            formatted_sub = self._format_value(sub_value, sub_config)
+                            sub_values.append(formatted_sub)
+                    
+                    if sub_values:
+                        line = f"{field_prefix}{field_label}：{''.join(sub_values)}{field_suffix}"
+                        lines.append(line)
+            elif format_type == "string_or_nested":
+                # 尝试直接值，如果不存在则尝试fallback字段
+                value = data.get(field_key)
+                fallback_key = field_config.get("fallback")
+                if value is None and fallback_key:
+                    value = data.get(fallback_key)
+                
+                if value is not None:
+                    formatted = self._format_value(value, field_config)
+                    line = f"{field_prefix}{field_label}：{formatted}{field_suffix}"
+                    lines.append(line)
+            else:
+                # 普通字段
+                value = data.get(field_key)
+                if value is not None:
+                    formatted = self._format_value(value, field_config)
+                    line = f"{field_prefix}{field_label}：{formatted}{field_suffix}"
+                    lines.append(line)
+        
+        # 添加章节分隔
+        lines.append(formatting.get("line_separator", "\n"))
+        
+        return lines
+    
+    def _format_historical_trend(
+        self,
+        daily_results: List[Dict],
+        section_config: Dict
+    ) -> List[str]:
+        """格式化历史趋势（特殊处理，因为是多条记录）"""
+        lines = []
+        
+        if not section_config.get("enabled", True):
+            return lines
+        
+        formatting = self.config.get("formatting", {})
+        section_prefix = formatting.get("section_prefix", "## ")
+        section_suffix = formatting.get("section_suffix", "\n")
+        field_prefix = formatting.get("field_prefix", "- ")
+        field_suffix = formatting.get("field_suffix", "\n")
+        
+        # 添加章节标题
+        title = section_config.get("title", "历史趋势")
+        lines.append(f"{section_prefix}{title}{section_suffix}")
+        
+        # 格式化每条记录
+        fields_config = section_config.get("fields", {})
+        for result in daily_results:
+            parts = []
+            for field_key, field_config in fields_config.items():
+                if not field_config.get("enabled", True):
+                    continue
+                
+                value = result.get(field_key)
+                if value is not None:
+                    formatted = self._format_value(value, field_config)
+                    parts.append(formatted)
+            
+            if parts:
+                date = result.get("date", "")
+                line = f"{field_prefix}{date}：{''.join(parts)}{field_suffix}"
+                lines.append(line)
+        
+        lines.append(formatting.get("line_separator", "\n"))
+        return lines
+    
+    def format_for_llm(
+        self,
+        anomaly_result: Dict,
+        baseline_info: Optional[Dict] = None,
+        related_indicators: Optional[Dict] = None,
+        user_profile: Optional[Dict] = None,
+        daily_results: Optional[List[Dict]] = None
+    ) -> str:
+        """
+        格式化异常检测结果为文本（给LLM）
+        
+        只提供数据，不做判断
+        所有格式都从配置文件读取，方便扩展
+        """
+        lines = []
+        formatting = self.config.get("formatting", {})
+        sections = self.config.get("sections", {})
+        
+        # 添加标题
+        header = formatting.get("header", "# 健康异常检测结果\n")
+        lines.append(header)
+        
+        # 异常概览章节
+        if "anomaly_overview" in sections:
+            section_config = sections["anomaly_overview"]
+            if section_config.get("enabled", True):
+                if "anomaly_pattern" in anomaly_result:
+                    # 异常模式格式
+                    pattern_data = anomaly_result["anomaly_pattern"]
+                    lines.extend(self._format_section("anomaly_overview", pattern_data, section_config))
+                elif "is_anomaly" in anomaly_result:
+                    # 实时检测格式
+                    lines.extend(self._format_section("anomaly_overview", anomaly_result, section_config))
+        
+        # 核心指标章节
+        if baseline_info and "core_indicators" in sections:
+            section_config = sections["core_indicators"]
+            # 重命名字段以匹配配置
+            core_data = {
+                "hrv_rmssd": baseline_info.get("current_value"),
+                "baseline_mean": baseline_info.get("baseline_mean"),
+                "deviation_pct": baseline_info.get("deviation_pct")
+            }
+            lines.extend(self._format_section("core_indicators", core_data, section_config))
+        
+        # 历史趋势章节
+        if daily_results and "historical_trend" in sections:
+            section_config = sections["historical_trend"]
+            lines.extend(self._format_historical_trend(daily_results, section_config))
+        
+        # 相关健康指标章节
+        if related_indicators and "related_indicators" in sections:
+            section_config = sections["related_indicators"]
+            lines.extend(self._format_section("related_indicators", related_indicators, section_config))
+        
+        # 用户背景信息章节
+        if user_profile and "user_profile" in sections:
+            section_config = sections["user_profile"]
+            lines.extend(self._format_section("user_profile", user_profile, section_config))
+        
+        return "".join(lines)
+    
+    @staticmethod
+    def format_realtime_result(result: Dict, config_path: Optional[Path] = None) -> str:
+        """格式化实时检测结果（静态方法，向后兼容）"""
+        formatter = AnomalyFormatter(config_path)
+        return formatter.format_for_llm(result)

wearable_anomaly_detector.py

@@ -0,0 +1,785 @@
+"""
+Wearable健康异常检测模型 - 标准化封装
+提供简单的API接口，用于实时异常检测
+"""
+
+import torch
+import numpy as np
+import json
+import pickle
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+from datetime import datetime, timedelta
+import pandas as pd
+
+# 添加项目根目录到路径
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from models.phased_lstm_tft import PhasedLSTM_TFT, PhasedLSTM_TFT_WithEnhancedAnomalyDetection
+from feature_calculator import FeatureCalculator
+
+# 导入工具模块（可选，如果不存在则使用None）
+try:
+    from utils.baseline_storage import BaselineStorage
+    from utils.api_client import HistoricalDataPlatformClient
+    from utils.formatter import AnomalyFormatter
+except ImportError:
+    BaselineStorage = None
+    HistoricalDataPlatformClient = None
+    AnomalyFormatter = None
+
+
+class WearableAnomalyDetector:
+    """
+    Wearable健康异常检测器
+    
+    使用示例:
+        detector = WearableAnomalyDetector(model_dir="checkpoints/phase2/exp_factor_balanced")
+        result = detector.predict(data_points)
+    """
+    
+    def __init__(
+        self,
+        model_dir: Union[str, Path],
+        device: Optional[str] = None,
+        threshold: Optional[float] = None
+    ):
+        """
+        初始化异常检测器
+        
+        参数:
+            model_dir: 模型目录路径（包含best_model.pt和配置文件）
+            device: 设备（'cuda'或'cpu'），如果为None则自动选择
+            threshold: 异常阈值，如果为None则从配置中读取
+        """
+        self.model_dir = Path(model_dir)
+        self.device = torch.device(device or ('cuda' if torch.cuda.is_available() else 'cpu'))
+        
+        # 加载配置
+        self.config = self._load_config()
+        
+        # 确定阈值
+        if threshold is not None:
+            self.threshold = float(threshold)
+        else:
+            config_threshold = self.config.get('threshold')
+            if config_threshold is not None:
+                self.threshold = float(config_threshold)
+            else:
+                self.threshold = 0.53  # 默认阈值
+                # 不打印警告，因为使用默认阈值是正常情况
+        
+        # 配置驱动特征计算（在加载模型之前，用于获取特征列表）
+        self.feature_calculator = FeatureCalculator(
+            config_path=self.config.get('feature_config_path'),
+            norm_params_path=Path(__file__).parent / 'processed_data' / 'stage3' / 'norm_params.json',
+            static_features_path=Path(__file__).parent / 'processed_data' / 'stage2' / 'static_features.csv',
+            storage_dir=Path(self.config.get('storage_dir', Path(__file__).parent / 'data_storage'))
+        )
+        self.features = self.feature_calculator.get_enabled_feature_names()
+        self.static_feature_names = [cfg["name"] for cfg in self.feature_calculator.static_feature_defs]
+        self.known_future_dim = max(len(self.feature_calculator.known_future_defs), 1)
+        self.factor_metadata = {
+            'enabled': self.feature_calculator.factor_enabled,
+            'factor_names': self.feature_calculator.factor_names,
+            'factor_dim': self.feature_calculator.factor_dim
+        }
+        
+        # 加载模型（会从Phase2权重推断正确的特征数量）
+        self.model = self._load_model()
+        self.model.eval()
+        
+        # 加载归一化参数（维持向后兼容）
+        self.norm_params = self._load_norm_params()
+        
+        print(f"✅ 模型加载成功")
+        print(f"  - 设备: {self.device}")
+        print(f"  - 阈值: {self.threshold:.4f}")
+        print(f"  - 配置的特征数: {len(self.features)}")
+        print(f"  - 模型实际特征数: {self.model.base_model.tft.output_layer.weight.shape[0] if hasattr(self.model, 'base_model') else '未知'}")
+    
+    def _load_config(self) -> Dict:
+        """加载模型配置"""
+        # 尝试多个可能的配置文件路径
+        config_paths = [
+            self.model_dir / 'config.json',
+            self.model_dir.parent / 'config.json',
+            Path(__file__).parent / 'config.json',
+            Path(__file__).parent / 'configs' / 'model_config.json',
+        ]
+        
+        for config_file in config_paths:
+            if config_file.exists():
+                try:
+                    with open(config_file, 'r', encoding='utf-8') as f:
+                        config = json.load(f)
+                        print(f"  ✅ 找到配置文件: {config_file}")
+                        return config
+                except Exception as e:
+                    print(f"  ⚠️  读取配置文件失败 {config_file}: {e}")
+                    continue
+        
+        # 尝试从summary.json读取
+        summary_file = self.model_dir / 'summary.json'
+        if summary_file.exists():
+            try:
+                with open(summary_file, 'r', encoding='utf-8') as f:
+                    summary = json.load(f)
+                    config = {
+                        'threshold': summary.get('best_threshold'),
+                        'features': [],  # 需要从其他地方获取
+                    }
+                    print(f"  ✅ 从summary.json读取配置")
+                    return config
+            except Exception as e:
+                print(f"  ⚠️  读取summary.json失败: {e}")
+        
+        # 如果都没有，返回空配置（使用默认值，这是正常的）
+        # 不打印警告，因为使用默认配置是正常情况
+        return {}
+    
+    def _load_model(self):
+        """加载模型 - 直接从Phase2 checkpoint加载（包含完整的base_model权重）"""
+        # 加载Phase2 checkpoint（最终模型）
+        phase2_model_path = self.model_dir / 'best_model.pt'
+        if not phase2_model_path.exists():
+            raise FileNotFoundError(f"Phase2模型不存在: {phase2_model_path}")
+        
+        print(f"  📦 加载Phase2 checkpoint: {phase2_model_path}")
+        checkpoint_phase2 = torch.load(phase2_model_path, map_location=self.device, weights_only=False)
+        phase2_state_dict = checkpoint_phase2['model_state_dict']
+        
+        # 从Phase2权重形状推断模型配置（Phase2 checkpoint包含完整的base_model权重）
+        if 'base_model.phased_lstm.lstm_layers.0.W_ih.weight' in phase2_state_dict:
+            inferred_num_features = phase2_state_dict['base_model.phased_lstm.lstm_layers.0.W_ih.weight'].shape[1]
+        else:
+            # 如果找不到，使用当前特征数量
+            inferred_num_features = len(self.features) if hasattr(self, 'features') else 24
+        
+        if 'base_model.tft.static_embedding.weight' in phase2_state_dict:
+            # static_embedding shape: [embedding_dim, num_static_features]
+            inferred_num_static = phase2_state_dict['base_model.tft.static_embedding.weight'].shape[1]
+        else:
+            inferred_num_static = len(self.static_feature_names) if hasattr(self, 'static_feature_names') else 2
+        
+        # 从权重推断其他配置
+        if 'base_model.tft.hidden_size' in phase2_state_dict:
+            # 如果checkpoint中有配置，可以直接读取
+            pass
+        
+        # 检查是否有factor_features
+        has_factor_fusion = 'factor_fusion.projection.weight' in phase2_state_dict
+        
+        print(f"  📊 从Phase2权重推断的模型配置:")
+        print(f"     - 时间序列特征: {inferred_num_features}")
+        print(f"     - 静态特征: {inferred_num_static}")
+        print(f"     - Factor融合: {'是' if has_factor_fusion else '否'}")
+        
+        # 构建模型配置（从权重推断，不依赖Phase1）
+        model_config = {
+            'num_features': inferred_num_features,
+            'num_static_features': inferred_num_static,
+            'num_known_future_features': 3,  # 通常是3（hour_of_day, day_of_week, is_weekend）
+            'lstm_hidden_size': 128,  # 从权重形状可以推断，这里用默认值
+            'lstm_layers': 2,  # 从权重键名可以推断
+            'lstm_alpha': 0.0001,  # 默认值
+            'tft_hidden_size': 128,  # 从权重形状可以推断
+            'tft_num_heads': 4,  # 默认值
+            'tft_num_encoder_layers': 3,  # 默认值
+            'tft_num_decoder_layers': 3,  # 默认值
+            'tft_dim_feedforward': 512,  # 默认值
+            'dropout': 0.1,  # 默认值
+        }
+        
+        # 创建基础模型（使用推断的配置）
+        base_model = PhasedLSTM_TFT(model_config)
+        base_model = base_model.to(self.device)
+        
+        # 加载factor_config
+        factor_config = self._load_factor_config()
+        
+        # 创建Phase2模型
+        model = PhasedLSTM_TFT_WithEnhancedAnomalyDetection(
+            base_model,
+            num_anomaly_types=4,
+            use_enhanced_head=True,
+            use_multi_source_heads=False,
+            use_domain_adversarial=False,
+            factor_config=factor_config
+        )
+        model = model.to(self.device)
+        
+        # 直接加载Phase2的完整权重（包括base_model和anomaly_head）
+        print(f"  🔄 加载Phase2完整权重（包括base_model和anomaly_head）...")
+        try:
+            model.load_state_dict(phase2_state_dict, strict=True)
+            print(f"  ✅ Phase2模型权重加载成功（严格模式）")
+        except RuntimeError as e:
+            print(f"  ⚠️  严格模式加载失败，尝试宽松模式: {str(e)[:150]}...")
+            missing_keys, unexpected_keys = model.load_state_dict(phase2_state_dict, strict=False)
+            if missing_keys:
+                print(f"  ⚠️  缺失的键 ({len(missing_keys)}个): {missing_keys[:3]}..." if len(missing_keys) > 3 else f"  ⚠️  缺失的键: {missing_keys}")
+            if unexpected_keys:
+                print(f"  ⚠️  ��外的键 ({len(unexpected_keys)}个): {unexpected_keys[:3]}..." if len(unexpected_keys) > 3 else f"  ⚠️  意外的键: {unexpected_keys}")
+            print(f"  ✅ Phase2模型权重加载成功（宽松模式）")
+        
+        return model
+    
+    def _load_factor_config(self) -> Optional[Dict]:
+        """加载因子特征配置"""
+        # 方法1: 从config.json读取（如果已加载）
+        if hasattr(self, 'factor_metadata') and self.factor_metadata:
+            if self.factor_metadata.get('enabled'):
+                return {
+                    'num_factors': len(self.factor_metadata.get('factor_names', [])),
+                    'factor_dim': self.factor_metadata.get('factor_dim', 0),
+                    'factor_names': self.factor_metadata.get('factor_names', []),
+                    'min_weight': 0.2,
+                    'dropout': 0.1,
+                }
+        
+        # 方法2: 从窗口信息文件读取
+        window_info_file = Path(__file__).parent / 'processed_data' / 'stage3' / 'window_info_multi_scale.json'
+        if window_info_file.exists():
+            with open(window_info_file, 'r') as f:
+                window_info = json.load(f)
+            factor_metadata = window_info.get('factor_features', {})
+            if factor_metadata and factor_metadata.get('enabled'):
+                return {
+                    'num_factors': len(factor_metadata.get('factor_names', [])),
+                    'factor_dim': factor_metadata.get('factor_dim', 0),
+                    'factor_names': factor_metadata.get('factor_names', []),
+                    'min_weight': 0.2,
+                    'dropout': 0.1,
+                }
+        return None
+    
+    def _load_norm_params(self) -> Optional[Dict]:
+        """加载归一化参数"""
+        norm_file = Path(__file__).parent / 'processed_data' / 'stage3' / 'norm_params.json'
+        if norm_file.exists():
+            with open(norm_file, 'r') as f:
+                return json.load(f)
+        return None
+    
+    def predict(
+        self,
+        data_points: List[Dict],
+        return_score: bool = True,
+        return_details: bool = False
+    ) -> Dict:
+        """
+        预测异常
+        
+        参数:
+            data_points: 数据点列表，每个数据点是一个字典，包含：
+                - timestamp: 时间戳（datetime或字符串）
+                - features: 特征字典，包含所有需要的特征值
+                - static_features: 静态特征字典（可选）
+            return_score: 是否返回异常分数
+            return_details: 是否返回详细信息
+        
+        返回:
+            {
+                'is_anomaly': bool,  # 是否异常
+                'anomaly_score': float,  # 异常分数（0-1）
+                'threshold': float,  # 使用的阈值
+                'details': dict (可选)  # 详细信息
+            }
+        """
+        user_id = data_points[0].get('deviceId') or data_points[0].get('user_id')
+        window = self.feature_calculator.build_window(data_points, user_id=user_id)
+        
+        # 转换为模型输入格式
+        model_input = self._prepare_model_input(window)
+        
+        # 模型预测
+        with torch.no_grad():
+            # 模型forward方法接受位置参数，需要按顺序传递
+            outputs = self.model(
+                model_input['x'],
+                model_input['delta_t'],
+                model_input['static_features'],
+                model_input['known_future_features'],
+                mask=model_input.get('mask'),
+                return_contrastive_features=model_input.get('return_contrastive_features', False),
+                source=None,
+                return_domain_features=False,
+                factor_features=model_input.get('factor_features')
+            )
+            anomaly_score = outputs['anomaly_score'].cpu().item()
+        
+        # 判断是否异常
+        is_anomaly = anomaly_score >= self.threshold
+        
+        result = {
+            'is_anomaly': bool(is_anomaly),
+            'threshold': float(self.threshold),
+        }
+        
+        if return_score:
+            result['anomaly_score'] = float(anomaly_score)
+        
+        if return_details:
+            result['details'] = {
+                'window_size': len(data_points),
+                'model_output': float(anomaly_score),
+                'prediction_confidence': abs(anomaly_score - self.threshold),
+            }
+        
+        return result
+    
+    def _prepare_model_input(self, window: Dict) -> Dict:
+        """准备模型输入"""
+        # 获取窗口大小（从window或默认12）
+        window_size = len(window.get('input_features', {}).get(self.features[0] if self.features else 'hr', []))
+        if window_size == 0:
+            window_size = 12  # 默认值
+        
+        input_features_list = []
+        for feat in self.features:
+            values = window['input_features'].get(feat, [0.0] * window_size)
+            input_features_list.append(values)
+        
+        # 转换为tensor
+        input_features = torch.tensor(
+            np.stack(input_features_list, axis=1),
+            dtype=torch.float32
+        ).unsqueeze(0).to(self.device)  # [1, window_size, num_features]
+        
+        delta_t = torch.tensor(
+            window['input_delta_t'],
+            dtype=torch.float32
+        ).unsqueeze(-1).unsqueeze(0).to(self.device)  # [1, window_size, 1]
+        
+        # 静态特征
+        static_feature_values = []
+        static_keys = self.static_feature_names or sorted(window['static_features'].keys())
+        for key in static_keys:
+            value = window['static_features'].get(key, 0.0)
+            static_feature_values.append(float(value))
+        
+        if len(static_feature_values) == 0:
+            static_feature_values = [0.0]
+        
+        static_features = torch.tensor(
+            static_feature_values,
+            dtype=torch.float32
+        ).unsqueeze(0).to(self.device)  # [1, num_static]
+        
+        # 已知未来特征
+        pred_len = len(window.get('target_timestamp', []))
+        if pred_len == 0:
+            pred_len = 6  # 默认预测长度
+        
+        known_future = torch.zeros(1, pred_len, self.known_future_dim, dtype=torch.float32).to(self.device)
+        if 'known_future_features' in window:
+            kf = window['known_future_features']
+            for idx, cfg in enumerate(self.feature_calculator.known_future_defs):
+                name = cfg['name']
+                if name in kf:
+                    series = kf[name][:pred_len]
+                    if name == 'hour_of_day':
+                        values = torch.tensor([float(h) / 23.0 for h in series], dtype=torch.float32)
+                    elif name == 'day_of_week':
+                        values = torch.tensor([float(d) / 6.0 for d in series], dtype=torch.float32)
+                    else:
+                        values = torch.tensor([float(v) for v in series], dtype=torch.float32)
+                    known_future[0, :len(series), idx] = values
+        
+        # 输入mask（假设所有数据都有效）
+        window_size = input_features.shape[1]  # 从实际输入获取窗口大小
+        input_mask = torch.ones(1, window_size, len(self.features), dtype=torch.float32).to(self.device)
+        
+        # 因子特征
+        factor_features = None
+        if window.get('factor_features'):
+            factor_names = self.factor_metadata.get('factor_names', [])
+            factor_dim = self.factor_metadata.get('factor_dim', 4)
+            factor_vectors = []
+            for name in factor_names:
+                vec = window['factor_features'].get(name, [0.0] * factor_dim)
+                factor_vectors.append(vec[:factor_dim])
+            if factor_vectors:
+                factor_features = torch.tensor(
+                    factor_vectors,
+                    dtype=torch.float32
+                ).unsqueeze(0).to(self.device)  # [1, num_factors, factor_dim]
+        
+        return {
+            'x': input_features,
+            'delta_t': delta_t,
+            'static_features': static_features,
+            'known_future_features': known_future,
+            'mask': input_mask,
+            'factor_features': factor_features,
+            'return_contrastive_features': False,
+            'source': None,
+            'return_domain_features': False,
+        }
+    
+    def batch_predict(
+        self,
+        windows: List[List[Dict]],
+        return_scores: bool = True
+    ) -> List[Dict]:
+        """
+        批量预测
+        
+        参数:
+            windows: 窗口列表，每个窗口是一个数据点列表
+            return_scores: 是否返回异常分数
+        
+        返回:
+            预测结果列表
+        """
+        results = []
+        for window_data in windows:
+            result = self.predict(window_data, return_score=return_scores)
+            results.append(result)
+        return results
+    
+    def update_threshold(self, threshold: float):
+        """更新异常阈值"""
+        self.threshold = threshold
+        print(f"✅ 阈值已更新为: {threshold:.4f}")
+    
+    def detect_realtime(
+        self,
+        data_points: List[Dict],
+        update_baseline: bool = True,
+        return_score: bool = True,
+        return_details: bool = False
+    ) -> Dict:
+        """
+        模式1：实时异常检测（短期数据）
+        
+        参数:
+            data_points: 数据点列表（至少12个，1小时数据）
+            update_baseline: 是否自动更新基线（默认True）
+            return_score: 是否返回异常分数
+            return_details: 是否返回详细信息
+        
+        返回:
+            检测结果字典
+        """
+        # 复用现有的predict方法
+        result = self.predict(data_points, return_score=return_score, return_details=return_details)
+        
+        # 可选：更新基线
+        if update_baseline and BaselineStorage:
+            try:
+                user_id = data_points[0].get('deviceId') or data_points[0].get('user_id')
+                if user_id:
+                    # 获取HRV值（用于更新基线）
+                    hrv_values = [dp.get('features', {}).get('hrv_rmssd') for dp in data_points]
+                    hrv_values = [v for v in hrv_values if v is not None]
+                    if hrv_values:
+                        avg_hrv = np.mean(hrv_values)
+                        # 这里需要初始化BaselineStorage（简化处理）
+                        # 实际使用时应该在__init__中初始化
+                        pass
+            except Exception as e:
+                print(f"⚠️  更新基线失败: {e}")
+        
+        return result
+    
+    def detect_pattern(
+        self,
+        data_points: List[Dict],
+        days: Optional[int] = None,
+        min_duration_days: Optional[int] = None,
+        format_for_llm: bool = False,
+        window_size: Optional[int] = None
+    ) -> Dict:
+        """
+        模式2：异常模式聚合（多天数据）
+        
+        参数:
+            data_points: 多天数据点列表
+            days: 天数（如果data_points是按天组织的）
+            min_duration_days: 最小持续天数（可选，默认从配置文件读取或3）
+            format_for_llm: 是否格式化输出给LLM
+            window_size: 窗口大小（可选，默认从配置文件读取或12）
+        
+        返回:
+            异常模式聚合结果
+        """
+        # 从配置文件读取参数（如果未提供）
+        if min_duration_days is None:
+            try:
+                config_path = Path(__file__).parent / "configs" / "detector_config.json"
+                if config_path.exists():
+                    with open(config_path, 'r', encoding='utf-8') as f:
+                        detector_config = json.load(f)
+                        min_duration_days = detector_config.get("pattern_detection", {}).get("min_duration_days", 3)
+                else:
+                    min_duration_days = 3  # 默认值
+            except Exception:
+                min_duration_days = 3  # 默认值
+        
+        if window_size is None:
+            try:
+                config_path = Path(__file__).parent / "configs" / "detector_config.json"
+                if config_path.exists():
+                    with open(config_path, 'r', encoding='utf-8') as f:
+                        detector_config = json.load(f)
+                        window_size = detector_config.get("detection", {}).get("window_size", 12)
+                else:
+                    window_size = 12  # 默认值
+            except Exception:
+                window_size = 12  # 默认值
+        
+        # 按天分组数据
+        daily_results = []
+        
+        # 如果data_points是按天组织的（每个元素是一天的数据）
+        if days and isinstance(data_points[0], list):
+            # data_points是[[day1_data], [day2_data], ...]格式
+            for day_data in data_points:
+                if len(day_data) >= window_size:  # 至少window_size个数据点
+                    result = self.predict(day_data, return_score=True)
+                    daily_results.append({
+                        'date': day_data[0].get('timestamp', ''),
+                        'anomaly_score': result.get('anomaly_score', 0.0),
+                        'is_anomaly': result.get('is_anomaly', False),
+                        'hrv_rmssd': np.mean([dp.get('features', {}).get('hrv_rmssd', 0) 
+                                             for dp in day_data if dp.get('features', {}).get('hrv_rmssd')]),
+                        'hr': np.mean([dp.get('features', {}).get('hr', 0) 
+                                      for dp in day_data if dp.get('features', {}).get('hr')])
+                    })
+        else:
+            # data_points是扁平列表，需要按天分组
+            # 简化处理：假设数据已经按时间排序
+            # 实际使用时应该按timestamp分组
+            pass
+        
+        # 检测异常模式
+        pattern_result = self._detect_anomaly_pattern(daily_results, min_duration_days)
+        
+        # 获取基线信息
+        user_id = data_points[0].get('deviceId') if isinstance(data_points[0], dict) else None
+        baseline_info = None
+        if user_id:
+            try:
+                baseline_info = self.feature_calculator.get_baseline_info(
+                    user_id=user_id,
+                    feature_name='hrv_rmssd'
+                )
+            except Exception as e:
+                print(f"⚠️  获取基线信息失败: {e}")
+        
+        # 获取相关指标
+        related_indicators = None
+        try:
+            if isinstance(data_points[0], dict):
+                related_indicators = self.feature_calculator.get_related_indicators(data_points)
+        except Exception as e:
+            print(f"⚠️  获取相关指标���败: {e}")
+        
+        result = {
+            'anomaly_pattern': pattern_result,
+            'baseline_info': baseline_info,
+            'related_indicators': related_indicators,
+            'daily_results': daily_results
+        }
+        
+        # 格式化输出（如果需要）
+        if format_for_llm and AnomalyFormatter:
+            formatter = AnomalyFormatter()
+            result['formatted_for_llm'] = formatter.format_for_llm(
+                result,
+                baseline_info=baseline_info,
+                related_indicators=related_indicators,
+                daily_results=daily_results
+            )
+        
+        return result
+    
+    def _detect_anomaly_pattern(
+        self,
+        daily_results: List[Dict],
+        min_duration_days: int = 3
+    ) -> Dict:
+        """
+        检测异常模式（内部方法）
+        复用wearable_branch中的逻辑
+        """
+        if not daily_results:
+            return {
+                'has_pattern': False,
+                'pattern_description': '无检测数据'
+            }
+        
+        # 按日期排序
+        sorted_results = sorted(
+            daily_results,
+            key=lambda x: self._parse_date(x.get('date') or x.get('timestamp'))
+        )
+        
+        # 提取异常日期和分数
+        anomaly_dates = []
+        anomaly_scores = []
+        
+        for result in sorted_results:
+            date = self._parse_date(result.get('date') or result.get('timestamp'))
+            if date is None:
+                continue
+            
+            date_str = date.strftime('%Y-%m-%d') if hasattr(date, 'strftime') else str(date)
+            score = result.get('anomaly_score', 0.0)
+            is_anomaly = result.get('is_anomaly', score >= self.threshold)
+            
+            if is_anomaly:
+                anomaly_dates.append(date_str)
+                anomaly_scores.append(score)
+        
+        # 判断是否存在异常模式
+        if len(anomaly_dates) < min_duration_days:
+            return {
+                'has_pattern': False,
+                'duration_days': len(anomaly_dates),
+                'anomaly_dates': anomaly_dates,
+                'anomaly_scores': anomaly_scores,
+                'pattern_description': f'异常仅持续{len(anomaly_dates)}天，未达到最小持续天数{min_duration_days}天'
+            }
+        
+        # 计算趋势
+        trend = self._calculate_trend(anomaly_scores)
+        
+        # 计算统计信息
+        max_score = max(anomaly_scores) if anomaly_scores else 0.0
+        min_score = min(anomaly_scores) if anomaly_scores else 0.0
+        avg_score = sum(anomaly_scores) / len(anomaly_scores) if anomaly_scores else 0.0
+        
+        # 生成模式描述
+        trend_desc = {
+            'worsening': '持续恶化',
+            'stable': '稳定异常',
+            'improving': '逐渐改善'
+        }.get(trend, '未知趋势')
+        
+        pattern_description = (
+            f"检测到持续{len(anomaly_dates)}天的异常模式，"
+            f"趋势：{trend_desc}，"
+            f"异常分数范围：{min_score:.4f} - {max_score:.4f}，"
+            f"平均异常分数：{avg_score:.4f}"
+        )
+        
+        return {
+            'has_pattern': True,
+            'anomaly_type': 'continuous_anomaly',
+            'duration_days': len(anomaly_dates),
+            'trend': trend,
+            'anomaly_scores': anomaly_scores,
+            'anomaly_dates': anomaly_dates,
+            'pattern_description': pattern_description,
+            'first_anomaly_date': anomaly_dates[0] if anomaly_dates else '',
+            'last_anomaly_date': anomaly_dates[-1] if anomaly_dates else '',
+            'max_score': max_score,
+            'min_score': min_score,
+            'avg_score': avg_score
+        }
+    
+    def _parse_date(self, date_input):
+        """解析日期"""
+        if date_input is None:
+            return None
+        if isinstance(date_input, datetime):
+            return date_input
+        if isinstance(date_input, str):
+            try:
+                return pd.to_datetime(date_input)
+            except:
+                return None
+        return None
+    
+    def _calculate_trend(self, scores: List[float]) -> str:
+        """计算趋势"""
+        if len(scores) < 2:
+            return 'stable'
+        
+        # 简单线性回归判断趋势
+        n = len(scores)
+        x = list(range(n))
+        y = scores
+        
+        sum_x = sum(x)
+        sum_y = sum(y)
+        sum_xy = sum(x[i] * y[i] for i in range(n))
+        sum_x2 = sum(x[i] ** 2 for i in range(n))
+        
+        slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x ** 2) if (n * sum_x2 - sum_x ** 2) != 0 else 0
+        
+        if slope > 0.01:
+            return 'worsening'
+        elif slope < -0.01:
+            return 'improving'
+        else:
+            return 'stable'
+
+
+def load_detector(model_dir: Union[str, Path], **kwargs) -> WearableAnomalyDetector:
+    """
+    便捷函数：加载异常检测器
+    
+    参数:
+        model_dir: 模型目录路径
+        **kwargs: 其他参数（device, threshold等）
+    
+    返回:
+        WearableAnomalyDetector实例
+    """
+    return WearableAnomalyDetector(model_dir, **kwargs)
+
+
+if __name__ == '__main__':
+    # 使用示例
+    print("=" * 80)
+    print("Wearable健康异常检测器 - 使用示例")
+    print("=" * 80)
+    
+    # 加载模型
+    model_dir = Path(__file__).parent / 'checkpoints' / 'phase2' / 'exp_factor_balanced'
+    detector = load_detector(model_dir)
+    
+    # 模拟数据点（实际使用时应该从实时数据流获取）
+    print("\n模拟数据点...")
+    data_points = []
+    base_time = datetime.now()
+    
+    # 使用一个真实的deviceId（如果静态特征表存在）
+    # 或者提供一个完整的静态特征示例
+    example_device_id = None
+    static_dict = detector.feature_calculator.static_features_dict
+    if static_dict:
+        example_device_id = list(static_dict.keys())[0]
+        print(f"  使用示例用户ID: {example_device_id}")
+    
+    for i in range(12):
+        data_point = {
+            'timestamp': base_time.replace(minute=i*5),
+            'deviceId': example_device_id,  # 提供deviceId以便加载完整静态特征
+            'features': {
+                'hr': 70.0 + np.random.randn() * 5,
+                'hrv_rmssd': 30.0 + np.random.randn() * 3,
+                # ... 其他特征（简化示例，实际需要所有36个特征）
+            },
+            'static_features': {
+                # 可以只提供部分特征，系统会自动从静态特征表补充
+                # 或者不提供，完全从静态特征表加载
+            }
+        }
+        data_points.append(data_point)
+    
+    # 预测
+    result = detector.predict(data_points, return_score=True, return_details=True)
+    
+    print(f"\n预测结果:")
+    print(f"  - 是否异常: {result['is_anomaly']}")
+    print(f"  - 异常分数: {result['anomaly_score']:.4f}")
+    print(f"  - 阈值: {result['threshold']:.4f}")
+    if 'details' in result:
+        print(f"  - 详细信息: {result['details']}")
+