## 🚀 快速开始

### 1. 环境要求

```bash
# 必需的Python包
pip install pandas numpy openpyxl h5py matplotlib seaborn umap-learn
```

### 2. 数据访问

#### 🔗 在线平台下载

- 您可以通过以下平台直接下载完整数据集：
- **ModelScope**: [https://www.modelscope.cn/datasets/PHMbench/PHM-Vibench/files](https://www.modelscope.cn/datasets/PHMbench/PHM-Vibench/files)
- **Hugging Face**: [https://huggingface.co/datasets/PHMbench/PHM-Vibench/tree/main](https://huggingface.co/datasets/PHMbench/PHM-Vibench/tree/main)
- 也可以直接运行PHM_bench 会自动下载

#### 💾 本地数据加载

```python
# 加载元数据
import pandas as pd
metadata = pd.read_excel('PHM-Vibench/metadata_25_10_30.xlsx')

# 加载H5数据
import h5py
with h5py.File('PHM-Vibench/Name.h5', 'r') as f:
    data = f['RM_001_CWRU'][:]
    print(f"数据形状: {data.shape}")
```

### 3. 数据分析

```python
# 使用UMAP进行降维可视化
import numpy as np
from umap import UMAP
import matplotlib.pyplot as plt

# 加载数据
# ... 数据加载代码 ...

# UMAP降维
reducer = UMAP(n_components=2, random_state=42)
embedding = reducer.fit_transform(data)

# 可视化
plt.figure(figsize=(10, 8))
plt.scatter(embedding[:, 0], embedding[:, 1], c=labels, cmap='Spectral', s=1)
plt.colorbar()
plt.title('UMAP Projection of Vibration Data')
plt.show()
```

### 4. 运行分析脚本

```bash
# 生成元数据
python datainfo.py

# 执行UMAP分析
python data_analysis.py --dataset RM_001_CWRU --trunc 2048

# 上传到ModelScope
python upload.py --file metadata_6_1.h5
```

## 🔧 工具脚本

### datainfo.py

元数据生成和管理工具，用于遍历数据目录并生成标准化的元数据文件。

```bash
# 生成CSV元数据
python datainfo.py

# 转换为H5格式
python datainfo.py --convert-h5

# 指定数据集
python datainfo.py --dataset RM_001_CWRU
```

### data_analysis.py

UMAP降维分析和可视化工具，支持大规模数据处理。

```bash
# 默认分析（2048点截断）
python data_analysis.py --dataset RM_001_CWRU

# 自定义截断长度
python data_analysis.py --dataset RM_002_XJTU --trunc 1024

# 并行处理
python data_analysis.py --parallel --n-jobs 4
```

### upload.py

大文件上传到ModelScope平台工具。

```bash
# 上传单个文件
python upload.py --file metadata_6_1.h5

# 批量上传
python upload.py --dir ./h5_files

# 断点续传
python upload.py --file large_file.h5 --resume
```

## 📊 数据分析流程

### 整体处理架构

[`data_analysis.py`](./data_analysis.py) 实现了基于UMAP的大规模振动数据降维可视化分析流程，专门针对多测试台、多故障类型的机械振动信号设计。

#### 7步标准化工作流

```
1. 元数据加载 → 2. 数据集选择 → 3. 原始数据处理 → 4. 智能采样 → 5. UMAP降维 → 6. 可视化 → 7. 输出生成
```

**处理规模**: 49,000+ 振动数据段，支持21个测试台的多源数据融合分析

### 核心算法详解

#### UMAP降维分析

针对振动信号时间序列特性优化的UMAP参数配置：

```python
umap_parameters = {
    'n_neighbors': 200,      # 适合时序数据的较高邻域数
    'min_dist': 0.1,         # 控制聚类分离度
    'n_components': 2,       # 2D可视化
    'metric': 'correlation', # 振动信号相关性度量
    'random_state': 42       # 可重现结果
}
```

**技术特点**:

- ✅ **自适应参数调整**: 根据样本数量动态优化 `n_neighbors`
- ✅ **相关性度量**: 使用相关系数更适合振动信号模式识别
- ✅ **鲁棒性处理**: 自动处理数据缺失和异常值

#### 智能数据采样策略

**分层采样机制**:

- 每个故障类型组合采样200个信号段
- 保证故障模式平衡表示
- 固定随机种子确保结果可重现

**信号预处理**:

- **截断长度**: 2048点 (平衡细节保留与计算效率)
- **零填充**: 统一不同长度信号格式
- **数值验证**: 自动过滤非数值和空数据

### 多级缓存系统

#### 原始数据缓存

```
analysis_raw_m2048_k200/
├── 00_cache/
│   ├── sampled_raw_segments_m2048_k200.npy    # 数据矩阵
│   └── sampled_raw_segments_m2048_k200.csv    # 元数据标签
├── 01_reports/          # 分析报告
└── 02_umap_plots/       # 可视化图表
```

#### UMAP嵌入缓存

- **缓存键**: 基于参数组合的智能缓存命名
- **自动清理**: 检测并移除损坏的缓存文件
- **版本控制**: 参数变更时自动重新计算

### 可视化输出系统

#### 多种图表类型

**全局视图**: 所有数据集的综合UMAP图

- 使用HUSL色彩调色板支持20+数据集
- 自动图例管理 (根据数据集数量显示/隐藏)

**分面视图**: 按数据集分离的多面板图

- **颜色编码**: Domain_id (轴承、齿轮、电机等)
- **标记样式**: Label (故障类型/严重程度)
- **子图框架**: 颜色与数据集身份匹配

#### 高质量输出格式

- **PNG**: 300 DPI 论文级质量
- **SVG**: 可缩放矢量图形
- **PDF**: 文档集成格式

### 性能优化技术

#### 并行处理架构

- **多线程加载**: `ProcessPoolExecutor` 数据加载并行化
- **CPU优化**: 自动检测并使用一半可用CPU核心
- **内存效率**: 分块处理避免内存溢出

#### 算法优化

- **计算复杂度**: 从O(n²)优化到O(n)采样策略
- **缓存命中**: 避免重复UMAP计算
- **内存映射**: 大文件高效访问

### 使用示例

#### 基础分析

```bash
# 默认UMAP分析 (2048点截断, 200段采样)
python data_analysis.py
```

#### 自定义参数

```bash
# 自定义截断长度和采样数量
python data_analysis.py --trunc 1024 --samples 100

# 指定数据集分析
python data_analysis.py --dataset RM_001_CWRU
```

#### 高性能选项

```bash
# 并行处理加速 (使用4个CPU核心)
python data_analysis.py --parallel --n-jobs 4

# 处理所有数据集 (不限制数量)
python data_analysis.py --num-datasets all
```

### 关键配置参数

| 参数                                | 默认值        | 说明                |
| ----------------------------------- | ------------- | ------------------- |
| `TRUNCATE_M_POINTS`               | 2048          | 信号截断长度 (点数) |
| `SAMPLE_K_SEGMENTS`               | 200           | 每组采样段数        |
| `DEFAULT_NUM_DATASETS_TO_DISPLAY` | 18            | 默认处理数据集数量  |
| `UMAP_n_neighbors`                | 200           | UMAP邻域大小        |
| `UMAP_min_dist`                   | 0.1           | UMAP聚类紧密度      |
| `UMAP_metric`                     | 'correlation' | 距离度量方式        |

### 与系统集成

**生态系统兼容**:

- 📋 **元数据系统**: 使用统一Excel元数据 (`metadata_25_10_30.xlsx`)
- 💾 **数据格式**: 读取H5格式数据文件 (`metadata_6_1.h5`)
- 📁 **目录结构**: 遵循PHM-Vibench标准化目录约定
- 🤖 **模型支持**: 为基础模型预训练准备数据

**输出集成**:

- 分析结果可直接用于故障诊断模型训练
- 可视化图表支持技术报告和论文发表
- 缓存数据支持快速迭代实验

# Data Analysis.py 详细伪代码文档

> **文件名**: `data_analysis.py`
> **版本**: 1.0
> **创建日期**: 2024-11-14
> **用途**: PHM-Vibench 振动数据分析工具
> **描述**: 机械故障诊断振动信号的UMAP降维分析和可视化工具

---

## 📋 目录
- [整体架构概览](#整体架构概览)
- [模块详细设计](#模块详细设计)
- [核心算法说明](#核心算法说明)
- [性能优化策略](#性能优化策略)
- [扩展性设计](#扩展性设计)
- [使用示例](#使用示例)
- [故障排除指南](#故障排除指南)

---

## 🏗️ 整体架构概览

### 模块化架构设计

```mermaid
graph TD
    A[Excel元数据] --> B[元数据加载模块]
    C[H5原始数据] --> D[数据处理模块]
    B --> E[数据选择模块]
    D --> F[数据采样模块]
    E --> G[UMAP降维模块]
    F --> G
    G --> H[可视化模块]
    H --> I[多格式输出]

    J[配置管理] --> B
    J --> D
    J --> G
    J --> H

    K[缓存管理] --> D
    K --> G
```

### 主要功能模块

1. **配置模块** - 全局参数管理
2. **元数据处理模块** - Excel数据加载和选择
3. **原始数据处理模块** - H5数据加载、截断、采样
4. **UMAP降维模块** - 降维分析和缓存
5. **可视化模块** - 绘图和多格式输出
6. **主控制模块** - 工作流程编排

### 数据流程图

```mermaid
flowchart LR
    A[Excel元数据] --> B[加载元数据]
    B --> C[数据集选择]
    C --> D[元数据验证]

    E[H5原始数据] --> F[检查缓存]
    F -->|缓存存在| G[加载缓存]
    F -->|缓存不存在| H[处理原始数据]
    H --> I[信号截断/填充]
    I --> J[分组采样]
    J --> K[保存缓存]

    G --> L[UMAP降维]
    K --> L
    L --> M[检查UMAP缓存]
    M -->|存在| N[加载UMAP]
    M -->|不存在| O[计算UMAP]
    O --> P[保存UMAP缓存]

    N --> Q[可视化生成]
    P --> Q
    Q --> R[多格式保存]
```

---

## 📦 模块详细设计

### 1. 配置模块 (Configuration Module)

#### 全局常量定义

```python
# === 全局配置常量 ===
CONSTANT TRUNCATE_M_POINTS = 2048          # 默认信号截断长度
CONSTANT SAMPLE_K_SEGMENTS = 200           # 每组采样段数
CONSTANT DEFAULT_NUM_DATASETS_TO_DISPLAY = 18 # 默认显示数据集数量

# 默认UMAP参数配置
DEFAULT_UMAP_PARAMS = {
    'n_neighbors': 200,      # 邻居数量
    'min_dist': 0.1,         # 最小距离
    'n_components': 2,       # 输出维度
    'metric': 'correlation', # 相关性距离度量
    'random_state': 42       # 随机种子
}

# 可视化配置
VISUALIZATION_CONFIG = {
    'figure_size_global': (16, 12),
    'figure_size_facet': (6, 5),
    'color_palette': 'husl',
    'markers': ['o', 's', 'D', '^', 'v', '<', '>', 'p', '*', 'h', 'H'],
    'dpi': 300,
    'formats': ['png', 'svg', 'pdf']
}
```

### 2. 元数据处理模块伪代码

```python
FUNCTION load_and_select_metadata(excel_path, num_datasets_to_display=None, reports_dir="reports"):
    """
    功能：加载Excel元数据，提取数据集名称，排序，选择子集
    """
    TRY:
        metadata_df = pandas.read_excel(excel_path)
    EXCEPT FileNotFoundError:
        RETURN None

    # 验证必需列
    REQUIRED_COLUMNS = ['Id']
    missing_required = [col for col in REQUIRED_COLUMNS if col not in metadata_df.columns]
    IF missing_required:
        RETURN None

    # 处理数据集名称列
    IF 'Name' not in metadata_df.columns:
        IF 'Dataset_id' not in metadata_df.columns:
            RETURN None
        ELSE:
            metadata_df['Dataset_Name'] = metadata_df['Dataset_id'].astype(str)
    ELSE:
        metadata_df['Dataset_Name'] = metadata_df['Name'].apply(extract_dataset_name)

    # 数据清洗和排序
    metadata_df['Id'] = pandas.to_numeric(metadata_df['Id'], errors='coerce')
    metadata_df.dropna(subset=['Id'], inplace=True)
    metadata_df.sort_values(by='Id', inplace=True)

    # 数据集选择
    selected_metadata_df = metadata_df.copy()
    IF num_datasets_to_display is not None AND num_datasets_to_display > 0:
        dataset_counts = selected_metadata_df['Dataset_Name'].value_counts()
        top_datasets = dataset_counts.nlargest(num_datasets_to_display).index
        selected_metadata_df = selected_metadata_df[
            selected_metadata_df['Dataset_Name'].isin(top_datasets)
        ]

    # 保存结果
    os.makedirs(reports_dir, exist_ok=True)
    selected_metadata_path = os.path.join(reports_dir, "selected_metadata.csv")
    selected_metadata_df.to_csv(selected_metadata_path, index=False)

    RETURN selected_metadata_df

FUNCTION extract_dataset_name(name):
    """从Name中提取数据集名称"""
    IF isinstance(name, str) AND '_' in name:
        RETURN name.split('_')[-1]
    ELSE:
        RETURN str(name)
```

### 3. 原始数据处理模块伪代码

```python
FUNCTION load_process_sample_raw_data(h5_filepath, selected_metadata_df, cache_dir,
                                     truncate_m_points=TRUNCATE_M_POINTS,
                                     sample_k_segments=SAMPLE_K_SEGMENTS,
                                     max_workers=None):
    """
    功能：加载、处理、采样原始振动数据
    """
    # 缓存检查
    matrix_cache_path = os.path.join(cache_dir,
        f"sampled_raw_segments_m{truncate_m_points}_k{sample_k_segments}.npy")
    labels_cache_path = os.path.join(cache_dir,
        f"sampled_raw_segments_labels_m{truncate_m_points}_k{sample_k_segments}.csv")

    IF os.path.exists(matrix_cache_path) AND os.path.exists(labels_cache_path):
        RETURN load_from_cache(matrix_cache_path, labels_cache_path)

    # 数据处理
    items_to_process = match_metadata_with_h5(selected_metadata_df, h5_filepath)
    IF not items_to_process:
        RETURN None, None

    # 并行处理
    all_processed_segments = parallel_process_segments(items_to_process, h5_filepath,
                                                      truncate_m_points, max_workers)

    # 数据整理和采样
    full_segments_df = pandas.DataFrame(all_processed_segments)
    sampled_df = group_and_sample(full_segments_df, sample_k_segments)

    # 保存缓存
    save_to_cache(sampled_df, matrix_cache_path, labels_cache_path)

    # 准备输出
    sampled_raw_segments_matrix = numpy.array(sampled_df['raw_segment'].tolist())
    sampled_labels_df = sampled_df.drop(columns=['raw_segment'])

    RETURN sampled_raw_segments_matrix, sampled_labels_df

FUNCTION _process_single_raw_segment(h5_key_meta_tuple, h5_filepath, truncate_m_points):
    """处理单个原始数据段"""
    h5_key, meta_info = h5_key_meta_tuple

    TRY:
        WITH h5py.File(h5_filepath, 'r') as h5f:
            raw_data = h5f[h5_key][()]

        IF not numpy.issubdtype(raw_data.dtype, numpy.number):
            RETURN None

        raw_data = raw_data.flatten()
        IF raw_data.size == 0:
            RETURN None

        # 数据长度标准化
        processed_data = standardize_length(raw_data, truncate_m_points)

        RETURN {
            'Id': meta_info['Id'],
            'H5_Key': h5_key,
            'Dataset_id': meta_info.get('Dataset_id', 'N/A'),
            'Dataset_Name': meta_info.get('Dataset_Name', 'N/A'),
            'Label': meta_info.get('Label', 'N/A'),
            'Domain_id': meta_info.get('Domain_id', 'N/A'),
            'Fault_level': meta_info.get('Fault_level', 'N/A'),
            'raw_segment': processed_data
        }
    EXCEPT Exception:
        RETURN None

FUNCTION standardize_length(data, target_length):
    """将数据标准化到指定长度"""
    IF data.size > target_length:
        RETURN data[:target_length]
    ELIF data.size < target_length:
        padding_length = target_length - data.size
        RETURN numpy.pad(data, (0, padding_length), 'constant')
    ELSE:
        RETURN data

FUNCTION group_and_sample(segments_df, sample_size):
    """分组采样"""
    grouping_cols = [col for col in ['Dataset_Name', 'Domain_id', 'Label']
                    if col in segments_df.columns]

    IF not grouping_cols:
        RETURN segments_df

    DEF sample_group(group):
        RETURN group.sample(n=min(len(group), sample_size), random_state=1)

    sampled_df = segments_df.groupby(grouping_cols, group_keys=False).apply(sample_group)
    sampled_df.sort_values(by='Id', inplace=True)

    RETURN sampled_df
```

### 4. UMAP降维模块伪代码

```python
FUNCTION run_umap_reduction(data_matrix, cache_dir, umap_params, filename_prefix="umap_embedding"):
    """
    功能：运行UMAP降维分析
    """
    # 参数提取
    n_neighbors = umap_params.get('n_neighbors', 15)
    min_dist = umap_params.get('min_dist', 0.1)
    n_components = umap_params.get('n_components', 2)
    metric = umap_params.get('metric', 'euclidean')
    random_state = umap_params.get('random_state', 42)

    # 缓存检查
    embedding_cache_path = os.path.join(cache_dir,
        f"{filename_prefix}_nn{n_neighbors}_md{min_dist}_c{n_components}_{metric}.npy")

    IF os.path.exists(embedding_cache_path):
        TRY:
            embedding = numpy.load(embedding_cache_path)
            RETURN embedding
        EXCEPT Exception:
            os.remove(embedding_cache_path)

    # 参数调整
    IF data_matrix.shape[0] <= n_neighbors:
        n_neighbors = max(1, data_matrix.shape[0] - 1)
        IF n_neighbors == 0:
            RETURN None

    # 运行UMAP
    reducer = umap.UMAP(
        n_neighbors=n_neighbors,
        min_dist=min_dist,
        n_components=n_components,
        metric=metric,
        random_state=random_state,
        verbose=True
    )

    TRY:
        embedding = reducer.fit_transform(data_matrix)
        numpy.save(embedding_cache_path, embedding)
        RETURN embedding
    EXCEPT Exception:
        RETURN None
```

### 5. 可视化模块伪代码

```python
FUNCTION plot_umap_global(umap_df, hue_col, output_dir, filename_base, title_suffix):
    """
    功能：绘制全局UMAP散点图
    """
    # 准备颜色映射
    unique_hues = sorted(umap_df[hue_col].unique())
    palette = seaborn.color_palette("husl", n_colors=len(unique_hues))
    color_map = dict(zip(unique_hues, palette))

    # 创建图形
    fig, ax = matplotlib.pyplot.subplots(figsize=(16, 12))
    seaborn.set_style("whitegrid")

    # 绘制散点图
    seaborn.scatterplot(
        x='UMAP1', y='UMAP2',
        hue=hue_col,
        hue_order=unique_hues,
        palette=color_map,
        data=umap_df,
        s=50, alpha=0.7, ax=ax,
        legend="auto" IF len(unique_hues) <= 20 ELSE False
    )

    # 设置标题和图例
    ax.set_title(f'Global UMAP: {title_suffix}', fontsize=18)
    IF len(unique_hues) > 1 AND len(unique_hues) <= 20:
        ax.legend(title=hue_col, bbox_to_anchor=(1.02, 1), loc='upper left')

    # 保存图形
    save_plot_multiformat(fig, output_dir, filename_base)
    matplotlib.pyplot.close(fig)

    RETURN color_map

FUNCTION plot_umap_faceted_by_dataset(umap_df, facet_col, color_col, style_col,
                                     dataset_color_map, output_dir, filename_base_prefix, title_prefix):
    """
    功能：绘制按数据集分面的UMAP图
    """
    unique_facets = sorted(umap_df[facet_col].unique())

    # 计算网格布局
    n_facets = len(unique_facets)
    n_cols = min(3, n_facets)
    n_rows = (n_facets + n_cols - 1) // n_cols

    # 创建子图网格
    fig, axes = matplotlib.pyplot.subplots(n_rows, n_cols,
                                         figsize=(6 * n_cols, 5 * n_rows),
                                         squeeze=False, sharex=True, sharey=True)
    axes_flat = axes.flatten()

    # 准备颜色和样式映射
    all_unique_colors = sorted(umap_df[color_col].astype(str).unique())
    color_palette = seaborn.color_palette("Set2", n_colors=len(all_unique_colors))

    all_unique_styles = sorted(umap_df[style_col].astype(str).unique())
    available_markers = ['o', 's', 'D', '^', 'v', '<', '>', 'p', '*', 'h', 'H']
    markers_map = {style_val: available_markers[j % len(available_markers)]
                  FOR j, style_val IN enumerate(all_unique_styles)}

    # 绘制每个分面
    FOR i, facet_value IN enumerate(unique_facets):
        IF i >= len(axes_flat):
            BREAK

        ax = axes_flat[i]
        facet_data = umap_df[umap_df[facet_col] == facet_value].copy()

        IF facet_data.empty:
            ax.text(0.5, 0.5, "No data", ha='center', va='center', transform=ax.transAxes)
            CONTINUE

        # 绘制散点图
        seaborn.scatterplot(
            x='UMAP1', y='UMAP2',
            hue=color_col,
            hue_order=all_unique_colors,
            palette=color_palette,
            style=style_col,
            style_order=[s for s in all_unique_styles if s in facet_data[style_col].unique()],
            markers=markers_map,
            data=facet_data,
            s=70, alpha=0.85, ax=ax,
            legend='auto'
        )

        ax.set_title(f"{facet_value}", fontsize=14, fontweight='bold',
                    color=dataset_color_map.get(facet_value, 'black'))

    # 清理多余子图
    FOR j IN range(i + 1, len(axes_flat)):
        fig.delaxes(axes_flat[j])

    # 设置总标题并保存
    fig.suptitle(f"{title_prefix}\\n(Faceted by {facet_col})", fontsize=20, y=0.99)
    matplotlib.pyplot.tight_layout(rect=[0.03, 0.03, 0.97, 0.96])

    filename = f"{filename_base_prefix}_facet_{facet_col}_color_{color_col}_style_{style_col}"
    save_plot_multiformat(fig, output_dir, filename)
    matplotlib.pyplot.close(fig)

FUNCTION save_plot_multiformat(fig, output_dir, filename_base, high_dpi=300):
    """将图形保存为多种格式"""
    formats = {'png': {'dpi': high_dpi}, 'svg': {}, 'pdf': {}}

    FOR format_name, options IN formats.items():
        TRY:
            save_path = os.path.join(output_dir, f"{filename_base}.{format_name}")
            fig.savefig(save_path, **options, bbox_inches='tight')
        EXCEPT Exception as e:
            PRINT f"Error saving {format_name}: {e}"
```

### 6. 主控制模块伪代码

```python
FUNCTION main():
    """
    功能：完整的分析工作流程控制
    """
    TRY:
        # === 阶段1: 初始化 ===
        excel_filepath = "metadata_25_10_30.xlsx"
        h5_filepath = "metadata_6_1.h5"

        # 文件验证
        IF not os.path.exists(excel_filepath):
            RAISE FileNotFoundError(f"Excel file not found: {excel_filepath}")
        IF not os.path.exists(h5_filepath):
            RAISE FileNotFoundError(f"H5 file not found: {h5_filepath}")

        # 目录创建
        base_output_dir = f"analysis_raw_m{TRUNCATE_M_POINTS}_k{SAMPLE_K_SEGMENTS}"
        cache_dir = os.path.join(base_output_dir, "00_cache")
        reports_dir = os.path.join(base_output_dir, "01_reports")
        umap_plots_dir = os.path.join(base_output_dir, "02_umap_plots")

        FOR d IN [cache_dir, reports_dir, umap_plots_dir]:
            os.makedirs(d, exist_ok=True)

        # === 阶段2: 参数配置 ===
        num_datasets_to_plot = DEFAULT_NUM_DATASETS_TO_DISPLAY
        max_parallel_workers = os.cpu_count() // 2 IF os.cpu_count() > 1 ELSE 1

        umap_parameters = {
            'n_neighbors': 200,
            'min_dist': 0.1,
            'n_components': 2,
            'metric': 'correlation',
            'random_state': 42
        }

        # === 阶段3: 元数据处理 ===
        selected_metadata = load_and_select_metadata(
            excel_filepath,
            num_datasets_to_display=num_datasets_to_plot,
            reports_dir=reports_dir
        )

        IF selected_metadata is None:
            RETURN

        # === 阶段4: 原始数据处理 ===
        sampled_raw_matrix, sampled_labels = load_process_sample_raw_data(
            h5_filepath, selected_metadata, cache_dir,
            truncate_m_points=TRUNCATE_M_POINTS,
            sample_k_segments=SAMPLE_K_SEGMENTS,
            max_workers=max_parallel_workers
        )

        IF sampled_raw_matrix is None:
            RETURN

        # === 阶段5: UMAP降维 ===
        umap_embedding = run_umap_reduction(
            sampled_raw_matrix, cache_dir, umap_parameters,
            filename_prefix=f"raw_m{TRUNCATE_M_POINTS}_k{SAMPLE_K_SEGMENTS}"
        )

        IF umap_embedding is None:
            RETURN

        # === 阶段6: 可视化生成 ===
        umap_plot_df = sampled_labels.copy()
        umap_plot_df['UMAP1'] = umap_embedding[:, 0]
        umap_plot_df['UMAP2'] = umap_embedding[:, 1]

        # 保存结果
        umap_results_path = os.path.join(reports_dir,
                                       f"umap_results_m{TRUNCATE_M_POINTS}_k{SAMPLE_K_SEGMENTS}.csv")
        umap_plot_df.to_csv(umap_results_path, index=False)

        # 生成图表
        dataset_color_palette = plot_umap_global(
            umap_plot_df, 'Dataset_Name', umap_plots_dir,
            "global_umap_by_dataset_name", "Colored by Dataset Name"
        )

        plot_umap_faceted_by_dataset(
            umap_plot_df, 'Dataset_Name', 'Domain_id', 'Label',
            dataset_color_palette or {}, umap_plots_dir,
            "faceted_umap_combined", "UMAP: Domain ID (Color) & Label (Marker)"
        )

        PRINT "Analysis Complete!"

    EXCEPT Exception as e:
        PRINT f"Error in main analysis: {e}"
    FINALLY:
        matplotlib.pyplot.close('all')

IF __name__ == '__main__':
    main()
```

---

## 🧮 核心算法说明

### 算法1: 自适应分组采样算法

```
目的: 从每个数据集中均匀采样，保证数据平衡性
时间复杂度: O(N) 其中N为总样本数
空间复杂度: O(N) 用于存储分组结果
```

```python
FUNCTION adaptive_grouped_sampling(data_segments, grouping_columns, sample_size, random_seed):
    SET random seed

    # 按分组列进行分组
    groups = create_groups(data_segments, grouping_columns)
    sampled_segments = []

    FOR EACH group IN groups:
        group_size = len(group)

        IF group_size <= sample_size:
            selected_from_group = group
        ELSE:
            selected_from_group = random_sample(group, sample_size)

        ADD selected_from_group TO sampled_segments

    RETURN sampled_segments
```

### 算法2: UMAP参数自适应调整

```
目的: 根据数据特征自动调整UMAP参数
```

```python
FUNCTION optimize_umap_parameters(data_matrix, initial_params):
    n_samples, n_features = data_matrix.shape

    # 基于数据规模调整邻居数
    target_neighbors = int(math.sqrt(n_samples))
    target_neighbors = max(15, min(target_neighbors, n_samples - 1))

    # 基于数据维度调整最小距离
    IF n_features > 1000:
        min_dist = 0.0
    ELIF n_features > 100:
        min_dist = 0.1
    ELSE:
        min_dist = 0.3

    RETURN {
        'n_neighbors': target_neighbors,
        'min_dist': min_dist,
        'n_components': initial_params.get('n_components', 2),
        'metric': 'correlation',
        'random_state': initial_params.get('random_state', 42)
    }
```

---

## 📈 数据统计

### 故障类型分布

TODO