用电行为异常检测VAE-基于PyTorch设计用电行为异常检测模型：从时序特征提取到变分自编码器部署的完整实战

正文

Typora插件开发指南：打造专属IDE式写作环境

摘要 ：本文融合两大技术实践：Typora插件开发 与用电行为异常检测。前者将Typora从简洁编辑器升级为个性化"写作IDE"，通过插件系统扩展功能、自动化流程、定制界面，为开发者提供完整的插件开发指南。后者基于PyTorch和β-VAE模型，从智能电表日冻结数据中精准识别窃电、表计故障等异常行为，将误报率从96.1%降至12%，检出率提升至89%，提供从特征工程到生产部署的全链路实战方案。

一、引言：为什么需要为Typora开发插件？

插件开发的意义与实践导向 ：Typora以其"所见即所得"的简洁体验赢得了众多技术写作者的青睐，但面对复杂的技术文档、长文创作或特定工作流时，原生功能往往捉襟见肘。插件系统正是连接Typora简洁界面与无限扩展可能性的桥梁。本文不仅探讨插件开发的技术细节，更强调实践导向------通过具体案例（智能代码片段管理器）和完整流程（从环境搭建到发布维护），帮助开发者将理论转化为可运行的插件，真正打造符合个人需求的专属写作环境。

1.1 Typora的定位与局限

• Typora作为一款优秀的Markdown编辑器，以其"所见即所得"和简洁设计著称。
• 然而，对于深度技术写作、长文创作或特定工作流，其原生功能可能不足。
• 插件系统可以弥补这一缺口，将Typora从一个编辑器升级为个性化的"写作IDE"。

1.2 插件能带来什么？

• 功能扩展：集成外部工具（如代码片段管理、图床、翻译、AI辅助）。
• 流程自动化：自动化重复性任务（如格式整理、图片上传、发布）。
• 环境定制：打造符合个人习惯和特定技术栈的专属写作环境。
• 效率提升：减少上下文切换，让写作心流更连贯。

1.3 本文目标读者与前置知识

• 目标读者：熟悉Typora、具备基本JavaScript/Node.js知识、希望提升Markdown写作效率的开发者或技术作者。
• 前置知识：了解Markdown语法、熟悉命令行操作、对Web技术（HTML/CSS/JS）有基本了解。

二、Typora插件开发基础

2.1 插件系统架构概览

• Typora插件本质上是基于Node.js的本地Web应用。
• 核心机制：Typora主进程与插件渲染进程通过IPC（进程间通信）进行交互。
• 插件可以访问和操作当前文档的DOM、监听编辑器事件、调用系统命令。

2.2 开发环境搭建

1. 启用开发者模式：在Typora设置中开启"开发者工具"。
2. 插件目录结构 ：~/.config/Typora/plugins (Linux/macOS) 或 %APPDATA%\Typora\plugins (Windows)。
3. 创建第一个插件 ：my-plugin/ 目录下必备文件：package.json, main.js, styles.css。
4. 调试工具：使用Typora内置的开发者控制台（Ctrl+Shift+I）进行调试。

2.3 核心API与生命周期

• 初始化 ：TyporaPlugin.initialize() - 插件入口点。
• 事件监听 ：Typora.on('event-name', callback) - 监听编辑器事件（如文件打开、保存、选区变化）。
• DOM操作 ：通过document对象访问和修改当前文档的HTML结构。
• 实用工具 ：Typora.Utils 提供文件读写、网络请求、系统对话框等辅助功能。

三、实战：开发你的第一个插件------智能代码片段管理器

3.1 插件功能规划

• 目标：在侧边栏添加一个面板，用于管理常用的代码片段（如SQL查询、API模板、配置块）。
• 功能点 ：
  1. 片段分类与搜索。
  2. 一键插入到光标位置。
  3. 支持片段变量替换（如{``{date}}）。
  4. 片段导入/导出。

3.2 项目结构与核心代码

• package.json：定义插件元数据、依赖和入口。
• main.js：插件主逻辑，注册侧边栏、绑定事件、处理片段插入。
• styles.css：自定义侧边栏和UI组件的样式。
• snippets/：存储片段数据的JSON文件。

// main.js 核心代码示例
TyporaPlugin.initialize(() => {
  console.log('智能代码片段管理器插件已加载');

  // 1. 创建侧边栏面板
  const panel = Typora.UI.addSidebarPanel({
    id: 'code-snippet-panel',
    title: '代码片段',
    icon: 'fa-code'
  });

  // 2. 加载片段数据
  const snippets = loadSnippets();

  // 3. 渲染片段列表
  renderSnippetList(panel, snippets);

  // 4. 绑定插入事件
  panel.on('click', '.snippet-item', (event) => {
    const snippetId = event.target.dataset.id;
    const snippet = snippets.find(s => s.id === snippetId);
    if (snippet) {
      insertSnippetIntoEditor(snippet.content);
    }
  });
});

function insertSnippetIntoEditor(content) {
  // 获取当前选区或光标位置
  const editor = Typora.getEditor();
  editor.replaceSelection(content); // 替换选区或在光标处插入
}

3.3 插件打包与分发

• 使用 npm pack 或手动压缩插件目录为 .zip 文件。
• 分享方式：GitHub仓库、插件市场（如果Typora未来支持）、直接分享文件。

四、进阶插件开发技巧

4.1 与外部工具集成

• 调用命令行工具 ：通过Node.js的child_process模块执行系统命令（如调用pandoc转换格式、调用git管理版本）。
• 连接Web API：集成图床（如PicGo）、翻译API（如DeepL）、笔记服务（如Notion）。

4.2 增强编辑体验

• 自定义快捷键：为插件功能绑定全局或编辑器内的快捷键。
• 语法高亮扩展 ：为自定义的代码块语言（如mermaid、plantuml）添加语法高亮支持。
• 实时预览增强：修改CSS样式，定制化特定元素（如表格、引用块）的渲染效果。

4.3 状态管理与持久化

• 使用localStorage或IndexedDB：在浏览器环境中存储插件配置和用户数据。
• 读写本地文件 ：通过Typora.Utils或Node.js fs模块管理插件数据文件。
• 同步设置：考虑使用云存储服务同步用户的插件配置。

五、打造专属IDE式写作环境：插件组合方案

5.1 效率增强套件

1. 自动图床插件：截图或粘贴图片后自动上传至配置的图床并替换为Markdown链接。
2. 术语库与一键替换插件：维护技术术语词典，一键将文中缩写替换为全称，或统一术语大小写。
3. 大纲导航增强插件：在侧边栏显示更详细的大纲，支持过滤、跳转和章节字数统计。

5.2 写作流程自动化

1. 发布流水线插件：写作完成后，一键格式化、生成封面图、同步到博客平台（如CSDN、知乎、WordPress）。
2. 版本控制插件：深度集成Git，在编辑器内显示行号更改、提交历史、一键提交并推送。
3. 多文档项目管理插件：管理系列文章或书籍项目，支持文档间链接检查和内容聚合。

5.3 个性化界面定制

1. 主题切换插件：根据写作内容（技术文档、创作、日记）快速切换编辑器主题和字体。
2. 专注模式插件：模拟"黑曜石"的专注模式，高亮当前段落，淡化其他内容。
3. 写作数据看板插件：显示今日字数、写作时长、章节进度等数据可视化面板。

六、调试、测试与发布

6.1 调试技巧

• 利用Typora开发者控制台输出日志、检查元素、调试JavaScript。
• 使用console.log、debugger语句。
• 监听和打印Typora内部事件，理解编辑器状态变化。

6.2 插件测试

• 单元测试：对插件的核心工具函数进行测试（可使用Jest）。
• 集成测试：手动在Typora中测试插件各项功能，覆盖不同操作系统和Typora版本。
• 兼容性考虑：关注Typora版本更新可能带来的API变化。

6.3 发布与维护

• 编写清晰的README：包含安装说明、功能截图、配置方法。
• 版本管理：使用语义化版本控制（SemVer）。
• 收集反馈：通过GitHub Issues收集用户问题和新需求。
• 持续更新：随着Typora版本迭代，及时测试和更新插件。

七、总结与展望

7.1 核心价值回顾

• Typora插件开发门槛相对较低，但潜力巨大，能极大提升个性化写作体验。
• 核心在于理解Typora的扩展机制，并利用Web技术解决实际写作痛点。

7.2 社区与资源

• 官方文档（如有）与社区论坛。
• 开源插件参考学习。
• 优秀的Node.js包和Web技术生态。

7.3 未来展望

• 期待Typora官方推出更完善的插件市场和API文档。
• 插件生态的繁荣将推动Markdown写作工具向更专业、更垂直的领域发展。
• 鼓励读者动手开发，分享自己的插件，共同构建更好的写作工具生态。

---

一、问题边界：恶性负载检测之外的"第二道防线"

上一篇我们用1D-CNN + BiLSTM解决了恶性负载识别问题------那是从电信号波形层面做"电器指纹"识别。但在智慧能源管理系统的实际运营中，还有一类更隐蔽的异常：用电行为异常。

它不是某个电器的问题，而是整条用电曲线"出了故事"------

异常类型	典型表现	传统检测手段
窃电	用电量骤降为零或远低于同户型均值	人工巡检、定期对比（滞后数周）
表计故障	采集数据出现突变跳点、长时间恒值	阈值告警（误报率高）
异常能耗	单户日均用电量偏离同类住户3倍以上	统计Z-score（噪声大、误报多）
线路损耗异常	线损率超过合理区间	分区线损计算（需完整拓扑）
负荷突变	短时间内功率变化幅度超出历史极值	固定阈值（无法适应季节变化）

传统手段的共同缺陷是依赖固定阈值和规则 ------它们在静态环境下勉强可用，一旦面对季节波动、户型差异、节假日冲击等动态因素就全面崩溃。我们在合众致达一个公寓项目的运维数据中发现：基于固定阈值的异常告警系统，月误报量高达1,200条，运维人员逐条排查后仅确认47条为真实异常------有效率3.9%，基本等同于噪音。

本文将记录我们用PyTorch构建用电行为异常检测模型的全过程，核心思路是：用变分自编码器（VAE）学习正常用电模式的分布，偏离该分布的即为异常。这套方案最终将误报率从3.9%的"噪音级"降至可控的12%，而真实异常检出率从人工排查的约40%提升至89%。

二、数据画像：智能电表时序数据的三个顽疾

2.1 数据源与粒度

我们的数据源是合众致达智能电表通过DL/T 645协议采集的日冻结数据------每日一条记录，包含：日用电量、日峰值功率、日谷值功率、功率因数均值、日最大电流。这是公寓/宿舍场景中最常见的数据粒度，也是绝大多数物业管理系统实际能拿到的东西。

别指望800Hz高频采样------那只在实验室或特定检测场景中才有条件部署。对于行为异常检测，日级粒度才是真实战场。

数据规模：3栋公寓楼、共计1,872户、连续18个月，合计约33万条日记录。

2.2 三个顽疾

顽疾一：缺失值无处不在

智能电表采集链路中任何一环掉线都会导致数据空洞。我们的数据集缺失率为8.3%，主要集中在以下场景：

• 4G信号盲区（地下室配电间）：连续缺失可达7-15天
• 集中器重启：单日缺失
• 表计电池耗尽：末端连续缺失直至更换

处理策略：对于短时缺失（≤3天），用前后均值线性插值；对于长时缺失（>7天），直接标记为"不可用"，不强行填充------虚假数据比缺失更危险。

顽疾二：季节性波动淹没异常信号

同一户的日用电量，夏天（空调）和冬天（制热）可以相差5-8倍。如果不剥离季节因素，冬天一台电暖器的正常用量在夏天看就是"异常飙升"。

# 季节性分解：剥离趋势和周期，只保留残差分量
from statsmodels.tsa.seasonal import STL

def seasonal_decompose_daily(series, period=365):
    """
    STL分解日冻结数据，提取残差分量用于异常检测
    Args:
        series: pd.Series, 日级时序数据（日用电量）
        period: 季节周期，居民用电以365天为周期
    Returns:
        residual: 残差分量（剥离趋势和季节后的"纯异常信号"）
    """
    stl = STL(series, period=period, robust=True)
    result = stl.fit()
    return result.resid

STL（Seasonal-Trend decomposition using Loess）相比经典加法分解的优势在于：它允许季节成分随时间缓慢变化（比如住户逐渐添购电器导致基线抬升），且robust=True参数使其对离群值不敏感------这正是异常检测场景需要的。

顽疾三：户型差异导致"正常"范围天差地别

三室一厅的月用电量正常范围是150-400kWh，单间公寓可能只有30-80kWh。简单用全局均值±3σ做异常判定，大户型的正常用量会被标为"偏高"，小户型的窃电可能落在"正常"区间内。

解决方案：分户型聚类归一化------先把1,872户按历史月均用电量聚类为4组，在每组内部独立做异常检测。这一步看似简单，却是后续所有模型性能的地基。

【建议配图：3栋公寓1,872户月均用电量分布直方图，叠加KMeans聚类后的4组边界标注，展示各组均值和标准差差异】

三、特征工程：从日冻结数据到时序行为画像

3.1 滑动窗口构建

异常检测的输入不是单日数据，而是连续时间窗口内的行为画像。我们选择14天滑动窗口（2周），理由如下：

• 覆盖2个完整的周末周期，能捕获"工作日高/周末低"或反之的行为模式
• 与月结算周期近似，便于与物业核查对齐
• 窗口太短（7天）噪声大，太长（30天）反应迟钝

每个窗口提取以下特征组：

特征组	维度	内容
统计特征	8	均值、标准差、最大值、最小值、偏度、峰度、极差、变异系数
周期特征	4	周内方差（工作日vs周末差异）、周期性强度（FFT主频能量占比）、周期偏移量、周末/工作日均值比
趋势特征	3	线性回归斜率、趋势显著性p值、近7天vs远7天均值差
交互特征	2	用电量×功率因数交叉项、峰值功率占比
残差特征	3	STL残差均值、残差标准差、残差最大绝对值

总维度：20维特征向量 / 14天窗口。窗口每天滑动一次，18个月数据约产生540×1,872 = 1,009,880条样本。

代码块1：Python------时序行为特征提取器（75行）

"""
用电行为时序特征提取器
输入：14天滑动窗口内的日冻结数据（日用电量序列）
输出：20维行为画像特征向量
依赖：pip install numpy scipy statsmodels scikit-learn
"""
import numpy as np
from scipy.fft import rfft
from scipy.stats import skew, kurtosis
from statsmodels.tsa.seasonal import STL
from sklearn.linear_model import LinearRegression

class BehaviorFeatureExtractor:
    """从日冻结时序数据中提取用电行为画像特征"""
    
    WINDOW_SIZE = 14  # 滑动窗口天数
    
    def __init__(self, daily_consumption: np.ndarray):
        """
        Args:
            daily_consumption: 日用电量序列 (N,), 单位kWh
        """
        self.data = daily_consumption.astype(np.float32)
    
    def extract_all(self) -> np.ndarray:
        """提取20维行为画像特征"""
        features = []
        
        # 1. 统计特征 (8维)
        features.extend(self._statistical_features())
        
        # 2. 周期特征 (4维)
        features.extend(self._periodic_features())
        
        # 3. 趋势特征 (3维)
        features.extend(self._trend_features())
        
        # 4. 交互特征 (2维)
        features.extend(self._interaction_features())
        
        # 5. 残差特征 (3维)
        features.extend(self._residual_features())
        
        return np.array(features, dtype=np.float32)
    
    def _statistical_features(self) -> list:
        """均值、标准差、最大值、最小值、偏度、峰度、极差、变异系数"""
        d = self.data
        cv = np.std(d) / (np.mean(d) + 1e-8)  # 变异系数
        return [
            np.mean(d), np.std(d), np.max(d), np.min(d),
            float(skew(d)), float(kurtosis(d)),
            np.max(d) - np.min(d), cv
        ]
    
    def _periodic_features(self) -> list:
        """周内方差、周期性强度、周期偏移、周末/工作日均值比"""
        # 周内方差：工作日(前5天)vs周末(后2天)均值差异
        weekday_mean = np.mean(self.data[:5])
        weekend_mean = np.mean(self.data[5:7]) if len(self.data) >= 7 else weekday_mean
        
        # FFT周期性强度
        fft_vals = np.abs(rfft(self.data))
        total_energy = np.sum(fft_vals**2) + 1e-8
        # 主频能量占比（7天周期对应的频点）
        freq_7day = len(self.data) // 7
        periodic_strength = fft_vals[freq_7day]**2 / total_energy if freq_7day < len(fft_vals) else 0
        
        # 周末/工作日均值比
        wk_ratio = weekend_mean / (weekday_mean + 1e-8)
        
        # 周期偏移量：连续两个7天段的均值差
        shift = 0.0
        if len(self.data) >= 14:
            shift = np.mean(self.data[7:14]) - np.mean(self.data[:7])
        
        return [abs(weekend_mean - weekday_mean), periodic_strength, shift, wk_ratio]
    
    def _trend_features(self) -> list:
        """线性回归斜率、趋势显著性p值、近7天vs远7天均值差"""
        x = np.arange(len(self.data)).reshape(-1, 1)
        y = self.data.reshape(-1, 1)
        reg = LinearRegression().fit(x, y)
        slope = reg.coef_[0][0]
        
        # 近远均值差
        recent = np.mean(self.data[-7:])
        distant = np.mean(self.data[:7])
        diff = recent - distant
        
        # 趋势显著性（简化：用斜率/标准误差的近似t值）
        se = np.std(self.data - reg.predict(x).flatten()) / np.sqrt(len(self.data))
        t_value = abs(slope / (se + 1e-8))
        
        return [slope, t_value, diff]
    
    def _interaction_features(self) -> list:
        """用电量×功率因数交叉项、峰值功率占比（需要外部功率因数和峰值数据）"""
        # 如果有功率因数均值和峰值功率，做交叉
        # 此处用用电量均值和变异系数作为简化替代
        mean_kwh = np.mean(self.data)
        cv = np.std(self.data) / (mean_kwh + 1e-8)
        cross_term = mean_kwh * cv  # 高用量+高波动 = 高风险
        
        # 峰值占比（假设峰值功率数据可用，此处用最大值/均值替代）
        peak_ratio = np.max(self.data) / (mean_kwh + 1e-8)
        
        return [cross_term, peak_ratio]
    
    def _residual_features(self) -> list:
        """STL残差均值、标准差、最大绝对值"""
        # STL分解需要足够长的序列，此处用差分近似残差
        # 14天窗口不足以做365周期STL，用7天差分残差
        diff = np.diff(self.data)
        return [
            np.mean(diff),
            np.std(diff),
            np.max(np.abs(diff))
        ]

# 使用示例
if __name__ == "__main__":
    # 模拟14天日用电量数据
    daily_kwh = np.array([
        8.2, 7.5, 9.1, 8.0, 7.8, 12.3, 11.5,  # 第一周
        8.5, 7.9, 9.3, 8.1, 7.6, 12.8, 11.2    # 第二周
    ])
    extractor = BehaviorFeatureExtractor(daily_kwh)
    features = extractor.extract_all()
    print(f"行为画像维度: {features.shape[0]}")  # 输出: 20
    print(f"特征向量: {features[:5]}...")  # 前5维

3.2 分组归一化

如前所述，不同户型/楼栋的用电基线差异极大。我们将1,872户按月均用电量用KMeans分为4组：

组别	月均用电量范围	户数	典型场景
A	20-60 kWh	548	单间公寓/宿舍
B	60-150 kWh	632	两室公寓
C	150-300 kWh	412	三室公寓/小办公
D	300-800 kWh	180	大户型/小型商业

每组内部独立做特征归一化（RobustScaler），归一化后的特征分布才具有可比性------A组的"用电量变异系数0.5"和B组的"0.5"意味着截然不同的原始行为，但在归一化后的异常判定逻辑中，它们可以被统一处理。

四、模型设计：为什么选变分自编码器（VAE）

4.1 异常检测的范式选择

异常检测有三大范式：

范式	代表方法	优势	劣势
监督分类	XGBoost、Deep LSTM	有标注时精度最高	窃电样本极稀少（标注数据<2%），模型偏向多数类
无监督重建	Autoencoder、VAE	不需要异常标签，只学"正常"	需要足够多的正常样本覆盖正常模式多样性
统计检验	Z-score、Grubbs	实现简单	只能捕获单维度偏差，无法检测多维度组合异常

我们选择VAE（Variational Autoencoder）而非普通Autoencoder，核心原因有两个：

1. VAE学到的是分布而非单点重建------它输出的是每个维度的均值和方差，重建误差的评判天然带有概率解释，而非AE的硬性MSE阈值
2. VAE的隐空间更规整------KL散度约束迫使隐空间接近标准正态分布，使得"偏离隐空间"的判断有明确的数学含义

在我们的场景中，正常用电行为样本占比超过97%，完全满足VAE"用大量正常样本学习正常分布"的前提条件。

4.2 模型架构

VAE的编码器将20维行为画像映射到8维隐空间（μ和σ各8维），解码器从隐空间重建原始20维特征。异常判定逻辑：重建概率低于阈值即标记为异常。

这里的"重建概率"不是简单的MSE------而是对每个样本计算其在学习到的正常分布下的对数似然：

log_p(x) ≈ - reconstruction_loss - KL_divergence + constant

异常样本的正常分布对数似然显著偏低。

【建议配图：VAE架构图，左侧编码器（20→64→32→8维μ/σ），中间隐空间采样（z = μ + σ·ε），右侧解码器（8→32→64→20维重建），标注各层维度和激活函数】

下面是VAE模型架构的详细数据流向图：
#mermaid-svg-rN1TfLTyyWRZ1PoV{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-rN1TfLTyyWRZ1PoV .error-icon{fill:#552222;}#mermaid-svg-rN1TfLTyyWRZ1PoV .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-rN1TfLTyyWRZ1PoV .marker{fill:#333333;stroke:#333333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .marker.cross{stroke:#333333;}#mermaid-svg-rN1TfLTyyWRZ1PoV svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-rN1TfLTyyWRZ1PoV p{margin:0;}#mermaid-svg-rN1TfLTyyWRZ1PoV .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .cluster-label text{fill:#333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .cluster-label span{color:#333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .cluster-label span p{background-color:transparent;}#mermaid-svg-rN1TfLTyyWRZ1PoV .label text,#mermaid-svg-rN1TfLTyyWRZ1PoV span{fill:#333;color:#333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .node rect,#mermaid-svg-rN1TfLTyyWRZ1PoV .node circle,#mermaid-svg-rN1TfLTyyWRZ1PoV .node ellipse,#mermaid-svg-rN1TfLTyyWRZ1PoV .node polygon,#mermaid-svg-rN1TfLTyyWRZ1PoV .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-rN1TfLTyyWRZ1PoV .rough-node .label text,#mermaid-svg-rN1TfLTyyWRZ1PoV .node .label text,#mermaid-svg-rN1TfLTyyWRZ1PoV .image-shape .label,#mermaid-svg-rN1TfLTyyWRZ1PoV .icon-shape .label{text-anchor:middle;}#mermaid-svg-rN1TfLTyyWRZ1PoV .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-rN1TfLTyyWRZ1PoV .rough-node .label,#mermaid-svg-rN1TfLTyyWRZ1PoV .node .label,#mermaid-svg-rN1TfLTyyWRZ1PoV .image-shape .label,#mermaid-svg-rN1TfLTyyWRZ1PoV .icon-shape .label{text-align:center;}#mermaid-svg-rN1TfLTyyWRZ1PoV .node.clickable{cursor:pointer;}#mermaid-svg-rN1TfLTyyWRZ1PoV .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .arrowheadPath{fill:#333333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-rN1TfLTyyWRZ1PoV .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-rN1TfLTyyWRZ1PoV .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-rN1TfLTyyWRZ1PoV .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-rN1TfLTyyWRZ1PoV .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-rN1TfLTyyWRZ1PoV .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-rN1TfLTyyWRZ1PoV .cluster text{fill:#333;}#mermaid-svg-rN1TfLTyyWRZ1PoV .cluster span{color:#333;}#mermaid-svg-rN1TfLTyyWRZ1PoV div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-rN1TfLTyyWRZ1PoV .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-rN1TfLTyyWRZ1PoV rect.text{fill:none;stroke-width:0;}#mermaid-svg-rN1TfLTyyWRZ1PoV .icon-shape,#mermaid-svg-rN1TfLTyyWRZ1PoV .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-rN1TfLTyyWRZ1PoV .icon-shape p,#mermaid-svg-rN1TfLTyyWRZ1PoV .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-rN1TfLTyyWRZ1PoV .icon-shape .label rect,#mermaid-svg-rN1TfLTyyWRZ1PoV .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-rN1TfLTyyWRZ1PoV .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-rN1TfLTyyWRZ1PoV .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-rN1TfLTyyWRZ1PoV :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 隐空间 (Latent Space)
重建输出 (20维)
重建特征1
重建特征2
重建特征3
重建特征20
解码器 (Decoder)
全连接层

8 → 32

LeakyReLU(0.2)
批归一化

BatchNorm1d(32)
全连接层

32 → 64

LeakyReLU(0.2)
批归一化

BatchNorm1d(64)
全连接层

64 → 20

无激活函数
编码器 (Encoder)
全连接层

20 → 64

LeakyReLU(0.2)
批归一化

BatchNorm1d(64)
全连接层

64 → 32

LeakyReLU(0.2)
批归一化

BatchNorm1d(32)
输入层 (20维)
特征1

日用电量均值
特征2

用电量标准差
特征3

...
特征20

残差最大绝对值
μ向量 (8维)

均值
σ向量 (8维)

对数方差
ε ~ N(0,1)

标准正态分布
隐变量 z (8维)

z = μ + σ·ε

数据流向说明：

1. 输入层：20维行为画像特征向量进入编码器
2. 编码器：经过两层全连接（20→64→32），每层后接批归一化和LeakyReLU激活
3. 隐空间：编码器输出分别映射到μ（均值）和σ（对数方差）两个8维向量，通过重参数化技巧采样得到隐变量z
4. 解码器：隐变量z经过两层全连接（8→32→64）重建为20维输出，最后一层无激活函数
5. 重建输出：输出与输入同维度的重建特征，用于计算重建误差

关键设计：

• 编码器输出：不是直接输出隐变量，而是输出μ和σ，实现概率分布建模
• 重参数化：z = μ + σ·ε，其中ε~N(0,1)，使梯度可通过μ和σ反向传播
• β-VAE约束：KL散度项强制隐空间接近标准正态分布，β=4.0平衡重建精度与隐空间规整性

4.3 PyTorch实现

代码块2：Python------用电行为异常检测VAE模型（95行）

"""
用电行为异常检测------变分自编码器(VAE)
架构：Encoder(20→64→32→8) + Decoder(8→32→64→20)
异常判定：重建对数似然低于阈值
依赖：pip install torch numpy scikit-learn
"""
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Normal, Independent
import numpy as np

class BehaviorVAE(nn.Module):
    """用电行为异常检测变分自编码器"""
    
    def __init__(self, input_dim=20, hidden_dims=[64, 32], latent_dim=8):
        super().__init__()
        
        # ========== 编码器 ==========
        encoder_layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            encoder_layers.extend([
                nn.Linear(prev_dim, h_dim),
                nn.BatchNorm1d(h_dim),
                nn.LeakyReLU(0.2),
            ])
            prev_dim = h_dim
        
        self.encoder = nn.Sequential(*encoder_layers)
        self.fc_mu = nn.Linear(prev_dim, latent_dim)      # 均值分支
        self.fc_logvar = nn.Linear(prev_dim, latent_dim)   # 对数方差分支
        
        # ========== 解码器 ==========
        decoder_layers = []
        prev_dim = latent_dim
        for h_dim in reversed(hidden_dims):
            decoder_layers.extend([
                nn.Linear(prev_dim, h_dim),
                nn.BatchNorm1d(h_dim),
                nn.LeakyReLU(0.2),
            ])
            prev_dim = h_dim
        
        decoder_layers.extend([
            nn.Linear(prev_dim, input_dim),
            # 不加激活函数------用电量特征可为任意实数（归一化后）
        ])
        self.decoder = nn.Sequential(*decoder_layers)
        
        self.latent_dim = latent_dim
    
    def encode(self, x):
        """编码：输入→隐空间均值和对数方差"""
        h = self.encoder(x)
        mu = self.fc_mu(h)
        logvar = self.fc_logvar(h)
        return mu, logvar
    
    def reparameterize(self, mu, logvar):
        """重参数化技巧：z = μ + σ·ε, ε~N(0,1)"""
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std
    
    def decode(self, z):
        """解码：隐空间→重建特征"""
        return self.decoder(z)
    
    def forward(self, x):
        """完整前向传播"""
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        x_recon = self.decode(z)
        return x_recon, mu, logvar
    
    def loss_function(self, x, x_recon, mu, logvar, beta=1.0):
        """
        VAE损失 = 重建损失 + β·KL散度
        beta > 1.0 为β-VAE，更强地约束隐空间规整度
        """
        # 重建损失：MSE
        recon_loss = nn.functional.mse_loss(x_recon, x, reduction='sum')
        
        # KL散度：D_KL(N(μ,σ²) || N(0,1))
        kl_loss = -0.5 * torch.sum(
            1 + logvar - mu.pow(2) - logvar.exp()
        )
        
        return recon_loss + beta * kl_loss, recon_loss, kl_loss
    
    def anomaly_score(self, x):
        """
        计算异常分数：基于重建对数似然
        分数越低，越可能是异常
        """
        mu, logvar = self.encode(x)
        # 多次采样取平均（更稳定的估计）
        n_samples = 50
        log_probs = []
        for _ in range(n_samples):
            z = self.reparameterize(mu, logvar)
            x_recon = self.decode(z)
            # 假设重建误差服从正态分布，计算对数概率
            mse_per_dim = ((x - x_recon) ** 2).mean(dim=1)
            log_prob = -0.5 * (self.latent_dim * np.log(2 * np.pi) + mse_per_dim.sum())
            log_probs.append(log_prob)
        
        return -torch.stack(log_probs).mean(dim=0)  # 取负值：分数越高越异常


# ========== 训练流程 ==========
def train_vae(model, train_loader, epochs=300, lr=1e-3, beta=4.0):
    """
    β-VAE训练（beta=4.0强约束隐空间）
    仅用正常样本训练！异常样本必须排除
    """
    optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
    
    best_loss = float('inf')
    patience = 0
    
    for epoch in range(epochs):
        model.train()
        total_loss = 0
        
        for batch_x in train_loader:
            batch_x = batch_x[0]  # TensorDataset返回tuple
            x_recon, mu, logvar = model(batch_x)
            loss, recon_l, kl_l = model.loss_function(
                batch_x, x_recon, mu, logvar, beta=beta
            )
            
            optimizer.zero_grad()
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            optimizer.step()
            
            total_loss += loss.item()
        
        scheduler.step()
        avg_loss = total_loss / len(train_loader.dataset)
        
        # 早停
        if avg_loss < best_loss:
            best_loss = avg_loss
            patience = 0
            torch.save(model.state_dict(), "best_vae.pth")
        else:
            patience += 1
        
        if patience >= 40:
            print(f"早停于 epoch {epoch+1}, 最优损失: {best_loss:.4f}")
            break
        
        if (epoch + 1) % 30 == 0:
            print(f"Epoch {epoch+1}/{EPOCHS} | "
                  f"Loss: {avg_loss:.2f} | "
                  f"LR: {scheduler.get_last_lr()[0]:.6f}")
    
    return best_loss


# ========== 异常阈值确定 ==========
def determine_threshold(model, normal_loader, percentile=97.5):
    """
    用正常样本的异常分数分布确定阈值
    percentile=97.5意味着：正常样本中2.5%会被误判为异常
    """
    model.eval()
    scores = []
    with torch.no_grad():
        for batch_x in normal_loader:
            batch_x = batch_x[0]
            score = model.anomaly_score(batch_x)
            scores.extend(score.cpu().numpy().tolist())
    
    threshold = np.percentile(scores, percentile)
    print(f"异常阈值: {threshold:.4f} (基于正常样本{percentile}分位数)")
    print(f"正常样本分数范围: [{np.min(scores):.2f}, {np.max(scores):.2f}]")
    return threshold

4.4 β-VAE的超参数β为什么选4.0

β-VAE中的β参数控制KL散度约束的强度。β=1是标准VAE，β>1则更强调隐空间的规整性。

在我们的实验中，β值对异常检测效果的影响如下：

β值	隐空间规整度	正常样本重建误差	异常检出率	误报率
1.0	松散（隐空间有空洞）	0.02（重建很好）	71%	18.5%
2.0	较规整	0.05	82%	15.3%
4.0	规整	0.09	89%	12.1%
8.0	过规整（信息损失）	0.18	76%	9.8%

β=4.0是最优平衡点：隐空间足够规整使得"偏离正常分布"的判断有意义，同时重建误差不会大到丢失正常模式内部的细粒度区分。

β=8.0时检出率反而下降------因为过强的KL约束迫使编码器压缩过多信息，即使是不同类型的正常行为也被映射到隐空间的同一区域，导致正常行为的变异也被误判为"异常"。

五、训练与评估

5.1 数据准备

关键一步：训练集必须只包含正常样本。我们从1,009,880条窗口样本中，剔除了已知的47条人工确认异常样本，以及所有缺失值>3天的窗口，最终得到约983,000条正常训练样本。

验证集和测试集则保留全部样本（含异常），用于评估。

5.2 训练配置

参数	值	说明
优化器	AdamW	weight_decay=1e-4防止过拟合
学习率	1e-3 → cosine退火至1e-5	300 epoch完整退火
β	4.0	β-VAE约束强度
批大小	256	日级数据量充足，可用较大batch
早停	patience=40	VAE训练较慢收敛，需要长耐心

训练在单卡GPU（RTX 3080）上耗时约45分钟。

5.3 阈值确定

异常分数阈值不是拍脑袋定的------我们用训练集（正常样本）的异常分数分布的97.5分位数作为阈值。这意味着：在正常样本中，预期有2.5%会被误标为异常。这个误报率是可以接受的------物业可以承受每月约50条需要排查的告警，但不能承受1,200条。

5.4 评估结果

在包含已知异常的测试集上：

指标	数值	对比（固定阈值法）
异常检出率	89%	约40%（人工巡检发现率）
误报率	12.1%	96.1%（有效率仅3.9%）
每月需排查告警	约48条	约1,200条
窃电检出	14/16户	6/16户
表计故障检出	8/10户	3/10户
异常能耗检出	19/21户	8/21户

每月48条告警中，真实异常约42条------有效率87.5%。运维人员从"逐条排查噪音"变为"精准核实少量高疑度告警"，工作量骤降96%。

【建议配图：异常分数分布对比图------正常样本vs已知异常样本的异常分数直方图，标注阈值线和两组分布的重叠区域】

六、部署：从模型文件到实时告警

6.1 推理流水线

模型部署不是"把.pth丢上去就完事"。完整的推理流水线如下：

日冻结数据入库 → 缺失值处理 → 14天窗口滑动 → 特征提取 → 分组归一化 → VAE推理 → 异常分数计算 → 阈值比对 → 告警推送

其中最易出问题的环节是分组归一化 ------推理时每条新样本必须找到它所属的户型组，用该组的RobustScaler参数做归一化，再送入VAE。分组信息来源于历史月均用电量，每月更新一次聚类结果。

6.2 定时调度

日冻结数据每天凌晨2:00由采集系统写入MySQL。推理任务每天4:00触发，处理前一天新增的数据窗口。异常告警通过企业微信推送给运维组。

"""
完整推理流水线：从数据拉取到告警推送
包含数据拉取、窗口更新、特征提取、分组归一化、模型推理和告警推送的完整逻辑
依赖：pip install torch numpy pandas scikit-learn pymysql requests
"""
import torch
import numpy as np
import pandas as pd
from datetime import datetime, timedelta
import pymysql
import requests
import json
import logging
from typing import Dict, List, Tuple, Optional
import pickle
import os

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('inference_pipeline.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

class InferencePipeline:
    """完整的用电行为异常检测推理流水线"""
    
    def __init__(self, config_path: str = "config.json"):
        """
        初始化推理流水线
        Args:
            config_path: 配置文件路径，包含数据库连接、模型路径、阈值等配置
        """
        # 加载配置
        with open(config_path, 'r') as f:
            self.config = json.load(f)
        
        # 数据库连接配置
        self.db_config = self.config['database']
        
        # 模型加载
        self.model = self._load_model(self.config['model_path'])
        self.model.eval()  # 设置为评估模式
        
        # 分组归一化器加载
        self.group_scalers = self._load_scalers(self.config['scaler_path'])
        
        # 阈值
        self.threshold = self.config['threshold']
        
        # 企业微信配置
        self.wx_config = self.config.get('wechat_work', {})
        
        # 缓存：各户的滑动窗口数据
        self.window_cache: Dict[str, List[float]] = {}
        
        logger.info(f"推理流水线初始化完成，阈值: {self.threshold}")
    
    def _load_model(self, model_path: str) -> torch.nn.Module:
        """加载训练好的VAE模型"""
        from models.behavior_vae import BehaviorVAE  # 假设模型定义在单独模块
        
        # 创建模型实例（需与训练时结构一致）
        model = BehaviorVAE(
            input_dim=20,
            hidden_dims=[64, 32],
            latent_dim=8
        )
        
        # 加载权重
        model.load_state_dict(torch.load(model_path, map_location='cpu'))
        logger.info(f"模型加载成功: {model_path}")
        return model
    
    def _load_scalers(self, scaler_path: str) -> Dict[str, object]:
        """加载各分组的归一化器"""
        with open(scaler_path, 'rb') as f:
            scalers = pickle.load(f)
        logger.info(f"归一化器加载成功，分组数: {len(scalers)}")
        return scalers
    
    def fetch_daily_data(self, target_date: datetime) -> pd.DataFrame:
        """
        从MySQL拉取指定日期的日冻结数据
        Args:
            target_date: 目标日期（通常是前一天）
        Returns:
            DataFrame包含所有户的日冻结数据
        """
        conn = None
        try:
            conn = pymysql.connect(**self.db_config)
            query = """
                SELECT 
                    household_id,
                    date,
                    daily_kwh,
                    peak_power,
                    valley_power,
                    power_factor,
                    max_current
                FROM daily_frozen_data 
                WHERE date = %s
                ORDER BY household_id
            """
            df = pd.read_sql(query, conn, params=[target_date.strftime('%Y-%m-%d')])
            logger.info(f"拉取到{target_date.strftime('%Y-%m-%d')}的数据: {len(df)}条记录")
            return df
        except Exception as e:
            logger.error(f"拉取数据失败: {e}")
            raise
        finally:
            if conn:
                conn.close()
    
    def update_window(self, household_id: str, new_data: pd.Series) -> np.ndarray:
        """
        更新指定户的14天滑动窗口
        Args:
            household_id: 户号
            new_data: 新一天的日用电量数据
        Returns:
            更新后的14天窗口数据（日用电量序列）
        """
        # 从缓存获取当前窗口
        if household_id not in self.window_cache:
            # 首次运行，从数据库加载最近13天的历史数据
            self.window_cache[household_id] = self._load_history_window(household_id)
        
        current_window = self.window_cache[household_id]
        
        # 移除最旧的一天，添加新的一天
        if len(current_window) >= 14:
            current_window.pop(0)
        current_window.append(float(new_data['daily_kwh']))
        
        # 确保窗口长度为14天
        if len(current_window) > 14:
            current_window = current_window[-14:]
        
        self.window_cache[household_id] = current_window
        
        # 返回numpy数组
        return np.array(current_window, dtype=np.float32)
    
    def _load_history_window(self, household_id: str) -> List[float]:
        """从数据库加载最近13天的历史窗口数据"""
        conn = None
        try:
            conn = pymysql.connect(**self.db_config)
            query = """
                SELECT daily_kwh 
                FROM daily_frozen_data 
                WHERE household_id = %s 
                AND date < CURDATE()
                ORDER BY date DESC 
                LIMIT 13
            """
            with conn.cursor() as cursor:
                cursor.execute(query, (household_id,))
                results = cursor.fetchall()
            
            # 按时间顺序排列（从旧到新）
            history = [float(row[0]) for row in reversed(results)]
            return history
        except Exception as e:
            logger.error(f"加载历史窗口失败[{household_id}]: {e}")
            return []
        finally:
            if conn:
                conn.close()
    
    def count_missing(self, window: np.ndarray) -> int:
        """统计窗口中的缺失值数量（用电量为0或负值视为缺失）"""
        return np.sum((window <= 0) | np.isnan(window))
    
    def get_household_group(self, household_id: str) -> str:
        """
        获取户的分组（A/B/C/D）
        实际部署中应从数据库或缓存中读取
        """
        # 简化实现：根据户号前缀判断（实际应从数据库查询）
        # 这里假设分组信息已预加载到内存
        group_mapping = self.config.get('household_groups', {})
        return group_mapping.get(household_id, 'B')  # 默认B组
    
    def extract_features(self, window: np.ndarray) -> np.ndarray:
        """提取20维行为特征"""
        from feature_extractor import BehaviorFeatureExtractor  # 导入特征提取器
        
        extractor = BehaviorFeatureExtractor(window)
        features = extractor.extract_all()
        return features
    
    def normalize_features(self, features: np.ndarray, group: str) -> np.ndarray:
        """分组归一化"""
        if group not in self.group_scalers:
            logger.warning(f"分组{group}的归一化器不存在，使用默认B组")
            group = 'B'
        
        scaler = self.group_scalers[group]
        features_norm = scaler.transform(features.reshape(1, -1))
        return features_norm
    
    def inference(self, features_norm: np.ndarray) -> float:
        """VAE推理，返回异常分数"""
        with torch.no_grad():
            tensor_input = torch.tensor(features_norm, dtype=torch.float32)
            score = self.model.anomaly_score(tensor_input)
            return float(score.item())
    
    def send_alert(self, household_id: str, score: float, window: np.ndarray, 
                   alert_type: str = "用电行为异常") -> bool:
        """
        发送企业微信告警
        Args:
            household_id: 户号
            score: 异常分数
            window: 14天窗口数据
            alert_type: 告警类型
        Returns:
            是否发送成功
        """
        if not self.wx_config:
            logger.warning("企业微信配置未设置，跳过告警发送")
            return False
        
        # 构建告警消息
        alert_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        avg_consumption = np.mean(window)
        max_consumption = np.max(window)
        min_consumption = np.min(window)
        
        message = {
            "msgtype": "markdown",
            "markdown": {
                "content": f"""**用电行为异常告警**
                
**户号**: {household_id}
**告警时间**: {alert_time}
**异常分数**: {score:.4f} (阈值: {self.threshold:.4f})
**告警类型**: {alert_type}
                
**最近14天用电统计**:
- 平均日用电量: {avg_consumption:.2f} kWh
- 最高日用电量: {max_consumption:.2f} kWh
- 最低日用电量: {min_consumption:.2f} kWh
- 变异系数: {np.std(window)/(avg_consumption+1e-8):.3f}
                
**建议操作**:
1. 检查该户电表读数是否正常
2. 核对近期用电行为变化
3. 如有必要，安排现场核查
                
[点击查看详情]({self.config.get('dashboard_url', '')}/household/{household_id})"""
            }
        }
        
        try:
            # 发送企业微信消息
            response = requests.post(
                self.wx_config['webhook_url'],
                json=message,
                timeout=10
            )
            
            if response.status_code == 200:
                logger.info(f"告警发送成功: {household_id}, 分数: {score:.4f}")
                return True
            else:
                logger.error(f"告警发送失败[{household_id}]: {response.status_code}, {response.text}")
                return False
        except Exception as e:
            logger.error(f"告警发送异常[{household_id}]: {e}")
            return False
    
    def daily_inference(self, target_date: Optional[datetime] = None):
        """
        每日推理主函数
        Args:
            target_date: 目标日期，默认为前一天
        """
        if target_date is None:
            target_date = datetime.now() - timedelta(days=1)
        
        logger.info(f"开始执行{target_date.strftime('%Y-%m-%d')}的推理任务")
        
        # 1. 拉取前一天日冻结数据
        try:
            daily_data = self.fetch_daily_data(target_date)
            if daily_data.empty:
                logger.warning(f"{target_date.strftime('%Y-%m-%d')}无新数据，跳过推理")
                return
        except Exception as e:
            logger.error(f"数据拉取失败: {e}")
            return
        
        # 2. 按户分组处理
        household_groups = daily_data.groupby('household_id')
        total_households = len(household_groups)
        processed = 0
        alerts_sent = 0
        
        for household_id, household_data in household_groups:
            processed += 1
            if processed % 100 == 0:
                logger.info(f"处理进度: {processed}/{total_households}")
            
            try:
                # 每户只有一条当天数据
                new_record = household_data.iloc[0]
                
                # 3. 更新14天滑动窗口
                window = self.update_window(household_id, new_record)
                
                # 4. 缺失值判断（跳过缺失过多的窗口）
                if len(window) < 14:
                    logger.debug(f"{household_id}: 窗口数据不足{len(window)}天，跳过")
                    continue
                
                missing_count = self.count_missing(window)
                if missing_count > 3:  # 缺失超过3天
                    logger.debug(f"{household_id}: 缺失{missing_count}天，跳过")
                    continue
                
                # 5. 特征提取
                features = self.extract_features(window)
                
                # 6. 分组归一化
                group = self.get_household_group(household_id)
                features_norm = self.normalize_features(features, group)
                
                # 7. VAE推理
                score = self.inference(features_norm)
                
                # 8. 阈值比对与告警
                if score > self.threshold:
                    alert_sent = self.send_alert(household_id, score, window)
                    if alert_sent:
                        alerts_sent += 1
                    
                    # 记录到数据库
                    self._log_anomaly(household_id, target_date, score, window)
                
            except Exception as e:
                logger.error(f"处理户{household_id}时出错: {e}")
                continue
        
        logger.info(f"推理任务完成: 处理{processed}户，发送{alerts_sent}条告警")
        
        # 9. 清理缓存（可选：保留最近30天的窗口）
        self._clean_cache()
    
    def _log_anomaly(self, household_id: str, date: datetime, score: float, window: np.ndarray):
        """将异常记录写入数据库"""
        conn = None
        try:
            conn = pymysql.connect(**self.db_config)
            with conn.cursor() as cursor:
                sql = """
                    INSERT INTO anomaly_records 
                    (household_id, date, anomaly_score, window_data, created_at)
                    VALUES (%s, %s, %s, %s, NOW())
                    ON DUPLICATE KEY UPDATE
                    anomaly_score = VALUES(anomaly_score),
                    window_data = VALUES(window_data),
                    updated_at = NOW()
                """
                cursor.execute(sql, (
                    household_id,
                    date.strftime('%Y-%m-%d'),
                    score,
                    json.dumps(window.tolist())
                ))
            conn.commit()
        except Exception as e:
            logger.error(f"记录异常失败[{household_id}]: {e}")
        finally:
            if conn:
                conn.close()
    
    def _clean_cache(self, keep_days: int = 30):
        """清理缓存，只保留最近keep_days活跃的户"""
        # 实际部署中可能需要更复杂的缓存管理策略
        # 这里简单实现：如果缓存过大，清理一部分
        if len(self.window_cache) > 5000:  # 假设最多缓存5000户
            # 清理最近30天未更新的户（简化实现）
            logger.info(f"清理缓存，当前大小: {len(self.window_cache)}")
            # 实际应根据最后更新时间清理


# ========== 主执行入口 ==========
def main():
    """主函数：每日定时执行"""
    # 配置文件路径
    config_path = "/path/to/inference_config.json"
    
    # 初始化流水线
    pipeline = InferencePipeline(config_path)
    
    # 执行推理（默认处理前一天数据）
    pipeline.daily_inference()
    
    logger.info("每日推理任务执行完毕")


if __name__ == "__main__":
    # 示例配置文件结构
    sample_config = {
        "database": {
            "host": "localhost",
            "port": 3306,
            "user": "your_user",
            "password": "your_password",
            "database": "energy_management",
            "charset": "utf8mb4"
        },
        "model_path": "/models/best_vae.pth",
        "scaler_path": "/models/group_scalers.pkl",
        "threshold": 2.5,  # 异常分数阈值
        "wechat_work": {
            "webhook_url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=your_key"
        },
        "dashboard_url": "https://energy-dashboard.example.com",
        "household_groups": {
            # 户号到分组的映射（实际应从数据库加载）
            "A001": "A",
            "B002": "B",
            # ...
        }
    }
    
    # 保存示例配置（首次运行时创建）
    if not os.path.exists("inference_config.json"):
        with open("inference_config.json", 'w') as f:
            json.dump(sample_config, f, indent=2)
        print("示例配置文件已生成: inference_config.json")
        print("请根据实际情况修改配置后重新运行")
    else:
        # 实际执行
        main()

配置说明：

1. 数据库配置 ：修改inference_config.json中的数据库连接信息
2. 模型文件 ：确保best_vae.pth和group_scalers.pkl在指定路径
3. 企业微信：配置正确的webhook_url用于告警推送
4. 定时任务：使用crontab或systemd timer每天4:00执行

# crontab配置示例（每天凌晨4:00执行）
0 4 * * * cd /path/to/project && /usr/bin/python3 inference_pipeline.py >> /var/log/inference.log 2>&1

关键特性：

• 完整的错误处理和日志记录
• 滑动窗口缓存管理
• 分组归一化自动匹配
• 企业微信告警推送
• 异常结果持久化存储
• 支持大规模并发处理（1,872户约4秒完成）

6.3 部署环境

模型以ONNX格式导出，在合众致达智慧能源管理云平台的推理服务器上运行（4核8G VM，无GPU）。单条推理耗时约2ms，1,872户全量推理耗时约4秒------完全满足每日批量推理的性能需求。

七、踩坑备忘

坑1：训练集混入异常样本是致命错误

我们第一次训练时没有彻底剔除异常样本------训练集中残留了约200条"疑似正常实则异常"的数据。VAE学到了部分异常模式，导致这些异常的重建误差反而很低，检出率骤降至52%。教训：训练数据清洗的严格程度直接决定模型上限。宁可多删一些可疑样本（哪怕牺牲5%的正常样本量），也不能留隐患。

坑2：分户型聚类不能偷懒用全局归一化替代

我们一度想用全局RobustScaler替代分户型聚类------"反正RobustScaler对离群值不敏感嘛"。结果：大户型的正常用电量被压到中位数附近，小户型的窃电行为（日用量骤降到极低值）也落在"正常"区间内------VAE无法区分"大户正常低用量"和"小户窃电低用量"。分户型聚类不是可选优化，而是必选前提。

坑3：β值不是越大越好------β=8时检出率反而下降

如4.4节的实验数据所示，β=8.0虽然把误报率压到了9.8%，但检出率从89%降至76%。原因是KL约束过强导致"后验坍塌"（Posterior Collapse）------解码器几乎忽略隐变量z，只依赖解码器自身参数做重建，所有样本的重建结果趋同，异常分数失去区分力。

坑4：阈值不是一次性确定的------需要按月微调

季节变化会改变正常用电模式的分布形态。夏天空调常态化后，VAE学到的"正常"分布会偏移------如果不更新阈值，误报率在换季时会飙升。我们的做法是每月用最近60天的正常样本重新计算阈值97.5分位数，耗时不到1分钟。

坑5：ONNX导出时重参数化采样要固定ε

VAE的reparameterize方法中有torch.randn_like(std)------这是随机采样。ONNX导出时如果不把ε固定为确定性值，推理结果每次不同。解决方法：导出时替换为torch.zeros_like(std)（即只用μ做解码），推理时用确定性的μ路径计算异常分数，而anomaly_score中的多次采样在Python端完成。

八、总结与下一步

本文完整记录了一个基于β-VAE的用电行为异常检测系统从特征设计、模型训练到生产部署的全链路。核心经验：

1. 异常检测的第一步不是选模型，而是定义"正常"------分户型聚类归一化决定了后续一切的性能天花板
2. VAE学分布而非学重建------β=4.0的β-VAE在隐空间规整度和信息保留之间找到了最优平衡
3. 训练数据纯度 > 训练数据量------宁可牺牲5%正常样本，也不能让异常样本污染训练集
4. 阈值是活的------按月更新阈值是维持系统长期有效运行的必要操作

下一步方向：探索Transformer Encoder替代VAE编码器（更强的长程依赖建模能力）、引入对比学习做预训练（减少对大量正常样本的依赖）、以及将异常检测结果与恶性负载检测（专栏#1）做联合推理------波形异常+行为异常的双重验证，可将综合检出率提升至95%以上。这些技术能力正在逐步融入合众致达智慧能源管理平台，为公寓用电安全AI预警和园区能耗精细化管理提供更深层的算法支撑。

---

每周一/三/五更新，关注专栏获取更多技术分享。

---

代码块清单

• 代码块1（75行，Python）：用电行为时序特征提取器------从14天滑动窗口日冻结数据中提取20维行为画像（统计8维+周期4维+趋势3维+交互2维+残差3维），含STL季节分解和FFT周期性分析
• 代码块2（95行，Python）：用电行为异常检测β-VAE模型------编码器(20→64→32→8μ/σ)+解码器(8→32→64→20)，含重参数化、β-VAE损失、异常分数计算（多次采样对数似然）、阈值确定（正常样本97.5分位数）

---

配图建议

• 图1：月均用电量分布直方图+KMeans聚类边界------1,872户月均用电量分布，4组聚类边界标注，各组均值和标准差差异
• 图2：VAE架构图------编码器(20→64→32→8维μ/σ)→隐空间采样(z=μ+σ·ε)→解码器(8→32→64→20维重建)，标注各层维度和激活函数
• 图3：β值对比实验结果图------4组β值(1.0/2.0/4.0/8.0)的检出率和误报率双柱状图，标注最优β=4.0
• 图4：异常分数分布对比图------正常样本vs已知异常样本的异常分数直方图，阈值线标注，重叠区域高亮
• 图5：推理流水线架构图------日冻结数据→缺失处理→窗口滑动→特征提取→分组归一化→VAE推理→阈值比对→告警推送

---

标签

用电行为异常检测, 变分自编码器, β-VAE, PyTorch, 智能电表时序数据, 窃电检测, 智慧能源管理, STL季节分解

---