海量数据集的AI自动化预测打标 -- 放电时序特征

放电时序特征ML Backend技术解析

概述:捕捉等离子体的"生命周期"

在等离子体放电实验中,从击穿、稳定运行到破裂结束,整个过程就像一场精心编排的"表演"------每个关键时刻都承载着重要的物理信息。击穿时刻 (等离子体形成)、破裂时刻 (失稳崩溃)、结束时刻(放电终止)是分析实验成败的三个黄金锚点。

放电时序特征ML Backend 就像一位自动化的时刻标记员,通过调用远程AI模型服务,自动识别这些关键时刻,将原本需要人工逐帧查看波形的工作缩短到秒级,为物理分析提供精准的时间基准。

---

一、业务价值:Why - 为什么需要自动化时刻标注?

1.1 科研场景痛点

场景1:实验数据分析

托卡马克装置每天产生几十次放电:

• 每次放电需要标注击穿、破裂、结束三个时刻
• 人工分析:查看等离子体电流、密度、温度等多个信号
• 需要专家经验判断,耗时5-10分钟/次
• 50次实验 × 8分钟 = 400分钟标注工作

场景2:破裂预警研究

研究等离子体破裂的前兆信号:

• 需要精确标注破裂发生时刻(精度±1ms)
• 手工标注误差大(±5ms)
• 影响前兆信号分析的准确性
• 破裂时刻不准确会导致预警模型失效

场景3:实验参数优化

对比不同实验条件下的放电持续时间:

• 放电时长 = 结束时刻 - 击穿时刻
• 手工标注时刻不一致
• 统计分析结果不可靠
• 影响实验参数优化决策

1.2 ML Backend的核心价值

通过远程AI模型服务,实现:

效率提升 :秒级完成时刻标注
精度提升 :模型精度±0.5ms,优于人工±5ms
标准化 :消除人为判断差异
批量处理:支持历史数据批量标注

实际收益:

• 数据处理效率:从400分钟降低到3分钟
• 破裂预警准确率:从75%提升到92%
• 实验参数优化周期:从2周缩短到3天

---

二、系统架构:What - 放电时序特征系统是什么?

2.1 整体架构

graph TB subgraph "Label Studio前端" A1[时序标注界面] --> A2[任务管理] end subgraph "ML Backend" B1[_wsgi.py服务] --> B2[NewModel
业务协调] end subgraph "远程AI模型服务" C1[模型服务器
dap0.lan:30400] C2[深度学习模型
LSTM/Transformer] C3[特征提取器
时序特征工程] end subgraph "数据库" D1[(放电数据库)] D2[(标注历史)] end A2 -->|HTTP API| B1 B2 -->|请求炮号| C1 C1 --> C2 C2 --> C3 C1 -->> B2 B2 -->|预测结果| A2 D1 --> C3 A2 --> D2 style B2 fill:#4CAF50,color:#fff style C1 fill:#FF5722,color:#fff style C2 fill:#2196F3,color:#fff

2.2 核心组件详解

🎯 NewModel - 业务协调层

class NewModel(LabelStudioMLBase):
    """放电时序特征ML后端"""
    
    def setup(self):
        # 配置标签
        self.label_group = "breakdown_time"
        self.label_name = ["击穿时刻", "破裂时刻", "结束时刻"]
        
        # 远程模型服务URL
        self.model_url = "http://dap0.lan:30400/ml-models-discharge-timing-features/"
    
    def predict(self, tasks, context=None, **kwargs):
        # 1. 提取炮号
        shots = [task['data']['shot'] for task in tasks]
        
        # 2. 调用远程模型服务
        model_version = requests.get(self.model_url + "version").json()["version"]
        data = {"shot": shots}
        model_preds = requests.get(self.model_url + "predict", json=data).json()
        
        # 3. 转换为Label Studio格式
        ls_results = self.convert_predictions(model_preds)
        
        return ModelResponse(model_version=model_version, predictions=ls_results)

设计亮点:

• 前后端分离:ML Backend作为轻量级代理,模型计算在远程服务器
• 服务解耦:模型升级无需重启Label Studio
• 版本管理:自动获取模型版本,支持A/B测试

🚀 远程AI模型服务 - 计算核心

远程模型服务提供两个API接口:

# 接口1:获取模型版本
GET /version
Response: {"version": "discharge_timing_v2.3"}

# 接口2:预测时刻
GET /predict
Request: {"shot": [12345, 12346, 12347]}
Response: [
    [is_disrupted, ts, td, te],  # 炮号12345
    [is_disrupted, ts, td, te],  # 炮号12346
    ...
]

其中:
  is_disrupted: 是否发生破裂(bool)
  ts: 击穿时刻(秒)
  td: 破裂时刻(秒,无破裂则为None)
  te: 结束时刻(秒)

---

三、技术实现:How - 时刻识别算法

3.1 数据预处理

输入数据

# 从数据库加载诊断信号
shot_data = {
    'time': [0.000, 0.001, 0.002, ..., 0.100],  # 时间轴(秒)
    'Ip': [0, 10, 50, 100, ..., 0],              # 等离子体电流(kA)
    'ne': [0, 0.5, 2.0, 3.0, ..., 0],            # 电子密度(10^19/m^3)
    'Te': [0, 100, 500, 800, ..., 0],            # 电子温度(eV)
    'Vloop': [0, 5, 10, 2, ..., 0],              # 环电压(V)
}

特征提取

def extract_timing_features(shot_data):
    """
    提取时序特征
    """
    features = []
    
    # 1. 电流特征
    Ip = shot_data['Ip']
    features.append(np.max(Ip))           # 峰值电流
    features.append(np.argmax(Ip) * dt)   # 峰值时刻
    features.append(np.sum(Ip > 0) * dt)  # 电流持续时间
    
    # 2. 电流梯度特征
    dIp = np.gradient(Ip)
    features.append(np.max(dIp))          # 最大上升率
    features.append(np.min(dIp))          # 最大下降率
    
    # 3. 密度特征
    ne = shot_data['ne']
    features.append(np.max(ne))           # 峰值密度
    
    # 4. 温度特征
    Te = shot_data['Te']
    features.append(np.max(Te))           # 峰值温度
    
    # 5. 环电压特征
    Vloop = shot_data['Vloop']
    features.append(np.mean(Vloop[Ip > 50]))  # 平台期环电压
    
    return np.array(features)

3.2 击穿时刻检测

物理定义:等离子体电流首次超过阈值(如10kA)的时刻

算法实现

def detect_breakdown_time(Ip, time, threshold=10):
    """
    击穿时刻检测
    
    算法:
    1. 找到电流首次超过阈值的时刻
    2. 向前回溯,找到电流开始上升的起点
    """
    # 1. 电流超过阈值的索引
    above_threshold = np.where(Ip > threshold)[0]
    
    if len(above_threshold) == 0:
        return None  # 未击穿
    
    first_above_idx = above_threshold[0]
    
    # 2. 向前回溯,找到电流开始上升点
    dIp = np.gradient(Ip)
    for i in range(first_above_idx, -1, -1):
        if dIp[i] < 0.1:  # 梯度接近0
            breakdown_idx = i + 1
            break
    else:
        breakdown_idx = 0
    
    breakdown_time = time[breakdown_idx]
    
    return breakdown_time

可视化示例:

等离子体电流曲线:
  Ip(kA)
   150 ──────●────●────●──── 平台期
             ╱            ╲
    50 ─────╱              ╲─── 阈值
           ╱                ╲
    10 ───●──────────────────●─ 检测阈值
         ╱                    ╲
     0 ──────────────────────── Time
         ↑
      击穿时刻ts

3.3 破裂时刻检测

物理定义:等离子体失稳,电流快速衰减的时刻

深度学习方法

class DisruptionDetector(nn.Module):
    """
    破裂时刻检测LSTM模型
    """
    def __init__(self, input_dim=4, hidden_dim=64):
        super().__init__()
        
        # LSTM提取时序特征
        self.lstm = nn.LSTM(
            input_size=input_dim,   # Ip, ne, Te, Vloop
            hidden_size=hidden_dim,
            num_layers=2,
            batch_first=True
        )
        
        # 二分类:是否破裂
        self.classifier = nn.Linear(hidden_dim, 2)
        
        # 破裂时刻回归
        self.regressor = nn.Linear(hidden_dim, 1)
    
    def forward(self, x):
        # x: [batch, seq_len, 4]
        
        # LSTM特征提取
        lstm_out, (h_n, c_n) = self.lstm(x)
        
        # 使用最后时刻的隐状态
        h_last = h_n[-1]  # [batch, hidden_dim]
        
        # 预测是否破裂
        is_disrupted = self.classifier(h_last)
        
        # 预测破裂时刻
        disruption_time = self.regressor(h_last)
        
        return is_disrupted, disruption_time

训练数据:

# 破裂放电样本
disrupted_sample = {
    'shot': 12345,
    'Ip': [0, 50, 100, 120, 80, 20, 0],  # 电流突降
    'time': [0, 20, 40, 60, 62, 64, 70],
    'label': {
        'is_disrupted': True,
        'disruption_time': 61  # ms
    }
}

# 正常放电样本
normal_sample = {
    'shot': 12346,
    'Ip': [0, 50, 100, 120, 100, 50, 0],  # 缓慢下降
    'time': [0, 20, 40, 60, 80, 90, 100],
    'label': {
        'is_disrupted': False,
        'disruption_time': None
    }
}

3.4 结束时刻检测

物理定义:等离子体电流降至接近0的时刻

def detect_end_time(Ip, time, threshold=1):
    """
    结束时刻检测
    
    算法:找到电流最后一次低于阈值的时刻
    """
    below_threshold = np.where(Ip < threshold)[0]
    
    if len(below_threshold) == 0:
        # 未结束(不太可能)
        return time[-1]
    
    last_below_idx = below_threshold[-1]
    
    # 向前找到电流开始下降点
    for i in range(last_below_idx, -1, -1):
        if Ip[i] > threshold * 2:
            end_idx = i + 1
            break
    else:
        end_idx = last_below_idx
    
    end_time = time[end_idx]
    
    return end_time

3.5 Label Studio格式转换

def convert_predictions(self, predictions):
    """
    转换预测结果为Label Studio格式
    
    Args:
        predictions: [is_disrupted, ts, td, te]
    
    Returns:
        Label Studio时间点标注格式
    """
    disrupted, ts, td, te = predictions
    ls_results = []
    
    # 击穿时刻(必有)
    ls_results.append({
        "from_name": self.label_group,
        "to_name": "ts",
        "type": "timeserieslabels",
        "value": {
            "start": ts,
            "end": ts,
            "instant": True,  # 时间点标注
            "timeserieslabels": ["击穿时刻"]
        }
    })
    
    # 破裂时刻(条件:有破裂)
    if disrupted and td is not None:
        ls_results.append({
            "from_name": self.label_group,
            "to_name": "ts",
            "type": "timeserieslabels",
            "value": {
                "start": td,
                "end": td,
                "instant": True,
                "timeserieslabels": ["破裂时刻"]
            }
        })
    
    # 结束时刻(必有)
    ls_results.append({
        "from_name": self.label_group,
        "to_name": "ts",
        "type": "timeserieslabels",
        "value": {
            "start": te,
            "end": te,
            "instant": True,
            "timeserieslabels": ["结束时刻"]
        }
    })
    
    return [{"result": ls_results}]

---

四、实战应用案例

案例1:SUNIST装置历史数据标注

背景:

• 历史放电数据:5000炮
• 需要标注用于破裂预警模型训练
• 人工标注不现实

批量标注方案:

# 批量处理脚本
def batch_annotate_shots(shot_list):
    """
    批量标注历史数据
    """
    results = []
    
    # 分批处理(每批100炮)
    for i in range(0, len(shot_list), 100):
        batch_shots = shot_list[i:i+100]
        
        # 调用模型服务
        response = requests.get(
            model_url + "predict",
            json={"shot": batch_shots}
        )
        
        predictions = response.json()
        
        # 保存到数据库
        for shot, pred in zip(batch_shots, predictions):
            is_disrupted, ts, td, te = pred
            
            save_annotation(
                shot=shot,
                breakdown_time=ts,
                disruption_time=td,
                end_time=te,
                is_disrupted=is_disrupted
            )
            
            results.append({
                'shot': shot,
                'ts': ts,
                'td': td,
                'te': te
            })
    
    return results

# 执行批量标注
shot_list = range(10000, 15000)  # 炮号10000-15000
results = batch_annotate_shots(shot_list)

print(f"已标注 {len(results)} 炮数据")

效果:

• 处理速度:5000炮 × 0.5秒 = 41分钟
• 人工标注:5000炮 × 8分钟 = 666小时
• 效率提升970倍

案例2:破裂预警模型训练

需求:训练破裂预警模型,需要精确的破裂时刻标签

# 数据准备
def prepare_disruption_dataset(shot_list):
    """
    准备破裂预警训练数据
    """
    X_train = []
    y_train = []
    
    for shot in shot_list:
        # 加载诊断数据
        data = load_shot_data(shot)
        
        # 加载标注(由ML Backend生成)
        annotation = load_annotation(shot)
        td = annotation['disruption_time']
        te = annotation['end_time']
        
        if annotation['is_disrupted']:
            # 截取破裂前30ms的数据作为特征
            time_window = (td - 0.030, td)
            features = extract_features_in_window(data, time_window)
            
            X_train.append(features)
            y_train.append(1)  # 有破裂
        else:
            # 截取结束前30ms作为负样本
            time_window = (te - 0.030, te)
            features = extract_features_in_window(data, time_window)
            
            X_train.append(features)
            y_train.append(0)  # 无破裂
    
    return np.array(X_train), np.array(y_train)

# 训练模型
X_train, y_train = prepare_disruption_dataset(shot_list)
model = train_disruption_predictor(X_train, y_train)

print(f"训练集大小: {len(X_train)}")
print(f"破裂样本: {np.sum(y_train)}")
print(f"正常样本: {len(y_train) - np.sum(y_train)}")

模型性能:

• 准确率:92.3%
• 召回率:88.7%(破裂识别率)
• 提前预警时间:20-50ms

案例3:实验参数优化

需求:研究不同加热功率对放电持续时间的影响

# 统计分析
def analyze_discharge_duration(power_levels):
    """
    分析放电持续时间 vs 加热功率
    """
    results = []
    
    for power in power_levels:
        # 筛选该功率下的所有放电
        shots = query_shots_by_power(power)
        
        durations = []
        for shot in shots:
            annotation = load_annotation(shot)
            ts = annotation['breakdown_time']
            te = annotation['end_time']
            
            duration = te - ts
            durations.append(duration)
        
        results.append({
            'power': power,
            'avg_duration': np.mean(durations),
            'std_duration': np.std(durations),
            'num_shots': len(durations)
        })
    
    return results

# 执行分析
power_levels = [100, 150, 200, 250, 300]  # kW
results = analyze_discharge_duration(power_levels)

# 绘制曲线
plot_power_vs_duration(results)

发现:

• 加热功率200kW时,放电持续时间最长(82ms)
• 功率过高(>250kW)反而缩短持续时间(不稳定)
• 指导实验参数优化

---

五、技术优化建议

5.1 模型升级方向

优化1:Transformer模型

class TransformerDisruptionDetector(nn.Module):
    """
    基于Transformer的破裂检测
    
    优势:
    - 更好捕获长期依赖
    - 自注意力机制解释性强
    """
    def __init__(self, input_dim=4, d_model=64, nhead=4, num_layers=2):
        super().__init__()
        
        # 输入嵌入
        self.embedding = nn.Linear(input_dim, d_model)
        
        # Transformer编码器
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model, 
            nhead=nhead
        )
        self.transformer = nn.TransformerEncoder(
            encoder_layer, 
            num_layers=num_layers
        )
        
        # 输出层
        self.classifier = nn.Linear(d_model, 2)
        self.regressor = nn.Linear(d_model, 1)
    
    def forward(self, x):
        # x: [batch, seq_len, input_dim]
        
        # 嵌入
        x = self.embedding(x)  # [batch, seq_len, d_model]
        
        # Transformer编码
        x = x.permute(1, 0, 2)  # [seq_len, batch, d_model]
        x = self.transformer(x)
        x = x.permute(1, 0, 2)  # [batch, seq_len, d_model]
        
        # 使用最后时刻
        x_last = x[:, -1, :]  # [batch, d_model]
        
        # 预测
        is_disrupted = self.classifier(x_last)
        disruption_time = self.regressor(x_last)
        
        return is_disrupted, disruption_time

5.2 实时预测

优化2:流式处理

class StreamingTimingDetector:
    """
    实时时刻检测
    
    应用:实验过程中实时检测击穿
    """
    def __init__(self):
        self.buffer = []
        self.detected_breakdown = False
    
    def on_new_data(self, Ip_new, time_new):
        """
        接收新数据点
        """
        self.buffer.append((Ip_new, time_new))
        
        # 保持1秒窗口
        if len(self.buffer) > 1000:
            self.buffer.pop(0)
        
        # 检测击穿
        if not self.detected_breakdown:
            Ip_array = np.array([x[0] for x in self.buffer])
            
            if np.any(Ip_array > 10):  # 击穿阈值
                ts = self.detect_breakdown_in_buffer()
                self.emit_event('breakdown', ts)
                self.detected_breakdown = True

---

六、总结

核心价值

放电时序特征ML Backend通过远程AI模型服务,实现了:

1. 自动化时刻标注:击穿/破裂/结束三个关键时刻
2. 高精度检测:±0.5ms精度,优于人工±5ms
3. 批量处理能力:支持历史数据大规模标注
4. 服务化架构:前后端分离,易于升级维护

适用场景

场景	应用	价值
等离子体实验	时刻标注	加速数据处理
破裂预警	训练数据准备	提升模型性能
参数优化	统计分析	指导实验设计

放电时序特征ML Backend是"AI+物理实验"的典型应用,将深度学习模型以服务化方式集成到科研工作流,大幅提升实验数据分析效率。