Datasets:

zerozero01
/

bolt-tightening-quality

# -*- coding: utf-8 -*-
"""
螺栓拧紧数据预处理与特征工程脚本
处理流程（对应「工业大数据预处理与特征工程」技术方向）：
  1. 数据清洗    —— 去除空行程段、3σ 异常值剔除 + 线性插值、缺失值处理
  2. 特征提取    —— 从力矩-转角时序提取 12 维时域特征
  3. 特征选择    —— Pearson 相关 + 共线性分析，降维至 10 维核心特征
  4. 特征标准化  —— Z-score（仅基于训练集统计量，避免数据泄露）
  5. 数据集划分  —— 7:2:1 分层随机抽样（按质量标签）
输入：data/raw/{benchmark,extended}/records.jsonl
输出：
  data/processed/train.csv / val.csv / test.csv   —— 标准化后特征集
  data/processed/feature_metadata.json            —— 特征元信息
用法：
    python data/preprocess.py
"""
from __future__ import annotations

import json
from pathlib import Path

import numpy as np
import pandas as pd

BASE_DIR = Path(__file__).resolve().parent
RAW_DIR = BASE_DIR / "raw"
PROCESSED_DIR = BASE_DIR / "processed"

# 各规格名义最终拧紧角度（用于计算「转角偏差量」特征）
NOMINAL_ANGLE = {"M12": 95.0, "M16": 135.0, "M20": 175.0, "M24": 220.0}

# 12 维时域特征定义
FEATURE_NAMES = [
    "torque_max",        # 力矩最大值 (N·m)
    "torque_mean",       # 力矩平均值 (N·m)
    "torque_std",        # 力矩标准差 (N·m)
    "torque_peak_angle", # 力矩峰值出现角度 (deg)
    "snug_torque",       # 贴合点扭矩 (N·m)
    "total_angle",       # 拧紧总转角 (deg)
    "avg_rate",          # 拧紧平均速率 (N·m/deg)
    "rising_slope",      # 力矩上升斜率 (N·m/deg)
    "torque_fluctuation",# 力矩波动率 (无量纲)
    "angle_deviation",   # 转角偏差量 (deg)
    "final_torque",      # 最终扭矩值 (N·m)
    "hold_fluctuation",  # 扭矩保持段波动率 (N·m)
]


def load_raw() -> pd.DataFrame:
    """加载原始数据（基准集 + 扩展集合并）。"""
    frames = []
    for sub in ("benchmark", "extended"):
        path = RAW_DIR / sub / "records.jsonl"
        with open(path, encoding="utf-8") as f:
            recs = [json.loads(line) for line in f if line.strip()]
        df = pd.DataFrame(recs)
        df["source"] = sub
        frames.append(df)
    return pd.concat(frames, ignore_index=True)


def clean_curve(angle: np.ndarray, torque: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    """数据清洗：去除空行程段 + 3σ 异常值剔除并线性插值补全。"""
    angle = np.asarray(angle, dtype=float)
    torque = np.asarray(torque, dtype=float)

    # 1) 去除空行程段：截取从贴合点（力矩首次超过峰值 30%）到终止
    if len(torque) == 0:
        return angle, torque
    thresh = 0.3 * np.max(torque)
    snug_idx = int(np.argmax(torque >= thresh))
    angle, torque = angle[snug_idx:], torque[snug_idx:]
    if len(torque) < 3:
        return angle, torque

    # 2) 3σ 异常值剔除：基于一阶差分（跳变点）识别离群点，线性插值补全
    diff = np.abs(np.diff(torque, prepend=torque[0]))
    mu, sigma = diff.mean(), diff.std()
    if sigma > 1e-9:
        outliers = diff > (mu + 3 * sigma)
        if outliers.any():
            idx = np.where(outliers)[0]
            valid = ~outliers
            # 仅当两端存在有效点时进行插值，否则保留原值
            torque_clean = torque.copy()
            for i in idx:
                if 0 < i < len(torque) - 1:
                    torque_clean[i] = (torque[i - 1] + torque[i + 1]) / 2.0
            torque = torque_clean

    return angle, torque


def extract_features(angle: np.ndarray, torque: np.ndarray, spec: str) -> dict:
    """提取 12 维时域特征。"""
    n = len(torque)
    torque_max = float(np.max(torque))
    peak_idx = int(np.argmax(torque))
    thresh = 0.3 * torque_max
    snug_idx = int(np.argmax(torque >= thresh)) if torque_max > 0 else 0

    grad = np.gradient(torque, angle)
    hold_start = int(n * 0.8)  # 保持段起点（末 20% 区间）

    snug_torque = float(torque[snug_idx])
    denom = float(angle[peak_idx] - angle[snug_idx]) if peak_idx > snug_idx else 1e-6

    return {
        "torque_max": torque_max,
        "torque_mean": float(np.mean(torque)),
        "torque_std": float(np.std(torque)),
        "torque_peak_angle": float(angle[peak_idx]),
        "snug_torque": snug_torque,
        "total_angle": float(angle[-1] - angle[0]),
        "avg_rate": float((torque_max - snug_torque) / denom),
        "rising_slope": float(np.max(grad[: peak_idx + 1])),
        "torque_fluctuation": float(np.std(torque) / (np.mean(torque) + 1e-6)),
        "angle_deviation": float(angle[-1] - NOMINAL_ANGLE.get(spec, np.nan)),
        "final_torque": float(torque[-1]),
        "hold_fluctuation": float(np.std(torque[hold_start:])),
    }


def select_features(feat_df: pd.DataFrame, y: pd.Series, threshold_corr: float = 0.1,
                    threshold_collinear: float = 0.97) -> tuple[list[str], dict]:
    """特征选择：剔除弱相关特征，合并共线性特征（连通分量聚类，保留每组代表）。"""
    corr_with_label = {f: float(np.corrcoef(feat_df[f], y)[0, 1]) for f in FEATURE_NAMES}
    abs_corr = {f: abs(c) for f, c in corr_with_label.items()}

    # 弱相关剔除
    kept = [f for f in FEATURE_NAMES if abs_corr[f] >= threshold_corr]
    dropped_weak = [f for f in FEATURE_NAMES if abs_corr[f] < threshold_corr]

    # 共线性合并：|corr| 高于阈值的特征对构成连通分量，每组保留与标签相关性最强的一个
    parent = {f: f for f in kept}

    def find(x: str) -> str:
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x

    def union(a: str, b: str) -> None:
        ra, rb = find(a), find(b)
        if ra != rb:
            parent[rb] = ra

    collinear_pairs = []
    for i in range(len(kept)):
        for j in range(i + 1, len(kept)):
            f_i, f_j = kept[i], kept[j]
            c = float(np.corrcoef(feat_df[f_i], feat_df[f_j])[0, 1])
            if abs(c) > threshold_collinear:
                collinear_pairs.append((f_i, f_j, round(c, 3)))
                union(f_i, f_j)

    clusters: dict[str, list[str]] = {}
    for f in kept:
        clusters.setdefault(find(f), []).append(f)

    selected, dropped_collinear = [], []
    for members in clusters.values():
        best = max(members, key=lambda f: abs_corr[f])
        selected.append(best)
        for m in members:
            if m != best:
                dropped_collinear.append({"kept": best, "dropped": m,
                                          "corr": next(c for a, b, c in collinear_pairs
                                                        if {a, b} == {best, m})})
    selected.sort()

    meta = {
        "pearson_with_label": {f: round(v, 4) for f, v in corr_with_label.items()},
        "dropped_weak": dropped_weak,
        "dropped_collinear": dropped_collinear,
        "selected_features": selected,
    }
    return selected, meta


def main() -> None:
    raw = load_raw()
    print(f"[OK] 加载原始数据 {len(raw)} 条")

    # 1) 清洗 + 2) 特征提取
    feature_rows = []
    for _, row in raw.iterrows():
        angle, torque = clean_curve(row["angle"], row["torque"])
        if len(torque) < 3:
            continue
        feats = extract_features(angle, torque, row["spec"])
        feats.update({"id": row["id"], "spec": row["spec"], "source": row["source"],
                      "label": row["label"], "label_name": row["label_name"]})
        feature_rows.append(feats)

    feat_df = pd.DataFrame(feature_rows)
    print(f"[OK] 特征提取完成，有效样本 {len(feat_df)} 条")

    # 3) 特征选择
    selected, meta = select_features(feat_df, feat_df["label"])
    print(f"[OK] 特征选择：{len(FEATURE_NAMES)} -> {len(selected)} 维")
    print(f"      剔除弱相关: {meta['dropped_weak']}")
    print(f"      合并共线性: {meta['dropped_collinear']}")

    # 4) 数据集划分（7:2:1 分层）
    from sklearn.model_selection import train_test_split
    train, temp = train_test_split(feat_df, test_size=0.3, stratify=feat_df["label"],
                                   random_state=42)
    val, test = train_test_split(temp, test_size=1 / 3, stratify=temp["label"],
                                 random_state=42)

    # 5) 特征标准化：仅基于训练集统计量
    mean = train[selected].mean()
    std = train[selected].std().replace(0, 1e-9)

    def standardize(df: pd.DataFrame) -> pd.DataFrame:
        out = df.copy()
        out[selected] = (out[selected] - mean) / std
        return out

    train_s, val_s, test_s = standardize(train), standardize(val), standardize(test)

    PROCESSED_DIR.mkdir(parents=True, exist_ok=True)
    cols = ["id", "spec", "source", "label", "label_name"] + selected
    train_s[cols].to_csv(PROCESSED_DIR / "train.csv", index=False, encoding="utf-8-sig")
    val_s[cols].to_csv(PROCESSED_DIR / "val.csv", index=False, encoding="utf-8-sig")
    test_s[cols].to_csv(PROCESSED_DIR / "test.csv", index=False, encoding="utf-8-sig")

    meta["n_samples"] = {"train": int(len(train)), "val": int(len(val)),
                         "test": int(len(test))}
    meta["standardization"] = {"mean": mean.round(6).to_dict(), "std": std.round(6).to_dict()}
    with open(PROCESSED_DIR / "feature_metadata.json", "w", encoding="utf-8") as f:
        json.dump(meta, f, ensure_ascii=False, indent=2)

    print(f"[OK] 数据集划分 -> train {len(train)} / val {len(val)} / test {len(test)}")
    print(f"[OK] 输出目录 {PROCESSED_DIR}")


if __name__ == "__main__":
    main()

	# -- coding: utf-8 --
	"""
	螺栓拧紧数据预处理与特征工程脚本

	处理流程（对应「工业大数据预处理与特征工程」技术方向）：
	1. 数据清洗 —— 去除空行程段、3σ 异常值剔除 + 线性插值、缺失值处理
	2. 特征提取 —— 从力矩-转角时序提取 12 维时域特征
	3. 特征选择 —— Pearson 相关 + 共线性分析，降维至 10 维核心特征
	4. 特征标准化 —— Z-score（仅基于训练集统计量，避免数据泄露）
	5. 数据集划分 —— 7:2:1 分层随机抽样（按质量标签）

	输入：data/raw/{benchmark,extended}/records.jsonl
	输出：
	data/processed/train.csv / val.csv / test.csv —— 标准化后特征集
	data/processed/feature_metadata.json —— 特征元信息

	用法：
	python data/preprocess.py
	"""
	from __future__ import annotations

	import json
	from pathlib import Path

	import numpy as np
	import pandas as pd

	BASE_DIR = Path(__file__).resolve().parent
	RAW_DIR = BASE_DIR / "raw"
	PROCESSED_DIR = BASE_DIR / "processed"

	# 各规格名义最终拧紧角度（用于计算「转角偏差量」特征）
	NOMINAL_ANGLE = {"M12": 95.0, "M16": 135.0, "M20": 175.0, "M24": 220.0}

	# 12 维时域特征定义
	FEATURE_NAMES = [
	"torque_max", # 力矩最大值 (N·m)
	"torque_mean", # 力矩平均值 (N·m)
	"torque_std", # 力矩标准差 (N·m)
	"torque_peak_angle", # 力矩峰值出现角度 (deg)
	"snug_torque", # 贴合点扭矩 (N·m)
	"total_angle", # 拧紧总转角 (deg)
	"avg_rate", # 拧紧平均速率 (N·m/deg)
	"rising_slope", # 力矩上升斜率 (N·m/deg)
	"torque_fluctuation",# 力矩波动率 (无量纲)
	"angle_deviation", # 转角偏差量 (deg)
	"final_torque", # 最终扭矩值 (N·m)
	"hold_fluctuation", # 扭矩保持段波动率 (N·m)
	]


	def load_raw() -> pd.DataFrame:
	"""加载原始数据（基准集 + 扩展集合并）。"""
	frames = []
	for sub in ("benchmark", "extended"):
	path = RAW_DIR / sub / "records.jsonl"
	with open(path, encoding="utf-8") as f:
	recs = [json.loads(line) for line in f if line.strip()]
	df = pd.DataFrame(recs)
	df["source"] = sub
	frames.append(df)
	return pd.concat(frames, ignore_index=True)


	def clean_curve(angle: np.ndarray, torque: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
	"""数据清洗：去除空行程段 + 3σ 异常值剔除并线性插值补全。"""
	angle = np.asarray(angle, dtype=float)
	torque = np.asarray(torque, dtype=float)

	# 1) 去除空行程段：截取从贴合点（力矩首次超过峰值 30%）到终止
	if len(torque) == 0:
	return angle, torque
	thresh = 0.3 * np.max(torque)
	snug_idx = int(np.argmax(torque >= thresh))
	angle, torque = angle[snug_idx:], torque[snug_idx:]
	if len(torque) < 3:
	return angle, torque

	# 2) 3σ 异常值剔除：基于一阶差分（跳变点）识别离群点，线性插值补全
	diff = np.abs(np.diff(torque, prepend=torque[0]))
	mu, sigma = diff.mean(), diff.std()
	if sigma > 1e-9:
	outliers = diff > (mu + 3 * sigma)
	if outliers.any():
	idx = np.where(outliers)[0]
	valid = ~outliers
	# 仅当两端存在有效点时进行插值，否则保留原值
	torque_clean = torque.copy()
	for i in idx:
	if 0 < i < len(torque) - 1:
	torque_clean[i] = (torque[i - 1] + torque[i + 1]) / 2.0
	torque = torque_clean

	return angle, torque


	def extract_features(angle: np.ndarray, torque: np.ndarray, spec: str) -> dict:
	"""提取 12 维时域特征。"""
	n = len(torque)
	torque_max = float(np.max(torque))
	peak_idx = int(np.argmax(torque))
	thresh = 0.3 * torque_max
	snug_idx = int(np.argmax(torque >= thresh)) if torque_max > 0 else 0

	grad = np.gradient(torque, angle)
	hold_start = int(n * 0.8) # 保持段起点（末 20% 区间）

	snug_torque = float(torque[snug_idx])
	denom = float(angle[peak_idx] - angle[snug_idx]) if peak_idx > snug_idx else 1e-6

	return {
	"torque_max": torque_max,
	"torque_mean": float(np.mean(torque)),
	"torque_std": float(np.std(torque)),
	"torque_peak_angle": float(angle[peak_idx]),
	"snug_torque": snug_torque,
	"total_angle": float(angle[-1] - angle[0]),
	"avg_rate": float((torque_max - snug_torque) / denom),
	"rising_slope": float(np.max(grad[: peak_idx + 1])),
	"torque_fluctuation": float(np.std(torque) / (np.mean(torque) + 1e-6)),
	"angle_deviation": float(angle[-1] - NOMINAL_ANGLE.get(spec, np.nan)),
	"final_torque": float(torque[-1]),
	"hold_fluctuation": float(np.std(torque[hold_start:])),
	}


	def select_features(feat_df: pd.DataFrame, y: pd.Series, threshold_corr: float = 0.1,
	threshold_collinear: float = 0.97) -> tuple[list[str], dict]:
	"""特征选择：剔除弱相关特征，合并共线性特征（连通分量聚类，保留每组代表）。"""
	corr_with_label = {f: float(np.corrcoef(feat_df[f], y)[0, 1]) for f in FEATURE_NAMES}
	abs_corr = {f: abs(c) for f, c in corr_with_label.items()}

	# 弱相关剔除
	kept = [f for f in FEATURE_NAMES if abs_corr[f] >= threshold_corr]
	dropped_weak = [f for f in FEATURE_NAMES if abs_corr[f] < threshold_corr]

	# 共线性合并：\|corr\| 高于阈值的特征对构成连通分量，每组保留与标签相关性最强的一个
	parent = {f: f for f in kept}

	def find(x: str) -> str:
	while parent[x] != x:
	parent[x] = parent[parent[x]]
	x = parent[x]
	return x

	def union(a: str, b: str) -> None:
	ra, rb = find(a), find(b)
	if ra != rb:
	parent[rb] = ra

	collinear_pairs = []
	for i in range(len(kept)):
	for j in range(i + 1, len(kept)):
	f_i, f_j = kept[i], kept[j]
	c = float(np.corrcoef(feat_df[f_i], feat_df[f_j])[0, 1])
	if abs(c) > threshold_collinear:
	collinear_pairs.append((f_i, f_j, round(c, 3)))
	union(f_i, f_j)

	clusters: dict[str, list[str]] = {}
	for f in kept:
	clusters.setdefault(find(f), []).append(f)

	selected, dropped_collinear = [], []
	for members in clusters.values():
	best = max(members, key=lambda f: abs_corr[f])
	selected.append(best)
	for m in members:
	if m != best:
	dropped_collinear.append({"kept": best, "dropped": m,
	"corr": next(c for a, b, c in collinear_pairs
	if {a, b} == {best, m})})
	selected.sort()

	meta = {
	"pearson_with_label": {f: round(v, 4) for f, v in corr_with_label.items()},
	"dropped_weak": dropped_weak,
	"dropped_collinear": dropped_collinear,
	"selected_features": selected,
	}
	return selected, meta


	def main() -> None:
	raw = load_raw()
	print(f"[OK] 加载原始数据 {len(raw)} 条")

	# 1) 清洗 + 2) 特征提取
	feature_rows = []
	for _, row in raw.iterrows():
	angle, torque = clean_curve(row["angle"], row["torque"])
	if len(torque) < 3:
	continue
	feats = extract_features(angle, torque, row["spec"])
	feats.update({"id": row["id"], "spec": row["spec"], "source": row["source"],
	"label": row["label"], "label_name": row["label_name"]})
	feature_rows.append(feats)

	feat_df = pd.DataFrame(feature_rows)
	print(f"[OK] 特征提取完成，有效样本 {len(feat_df)} 条")

	# 3) 特征选择
	selected, meta = select_features(feat_df, feat_df["label"])
	print(f"[OK] 特征选择：{len(FEATURE_NAMES)} -> {len(selected)} 维")
	print(f" 剔除弱相关: {meta['dropped_weak']}")
	print(f" 合并共线性: {meta['dropped_collinear']}")

	# 4) 数据集划分（7:2:1 分层）
	from sklearn.model_selection import train_test_split
	train, temp = train_test_split(feat_df, test_size=0.3, stratify=feat_df["label"],
	random_state=42)
	val, test = train_test_split(temp, test_size=1 / 3, stratify=temp["label"],
	random_state=42)

	# 5) 特征标准化：仅基于训练集统计量
	mean = train[selected].mean()
	std = train[selected].std().replace(0, 1e-9)

	def standardize(df: pd.DataFrame) -> pd.DataFrame:
	out = df.copy()
	out[selected] = (out[selected] - mean) / std
	return out

	train_s, val_s, test_s = standardize(train), standardize(val), standardize(test)

	PROCESSED_DIR.mkdir(parents=True, exist_ok=True)
	cols = ["id", "spec", "source", "label", "label_name"] + selected
	train_s[cols].to_csv(PROCESSED_DIR / "train.csv", index=False, encoding="utf-8-sig")
	val_s[cols].to_csv(PROCESSED_DIR / "val.csv", index=False, encoding="utf-8-sig")
	test_s[cols].to_csv(PROCESSED_DIR / "test.csv", index=False, encoding="utf-8-sig")

	meta["n_samples"] = {"train": int(len(train)), "val": int(len(val)),
	"test": int(len(test))}
	meta["standardization"] = {"mean": mean.round(6).to_dict(), "std": std.round(6).to_dict()}
	with open(PROCESSED_DIR / "feature_metadata.json", "w", encoding="utf-8") as f:
	json.dump(meta, f, ensure_ascii=False, indent=2)

	print(f"[OK] 数据集划分 -> train {len(train)} / val {len(val)} / test {len(test)}")
	print(f"[OK] 输出目录 {PROCESSED_DIR}")


	if __name__ == "__main__":
	main()