scripts/quick_check.py

#!/usr/bin/env python3
"""
PHM-Vibench Metadata 快速验证和修复脚本
用于检查和修复 metadata_25_10_30.xlsx 中的关键问题
"""

import pandas as pd
import numpy as np
import h5py
import os
from datetime import datetime
import json
import sys

class MetadataChecker:
    def __init__(self):
        self.base_path = '/home/user/data/PHMbenchdata/PHM-Vibench'
        self.metadata_path = os.path.join(self.base_path, 'metadata_25_10_30.xlsx')
        self.h5_path = os.path.join(self.base_path, 'metadata_6_1.h5')
        self.backup_path = os.path.join(self.base_path, 'backups')
        self.log_path = os.path.join(self.base_path, 'log')

        # 确保目录存在
        os.makedirs(self.backup_path, exist_ok=True)
        os.makedirs(self.log_path, exist_ok=True)

    def load_metadata(self):
        """加载metadata文件"""
        print(f"📂 加载 metadata 文件: {self.metadata_path}")
        self.df = pd.read_excel(self.metadata_path)
        print(f"✅ 成功加载 {len(self.df)} 条记录")

    def check_h5_data(self):
        """检查H5文件中的实际数据维度"""
        print("\n🔍 检查 H5 文件数据维度...")

        if not os.path.exists(self.h5_path):
            print(f"❌ H5文件不存在: {self.h5_path}")
            return

        with h5py.File(self.h5_path, 'r') as f:
            # Dataset_id 18 对应的Id范围: 47288-47566
            print("\n=== Dataset_id 18 (Id: 47288-47566) ===")
            shapes_18 = []
            for i in range(47288, min(47298, 47567)):  # 检查前10个
                key = str(i)
                if key in f:
                    data = f[key][()]
                    if isinstance(data, np.ndarray):
                        shapes_18.append(data.shape)
                        print(f"  Id {i}: shape={data.shape}")

            # Dataset_id 20 对应的Id范围: 47567-50126
            print("\n=== Dataset_id 20 (Id: 47567-47577) ===")
            shapes_20 = []
            for i in range(47567, min(47577, 50127)):  # 检查前10个
                key = str(i)
                if key in f:
                    data = f[key][()]
                    if isinstance(data, np.ndarray):
                        shapes_20.append(data.shape)
                        print(f"  Id {i}: shape={data.shape}")

            # 更多抽样检查
            print("\n=== 抽样统计 ===")
            for i in range(47288, 47567, 20):  # 每20个抽样
                key = str(i)
                if key in f:
                    data = f[key][()]
                    if isinstance(data, np.ndarray):
                        shapes_18.append(data.shape)

            for i in range(47567, 50127, 100):  # 每100个抽样
                key = str(i)
                if key in f:
                    data = f[key][()]
                    if isinstance(data, np.ndarray):
                        shapes_20.append(data.shape)

            if shapes_18:
                unique_shapes_18 = set(shapes_18)
                print(f"\nDataset_id 18 数据维度分布:")
                for shape in unique_shapes_18:
                    count = shapes_18.count(shape)
                    print(f"  {shape}: {count} 次")

            if shapes_20:
                unique_shapes_20 = set(shapes_20)
                print(f"\nDataset_id 20 数据维度分布:")
                for shape in unique_shapes_20:
                    count = shapes_20.count(shape)
                    print(f"  {shape}: {count} 次")

            # 保存检查结果
            self.h5_shapes_18 = shapes_18 if shapes_18 else []
            self.h5_shapes_20 = shapes_20 if shapes_20 else []

    def analyze_metadata_issues(self):
        """分析metadata中的问题"""
        print("\n📊 分析 metadata 问题...")

        # Dataset_id 18
        df_18 = self.df[self.df['Dataset_id'] == 18]
        print(f"\nDataset_id 18:")
        print(f"  记录数: {len(df_18)}")
        if len(df_18) > 0:
            print(f"  Channel: {df_18['Channel'].unique()}")
            print(f"  Sample_lenth: {df_18['Sample_lenth'].unique()}")
            print(f"  Name: {df_18['Name'].unique()}")
            self.meta_channel_18 = df_18['Channel'].iloc[0]
            self.meta_length_18 = df_18['Sample_lenth'].iloc[0]

        # Dataset_id 20
        df_20 = self.df[self.df['Dataset_id'] == 20]
        print(f"\nDataset_id 20:")
        print(f"  记录数: {len(df_20)}")
        if len(df_20) > 0:
            print(f"  Channel: {df_20['Channel'].unique()}")
            print(f"  Sample_lenth: {df_20['Sample_lenth'].unique()}")
            print(f"  Name: {df_20['Name'].unique()}")
            self.meta_channel_20 = df_20['Channel'].iloc[0]
            self.meta_length_20 = df_20['Sample_lenth'].iloc[0]

    def identify_issues(self):
        """识别需要修复的问题"""
        print("\n⚠️ 识别问题...")

        self.issues = []

        # 检查Dataset_id 18
        if hasattr(self, 'h5_shapes_18') and self.h5_shapes_18:
            # 统计各种形状的出现次数
            shape_counts_18 = {}
            for shape in self.h5_shapes_18:
                shape_counts_18[shape] = shape_counts_18.get(shape, 0) + 1

            # 找出最常见的形状
            most_common_shape = max(shape_counts_18.items(), key=lambda x: x[1])
            actual_length = int(most_common_shape[0][0])
            actual_channels = int(most_common_shape[0][1])

            print(f"\nDataset_id 18 维度统计:")
            for shape, count in sorted(shape_counts_18.items(), key=lambda x: x[1], reverse=True)[:5]:
                print(f"  {shape}: {count}次")

            if self.meta_length_18 != actual_length:
                self.issues.append({
                    'dataset_id': 18,
                    'type': 'sample_length_mismatch',
                    'metadata_value': self.meta_length_18,
                    'h5_value': actual_length,
                    'description': f"Sample_lenth不匹配: metadata={self.meta_length_18}, H5实际={actual_length}"
                })

            if self.meta_channel_18 != actual_channels:
                self.issues.append({
                    'dataset_id': 18,
                    'type': 'channel_mismatch',
                    'metadata_value': self.meta_channel_18,
                    'h5_value': actual_channels,
                    'description': f"Channel不匹配: metadata={self.meta_channel_18}, H5实际={actual_channels}"
                })

        # 检查Dataset_id 20
        if hasattr(self, 'h5_shapes_20') and self.h5_shapes_20:
            # 统计各种形状的出现次数
            shape_counts_20 = {}
            for shape in self.h5_shapes_20:
                shape_counts_20[shape] = shape_counts_20.get(shape, 0) + 1

            # 找出最常见的形状
            most_common_shape = max(shape_counts_20.items(), key=lambda x: x[1])
            actual_length = int(most_common_shape[0][0])
            actual_channels = int(most_common_shape[0][1])

            print(f"\nDataset_id 20 维度统计:")
            for shape, count in sorted(shape_counts_20.items(), key=lambda x: x[1], reverse=True)[:5]:
                print(f"  {shape}: {count}次")

            if self.meta_length_20 != actual_length:
                self.issues.append({
                    'dataset_id': 20,
                    'type': 'sample_length_mismatch',
                    'metadata_value': self.meta_length_20,
                    'h5_value': actual_length,
                    'description': f"Sample_lenth不匹配: metadata={self.meta_length_20}, H5实际={actual_length}"
                })

            if self.meta_channel_20 != actual_channels:
                self.issues.append({
                    'dataset_id': 20,
                    'type': 'channel_mismatch',
                    'metadata_value': self.meta_channel_20,
                    'h5_value': actual_channels,
                    'description': f"Channel不匹配: metadata={self.meta_channel_20}, H5实际={actual_channels}"
                })

        # 输出问题汇总
        if self.issues:
            print(f"\n发现 {len(self.issues)} 个问题:")
            for i, issue in enumerate(self.issues, 1):
                print(f"\n问题 {i}: Dataset_id {issue['dataset_id']}")
                print(f"  类型: {issue['type']}")
                print(f"  描述: {issue['description']}")
        else:
            print("\n✅ 未发现明显问题")

    def backup_metadata(self):
        """备份原始metadata文件"""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        backup_file = os.path.join(self.backup_path, f"metadata_25_10_30_backup_{timestamp}.xlsx")

        print(f"\n💾 备份原始文件到: {backup_file}")
        self.df.to_excel(backup_file, index=False)
        print("✅ 备份完成")

        return backup_file

    def fix_metadata(self):
        """修复metadata中的问题"""
        if not self.issues:
            print("\n✅ 没有需要修复的问题")
            return

        print("\n🔧 开始修复 metadata...")

        # 创建修复后的DataFrame副本
        df_fixed = self.df.copy()
        fix_log = []

        for issue in self.issues:
            dataset_id = issue['dataset_id']

            if issue['type'] == 'sample_length_mismatch':
                mask = df_fixed['Dataset_id'] == dataset_id
                old_value = df_fixed.loc[mask, 'Sample_lenth'].iloc[0]
                new_value = issue['h5_value']

                df_fixed.loc[mask, 'Sample_lenth'] = new_value
                fix_log.append({
                    'dataset_id': dataset_id,
                    'field': 'Sample_lenth',
                    'old_value': old_value,
                    'new_value': new_value,
                    'records_affected': mask.sum()
                })
                print(f"  ✓ Dataset_id {dataset_id}: Sample_lenth {old_value} → {new_value}")

            elif issue['type'] == 'channel_mismatch':
                mask = df_fixed['Dataset_id'] == dataset_id
                old_value = df_fixed.loc[mask, 'Channel'].iloc[0]
                new_value = issue['h5_value']

                df_fixed.loc[mask, 'Channel'] = new_value
                fix_log.append({
                    'dataset_id': dataset_id,
                    'field': 'Channel',
                    'old_value': old_value,
                    'new_value': new_value,
                    'records_affected': mask.sum()
                })
                print(f"  ✓ Dataset_id {dataset_id}: Channel {old_value} → {new_value}")

        # 保存修复后的文件
        fixed_file = os.path.join(self.base_path, 'metadata_25_10_30_fixed.xlsx')
        df_fixed.to_excel(fixed_file, index=False)
        print(f"\n✅ 修复后的文件保存到: {fixed_file}")

        # 保存修复日志
        log_file = os.path.join(self.log_path, 'fix_log.json')
        # 转换numpy类型为python原生类型
        issues_serializable = []
        for issue in self.issues:
            issue_copy = issue.copy()
            if 'metadata_value' in issue_copy:
                issue_copy['metadata_value'] = int(issue_copy['metadata_value']) if hasattr(issue_copy['metadata_value'], 'dtype') else issue_copy['metadata_value']
            if 'h5_value' in issue_copy:
                issue_copy['h5_value'] = int(issue_copy['h5_value']) if hasattr(issue_copy['h5_value'], 'dtype') else issue_copy['h5_value']
            issues_serializable.append(issue_copy)

        fixes_serializable = []
        for fix in fix_log:
            fix_copy = fix.copy()
            for key in ['old_value', 'new_value']:
                if key in fix_copy and hasattr(fix_copy[key], 'dtype'):
                    fix_copy[key] = int(fix_copy[key])
            if 'records_affected' in fix_copy and hasattr(fix_copy['records_affected'], 'dtype'):
                fix_copy['records_affected'] = int(fix_copy['records_affected'])
            fixes_serializable.append(fix_copy)

        with open(log_file, 'w', encoding='utf-8') as f:
            json.dump({
                'timestamp': datetime.now().isoformat(),
                'issues_found': issues_serializable,
                'fixes_applied': fixes_serializable
            }, f, indent=2, ensure_ascii=False)
        print(f"📝 修复日志保存到: {log_file}")

        self.df_fixed = df_fixed
        self.fix_log = fix_log

    def generate_report(self):
        """生成验证报告"""
        report = {
            'timestamp': datetime.now().isoformat(),
            'metadata_file': self.metadata_path,
            'h5_file': self.h5_path,
            'total_records': len(self.df),
            'issues_found': len(self.issues) if hasattr(self, 'issues') else 0,
            'dataset_analysis': {
                'dataset_18': {
                    'id_range': '47288-47566',
                    'records': len(self.df[self.df['Dataset_id'] == 18]),
                    'metadata_channel': self.meta_channel_18 if hasattr(self, 'meta_channel_18') else None,
                    'metadata_length': self.meta_length_18 if hasattr(self, 'meta_length_18') else None
                },
                'dataset_20': {
                    'id_range': '47567-50126',
                    'records': len(self.df[self.df['Dataset_id'] == 20]),
                    'metadata_channel': self.meta_channel_20 if hasattr(self, 'meta_channel_20') else None,
                    'metadata_length': self.meta_length_20 if hasattr(self, 'meta_length_20') else None
                }
            }
        }

        report_file = os.path.join(self.log_path, 'validation_report.json')
        with open(report_file, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)

        print(f"\n📊 验证报告保存到: {report_file}")

    def run(self, auto_fix=False):
        """运行完整的验证和修复流程"""
        print("=" * 60)
        print("🚀 PHM-Vibench Metadata 验证和修复工具")
        print("=" * 60)

        # 1. 加载数据
        self.load_metadata()

        # 2. 检查H5数据
        self.check_h5_data()

        # 3. 分析metadata
        self.analyze_metadata_issues()

        # 4. 识别问题
        self.identify_issues()

        # 5. 备份
        backup_file = self.backup_metadata()

        # 6. 修复（如果需要）
        if auto_fix and self.issues:
            self.fix_metadata()

        # 7. 生成报告
        self.generate_report()

        print("\n" + "=" * 60)
        print("✅ 验证完成!")
        print("=" * 60)

        if hasattr(self, 'issues') and self.issues:
            print(f"\n发现 {len(self.issues)} 个问题需要修复")
            print("使用 --fix 参数执行自动修复")
        else:
            print("\n✅ 未发现问题")


def main():
    import argparse

    parser = argparse.ArgumentParser(description='PHM-Vibench Metadata 验证和修复工具')
    parser.add_argument('--fix', action='store_true', help='自动修复发现的问题')
    parser.add_argument('--check-only', action='store_true', help='仅检查不修复')

    args = parser.parse_args()

    checker = MetadataChecker()

    if args.check_only:
        checker.run(auto_fix=False)
    else:
        checker.run(auto_fix=args.fix)


if __name__ == "__main__":
    main()