Data Exploration Visualization

#!/usr/bin/env python3
"""
金融数据分析示例
演示如何使用数据探索可视化技能进行金融数据分析
"""

import sys
import os
import pandas as pd
import numpy as np
from pathlib import Path

# 添加技能路径
skill_path = Path(__file__).parent.parent
sys.path.append(str(skill_path / "scripts"))

def create_financial_sample_data():
    """创建金融数据样本"""
    print("💰 创建金融数据样本...")

    np.random.seed(123)
    n_customers = 1000

    # 基础客户信息
    data = {
        'customer_id': [f'C{i:06d}' for i in range(1, n_customers + 1)],
        'age': np.random.randint(18, 80, n_customers),
        'gender': np.random.choice(['男', '女'], n_customers, p=[0.52, 0.48]),
        'income': np.random.lognormal(10.5, 0.5, n_customers),  # 收入分布
        'credit_score': np.random.normal(650, 100, n_customers),
        'employment_years': np.random.exponential(5, n_customers),
        'home_ownership': np.random.choice(['租房', '按揭', '自有'], n_customers, p=[0.35, 0.45, 0.20]),
        'marital_status': np.random.choice(['单身', '已婚', '离异'], n_customers, p=[0.3, 0.6, 0.1]),
        'education_level': np.random.choice(['高中', '本科', '硕士', '博士'], n_customers, p=[0.3, 0.4, 0.25, 0.05]),
        'debt_to_income_ratio': np.random.beta(2, 5, n_customers),  # 负债收入比
        'savings_amount': np.random.exponential(10000, n_customers),
        'credit_cards_count': np.random.poisson(2, n_customers),
        'late_payments_last_year': np.random.poisson(1, n_customers),
        'bankruptcy_history': np.random.choice([0, 1], n_customers, p=[0.95, 0.05]),
        'loan_amount': np.random.lognormal(9, 1, n_customers),
        'loan_purpose': np.random.choice(
            ['购房', '购车', '教育', '装修', '债务整合', '其他'],
            n_customers, p=[0.25, 0.2, 0.15, 0.15, 0.15, 0.1]
        ),
        'loan_term_months': np.random.choice([12, 24, 36, 48, 60], n_customers, p=[0.1, 0.2, 0.3, 0.25, 0.15]),
        'interest_rate': np.random.uniform(3.5, 15.0, n_customers),
    }

    # 创建相关性
    df = pd.DataFrame(data)

    # 收入与信用分数的相关性
    df['credit_score'] = np.clip(
        df['credit_score'] + (df['income'] - df['income'].mean()) / df['income'].std() * 20,
        300, 850
    )

    # 年龄与工作年限的相关性
    df['employment_years'] = np.minimum(df['employment_years'], df['age'] - 18)

    # 收入与贷款金额的相关性
    df['loan_amount'] = df['loan_amount'] * (0.5 + 0.5 * df['income'] / df['income'].mean())

    # 负债收入比与利率的相关性
    df['interest_rate'] = df['interest_rate'] + df['debt_to_income_ratio'] * 5

    # 信用评分与利率的相关性（负相关）
    df['interest_rate'] = df['interest_rate'] - (df['credit_score'] - 650) / 100

    # 计算违约概率（目标变量）
    default_probability = (
        (df['credit_score'] < 600) * 0.4 +
        (df['debt_to_income_ratio'] > 0.4) * 0.3 +
        (df['late_payments_last_year'] > 3) * 0.2 +
        (df['bankruptcy_history'] == 1) * 0.3 +
        (df['employment_years'] < 1) * 0.2 +
        (df['income'] < 30000) * 0.15 +
        np.random.normal(0, 0.1, n_customers)
    )

    # 转换为二分类
    df['loan_default'] = (default_probability > 0.3).astype(int)

    # 风险等级
    risk_conditions = [
        df['credit_score'] >= 750,
        (df['credit_score'] >= 700) & (df['credit_score'] < 750),
        (df['credit_score'] >= 650) & (df['credit_score'] < 700),
        (df['credit_score'] >= 600) & (df['credit_score'] < 650),
        df['credit_score'] < 600
    ]

    risk_labels = ['AAA', 'AA', 'A', 'BBB', 'BB']
    df['risk_rating'] = np.select(risk_conditions, risk_labels, default='BB')

    # 添加一些缺失值
    missing_indices = np.random.choice(df.index, size=int(0.08 * len(df)), replace=False)
    df.loc[missing_indices, 'savings_amount'] = np.nan

    missing_indices = np.random.choice(df.index, size=int(0.05 * len(df)), replace=False)
    df.loc[missing_indices, 'employment_years'] = np.nan

    # 保存数据
    output_dir = Path(__file__).parent / "data"
    output_dir.mkdir(exist_ok=True)

    data_path = output_dir / "financial_data_sample.csv"
    df.to_csv(data_path, index=False, encoding='utf-8-sig')

    print(f"   ✓ 金融数据样本已保存: {data_path}")
    print(f"   ✓ 数据形状: {df.shape}")
    print(f"   ✓ 违约率: {df['loan_default'].mean():.2%}")
    print(f"   ✓ 平均信用分数: {df['credit_score'].mean():.1f}")

    return df, data_path

def run_financial_eda_analysis(data_path):
    """运行金融数据EDA分析"""
    print("\n🔍 运行金融数据探索性分析...")

    try:
        from eda_analyzer import EDAAnalyzer

        analyzer = EDAAnalyzer()

        # 加载数据
        print("   加载数据...")
        data = analyzer.load_data(data_path)

        # 自动化EDA分析
        print("   执行自动化EDA分析...")
        eda_results = analyzer.auto_eda(data)

        # 保存EDA结果
        output_dir = Path(__file__).parent / "results"
        output_dir.mkdir(exist_ok=True)

        eda_path = output_dir / "financial_eda_results.json"
        analyzer.export_results(eda_results, eda_path)

        print(f"   ✓ EDA分析完成，结果已保存: {eda_path}")

        # 显示关键发现
        print("\n📊 关键发现:")
        if 'insights' in eda_results:
            for insight in eda_results['insights'][:3]:
                print(f"   - {insight}")

        return eda_results, data

    except Exception as e:
        print(f"   ❌ EDA分析失败: {str(e)}")
        return None, None

def run_financial_visualization(data):
    """运行金融数据可视化"""
    print("\n📈 生成金融数据可视化图表...")

    try:
        from visualizer import DataVisualizer

        visualizer = DataVisualizer()

        # 自动可视化
        charts = visualizer.auto_visualize(
            data,
            target_col='loan_default',
            save_charts=True,
            output_dir=str(Path(__file__).parent / "results" / "charts")
        )

        print(f"   ✓ 可视化完成，生成了 {charts['charts_generated']} 个图表")

        # 生成金融专项图表
        financial_charts = {}

        # 1. 信用分数分布
        fig = visualizer.plot_distribution(
            data, 'credit_score',
            interactive=True
        )
        financial_charts['credit_score_distribution'] = fig

        # 2. 收入 vs 贷款金额
        fig = visualizer.plot_scatter(
            data, 'income', 'loan_amount',
            color_col='loan_default',
            interactive=True
        )
        financial_charts['income_loan_scatter'] = fig

        # 3. 风险等级分布
        fig = visualizer.plot_categorical(
            data, 'risk_rating',
            interactive=True
        )
        financial_charts['risk_rating_distribution'] = fig

        # 4. 违约率 vs 特征分析
        default_by_purpose = data.groupby('loan_purpose')['loan_default'].mean().sort_values()
        fig = visualizer.plot_categorical(
            data, 'loan_purpose',
            interactive=True
        )
        financial_charts['default_by_purpose'] = fig

        print(f"   ✓ 金融专项图表生成完成: {len(financial_charts)} 个")

        return financial_charts

    except Exception as e:
        print(f"   ❌ 可视化生成失败: {str(e)}")
        return None

def run_financial_modeling(data, data_path):
    """运行金融数据建模"""
    print("\n🤖 运行金融数据建模...")

    try:
        from data_preprocessor import DataPreprocessor
        from modeling_evaluator import ModelingEvaluator

        # 数据预处理
        print("   数据预处理...")
        preprocessor = DataPreprocessor({
            'missing_threshold': 0.2,
            'feature_selection': True,
            'k_features': 15,
            'balance_data': True,  # 平衡违约样本
            'balance_method': 'smote'
        })

        # 预处理数据
        preprocessing_results = preprocessor.auto_preprocess(
            data,
            target_col='loan_default',
            save_report=True
        )

        # 模型训练
        print("   模型训练...")
        modeler = ModelingEvaluator({
            'cv_folds': 5,
            'enable_hyperparameter_tuning': True,
            'n_iter_search': 15,  # 减少搜索次数加快演示
            'scoring_metric': 'roc_auc'  # 使用ROC AUC作为评估指标
        })

        # 自动建模
        model_results = modeler.auto_modeling(
            data,
            target_col='loan_default',
            model_names=['logistic_regression', 'random_forest', 'xgboost', 'lightgbm']
        )

        print(f"   ✓ 模型训练完成，最佳模型: {model_results['best_model']['name']}")

        # 保存模型
        output_dir = Path(__file__).parent / "results" / "models"
        modeler.save_models(str(output_dir))

        return preprocessing_results, model_results

    except Exception as e:
        print(f"   ❌ 建模失败: {str(e)}")
        return None, None

def calculate_credit_risk_score(data, model_results):
    """计算综合信用风险评分"""
    print("\n📊 计算综合信用风险评分...")

    try:
        # 基于模型结果计算风险评分
        if model_results and 'best_model' in model_results:
            best_model_name = model_results['best_model']['name']
            print(f"   使用模型: {best_model_name}")

            # 创建风险评分表
            risk_scores = []

            for _, row in data.iterrows():
                # 基础信用分数
                base_score = row['credit_score']

                # 调整因子
                adjustments = 0

                # 收入调整
                if row['income'] > 100000:
                    adjustments += 20
                elif row['income'] < 30000:
                    adjustments -= 30

                # 负债收入比调整
                if row['debt_to_income_ratio'] > 0.4:
                    adjustments -= 40
                elif row['debt_to_income_ratio'] < 0.2:
                    adjustments += 15

                # 逾期记录调整
                if row['late_payments_last_year'] > 2:
                    adjustments -= 25

                # 破产历史调整
                if row['bankruptcy_history'] == 1:
                    adjustments -= 100

                # 就业稳定性调整
                if row['employment_years'] > 5:
                    adjustments += 10
                elif row['employment_years'] < 1:
                    adjustments -= 20

                final_score = base_score + adjustments
                final_score = np.clip(final_score, 300, 850)

                risk_scores.append(final_score)

            # 添加到数据中
            data = data.copy()
            data['comprehensive_risk_score'] = risk_scores

            # 风险等级
            score_conditions = [
                data['comprehensive_risk_score'] >= 780,
                (data['comprehensive_risk_score'] >= 740) & (data['comprehensive_risk_score'] < 780),
                (data['comprehensive_risk_score'] >= 700) & (data['comprehensive_risk_score'] < 740),
                (data['comprehensive_risk_score'] >= 660) & (data['comprehensive_risk_score'] < 700),
                (data['comprehensive_risk_score'] >= 620) & (data['comprehensive_risk_score'] < 660),
                data['comprehensive_risk_score'] < 620
            ]

            risk_labels = ['AA+', 'AA', 'A', 'BBB', 'BB', 'B']
            data['final_risk_rating'] = np.select(score_conditions, risk_labels, default='B')

            print(f"   ✓ 风险评分计算完成")
            print(f"   ✓ 平均风险评分: {data['comprehensive_risk_score'].mean():.1f}")

            # 保存风险评分结果
            output_dir = Path(__file__).parent / "results"
            data.to_csv(output_dir / "credit_risk_scores.csv", index=False, encoding='utf-8-sig')

            return data

        else:
            print("   ⚠️ 无法计算风险评分，缺少模型结果")
            return data

    except Exception as e:
        print(f"   ❌ 风险评分计算失败: {str(e)}")
        return data

def generate_financial_report(data, eda_results, model_results):
    """生成金融数据分析报告"""
    print("\n📋 生成金融数据分析报告...")

    try:
        from report_generator import ReportGenerator

        # 配置金融特化报告
        generator = ReportGenerator({
            'report_title': '金融信贷风险分析报告',
            'author': '金融风险分析助手',
            'company': '金融机构',
            'include_recommendations': True
        })

        # 生成报告
        output_dir = Path(__file__).parent / "results"
        output_path = output_dir / "financial_analysis_report.html"

        report_path = generator.generate_comprehensive_report(
            data=data,
            eda_results=eda_results,
            model_results=model_results,
            output_path=str(output_path),
            format="html"
        )

        print(f"   ✓ 金融分析报告已生成: {report_path}")

        # 生成快速报告
        quick_report_path = output_dir / "financial_quick_report.html"
        generator.generate_quick_report(
            data=data,
            target_col='loan_default',
            output_path=str(quick_report_path)
        )

        print(f"   ✓ 快速报告已生成: {quick_report_path}")

        return report_path

    except Exception as e:
        print(f"   ❌ 报告生成失败: {str(e)}")
        return None

def main():
    """主函数"""
    print("💰 金融数据分析示例")
    print("=" * 50)

    # 创建输出目录
    output_dir = Path(__file__).parent / "results"
    output_dir.mkdir(exist_ok=True)

    # 1. 创建样本数据
    data, data_path = create_financial_sample_data()

    # 2. EDA分析
    eda_results, processed_data = run_financial_eda_analysis(data_path)

    if processed_data is None:
        processed_data = data

    # 3. 可视化
    charts = run_financial_visualization(processed_data)

    # 4. 建模
    preprocessing_results, model_results = run_financial_modeling(processed_data, data_path)

    # 5. 计算风险评分
    scored_data = calculate_credit_risk_score(processed_data, model_results)

    # 6. 生成报告
    report_path = generate_financial_report(scored_data, eda_results, model_results)

    # 7. 总结
    print("\n🎉 金融数据分析完成！")
    print("\n📁 生成的文件:")

    results_dir = Path(__file__).parent / "results"
    if results_dir.exists():
        for file_path in results_dir.rglob("*"):
            if file_path.is_file():
                relative_path = file_path.relative_to(results_dir)
                print(f"   📄 {relative_path}")

    print(f"\n📊 主要发现:")
    if eda_results and 'data_quality' in eda_results:
        print(f"   - 数据质量分数: {eda_results['data_quality'].get('overall_score', 'N/A')}")

    if model_results and 'best_model' in model_results:
        best_model = model_results['best_model']
        if best_model and 'metrics' in best_model:
            auc = best_model['metrics'].get('auc', 0)
            print(f"   - 最佳模型AUC: {auc:.3f}")

    default_rate = processed_data['loan_default'].mean()
    print(f"   - 整体违约率: {default_rate:.2%}")

    avg_credit_score = processed_data['credit_score'].mean()
    print(f"   - 平均信用分数: {avg_credit_score:.1f}")

    if 'comprehensive_risk_score' in scored_data.columns:
        avg_risk_score = scored_data['comprehensive_risk_score'].mean()
        print(f"   - 综合风险评分: {avg_risk_score:.1f}")

    if report_path:
        print(f"\n📋 详细分析报告: {report_path}")
        print("   请在浏览器中打开HTML文件查看完整的交互式报告。")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
医疗数据分析示例
演示如何使用数据探索可视化技能进行医疗数据分析
"""

import sys
import os
import pandas as pd
import numpy as np
from pathlib import Path

# 添加技能路径
skill_path = Path(__file__).parent.parent
sys.path.append(str(skill_path / "scripts"))

def create_medical_sample_data():
    """创建医疗数据样本"""
    print("🏥 创建医疗数据样本...")

    np.random.seed(42)
    n_patients = 500

    # 基础患者信息
    data = {
        'patient_id': [f'P{i:04d}' for i in range(1, n_patients + 1)],
        'age': np.random.randint(18, 85, n_patients),
        'gender': np.random.choice(['男', '女'], n_patients, p=[0.48, 0.52]),
        'blood_type': np.random.choice(['A', 'B', 'AB', 'O'], n_patients, p=[0.3, 0.25, 0.1, 0.35]),
        'blood_pressure_systolic': np.random.normal(120, 15, n_patients),
        'blood_pressure_diastolic': np.random.normal(80, 10, n_patients),
        'heart_rate': np.random.normal(75, 10, n_patients),
        'cholesterol': np.random.normal(200, 40, n_patients),
        'glucose': np.random.normal(100, 25, n_patients),
        'bmi': np.random.normal(25, 5, n_patients),
        'smoking_status': np.random.choice(['从不', '曾经', '现在'], n_patients, p=[0.4, 0.3, 0.3]),
        'alcohol_consumption': np.random.choice(['无', '偶尔', '经常'], n_patients, p=[0.3, 0.5, 0.2]),
        'exercise_frequency': np.random.choice(['从不', '偶尔', '经常'], n_patients, p=[0.2, 0.4, 0.4]),
        'family_history': np.random.choice([0, 1], n_patients, p=[0.7, 0.3]),
        'medications_count': np.random.randint(0, 8, n_patients),
        'doctor_visits_last_year': np.random.randint(0, 15, n_patients),
    }

    # 创建相关性：年龄和某些健康指标的关系
    data['cholesterol'] += np.random.normal(0, data['age'] * 0.5, n_patients)
    data['blood_pressure_systolic'] += np.random.normal(0, data['age'] * 0.3, n_patients)

    # BMI计算
    data['bmi'] = np.maximum(15, data['bmi'])  # 确保BMI合理

    # 诊断结果（二分类：0=健康，1=有疾病风险）
    risk_score = (
        (data['age'] > 60) * 0.3 +
        (data['cholesterol'] > 240) * 0.2 +
        (data['blood_pressure_systolic'] > 140) * 0.2 +
        (data['bmi'] > 30) * 0.15 +
        (data['family_history']) * 0.1 +
        (data['smoking_status'] == '现在') * 0.15 +
        (data['alcohol_consumption'] == '经常') * 0.1
    )

    # 添加噪声并转换为二分类
    risk_score += np.random.normal(0, 0.1, n_patients)
    data['disease_risk'] = (risk_score > 0.4).astype(int)

    # 疾病类型（针对有风险的患者）
    disease_types = ['无', '高血压', '糖尿病', '心脏病', '综合风险']
    data['disease_type'] = '无'
    risk_mask = data['disease_risk'] == 1
    data.loc[risk_mask, 'disease_type'] = np.random.choice(
        ['高血压', '糖尿病', '心脏病', '综合风险'],
        risk_mask.sum(),
        p=[0.35, 0.25, 0.25, 0.15]
    )

    # 创建DataFrame
    df = pd.DataFrame(data)

    # 添加一些缺失值模拟真实数据
    missing_indices = np.random.choice(df.index, size=int(0.05 * len(df)), replace=False)
    df.loc[missing_indices, 'cholesterol'] = np.nan

    missing_indices = np.random.choice(df.index, size=int(0.03 * len(df)), replace=False)
    df.loc[missing_indices, 'glucose'] = np.nan

    # 保存数据
    output_dir = Path(__file__).parent / "data"
    output_dir.mkdir(exist_ok=True)

    data_path = output_dir / "medical_data_sample.csv"
    df.to_csv(data_path, index=False, encoding='utf-8-sig')

    print(f"   ✓ 医疗数据样本已保存: {data_path}")
    print(f"   ✓ 数据形状: {df.shape}")
    print(f"   ✓ 疾病风险分布: {df['disease_risk'].value_counts().to_dict()}")

    return df, data_path

def run_medical_eda_analysis(data_path):
    """运行医疗数据EDA分析"""
    print("\n🔍 运行医疗数据探索性分析...")

    try:
        from eda_analyzer import EDAAnalyzer

        analyzer = EDAAnalyzer()

        # 加载数据
        print("   加载数据...")
        data = analyzer.load_data(data_path)

        # 自动化EDA分析
        print("   执行自动化EDA分析...")
        eda_results = analyzer.auto_eda(data)

        # 保存EDA结果
        output_dir = Path(__file__).parent / "results"
        output_dir.mkdir(exist_ok=True)

        eda_path = output_dir / "medical_eda_results.json"
        analyzer.export_results(eda_results, eda_path)

        print(f"   ✓ EDA分析完成，结果已保存: {eda_path}")

        # 显示关键发现
        print("\n📊 关键发现:")
        if 'insights' in eda_results:
            for insight in eda_results['insights'][:3]:
                print(f"   - {insight}")

        return eda_results, data

    except Exception as e:
        print(f"   ❌ EDA分析失败: {str(e)}")
        return None, None

def run_medical_visualization(data):
    """运行医疗数据可视化"""
    print("\n📈 生成医疗数据可视化图表...")

    try:
        from visualizer import DataVisualizer

        visualizer = DataVisualizer()

        # 自动可视化
        charts = visualizer.auto_visualize(
            data,
            target_col='disease_risk',
            save_charts=True,
            output_dir=str(Path(__file__).parent / "results" / "charts")
        )

        print(f"   ✓ 可视化完成，生成了 {charts['charts_generated']} 个图表")

        # 生成医疗专项图表
        medical_charts = {}

        # 1. 年龄分布 vs 疾病风险
        fig = visualizer.plot_distribution(
            data[data['disease_risk'] == 1],
            'age',
            interactive=True
        )
        medical_charts['high_risk_age_distribution'] = fig

        # 2. BMI vs 疾病风险散点图
        fig = visualizer.plot_scatter(
            data, 'age', 'bmi',
            color_col='disease_risk',
            interactive=True
        )
        medical_charts['age_bmi_risk_scatter'] = fig

        # 3. 疾病类型分布
        disease_counts = data['disease_type'].value_counts()
        fig = visualizer.plot_categorical(
            data, 'disease_type',
            interactive=True
        )
        medical_charts['disease_type_distribution'] = fig

        print(f"   ✓ 医疗专项图表生成完成: {len(medical_charts)} 个")

        return medical_charts

    except Exception as e:
        print(f"   ❌ 可视化生成失败: {str(e)}")
        return None

def run_medical_modeling(data, data_path):
    """运行医疗数据建模"""
    print("\n🤖 运行医疗数据建模...")

    try:
        from data_preprocessor import DataPreprocessor
        from modeling_evaluator import ModelingEvaluator

        # 数据预处理
        print("   数据预处理...")
        preprocessor = DataPreprocessor({
            'missing_threshold': 0.3,
            'feature_selection': True,
            'k_features': 10
        })

        # 预处理数据
        preprocessing_results = preprocessor.auto_preprocess(
            data,
            target_col='disease_risk',
            save_report=True
        )

        # 模型训练
        print("   模型训练...")
        modeler = ModelingEvaluator({
            'cv_folds': 5,
            'enable_hyperparameter_tuning': True,
            'n_iter_search': 20  # 减少搜索次数加快演示
        })

        # 自动建模
        model_results = modeler.auto_modeling(
            data,
            target_col='disease_risk',
            model_names=['logistic_regression', 'random_forest', 'xgboost']
        )

        print(f"   ✓ 模型训练完成，最佳模型: {model_results['best_model']['name']}")

        # 保存模型
        output_dir = Path(__file__).parent / "results" / "models"
        modeler.save_models(str(output_dir))

        return preprocessing_results, model_results

    except Exception as e:
        print(f"   ❌ 建模失败: {str(e)}")
        return None, None

def generate_medical_report(data, eda_results, model_results):
    """生成医疗数据分析报告"""
    print("\n📋 生成医疗数据分析报告...")

    try:
        from report_generator import ReportGenerator

        # 配置医疗特化报告
        generator = ReportGenerator({
            'report_title': '医疗数据分析报告',
            'author': '医疗数据分析助手',
            'company': '医疗机构',
            'medical_specialization': True
        })

        # 生成报告
        output_dir = Path(__file__).parent / "results"
        output_path = output_dir / "medical_analysis_report.html"

        report_path = generator.generate_comprehensive_report(
            data=data,
            eda_results=eda_results,
            model_results=model_results,
            output_path=str(output_path),
            format="html"
        )

        print(f"   ✓ 医疗分析报告已生成: {report_path}")

        # 生成快速报告
        quick_report_path = output_dir / "medical_quick_report.html"
        generator.generate_quick_report(
            data=data,
            target_col='disease_risk',
            output_path=str(quick_report_path)
        )

        print(f"   ✓ 快速报告已生成: {quick_report_path}")

        return report_path

    except Exception as e:
        print(f"   ❌ 报告生成失败: {str(e)}")
        return None

def main():
    """主函数"""
    print("🏥 医疗数据分析示例")
    print("=" * 50)

    # 创建输出目录
    output_dir = Path(__file__).parent / "results"
    output_dir.mkdir(exist_ok=True)

    # 1. 创建样本数据
    data, data_path = create_medical_sample_data()

    # 2. EDA分析
    eda_results, processed_data = run_medical_eda_analysis(data_path)

    if processed_data is None:
        processed_data = data

    # 3. 可视化
    charts = run_medical_visualization(processed_data)

    # 4. 建模
    preprocessing_results, model_results = run_medical_modeling(processed_data, data_path)

    # 5. 生成报告
    report_path = generate_medical_report(processed_data, eda_results, model_results)

    # 6. 总结
    print("\n🎉 医疗数据分析完成！")
    print("\n📁 生成的文件:")

    results_dir = Path(__file__).parent / "results"
    if results_dir.exists():
        for file_path in results_dir.rglob("*"):
            if file_path.is_file():
                relative_path = file_path.relative_to(results_dir)
                print(f"   📄 {relative_path}")

    print(f"\n📊 主要发现:")
    if eda_results and 'data_quality' in eda_results:
        print(f"   - 数据质量分数: {eda_results['data_quality'].get('overall_score', 'N/A')}")

    if model_results and 'best_model' in model_results:
        best_model = model_results['best_model']
        if best_model and 'metrics' in best_model:
            accuracy = best_model['metrics'].get('accuracy', 0)
            print(f"   - 最佳模型准确率: {accuracy:.3f}")

    disease_risk_counts = processed_data['disease_risk'].value_counts()
    print(f"   - 高风险患者比例: {disease_risk_counts.get(1, 0) / len(processed_data) * 100:.1f}%")

    if report_path:
        print(f"\n📋 详细分析报告: {report_path}")
        print("   请在浏览器中打开HTML文件查看完整的交互式报告。")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
快速开始示例
演示如何快速使用数据探索可视化技能进行数据分析
"""

import sys
import os
import pandas as pd
import numpy as np
from pathlib import Path

# 添加技能路径
skill_path = Path(__file__).parent.parent
sys.path.append(str(skill_path / "scripts"))

def create_sample_data():
    """创建示例数据集"""
    print("📊 创建示例数据集...")

    np.random.seed(42)
    n_samples = 800

    data = {
        'id': range(1, n_samples + 1),
        'age': np.random.randint(18, 75, n_samples),
        'gender': np.random.choice(['Male', 'Female'], n_samples, p=[0.52, 0.48]),
        'income': np.random.lognormal(10.5, 0.6, n_samples),
        'education': np.random.choice(['High School', 'Bachelor', 'Master', 'PhD'],
                                   n_samples, p=[0.3, 0.4, 0.25, 0.05]),
        'experience_years': np.random.exponential(8, n_samples),
        'satisfaction': np.random.randint(1, 6, n_samples),
        'performance_score': np.random.normal(75, 15, n_samples),
        'team_size': np.random.randint(2, 15, n_samples),
        'hours_per_week': np.random.normal(40, 5, n_samples),
        'projects_completed': np.random.poisson(8, n_samples),
        'training_hours': np.random.randint(0, 100, n_samples),
        'salary': np.random.lognormal(10.8, 0.4, n_samples),
    }

    # 创建相关性
    df = pd.DataFrame(data)

    # 经验与薪资的相关性
    df['salary'] = df['salary'] * (0.7 + 0.3 * df['experience_years'] / df['experience_years'].max())

    # 绩效与满意度相关性
    df['performance_score'] = df['performance_score'] + df['satisfaction'] * 3

    # 项目完成数量与经验相关性
    df['projects_completed'] = df['projects_completed'] + (df['experience_years'] / 2).astype(int)

    # 创建目标变量：高绩效员工（绩效分数 > 85）
    df['high_performer'] = (df['performance_score'] > 85).astype(int)

    # 添加一些缺失值
    missing_indices = np.random.choice(df.index, size=int(0.05 * len(df)), replace=False)
    df.loc[missing_indices, 'training_hours'] = np.nan

    print(f"   ✓ 数据集创建完成: {df.shape}")
    print(f"   ✓ 高绩效员工比例: {df['high_performer'].mean():.2%}")

    return df

def quick_eda_example():
    """快速EDA示例"""
    print("\n🔍 快速EDA分析示例...")

    # 创建数据
    data = create_sample_data()

    try:
        from eda_analyzer import EDAAnalyzer

        # 初始化分析器
        analyzer = EDAAnalyzer()

        # 自动化EDA分析
        print("   执行自动化EDA...")
        results = analyzer.auto_eda(data)

        print(f"   ✓ EDA分析完成")
        print(f"   - 数据质量分数: {results.get('data_quality', {}).get('overall_score', 'N/A')}")
        print(f"   - 发现的洞察: {len(results.get('insights', []))}")

        # 显示前3个洞察
        insights = results.get('insights', [])[:3]
        for i, insight in enumerate(insights, 1):
            print(f"   {i}. {insight}")

        return data, results

    except Exception as e:
        print(f"   ❌ EDA分析失败: {str(e)}")
        return data, None

def quick_visualization_example(data):
    """快速可视化示例"""
    print("\n📈 快速可视化示例...")

    try:
        from visualizer import DataVisualizer

        # 初始化可视化器
        visualizer = DataVisualizer()

        # 自动生成图表
        print("   自动生成可视化图表...")
        charts = visualizer.auto_visualize(
            data,
            target_col='high_performer',
            save_charts=True,
            output_dir='quick_start_charts'
        )

        print(f"   ✓ 生成了 {charts['charts_generated']} 个图表")

        # 生成特定图表
        print("   生成特定图表...")

        # 1. 年龄分布
        age_chart = visualizer.plot_distribution(data, 'age', interactive=False)
        print("     ✓ 年龄分布图")

        # 2. 薪资 vs 经验散点图
        scatter_chart = visualizer.plot_scatter(
            data, 'experience_years', 'salary',
            color_col='high_performer',
            interactive=False
        )
        print("     ✓ 薪资-经验散点图")

        # 3. 教育水平分布
        education_chart = visualizer.plot_categorical(data, 'education', interactive=False)
        print("     ✓ 教育水平分布图")

        return charts

    except Exception as e:
        print(f"   ❌ 可视化失败: {str(e)}")
        return None

def quick_preprocessing_example(data):
    """快速数据预处理示例"""
    print("\n🧹 快速数据预处理示例...")

    try:
        from data_preprocessor import DataPreprocessor

        # 初始化预处理器
        preprocessor = DataPreprocessor({
            'missing_threshold': 0.3,
            'feature_selection': False,  # 关闭特征选择以加快演示
            'test_size': 0.2
        })

        # 自动预处理
        print("   执行自动预处理...")
        results = preprocessor.auto_preprocess(
            data,
            target_col='high_performer',
            save_report=True
        )

        print(f"   ✓ 预处理完成")
        print(f"   - 原始数据: {results['original_data'].shape}")
        print(f"   - 预处理后: {results['preprocessed_data'].shape}")
        print(f"   - 预处理步骤: {len(results['preprocessing_steps'])}")

        # 显示预处理步骤
        for step in results['preprocessing_steps'][:5]:
            print(f"     - {step}")

        return results

    except Exception as e:
        print(f"   ❌ 预处理失败: {str(e)}")
        return None

def quick_modeling_example(data):
    """快速建模示例"""
    print("\n🤖 快速建模示例...")

    try:
        from modeling_evaluator import ModelingEvaluator

        # 初始化建模器
        modeler = ModelingEvaluator({
            'cv_folds': 3,  # 减少折数加快演示
            'enable_hyperparameter_tuning': False,  # 关闭调参加快演示
            'n_iter_search': 5
        })

        # 自动建模
        print("   执行自动建模...")
        results = modeler.auto_modeling(
            data,
            target_col='high_performer',
            model_names=['logistic_regression', 'random_forest']  # 使用较少的模型
        )

        print(f"   ✓ 建模完成")
        print(f"   - 训练模型数: {len(results['model_results'])}")
        print(f"   - 最佳模型: {results['best_model']['name']}")

        best_metrics = results['best_model']['metrics']
        print(f"   - 最佳准确率: {best_metrics.get('accuracy', 0):.3f}")

        return results

    except Exception as e:
        print(f"   ❌ 建模失败: {str(e)}")
        return None

def quick_report_example(data, eda_results=None, model_results=None):
    """快速报告生成示例"""
    print("\n📋 快速报告生成示例...")

    try:
        from report_generator import ReportGenerator

        # 初始化报告生成器
        generator = ReportGenerator({
            'report_title': '员工绩效分析报告',
            'author': '数据分析助手',
            'include_toc': True,
            'include_summary': True
        })

        # 生成快速报告
        print("   生成快速分析报告...")
        report_path = generator.generate_quick_report(
            data=data,
            target_col='high_performer',
            output_path='quick_analysis_report.html'
        )

        print(f"   ✓ 报告已生成: {report_path}")

        # 如果有完整结果，生成综合报告
        if eda_results or model_results:
            print("   生成综合分析报告...")
            comprehensive_path = generator.generate_comprehensive_report(
                data=data,
                eda_results=eda_results,
                model_results=model_results,
                output_path='comprehensive_analysis_report.html',
                format='html'
            )

            print(f"   ✓ 综合报告已生成: {comprehensive_path}")

        return report_path

    except Exception as e:
        print(f"   ❌ 报告生成失败: {str(e)}")
        return None

def run_complete_pipeline():
    """运行完整分析流程"""
    print("🚀 运行完整数据分析流程...")

    # 创建输出目录
    output_dir = Path('quick_start_output')
    output_dir.mkdir(exist_ok=True)

    # 1. 数据创建和EDA
    data, eda_results = quick_eda_example()

    # 2. 可视化
    charts = quick_visualization_example(data)

    # 3. 预处理
    preprocessing_results = quick_preprocessing_example(data)

    # 4. 建模
    model_results = quick_modeling_example(data)

    # 5. 报告生成
    report_path = quick_report_example(data, eda_results, model_results)

    # 6. 总结
    print("\n🎉 快速开始示例完成！")

    # 显示统计信息
    print(f"\n📊 数据摘要:")
    print(f"   - 样本数量: {len(data):,}")
    print(f"   - 特征数量: {len(data.columns)}")
    print(f"   - 高绩效员工: {data['high_performer'].sum()} ({data['high_performer'].mean():.1%})")

    print(f"\n📈 分析结果:")
    if eda_results:
        quality_score = eda_results.get('data_quality', {}).get('overall_score', 0)
        print(f"   - 数据质量分数: {quality_score:.1f}")

    if model_results:
        best_accuracy = model_results['best_model']['metrics'].get('accuracy', 0)
        print(f"   - 最佳模型准确率: {best_accuracy:.3f}")

    if charts:
        print(f"   - 生成图表数: {charts['charts_generated']}")

    # 显示生成的文件
    print(f"\n📁 生成的文件:")
    for file_path in Path('.').glob('quick_start_*'):
        if file_path.is_file():
            print(f"   📄 {file_path}")

    if report_path:
        print(f"\n📋 分析报告: {report_path}")
        print("   请在浏览器中打开HTML文件查看完整报告。")

def demonstrate_specific_features():
    """演示特定功能"""
    print("\n🔧 演示特定功能...")

    try:
        # 1. 数据质量检查
        from eda_analyzer import EDAAnalyzer
        data = create_sample_data()
        analyzer = EDAAnalyzer()

        print("   1. 数据质量检查...")
        quality_report = analyzer.data_quality_check(data)
        print(f"      - 数据行数: {quality_report['total_rows']}")
        print(f"      - 数据列数: {quality_report['total_columns']}")
        print(f"      - 缺失值: {quality_report['missing_values']}")

        # 2. 异常值检测
        print("\n   2. 异常值检测...")
        outliers = analyzer.detect_outliers(data, 'salary')
        print(f"      - 薪资异常值: {outliers.sum()} 个")

        # 3. 相关性分析
        print("\n   3. 相关性分析...")
        correlation_matrix = analyzer.correlation_analysis(data)
        strong_corr = []
        for i in range(len(correlation_matrix.columns)):
            for j in range(i+1, len(correlation_matrix.columns)):
                corr_val = correlation_matrix.iloc[i, j]
                if abs(corr_val) > 0.5:
                    strong_corr.append(
                        f"{correlation_matrix.columns[i]} - {correlation_matrix.columns[j]}: {corr_val:.2f}"
                    )
        print(f"      - 强相关性特征对: {len(strong_corr)}")
        for corr in strong_corr[:3]:
            print(f"        • {corr}")

        # 4. 特征重要性
        if model_results := quick_modeling_example(data):
            print("\n   4. 特征重要性分析...")
            if 'feature_importance' in model_results:
                top_features = list(model_results['feature_importance'].keys())[:5]
                print(f"      - 最重要的5个特征:")
                for i, feature in enumerate(top_features, 1):
                    print(f"        {i}. {feature}")

    except Exception as e:
        print(f"   ❌ 功能演示失败: {str(e)}")

def main():
    """主函数"""
    print("🎯 数据探索可视化技能 - 快速开始示例")
    print("=" * 60)

    try:
        # 检查依赖
        print("🔍 检查依赖包...")
        required_packages = ['pandas', 'numpy', 'matplotlib', 'seaborn', 'scikit-learn']
        missing_packages = []

        for package in required_packages:
            try:
                __import__(package)
            except ImportError:
                missing_packages.append(package)

        if missing_packages:
            print(f"   ❌ 缺少依赖包: {', '.join(missing_packages)}")
            print(f"   请安装: pip install {' '.join(missing_packages)}")
            return

        print("   ✓ 所有依赖包已安装")

        # 运行完整流程
        run_complete_pipeline()

        # 演示特定功能
        demonstrate_specific_features()

        # 使用建议
        print("\n💡 使用建议:")
        print("   1. 将您自己的CSV数据替换示例数据")
        print("   2. 调整配置参数以适应您的需求")
        print("   3. 查看生成的HTML报告获取详细分析结果")
        print("   4. 尝试不同的模型和预处理方法")
        print("   5. 使用图表功能创建自定义可视化")

        print("\n📚 更多示例:")
        print("   - medical_data_analysis.py: 医疗数据分析示例")
        print("   - financial_data_analysis.py: 金融数据分析示例")

    except Exception as e:
        print(f"\n❌ 示例运行失败: {str(e)}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
数据探索可视化技能快速测试
快速验证所有核心功能是否正常工作
"""

import sys
import os
import pandas as pd
import numpy as np
from pathlib import Path
import time
import traceback

# 添加技能路径
skill_path = Path(__file__).parent
sys.path.append(str(skill_path / "scripts"))

def create_test_data():
    """创建测试数据"""
    print("📊 创建测试数据...")

    np.random.seed(42)
    n_samples = 200

    data = {
        'id': range(1, n_samples + 1),
        'age': np.random.randint(18, 70, n_samples),
        'gender': np.random.choice(['Male', 'Female'], n_samples),
        'income': np.random.lognormal(10, 0.5, n_samples),
        'score': np.random.normal(75, 15, n_samples),
        'category': np.random.choice(['A', 'B', 'C'], n_samples, p=[0.5, 0.3, 0.2]),
        'target': np.random.choice([0, 1], n_samples, p=[0.7, 0.3])
    }

    df = pd.DataFrame(data)

    # 添加一些缺失值
    missing_indices = np.random.choice(df.index, size=10, replace=False)
    df.loc[missing_indices, 'income'] = np.nan

    print(f"   ✓ 测试数据创建完成: {df.shape}")
    return df

def check_dependencies():
    """检查依赖包"""
    print("🔍 检查依赖包...")

    required_packages = {
        'pandas': 'pandas',
        'numpy': 'numpy',
        'matplotlib': 'matplotlib',
        'seaborn': 'seaborn',
        'scipy': 'scipy',
        'sklearn': 'scikit-learn',
        'xgboost': 'xgboost',
        'plotly': 'plotly',
        'jinja2': 'jinja2'
    }

    optional_packages = {
        'shap': 'shap',
        'lightgbm': 'lightgbm',
        'imblearn': 'imbalanced-learn',
        'weasyprint': 'weasyprint'
    }

    missing_required = []
    missing_optional = []

    # 检查必需包
    for module_name, package_name in required_packages.items():
        try:
            __import__(module_name)
        except ImportError:
            missing_required.append(package_name)

    # 检查可选包
    for module_name, package_name in optional_packages.items():
        try:
            __import__(module_name)
        except ImportError:
            missing_optional.append(package_name)

    if missing_required:
        print("   ❌ 缺少必需依赖包:")
        for package in missing_required:
            print(f"      - {package}")
        print(f"\n   请安装: pip install {' '.join(missing_required)}")
        return False

    if missing_optional:
        print("   ⚠️ 缺少可选依赖包 (某些功能可能不可用):")
        for package in missing_optional:
            print(f"      - {package}")

    print("   ✓ 所有必要依赖包已安装")
    return True

def test_eda_analyzer():
    """测试EDA分析器"""
    print("\n🔍 测试EDA分析器...")

    try:
        from eda_analyzer import EDAAnalyzer

        # 创建分析器
        analyzer = EDAAnalyzer()

        # 创建测试数据
        data = create_test_data()

        # 测试基本功能
        print("   测试数据质量检查...")
        quality_report = analyzer.data_quality_check(data)
        assert quality_report is not None, "数据质量检查失败"
        print("     ✓ 数据质量检查")

        print("   测试统计摘要...")
        stats_summary = analyzer.generate_statistical_summary(data)
        assert stats_summary is not None, "统计摘要生成失败"
        print("     ✓ 统计摘要生成")

        print("   测试相关性分析...")
        corr_matrix = analyzer.correlation_analysis(data)
        assert corr_matrix is not None, "相关性分析失败"
        print("     ✓ 相关性分析")

        print("   测试自动EDA...")
        eda_results = analyzer.auto_eda(data)
        assert eda_results is not None, "自动EDA失败"
        print("     ✓ 自动EDA分析")

        print("   ✓ EDA分析器测试通过")
        return True, eda_results

    except Exception as e:
        print(f"   ❌ EDA分析器测试失败: {str(e)}")
        traceback.print_exc()
        return False, None

def test_visualizer():
    """测试可视化器"""
    print("\n📈 测试可视化器...")

    try:
        from visualizer import DataVisualizer

        # 创建可视化器
        visualizer = DataVisualizer()

        # 创建测试数据
        data = create_test_data()

        # 测试分布图
        print("   测试分布图...")
        fig = visualizer.plot_distribution(data, 'age', interactive=False)
        assert fig is not None, "分布图生成失败"
        print("     ✓ 分布图生成")

        # 测试相关性热图
        print("   测试相关性热图...")
        numeric_cols = data.select_dtypes(include=[np.number]).columns.tolist()
        if len(numeric_cols) > 1:
            fig = visualizer.plot_correlation(data, numeric_cols, interactive=False)
            assert fig is not None, "相关性热图生成失败"
            print("     ✓ 相关性热图生成")

        # 测试散点图
        print("   测试散点图...")
        if len(numeric_cols) >= 2:
            fig = visualizer.plot_scatter(data, numeric_cols[0], numeric_cols[1], interactive=False)
            assert fig is not None, "散点图生成失败"
            print("     ✓ 散点图生成")

        # 测试自动可视化
        print("   测试自动可视化...")
        charts = visualizer.auto_visualize(
            data,
            target_col='target',
            save_charts=False
        )
        assert charts is not None, "自动可视化失败"
        print("     ✓ 自动可视化")

        print("   ✓ 可视化器测试通过")
        return True

    except Exception as e:
        print(f"   ❌ 可视化器测试失败: {str(e)}")
        traceback.print_exc()
        return False

def test_preprocessor():
    """测试数据预处理器"""
    print("\n🧹 测试数据预处理器...")

    try:
        from data_preprocessor import DataPreprocessor

        # 创建预处理器
        preprocessor = DataPreprocessor({
            'missing_threshold': 0.5,
            'feature_selection': False,  # 关闭特征选择加快测试
            'test_size': 0.2
        })

        # 创建测试数据
        data = create_test_data()

        # 测试数据质量分析
        print("   测试数据质量分析...")
        quality_report = preprocessor.analyze_data_quality(data)
        assert quality_report is not None, "数据质量分析失败"
        print("     ✓ 数据质量分析")

        # 测试数据清洗
        print("   测试数据清洗...")
        cleaned_data = preprocessor.clean_data(data)
        assert cleaned_data is not None, "数据清洗失败"
        print("     ✓ 数据清洗")

        # 测试类型转换
        print("   测试类型转换...")
        transformed_data = preprocessor.transform_data_types(cleaned_data)
        assert transformed_data is not None, "类型转换失败"
        print("     ✓ 类型转换")

        # 测试自动预处理
        print("   测试自动预处理...")
        results = preprocessor.auto_preprocess(data, target_col='target', save_report=False)
        assert results is not None, "自动预处理失败"
        assert 'preprocessed_data' in results, "预处理数据缺失"
        print("     ✓ 自动预处理")

        print("   ✓ 数据预处理器测试通过")
        return True, results

    except Exception as e:
        print(f"   ❌ 数据预处理器测试失败: {str(e)}")
        traceback.print_exc()
        return False, None

def test_modeling_evaluator():
    """测试建模评估器"""
    print("\n🤖 测试建模评估器...")

    try:
        from modeling_evaluator import ModelingEvaluator

        # 创建建模器
        modeler = ModelingEvaluator({
            'cv_folds': 3,  # 减少折数加快测试
            'enable_hyperparameter_tuning': False,  # 关闭调加快测试
            'n_iter_search': 5
        })

        # 创建测试数据
        data = create_test_data()

        # 测试单个模型训练
        print("   测试单个模型训练...")
        # 准备数据
        X = data[['age', 'income', 'score']]
        y = data['target']

        # 分割数据
        from sklearn.model_selection import train_test_split
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

        result = modeler.train_single_model(
            X_train, y_train, X_test, y_test,
            'logistic_regression', tune_hyperparameters=False
        )
        assert result is not None, "单个模型训练失败"
        print("     ✓ 单个模型训练")

        # 测试多模型训练
        print("   测试多模型训练...")
        results = modeler.train_multiple_models(
            X_train, y_train, X_test, y_test,
            model_names=['logistic_regression', 'random_forest']
        )
        assert results is not None, "多模型训练失败"
        print("     ✓ 多模型训练")

        # 测试自动建模
        print("   测试自动建模...")
        modeling_results = modeler.auto_modeling(
            data,
            target_col='target',
            model_names=['logistic_regression', 'random_forest']
        )
        assert modeling_results is not None, "自动建模失败"
        print("     ✓ 自动建模")

        print("   ✓ 建模评估器测试通过")
        return True, modeling_results

    except Exception as e:
        print(f"   ❌ 建模评估器测试失败: {str(e)}")
        traceback.print_exc()
        return False, None

def test_report_generator():
    """测试报告生成器"""
    print("\n📋 测试报告生成器...")

    try:
        from report_generator import ReportGenerator

        # 创建报告生成器
        generator = ReportGenerator({
            'report_title': '测试报告',
            'author': '测试用户'
        })

        # 创建测试数据
        data = create_test_data()

        # 测试快速报告生成
        print("   测试快速报告生成...")
        report_path = generator.generate_quick_report(
            data=data,
            target_col='target',
            output_path='test_quick_report.html'
        )
        assert report_path is not None, "快速报告生成失败"
        assert os.path.exists(report_path), "报告文件不存在"
        print("     ✓ 快速报告生成")

        # 测试综合报告生成
        print("   测试综合报告生成...")
        # 创建模拟的EDA和建模结果
        eda_results = {
            'data_quality': {'overall_score': 85.5},
            'insights': ['测试洞察1', '测试洞察2']
        }

        model_results = {
            'best_model': {
                'name': 'logistic_regression',
                'metrics': {'accuracy': 0.85, 'precision': 0.82, 'recall': 0.88, 'f1': 0.85}
            }
        }

        comprehensive_path = generator.generate_comprehensive_report(
            data=data,
            eda_results=eda_results,
            model_results=model_results,
            output_path='test_comprehensive_report.html',
            format='html'
        )
        assert comprehensive_path is not None, "综合报告生成失败"
        assert os.path.exists(comprehensive_path), "综合报告文件不存在"
        print("     ✓ 综合报告生成")

        print("   ✓ 报告生成器测试通过")
        return True

    except Exception as e:
        print(f"   ❌ 报告生成器测试失败: {str(e)}")
        traceback.print_exc()
        return False

def test_integration():
    """集成测试"""
    print("\n🔗 测试模块集成...")

    try:
        # 创建测试数据
        data = create_test_data()

        # 1. EDA分析
        print("   1. 执行EDA分析...")
        from eda_analyzer import EDAAnalyzer
        analyzer = EDAAnalyzer()
        eda_results = analyzer.auto_eda(data)

        # 2. 数据预处理
        print("   2. 执行数据预处理...")
        from data_preprocessor import DataPreprocessor
        preprocessor = DataPreprocessor()
        preprocessing_results = preprocessor.auto_preprocess(data, target_col='target')

        # 3. 可视化
        print("   3. 生成可视化...")
        from visualizer import DataVisualizer
        visualizer = DataVisualizer()
        charts = visualizer.auto_visualize(data, target_col='target', save_charts=False)

        # 4. 建模
        print("   4. 执行建模...")
        from modeling_evaluator import ModelingEvaluator
        modeler = ModelingEvaluator({'enable_hyperparameter_tuning': False})
        model_results = modeler.auto_modeling(data, target_col='target', model_names=['logistic_regression'])

        # 5. 报告生成
        print("   5. 生成报告...")
        from report_generator import ReportGenerator
        generator = ReportGenerator()
        report_path = generator.generate_comprehensive_report(
            data=data,
            eda_results=eda_results,
            model_results=model_results,
            output_path='test_integration_report.html'
        )

        # 验证所有步骤都成功
        assert eda_results is not None, "EDA分析失败"
        assert preprocessing_results is not None, "数据预处理失败"
        assert charts is not None, "可视化失败"
        assert model_results is not None, "建模失败"
        assert report_path is not None and os.path.exists(report_path), "报告生成失败"

        print("   ✓ 集成测试通过")
        return True

    except Exception as e:
        print(f"   ❌ 集成测试失败: {str(e)}")
        traceback.print_exc()
        return False

def test_performance():
    """性能测试"""
    print("\n⚡ 性能测试...")

    try:
        import time

        # 创建较大的测试数据
        print("   创建性能测试数据...")
        n_samples = 1000
        data = pd.DataFrame({
            'feature_1': np.random.randn(n_samples),
            'feature_2': np.random.randn(n_samples),
            'feature_3': np.random.randn(n_samples),
            'target': np.random.choice([0, 1], n_samples)
        })

        # 测试EDA性能
        print("   测试EDA性能...")
        start_time = time.time()
        from eda_analyzer import EDAAnalyzer
        analyzer = EDAAnalyzer()
        analyzer.auto_eda(data)
        eda_time = time.time() - start_time
        print(f"     ✓ EDA耗时: {eda_time:.2f}秒")

        # 测试建模性能
        print("   测试建模性能...")
        start_time = time.time()
        from modeling_evaluator import ModelingEvaluator
        modeler = ModelingEvaluator({'enable_hyperparameter_tuning': False})
        modeler.auto_modeling(data, target_col='target', model_names=['logistic_regression'])
        modeling_time = time.time() - start_time
        print(f"     ✓ 建模耗时: {modeling_time:.2f}秒")

        # 性能断言
        assert eda_time < 30, f"EDA耗时过长: {eda_time}秒"
        assert modeling_time < 60, f"建模耗时过长: {modeling_time}秒"

        print("   ✓ 性能测试通过")
        return True

    except Exception as e:
        print(f"   ❌ 性能测试失败: {str(e)}")
        return False

def cleanup_test_files():
    """清理测试文件"""
    print("\n🧹 清理测试文件...")

    test_files = [
        'test_quick_report.html',
        'test_comprehensive_report.html',
        'test_integration_report.html',
        'quick_start_charts',
        'quick_start_output'
    ]

    cleaned = 0
    for file_path in test_files:
        path = Path(file_path)
        try:
            if path.is_file():
                path.unlink()
                cleaned += 1
            elif path.is_dir():
                import shutil
                shutil.rmtree(path)
                cleaned += 1
        except:
            pass

    print(f"   ✓ 清理了 {cleaned} 个测试文件")

def main():
    """主测试函数"""
    print("🧪 数据探索可视化技能 - 快速测试")
    print("=" * 60)

    start_time = time.time()

    # 测试结果记录
    test_results = {
        'dependencies': False,
        'eda_analyzer': False,
        'visualizer': False,
        'preprocessor': False,
        'modeling_evaluator': False,
        'report_generator': False,
        'integration': False,
        'performance': False
    }

    try:
        # 1. 检查依赖
        test_results['dependencies'] = check_dependencies()
        if not test_results['dependencies']:
            print("\n❌ 依赖检查失败，无法继续测试")
            return

        # 2. 测试各个模块
        test_results['eda_analyzer'], eda_results = test_eda_analyzer()
        test_results['visualizer'] = test_visualizer()
        test_results['preprocessor'], preprocessing_results = test_preprocessor()
        test_results['modeling_evaluator'], modeling_results = test_modeling_evaluator()
        test_results['report_generator'] = test_report_generator()

        # 3. 集成测试
        test_results['integration'] = test_integration()

        # 4. 性能测试
        test_results['performance'] = test_performance()

        # 5. 生成测试报告
        total_time = time.time() - start_time

        print("\n" + "=" * 60)
        print("📋 测试结果摘要")
        print("=" * 60)

        passed_tests = sum(test_results.values())
        total_tests = len(test_results)

        for test_name, result in test_results.items():
            status = "✅ 通过" if result else "❌ 失败"
            print(f"{test_name:20} : {status}")

        print(f"\n总体结果: {passed_tests}/{total_tests} 测试通过")
        print(f"测试耗时: {total_time:.2f}秒")

        if passed_tests == total_tests:
            print("\n🎉 所有测试通过！数据探索可视化技能已就绪。")
            print("\n💡 下一步:")
            print("   1. 运行 examples/quick_start_example.py 体验完整功能")
            print("   2. 运行 examples/medical_data_analysis.py 查看医疗数据示例")
            print("   3. 运行 examples/financial_data_analysis.py 查看金融数据示例")
        else:
            failed_tests = [name for name, result in test_results.items() if not result]
            print(f"\n⚠️  {len(failed_tests)} 个测试失败: {', '.join(failed_tests)}")
            print("   请检查错误信息并修复问题后重新测试。")

    except KeyboardInterrupt:
        print("\n\n⏹️ 测试被用户中断")
    except Exception as e:
        print(f"\n\n💥 测试过程中发生异常: {str(e)}")
        traceback.print_exc()
    finally:
        # 清理测试文件
        cleanup_test_files()

if __name__ == "__main__":
    main()