Ltv Predictor

订单号,产品码,消费日期,产品说明,数量,单价,用户码,城市
1001,PROD001,2022-06-01 09:15,绿联usb分线器,2,25.50,CUST001,北京
1002,PROD002,2022-06-01 10:30,加大男装T恤,1,89.00,CUST002,上海
1003,PROD003,2022-06-01 11:45,进口白心火龙果,3,35.00,CUST001,北京
1004,PROD004,2022-06-02 08:20,大连美早樱桃,2,68.00,CUST003,深圳
1005,PROD001,2022-06-02 14:15,绿联usb分线器,1,25.50,CUST004,广州
1006,PROD005,2022-06-03 09:30,泰国新鲜鳕鱼,1,128.00,CUST002,上海
1007,PROD002,2022-06-03 16:45,加大男装T恤,2,89.00,CUST005,杭州
1008,PROD006,2022-06-04 10:10,有机蔬菜套餐,1,45.00,CUST001,北京
1009,PROD003,2022-06-04 13:25,进口白心火龙果,2,35.00,CUST006,成都
1010,PROD007,2022-06-05 08:55,进口牛奶,4,28.00,CUST003,深圳
1011,PROD001,2022-06-05 15:30,绿联usb分线器,3,25.50,CUST007,南京
1012,PROD008,2022-06-06 11:20,手工巧克力,1,58.00,CUST002,上海
1013,PROD004,2022-06-06 17:40,大连美早樱桃,1,68.00,CUST008,西安
1014,PROD005,2022-06-07 09:05,泰国新鲜鳕鱼,2,128.00,CUST001,北京
1015,PROD009,2022-06-07 14:50,进口咖啡豆,1,88.00,CUST009,武汉
1016,PROD002,2022-06-08 10:30,加大男装T恤,1,89.00,CUST004,广州
1017,PROD006,2022-06-08 16:15,有机蔬菜套餐,2,45.00,CUST010,重庆
1018,PROD010,2022-06-09 08:45,进口橄榄油,1,158.00,CUST005,杭州
1019,PROD001,2022-06-09 13:20,绿联usb分线器,2,25.50,CUST011,天津
1020,PROD003,2022-06-10 09:40,进口白心火龙果,1,35.00,CUST006,成都
1021,PROD011,2022-06-10 15:55,精选坚果礼盒,1,98.00,CUST002,上海
1022,PROD007,2022-06-11 08:25,进口牛奶,3,28.00,CUST012,苏州
1023,PROD004,2022-06-11 14:10,大连美早樱桃,2,68.00,CUST007,南京
1024,PROD012,2022-06-12 10:50,进口牛肉,2,188.00,CUST013,青岛
1025,PROD008,2022-06-12 17:30,手工巧克力,2,58.00,CUST008,西安
1026,PROD002,2022-06-13 09:15,加大男装T恤,3,89.00,CUST001,北京
1027,PROD013,2022-06-13 15:40,进口红酒,1,268.00,CUST014,长沙
1028,PROD006,2022-06-14 11:05,有机蔬菜套餐,1,45.00,CUST009,武汉
1029,PROD009,2022-06-14 16:50,进口咖啡豆,1,88.00,CUST015,厦门
1030,PROD001,2022-06-15 08:30,绿联usb分线器,1,25.50,CUST010,重庆
1031,PROD014,2022-06-15 14:20,进口茶叶,2,128.00,CUST004,广州
1032,PROD005,2022-06-16 10:45,泰国新鲜鳕鱼,1,128.00,CUST016,大连
1033,PROD007,2022-06-16 17:15,进口牛奶,2,28.00,CUST011,天津
1034,PROD010,2022-06-17 09:50,进口橄榄油,2,158.00,CUST005,杭州
1035,PROD012,2022-06-17 15:25,进口牛肉,1,188.00,CUST017,郑州
1036,PROD003,2022-06-18 08:40,进口白心火龙果,3,35.00,CUST012,苏州
1037,PROD015,2022-06-18 14:55,进口水果礼盒,1,168.00,CUST018,济南
1038,PROD008,2022-06-19 11:30,手工巧克力,1,58.00,CUST013,青岛
1039,PROD011,2022-06-19 16:40,精选坚果礼盒,2,98.00,CUST006,成都
1040,PROD002,2022-06-20 09:05,加大男装T恤,2,89.00,CUST019,合肥
1041,PROD013,2022-06-20 15:20,进口红酒,2,268.00,CUST009,武汉
1042,PROD006,2022-06-21 10:15,有机蔬菜套餐,3,45.00,CUST014,长沙
1043,PROD016,2022-06-21 17:05,进口海鲜套餐,1,288.00,CUST020,福州
1044,PROD004,2022-06-22 08:50,大连美早樱桃,1,68.00,CUST015,厦门
1045,PROD009,2022-06-22 14:35,进口咖啡豆,3,88.00,CUST010,重庆
1046,PROD014,2022-06-23 11:40,进口茶叶,1,128.00,CUST016,大连
1047,PROD017,2022-06-23 16:25,进口奶酪,2,78.00,CUST011,天津
1048,PROD010,2022-06-24 09:30,进口橄榄油,1,158.00,CUST021,昆明
1049,PROD012,2022-06-24 15:45,进口牛肉,3,188.00,CUST012,苏州
1050,PROD018,2022-06-25 08:55,进口零食大礼包,1,198.00,CUST017,郑州

#!/usr/bin/env python3
"""
电商LTV分析完整示例
演示如何使用LTV预测技能进行完整的电商客户生命周期价值分析
"""

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

# 添加技能模块路径
current_dir = Path(__file__).parent
sys.path.append(str(current_dir.parent / 'scripts'))

from quick_analysis import quick_ltv_analysis

def main():
    """电商LTV分析示例"""
    print("🛒 电商客户生命周期价值分析示例")
    print("=" * 60)

    # 示例数据文件路径
    sample_data_path = current_dir.parent / 'data' / 'sample_orders.csv'
    output_dir = current_dir.parent / 'examples' / 'ecommerce_analysis_results'

    print(f"📁 示例数据: {sample_data_path}")
    print(f"📁 输出目录: {output_dir}")
    print()

    # 检查数据文件是否存在
    if not sample_data_path.exists():
        print(f"❌ 示例数据文件不存在: {sample_data_path}")
        print("请先运行数据准备脚本或检查文件路径。")
        return

    try:
        # 1. 基础LTV分析
        print("1️⃣ 执行基础LTV分析...")
        print("-" * 30)

        basic_config = {
            'data_processor_config': {
                'feature_period_months': 3,  # 使用前3个月数据
                'prediction_period_months': 12,  # 预测后12个月
                'remove_outliers': True,
                'min_orders_per_customer': 1
            },
            'regression_config': {
                'test_size': 0.2,
                'cv_folds': 5,
                'scoring_metric': 'r2',
                'enable_hyperparameter_tuning': False
            },
            'models_to_train': ['linear_regression', 'random_forest']
        }

        results = quick_ltv_analysis(
            file_path=str(sample_data_path),
            feature_period_months=3,
            prediction_period_months=12,
            output_dir=str(output_dir / 'basic_analysis'),
            config=basic_config,
            generate_charts=True,
            generate_reports=True
        )

        print("✅ 基础LTV分析完成")

        # 2. 高级LTV分析（包含调优）
        print("\n2️⃣ 执行高级LTV分析...")
        print("-" * 30)

        advanced_config = {
            'data_processor_config': {
                'feature_period_months': 6,  # 使用前6个月数据
                'prediction_period_months': 12,  # 预测后12个月
                'remove_outliers': True,
                'min_orders_per_customer': 2  # 至少2个订单
            },
            'regression_config': {
                'test_size': 0.2,
                'cv_folds': 10,  # 更多折交叉验证
                'scoring_metric': 'r2',
                'enable_hyperparameter_tuning': True  # 启用超参数调优
            },
            'models_to_train': ['linear_regression', 'random_forest']
        }

        advanced_results = quick_ltv_analysis(
            file_path=str(sample_data_path),
            feature_period_months=6,
            prediction_period_months=12,
            output_dir=str(output_dir / 'advanced_analysis'),
            config=advanced_config,
            generate_charts=True,
            generate_reports=True
        )

        print("✅ 高级LTV分析完成")

        # 3. 结果比较
        print("\n3️⃣ 分析结果比较...")
        print("-" * 30)

        basic_summary = results.get('summary', {})
        advanced_summary = advanced_results.get('summary', {})

        print("基础分析结果:")
        print(f"  - 最佳模型: {basic_summary.get('model_summary', {}).get('best_model', 'Unknown')}")
        print(f"  - R²分数: {basic_summary.get('model_summary', {}).get('best_r2_score', 0):.4f}")
        print(f"  - 分析客户数: {basic_summary.get('data_summary', {}).get('total_customers', 0)}")
        print(f"  - 平均LTV: {basic_summary.get('data_summary', {}).get('avg_ltv', 0):.0f}")

        print("\n高级分析结果:")
        print(f"  - 最佳模型: {advanced_summary.get('model_summary', {}).get('best_model', 'Unknown')}")
        print(f"  - R²分数: {advanced_summary.get('model_summary', {}).get('best_r2_score', 0):.4f}")
        print(f"  - 分析客户数: {advanced_summary.get('data_summary', {}).get('total_customers', 0)}")
        print(f"  - 平均LTV: {advanced_summary.get('data_summary', {}).get('avg_ltv', 0):.0f}")

        # 4. 业务洞察
        print("\n4️⃣ 业务洞察...")
        print("-" * 30)

        # 获取RFM数据进行分析
        basic_rfm_path = results['output_paths']['rfm_features']
        if os.path.exists(basic_rfm_path):
            rfm_data = pd.read_csv(basic_rfm_path)

            # 客户价值分层统计
            if '客户价值分层' in rfm_data.columns:
                segment_counts = rfm_data['客户价值分层'].value_counts()
                print("客户价值分层分布:")
                for segment, count in segment_counts.items():
                    percentage = (count / len(rfm_data)) * 100
                    print(f"  - {segment}: {count}人 ({percentage:.1f}%)")

            # 城市分析
            if '城市' in rfm_data.columns:
                city_ltv = rfm_data.groupby('城市')['年度LTV'].agg(['count', 'mean']).sort_values('mean', ascending=False)
                print("\n城市LTV排名:")
                for city, stats in city_ltv.head(5).iterrows():
                    print(f"  - {city}: {stats['count']}人, 平均LTV {stats['mean']:,.0f}")

        # 5. 推荐策略
        print("\n5️⃣ 推荐营销策略...")
        print("-" * 30)

        recommendations = basic_summary.get('recommendations_summary', [])
        if recommendations:
            for i, rec in enumerate(recommendations[:5], 1):  # 显示前5条建议
                print(f"  {i}. {rec}")
        else:
            print("  基于分析结果，建议:")
            print("  1. 针对高价值客户设计VIP维护计划")
            print("  2. 对中价值客户进行交叉销售和向上销售")
            print("  3. 对低价值客户制定激活和留存策略")
            print("  4. 重点关注一线城市客户的个性化服务")
            print("  5. 建立客户生命周期管理流程")

        # 6. 文件生成总结
        print("\n6️⃣ 生成文件总结...")
        print("-" * 30)

        print("基础分析生成文件:")
        print(f"  📊 RFM特征数据: {results['output_paths']['rfm_features']}")
        print(f"  🤖 训练模型: {results['output_paths']['models']}")
        print(f"  📋 分析摘要: {results['summary_path']}")

        chart_count = len(results.get('chart_paths', {}))
        report_count = len(results.get('report_paths', {}))
        print(f"  📈 可视化图表: {chart_count}个")
        print(f"  📄 分析报告: {report_count}个")

        print("\n高级分析生成文件:")
        print(f"  📊 RFM特征数据: {advanced_results['output_paths']['rfm_features']}")
        print(f"  🤖 训练模型: {advanced_results['output_paths']['models']}")
        print(f"  📋 分析摘要: {advanced_results['summary_path']}")

        chart_count = len(advanced_results.get('chart_paths', {}))
        report_count = len(advanced_results.get('report_paths', {}))
        print(f"  📈 可视化图表: {chart_count}个")
        print(f"  📄 分析报告: {report_count}个")

        print("\n" + "=" * 60)
        print("🎉 电商LTV分析示例完成！")
        print("=" * 60)
        print(f"📁 所有结果已保存至: {output_dir}")
        print("\n📖 后续步骤:")
        print("1. 查看生成的HTML报告了解详细分析结果")
        print("2. 使用可视化图表洞察客户行为模式")
        print("3. 基于推荐策略制定营销计划")
        print("4. 定期更新数据重新分析以跟踪变化")

    except Exception as e:
        print(f"\n❌ 分析过程中出现错误: {str(e)}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
快速LTV预测示例
演示如何使用已训练的模型快速预测新客户的LTV
"""

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

# 添加技能模块路径
current_dir = Path(__file__).parent
sys.path.append(str(current_dir.parent / 'scripts'))

from quick_analysis import quick_ltv_analysis, predict_new_customers, batch_predict_ltv

def create_sample_new_customers():
    """创建示例新客户数据"""
    np.random.seed(42)

    # 模拟新客户订单数据
    new_customers = []

    # 生成10个新客户的近期订单
    for i in range(10, 20):  # 客户ID从10开始
        customer_id = f"CUST{i:03d}"
        city = np.random.choice(['北京', '上海', '深圳', '广州', '杭州', '成都', '武汉'])

        # 每个客户1-3个订单
        num_orders = np.random.randint(1, 4)

        for j in range(num_orders):
            order_id = 2000 + i * 10 + j
            product_code = f"PROD{np.random.randint(1, 15):03d}"
            order_date = pd.Timestamp('2023-01-01') + pd.Timedelta(days=np.random.randint(0, 90))
            product_desc = f"测试产品{product_code}"
            quantity = np.random.randint(1, 5)
            price = np.random.uniform(20, 200)

            new_customers.append({
                '订单号': order_id,
                '产品码': product_code,
                '消费日期': order_date.strftime('%Y-%m-%d %H:%M'),
                '产品说明': product_desc,
                '数量': quantity,
                '单价': round(price, 2),
                '用户码': customer_id,
                '城市': city
            })

    return pd.DataFrame(new_customers)

def main():
    """快速LTV预测示例"""
    print("⚡ 快速LTV预测示例")
    print("=" * 60)

    # 路径设置
    sample_data_path = current_dir.parent / 'data' / 'sample_orders.csv'
    model_output_dir = current_dir.parent / 'examples' / 'quick_prediction' / 'models'
    new_customers_output_dir = current_dir.parent / 'examples' / 'quick_prediction'

    print(f"📁 训练数据: {sample_data_path}")
    print(f"🤖 模型目录: {model_output_dir}")
    print(f"📁 输出目录: {new_customers_output_dir}")
    print()

    try:
        # 第一步：训练基础模型
        print("1️⃣ 训练LTV预测模型...")
        print("-" * 30)

        if not sample_data_path.exists():
            print(f"❌ 示例数据文件不存在: {sample_data_path}")
            return

        # 快速训练配置
        quick_config = {
            'data_processor_config': {
                'feature_period_months': 3,
                'prediction_period_months': 12,
                'remove_outliers': False,  # 快速训练不去除异常值
                'min_orders_per_customer': 1
            },
            'regression_config': {
                'test_size': 0.3,  # 更大的测试集
                'cv_folds': 3,  # 更少的交叉验证折数
                'scoring_metric': 'r2',
                'enable_hyperparameter_tuning': False  # 不调以节省时间
            },
            'models_to_train': ['random_forest']  # 只训练随机森林
        }

        # 训练模型
        training_results = quick_ltv_analysis(
            file_path=str(sample_data_path),
            feature_period_months=3,
            prediction_period_months=12,
            output_dir=str(model_output_dir),
            config=quick_config,
            generate_charts=False,  # 不生成图表以节省时间
            generate_reports=False   # 不生成报告以节省时间
        )

        print("✅ 模型训练完成")

        # 第二步：创建新客户数据
        print("\n2️⃣ 创建新客户数据...")
        print("-" * 30)

        new_customers_df = create_sample_new_customers()
        new_customers_file = new_customers_output_dir / 'new_customers.csv'
        new_customers_df.to_csv(new_customers_file, index=False, encoding='utf-8-sig')

        print(f"✅ 新客户数据已创建: {new_customers_file}")
        print(f"   - 客户数: {new_customers_df['用户码'].nunique()}")
        print(f"   - 订单数: {len(new_customers_df)}")
        print(f"   - 时间范围: {new_customers_df['消费日期'].min()} 至 {new_customers_df['消费日期'].max()}")

        # 第三步：预测新客户LTV
        print("\n3️⃣ 预测新客户LTV...")
        print("-" * 30)

        predictions_file = new_customers_output_dir / 'new_customer_predictions.csv'
        predictions_df = predict_new_customers(
            model_dir=str(model_output_dir),
            new_orders_file=str(new_customers_file),
            output_path=str(predictions_file)
        )

        print("✅ 新客户LTV预测完成")

        # 第四步：分析预测结果
        print("\n4️⃣ 分析预测结果...")
        print("-" * 30)

        if predictions_df is not None:
            print("预测结果统计:")
            print(f"  - 预测客户数: {len(predictions_df)}")
            print(f"  - 平均预测LTV: {predictions_df['预测LTV'].mean():,.0f}")
            print(f"  - 最高预测LTV: {predictions_df['预测LTV'].max():,.0f}")
            print(f"  - 最低预测LTV: {predictions_df['预测LTV'].min():,.0f}")

            # 按城市分组分析（如果有城市信息）
            if '城市' in predictions_df.columns:
                city_analysis = predictions_df.groupby('城市')['预测LTV'].agg(['count', 'mean', 'std']).round(2)
                print("\n各城市LTV预测:")
                for city, stats in city_analysis.iterrows():
                    print(f"  - {city}: {stats['count']}人, 平均{stats['mean']:,.0f}, 标准差{stats['std']:,.0f}")
            else:
                print("\n注：预测结果中不包含城市信息，无法按城市分析")

            # 客户分群
            def categorize_ltv(ltv):
                if ltv >= 1000:
                    return "高价值客户"
                elif ltv >= 500:
                    return "中价值客户"
                else:
                    return "低价值客户"

            predictions_df['价值分层'] = predictions_df['预测LTV'].apply(categorize_ltv)
            segment_counts = predictions_df['价值分层'].value_counts()
            print("\n客户价值分层:")
            for segment, count in segment_counts.items():
                percentage = (count / len(predictions_df)) * 100
                print(f"  - {segment}: {count}人 ({percentage:.1f}%)")

        # 第五步：生成快速建议
        print("\n5️⃣ 营销建议...")
        print("-" * 30)

        if predictions_df is not None:
            # 高价值客户建议
            high_value = predictions_df[predictions_df['预测LTV'] >= 1000]
            if not high_value.empty:
                print("高价值客户策略:")
                print("  - 提供VIP专属服务")
                print("  - 安排客户经理专人对接")
                print("  - 定制个性化营销方案")
                print(f"  - 重点维护的{len(high_value)}位客户: {', '.join(high_value['用户码'].tolist())}")

            # 中价值客户建议
            medium_value = predictions_df[(predictions_df['预测LTV'] >= 500) & (predictions_df['预测LTV'] < 1000)]
            if not medium_value.empty:
                print("\n中价值客户策略:")
                print("  - 推荐升级产品和套餐")
                print("  - 提供优惠券刺激消费")
                print("  - 增加互动频率")
                print(f"  - 重点关注的{len(medium_value)}位客户: {', '.join(medium_value['用户码'].tolist())}")

            # 低价值客户建议
            low_value = predictions_df[predictions_df['预测LTV'] < 500]
            if not low_value.empty:
                print("\n低价值客户策略:")
                print("  - 发放新人礼包和优惠券")
                print("  - 推荐性价比高的产品")
                print("  - 增加产品体验机会")
                print(f"  - 需要激活的{len(low_value)}位客户: {', '.join(low_value['用户码'].tolist())}")

        # 第六步：总结
        print("\n6️⃣ 预测总结...")
        print("-" * 30)

        print("✅ 快速LTV预测流程完成")
        print(f"📁 模型文件: {model_output_dir}")
        print(f"📊 新客户数据: {new_customers_file}")
        print(f"🎯 预测结果: {predictions_file}")

        print("\n📖 使用说明:")
        print("1. 模型已训练并保存，可直接用于新客户预测")
        print("2. 新客户数据格式需与训练数据保持一致")
        print("3. 预测结果可用于制定个性化营销策略")
        print("4. 建议定期重新训练模型以保持预测准确性")

        print("\n🔧 批量预测:")
        print("如需批量预测大量客户，可使用:")
        print(f"python -c \"from quick_analysis import batch_predict_ltv; batch_predict_ltv('{model_output_dir}', 'rfm_file.csv', 'batch_predictions.csv')\"")

    except Exception as e:
        print(f"\n❌ 预测过程中出现错误: {str(e)}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    main()

{
  "timestamp": "2025-12-20 00:25:14",
  "data_summary": {
    "total_customers": 21,
    "total_orders": "Unknown",
    "date_range": [
      "2022-06-01",
      "2022-06-25"
    ],
    "avg_ltv": 357.4047619047619,
    "median_ltv": 301.0
  },
  "model_summary": {
    "best_model": "random_forest",
    "best_r2_score": 0.48296743825855337,
    "best_mae": 114.6276462585034,
    "best_rmse": 157.18971424672202,
    "best_mape": 19.351985948660396
  },
  "feature_summary": {
    "most_important_feature": "Unknown",
    "feature_importance": {
      "M值": 0.9822450117626177,
      "F值": 0.010390131073788061,
      "R值": 0.0073648571635942794
    }
  },
  "segment_summary": {
    "segment_counts": {
      "铜牌客户": 5,
      "金牌客户": 5,
      "银牌客户": 4,
      "钻石客户": 4,
      "白金客户": 3
    },
    "high_value_customers": "7"
  },
  "recommendations_summary": [
    "模型预测性能一般，建议增加更多特征数据或尝试其他算法",
    "样本量较少，建议积累更多数据以提高模型稳定性"
  ],
  "generated_files": {
    "charts": {},
    "reports": {}
  }
}

��T}�(�config�}�(�	test_size�G?�333333�random_state�K*�cv_folds�K�scoring_metric��r2��enable_hyperparameter_tuning���
n_iter_search�K2�feature_columns�]�(�R值��F值��M值�e�
target_column��	年度LTV�u�
feature_names�]�(�R值��F值��M值�e�model_performance�}��
random_forest�}�(�r2_score�G?���B���mae�G@\�+[6n��mse�G@�!&����rmse��numpy.core.multiarray��scalar����numpy��dtype����f8�����R�(K�
<�NNNJ����J����Kt�bC4��#�c@���R��mape�h h&C�%J�Z3@���R�us�feature_importance�}�h}�(hh h&C�E�n�?���R�hh h&CC�M�kG�?���R�hh h&C ��ʜ*~?���R�us�best_model_name�hu.

用户码,R值,F值,M值,年度LTV,R_分位数,F_分位数,M_分位数,RFM_分群,RFM_得分,客户价值分层
CUST001,80,4,673.0,673.0,A,D,D,ADD,17.05,钻石客户
CUST002,82,4,373.0,373.0,A,D,C,ADC,13.05,金牌客户
CUST003,88,2,248.0,248.0,A,B,B,ABB,6.25,银牌客户
CUST004,77,3,370.5,370.5,B,C,C,BCC,12.0,金牌客户
CUST005,75,3,652.0,652.0,B,C,D,BCD,15.2,钻石客户
CUST006,73,3,301.0,301.0,C,C,B,CCB,12.3,金牌客户
CUST007,81,2,212.5,212.5,A,B,A,ABA,6.15,银牌客户
CUST008,80,2,184.0,184.0,A,B,A,ABA,5.949999999999999,铜牌客户
CUST009,72,3,669.0,669.0,C,C,D,CCD,16.7,钻石客户
CUST010,70,3,379.5,379.5,D,C,C,DCC,15.0,白金客户
CUST011,69,3,263.0,263.0,D,C,B,DCB,12.8,金牌客户
CUST012,68,3,753.0,753.0,D,C,D,DCD,19.3,钻石客户
CUST013,73,2,434.0,434.0,C,B,D,CBD,13.05,金牌客户
CUST014,71,2,403.0,403.0,C,B,C,CBC,13.35,白金客户
CUST015,71,2,156.0,156.0,C,B,A,CBA,5.85,铜牌客户
CUST016,69,2,256.0,256.0,D,B,B,DBB,10.05,银牌客户
CUST017,68,2,386.0,386.0,D,B,C,DBC,14.05,白金客户
CUST018,74,1,168.0,168.0,B,A,A,BAA,3.85,铜牌客户
CUST019,73,1,178.0,178.0,C,A,A,CAA,4.75,铜牌客户
CUST020,71,1,288.0,288.0,C,A,B,CAB,8.55,银牌客户
CUST021,68,1,158.0,158.0,D,A,A,DAA,5.75,铜牌客户

{
  "timestamp": "2025-12-20 00:25:14",
  "config": {
    "data_processor_config": {
      "feature_period_months": 3,
      "prediction_period_months": 12,
      "remove_outliers": false,
      "min_orders_per_customer": 1
    },
    "regression_config": {
      "test_size": 0.3,
      "cv_folds": 3,
      "scoring_metric": "r2",
      "enable_hyperparameter_tuning": false
    },
    "feature_columns": [
      "R值",
      "F值",
      "M值"
    ],
    "target_column": "年度LTV",
    "models_to_train": [
      "random_forest"
    ],
    "customer_column": "用户码"
  },
  "data_summary": {
    "total_customers": 21,
    "date_range": [
      "2022-06-01",
      "2022-06-25"
    ],
    "rfm_statistics": {
      "R值": {
        "mean": 73.95238095238095,
        "median": 73.0,
        "std": 5.472441781108233,
        "min": "68",
        "max": "88"
      },
      "F值": {
        "mean": 2.3333333333333335,
        "median": 2.0,
        "std": 0.9128709291752769,
        "min": "1",
        "max": "4"
      },
      "M值": {
        "mean": 357.4047619047619,
        "median": 301.0,
        "std": 185.50691490127926,
        "min": 156.0,
        "max": 753.0
      },
      "年度LTV": {
        "mean": 357.4047619047619,
        "median": 301.0,
        "std": 185.50691490127926,
        "min": 156.0,
        "max": 753.0
      }
    },
    "high_value_customers": {
      "top_10_percent_threshold": 669.0,
      "count": 3
    }
  },
  "model_summary": {
    "total_models_trained": 1,
    "best_model": "random_forest",
    "feature_names": [
      "R值",
      "F值",
      "M值"
    ],
    "model_performance": {
      "random_forest": {
        "r2_score": 0.48296743825855337,
        "mae": 114.6276462585034,
        "mse": 24708.606264966125,
        "rmse": 157.18971424672202,
        "mape": 19.351985948660396
      }
    },
    "feature_importance": {
      "random_forest": {
        "M值": 0.9822450117626177,
        "F值": 0.010390131073788061,
        "R值": 0.0073648571635942794
      }
    },
    "best_performance": {
      "r2_score": 0.48296743825855337,
      "mae": 114.6276462585034,
      "mse": 24708.606264966125,
      "rmse": 157.18971424672202,
      "mape": 19.351985948660396
    }
  },
  "best_model_performance": {
    "model_name": "random_forest",
    "r2_score": 0.48296743825855337,
    "mae": 114.6276462585034,
    "rmse": 157.18971424672202,
    "mape": 19.351985948660396
  },
  "feature_analysis": {
    "feature_importance": {
      "random_forest": {
        "M值": 0.9822450117626177,
        "F值": 0.010390131073788061,
        "R值": 0.0073648571635942794
      }
    },
    "best_model_features": {
      "M值": 0.9822450117626177,
      "F值": 0.010390131073788061,
      "R值": 0.0073648571635942794
    },
    "feature_insights": {
      "most_important_feature": "M值",
      "most_important_score": 0.9822450117626177,
      "feature_ranking": {
        "M值": 0.9822450117626177,
        "F值": 0.010390131073788061,
        "R值": 0.0073648571635942794
      },
      "feature_contribution_analysis": {
        "M值": "消费金额贡献了98.2%的预测信息，历史消费金额是LTV的关键指标",
        "F值": "消费频率贡献了1.0%的预测信息，频繁购买客户更有价值",
        "R值": "最近消费时间贡献了0.7%的预测信息，客户活跃度对LTV影响显著"
      }
    }
  },
  "recommendations": [
    "模型预测性能一般，建议增加更多特征数据或尝试其他算法",
    "样本量较少，建议积累更多数据以提高模型稳定性"
  ]
}

用户码,R值,F值,M值,年度LTV,R_分位数,F_分位数,M_分位数,RFM_分群,RFM_得分,预测LTV,预测时间
CUST010,22,1,127.43,0.0,B,A,A,BAA,1.9,185.80339484126984,2025-12-20 00:25:14
CUST011,6,3,1354.62,0.0,D,D,D,DDD,9.3,462.28403968253974,2025-12-20 00:25:14
CUST012,18,1,228.92,0.0,B,A,A,BAA,3.1,215.76969246031746,2025-12-20 00:25:14
CUST013,35,1,135.32999999999998,0.0,A,A,A,AAA,2.0,185.80339484126984,2025-12-20 00:25:14
CUST014,32,3,1052.52,0.0,A,D,D,ADD,7.8,462.28403968253974,2025-12-20 00:25:14
CUST015,5,2,560.72,0.0,D,B,C,DBC,7.05,460.65070634920636,2025-12-20 00:25:14
CUST016,16,2,503.09999999999997,0.0,C,B,C,CBC,5.95,460.65070634920636,2025-12-20 00:25:14
CUST017,40,2,376.78999999999996,0.0,A,B,B,ABB,3.8499999999999996,404.9150873015874,2025-12-20 00:25:14
CUST018,16,2,431.21,0.0,C,B,B,CBB,5.45,460.65070634920636,2025-12-20 00:25:14
CUST019,5,3,840.53,0.0,D,D,D,DDD,8.6,462.28403968253974,2025-12-20 00:25:14

订单号,产品码,消费日期,产品说明,数量,单价,用户码,城市
2100,PROD011,2023-03-13 00:00,测试产品PROD011,1,127.43,CUST010,武汉
2110,PROD007,2023-03-16 00:00,测试产品PROD007,3,175.91,CUST011,上海
2111,PROD004,2023-01-24 00:00,测试产品PROD004,3,23.71,CUST011,上海
2112,PROD002,2023-03-29 00:00,测试产品PROD002,4,188.94,CUST011,上海
2120,PROD001,2023-03-17 00:00,测试产品PROD001,2,114.46,CUST012,上海
2130,PROD001,2023-02-28 00:00,测试产品PROD001,3,45.11,CUST013,广州
2140,PROD014,2023-03-03 00:00,测试产品PROD014,3,131.31,CUST014,广州
2141,PROD012,2023-02-24 00:00,测试产品PROD012,4,126.63,CUST014,广州
2142,PROD003,2023-02-20 00:00,测试产品PROD003,3,50.69,CUST014,广州
2150,PROD004,2023-03-30 00:00,测试产品PROD004,4,121.39,CUST015,武汉
2151,PROD010,2023-01-09 00:00,测试产品PROD010,2,37.58,CUST015,武汉
2160,PROD012,2023-03-12 00:00,测试产品PROD012,4,109.13,CUST016,广州
2161,PROD003,2023-03-19 00:00,测试产品PROD003,1,66.58,CUST016,广州
2162,PROD008,2023-01-04 00:00,测试产品PROD008,2,96.53,CUST016,广州
2170,PROD004,2023-02-23 00:00,测试产品PROD004,1,194.53,CUST017,成都
2171,PROD010,2023-02-13 00:00,测试产品PROD010,2,91.13,CUST017,成都
2180,PROD008,2023-03-19 00:00,测试产品PROD008,3,113.75,CUST018,广州
2181,PROD014,2023-02-09 00:00,测试产品PROD014,1,89.96,CUST018,广州
2190,PROD005,2023-01-24 00:00,测试产品PROD005,2,193.75,CUST019,上海
2191,PROD012,2023-02-10 00:00,测试产品PROD012,1,164.4,CUST019,上海
2192,PROD001,2023-03-30 00:00,测试产品PROD001,3,96.21,CUST019,上海

��]
�sklearn.linear_model._base��LinearRegression���)��}�(�
fit_intercept���copy_X���tol�G>�����퍌n_jobs�N�positive���feature_names_in_��joblib.numpy_pickle��NumpyArrayWrapper���)��}�(�subclass��numpy��ndarray����shape�K���order��
C��dtype�h�dtype����O8�����R�(K�
|�NNNJ����J����K?t�b�
allow_mmap���numpy_array_alignment_bytes�Kub����numpy.core.multiarray��_reconstruct����numpy��ndarray���K��C
b���R�(K
K��h�dtype����O8�����R�(K�
|�NNNJ����J����K?t�b�]�(�R值��F值��M值�et�b.�b�n_features_in_�K�coef_�h
)��}�(hhhK��hhhh�f8�����R�(K�
<�NNNJ����J����Kt�bh �h!Kub���2��4ɼ�-=�?�9�rank_�K�	singular_�h
)��}�(hhhK��hhhh)h �h!Kub�����g�M�U@F�Wy�4@��?��5
@�_�
intercept_��numpy.core.multiarray��scalar���h)CH����R��_sklearn_version��1.8.0�ub.

��X}�(�config�}�(�	test_size�G?�333333�random_state�K*�cv_folds�K�scoring_metric��r2��enable_hyperparameter_tuning���
n_iter_search�K2�feature_columns�]�(�R值��F值��M值�e�
target_column��	年度LTV�u�
feature_names�]�(�R值��F值��M值�e�model_performance�}��linear_regression�}�(�r2_score�G?��mae�G=D�mse�G:�6�m��n�rmse��numpy.core.multiarray��scalar����numpy��dtype����f8�����R�(K�
<�NNNJ����J����Kt�bC����hxG=���R��mape�h h&Cc����'!=���R�us�feature_importance�}�h}�(hh h&C�?���R�hh h&C�-=���R�hh h&C2��4�<���R�us�best_model_name�hu.

用户码,R值,F值,M值,年度LTV,R_分位数,F_分位数,M_分位数,RFM_分群,RFM_得分,客户价值分层
CUST001,80,4,673.0,673.0,A,D,D,ADD,17.05,钻石客户
CUST002,82,4,373.0,373.0,A,D,C,ADC,13.05,金牌客户
CUST003,88,2,248.0,248.0,A,B,B,ABB,6.25,银牌客户
CUST004,77,3,370.5,370.5,B,C,C,BCC,12.0,金牌客户
CUST005,75,3,652.0,652.0,B,C,D,BCD,15.2,钻石客户
CUST006,73,3,301.0,301.0,C,C,B,CCB,12.3,金牌客户
CUST007,81,2,212.5,212.5,A,B,A,ABA,6.15,银牌客户
CUST008,80,2,184.0,184.0,A,B,A,ABA,5.949999999999999,铜牌客户
CUST009,72,3,669.0,669.0,C,C,D,CCD,16.7,钻石客户
CUST010,70,3,379.5,379.5,D,C,C,DCC,15.0,白金客户
CUST011,69,3,263.0,263.0,D,C,B,DCB,12.8,金牌客户
CUST012,68,3,753.0,753.0,D,C,D,DCD,19.3,钻石客户
CUST013,73,2,434.0,434.0,C,B,D,CBD,13.05,金牌客户
CUST014,71,2,403.0,403.0,C,B,C,CBC,13.35,白金客户
CUST015,71,2,156.0,156.0,C,B,A,CBA,5.85,铜牌客户
CUST016,69,2,256.0,256.0,D,B,B,DBB,10.05,银牌客户
CUST017,68,2,386.0,386.0,D,B,C,DBC,14.05,白金客户
CUST018,74,1,168.0,168.0,B,A,A,BAA,3.85,铜牌客户
CUST019,73,1,178.0,178.0,C,A,A,CAA,4.75,铜牌客户
CUST020,71,1,288.0,288.0,C,A,B,CAB,8.55,银牌客户
CUST021,68,1,158.0,158.0,D,A,A,DAA,5.75,铜牌客户

{
  "timestamp": "2025-12-20 00:25:00",
  "config": {
    "data_processor_config": {
      "feature_period_months": 3,
      "prediction_period_months": 6,
      "remove_outliers": false,
      "min_orders_per_customer": 1
    },
    "regression_config": {
      "test_size": 0.3,
      "cv_folds": 3,
      "scoring_metric": "r2",
      "enable_hyperparameter_tuning": false
    },
    "feature_columns": [
      "R值",
      "F值",
      "M值"
    ],
    "target_column": "年度LTV",
    "models_to_train": [
      "linear_regression"
    ],
    "customer_column": "用户码"
  },
  "data_summary": {
    "total_customers": 21,
    "date_range": [
      "2022-06-01",
      "2022-06-25"
    ],
    "rfm_statistics": {
      "R值": {
        "mean": 73.95238095238095,
        "median": 73.0,
        "std": 5.472441781108233,
        "min": "68",
        "max": "88"
      },
      "F值": {
        "mean": 2.3333333333333335,
        "median": 2.0,
        "std": 0.9128709291752769,
        "min": "1",
        "max": "4"
      },
      "M值": {
        "mean": 357.4047619047619,
        "median": 301.0,
        "std": 185.50691490127926,
        "min": 156.0,
        "max": 753.0
      },
      "年度LTV": {
        "mean": 357.4047619047619,
        "median": 301.0,
        "std": 185.50691490127926,
        "min": 156.0,
        "max": 753.0
      }
    },
    "high_value_customers": {
      "top_10_percent_threshold": 669.0,
      "count": 3
    }
  },
  "model_summary": {
    "total_models_trained": 1,
    "best_model": "linear_regression",
    "feature_names": [
      "R值",
      "F值",
      "M值"
    ],
    "model_performance": {
      "linear_regression": {
        "r2_score": 1.0,
        "mae": 1.4210854715202004e-13,
        "mse": 2.781117851915174e-26,
        "rmse": 1.6676683878742723e-13,
        "mape": 3.047491048709334e-14
      }
    },
    "feature_importance": {
      "linear_regression": {
        "M值": 1.0000000000000004,
        "F值": 5.3179682879545e-14,
        "R值": 6.996024142584277e-16
      }
    },
    "best_performance": {
      "r2_score": 1.0,
      "mae": 1.4210854715202004e-13,
      "mse": 2.781117851915174e-26,
      "rmse": 1.6676683878742723e-13,
      "mape": 3.047491048709334e-14
    }
  },
  "best_model_performance": {
    "model_name": "linear_regression",
    "r2_score": 1.0,
    "mae": 1.4210854715202004e-13,
    "rmse": 1.6676683878742723e-13,
    "mape": 3.047491048709334e-14
  },
  "feature_analysis": {
    "feature_importance": {
      "linear_regression": {
        "M值": 1.0000000000000004,
        "F值": 5.3179682879545e-14,
        "R值": 6.996024142584277e-16
      }
    },
    "best_model_features": {
      "M值": 1.0000000000000004,
      "F值": 5.3179682879545e-14,
      "R值": 6.996024142584277e-16
    },
    "feature_insights": {
      "most_important_feature": "M值",
      "most_important_score": 1.0000000000000004,
      "feature_ranking": {
        "M值": 1.0000000000000004,
        "F值": 5.3179682879545e-14,
        "R值": 6.996024142584277e-16
      },
      "feature_contribution_analysis": {
        "M值": "消费金额贡献了100.0%的预测信息，历史消费金额是LTV的关键指标",
        "F值": "消费频率贡献了0.0%的预测信息，频繁购买客户更有价值",
        "R值": "最近消费时间贡献了0.0%的预测信息，客户活跃度对LTV影响显著"
      }
    }
  },
  "recommendations": [
    "模型预测性能优秀（R² > 0.7），可用于精准营销和客户价值管理",
    "样本量较少，建议积累更多数据以提高模型稳定性"
  ]
}

#!/usr/bin/env python3
"""
简单的功能测试脚本
"""

import sys
from pathlib import Path

# 添加技能模块路径
current_dir = Path(__file__).parent
sys.path.append(str(current_dir.parent / 'scripts'))

try:
    print("🧪 测试数据处理器...")
    from data_processor import DataProcessor
    import pandas as pd

    # 初始化处理器
    processor = DataProcessor()

    # 加载示例数据
    sample_data_path = current_dir.parent / 'data' / 'sample_orders.csv'
    if not sample_data_path.exists():
        print("❌ 示例数据文件不存在")
        sys.exit(1)

    data = processor.load_order_data(str(sample_data_path))
    print(f"✅ 数据加载成功: {data.shape}")

    # 测试RFM计算
    rfm_data = processor.calculate_rfm_features(data, 3, 12)
    print(f"✅ RFM计算成功: {rfm_data.shape}")

    # 检查关键列
    required_columns = ['R值', 'F值', 'M值', '年度LTV']
    missing_columns = [col for col in required_columns if col not in rfm_data.columns]
    if missing_columns:
        print(f"❌ 缺少列: {missing_columns}")
    else:
        print("✅ RFM特征列完整")

    print("\n🧪 测试回归模型...")
    from regression_models import RegressionModels
    import numpy as np

    # 创建测试数据
    X = np.random.rand(50, 3)
    y = X[:, 0] * 2 + X[:, 1] * 3 + np.random.randn(50) * 0.1

    models = RegressionModels()

    # 测试线性回归
    linear_model = models.train_single_model('linear_regression', X, y)
    if linear_model is not None:
        print("✅ 线性回归训练成功")

    # 测试随机森林
    rf_model = models.train_single_model('random_forest', X, y)
    if rf_model is not None:
        print("✅ 随机森林训练成功")

    print("\n🧪 测试完整分析...")
    from ltv_predictor import complete_ltv_analysis

    # 快速配置
    config = {
        'data_processor_config': {
            'feature_period_months': 3,
            'prediction_period_months': 6,
            'remove_outliers': False,
            'min_orders_per_customer': 1
        },
        'regression_config': {
            'test_size': 0.3,
            'cv_folds': 3,
            'scoring_metric': 'r2',
            'enable_hyperparameter_tuning': False
        },
        'models_to_train': ['linear_regression']
    }

    output_dir = current_dir.parent / 'examples' / 'simple_test_results'

    results = complete_ltv_analysis(
        str(sample_data_path),
        output_dir=str(output_dir),
        config=config
    )

    if results and 'predictor' in results:
        print("✅ 完整分析流程测试成功")
        print(f"   - 分析客户数: {len(results['rfm_data'])}")
        print(f"   - 输出目录: {output_dir}")
    else:
        print("❌ 完整分析流程测试失败")

    print("\n🎉 所有基础功能测试通过！")

except ImportError as e:
    print(f"❌ 模块导入失败: {e}")
    sys.exit(1)
except Exception as e:
    print(f"❌ 测试过程中出现错误: {e}")
    import traceback
    traceback.print_exc()
    sys.exit(1)

#!/usr/bin/env python3
"""
LTV预测技能测试验证脚本
全面测试LTV预测技能的各个模块和功能
"""

import sys
import os
from pathlib import Path
import pandas as pd
import numpy as np
import unittest
from unittest.mock import patch, MagicMock

# 添加技能模块路径
current_dir = Path(__file__).parent
sys.path.append(str(current_dir.parent / 'scripts'))

try:
    from data_processor import DataProcessor
    from regression_models import RegressionModels
    from ltv_predictor import LTVPredictor, complete_ltv_analysis
    from visualizer import DataVisualizer
    from report_generator import generate_comprehensive_report
    from quick_analysis import quick_ltv_analysis
except ImportError as e:
    print(f"❌ 模块导入失败: {e}")
    sys.exit(1)

class TestLTVPredictor(unittest.TestCase):
    """LTV预测技能测试类"""

    @classmethod
    def setUpClass(cls):
        """测试环境设置"""
        cls.sample_data_path = current_dir.parent / 'data' / 'sample_orders.csv'
        cls.test_output_dir = current_dir.parent / 'examples' / 'test_results'
        cls.test_output_dir.mkdir(parents=True, exist_ok=True)

        if not cls.sample_data_path.exists():
            cls.skipTest(cls, "示例数据文件不存在")

    def setUp(self):
        """每个测试前的设置"""
        self.test_data = pd.read_csv(self.sample_data_path)

    def test_data_processor(self):
        """测试数据处理器"""
        print("\n🧪 测试数据处理器...")

        processor = DataProcessor()

        # 测试数据加载
        loaded_data = processor.load_order_data(str(self.sample_data_path))
        self.assertIsNotNone(loaded_data)
        self.assertEqual(len(loaded_data), 50)  # 示例数据有50行

        # 测试RFM特征计算
        rfm_data = processor.calculate_rfm_features(
            loaded_data,
            feature_period_months=3,
            prediction_period_months=12
        )
        self.assertIsNotNone(rfm_data)
        self.assertTrue(len(rfm_data) > 0)

        # 检查RFM特征列是否存在
        expected_columns = ['R值', 'F值', 'M值', '年度LTV']
        for col in expected_columns:
            self.assertIn(col, rfm_data.columns, f"缺少RFM特征列: {col}")

        print("✅ 数据处理器测试通过")

    def test_regression_models(self):
        """测试回归模型"""
        print("\n🧪 测试回归模型...")

        # 创建测试数据
        X = np.random.rand(100, 3)  # 100个样本，3个特征
        y = X[:, 0] * 2 + X[:, 1] * 3 + X[:, 2] * 1 + np.random.randn(100) * 0.1

        models = RegressionModels()

        # 测试线性回归
        linear_model = models.train_linear_regression(X, y)
        self.assertIsNotNone(linear_model)

        # 测试随机森林
        rf_model = models.train_random_forest(X, y)
        self.assertIsNotNone(rf_model)

        # 测试模型评估
        evaluation = models.evaluate_model(linear_model, X, y)
        self.assertIn('r2_score', evaluation)
        self.assertIn('mae', evaluation)
        self.assertIn('rmse', evaluation)

        print("✅ 回归模型测试通过")

    def test_ltv_predictor_integration(self):
        """测试LTV预测器集成"""
        print("\n🧪 测试LTV预测器集成...")

        try:
            # 快速配置以节省测试时间
            test_config = {
                'data_processor_config': {
                    'feature_period_months': 3,
                    'prediction_period_months': 6,  # 缩短预测期
                    'remove_outliers': False,
                    'min_orders_per_customer': 1
                },
                'regression_config': {
                    'test_size': 0.3,
                    'cv_folds': 3,
                    'scoring_metric': 'r2',
                    'enable_hyperparameter_tuning': False
                },
                'models_to_train': ['linear_regression']  # 只测试线性回归
            }

            # 执行完整分析
            results = complete_ltv_analysis(
                str(self.sample_data_path),
                output_dir=str(self.test_output_dir / 'integration_test'),
                config=test_config
            )

            # 验证结果结构
            self.assertIn('predictor', results)
            self.assertIn('rfm_data', results)
            self.assertIn('training_results', results)
            self.assertIn('summary_report', results)
            self.assertIn('output_paths', results)

            # 验证RFM数据
            rfm_data = results['rfm_data']
            self.assertIsInstance(rfm_data, pd.DataFrame)
            self.assertTrue(len(rfm_data) > 0)

            # 验证模型结果
            training_results = results['training_results']
            self.assertIn('model_results', training_results)

            print("✅ LTV预测器集成测试通过")

        except Exception as e:
            self.fail(f"LTV预测器集成测试失败: {str(e)}")

    def test_visualizer(self):
        """测试可视化模块"""
        print("\n🧪 测试可视化模块...")

        try:
            # 创建测试数据
            test_rfm = pd.DataFrame({
                'R值': np.random.randint(1, 365, 50),
                'F值': np.random.randint(1, 20, 50),
                'M值': np.random.uniform(100, 5000, 50),
                '年度LTV': np.random.uniform(500, 5000, 50),
                '客户价值分层': np.random.choice(['青铜客户', '白银客户', '黄金客户', '白金客户'], 50)
            })

            # 创建模型结果
            model_results = {
                'linear_regression': {
                    'r2_score': 0.75,
                    'mae': 250.5,
                    'rmse': 350.2,
                    'mape': 15.3
                }
            }

            visualizer = DataVisualizer()

            # 测试RFM分布图
            chart_path = self.test_output_dir / 'test_rfm_distribution.png'
            visualizer.plot_rfm_distribution(
                test_rfm, save_path=str(chart_path), show_plot=False
            )
            self.assertTrue(chart_path.exists())

            # 测试模型性能图
            perf_chart_path = self.test_output_dir / 'test_model_performance.png'
            visualizer.plot_model_performance(
                model_results, save_path=str(perf_chart_path), show_plot=False
            )
            self.assertTrue(perf_chart_path.exists())

            print("✅ 可视化模块测试通过")

        except Exception as e:
            self.fail(f"可视化模块测试失败: {str(e)}")

    def test_quick_analysis(self):
        """测试快速分析功能"""
        print("\n🧪 测试快速分析功能...")

        try:
            # 使用最小配置进行快速测试
            results = quick_ltv_analysis(
                file_path=str(self.sample_data_path),
                feature_period_months=3,
                prediction_period_months=6,
                output_dir=str(self.test_output_dir / 'quick_test'),
                generate_charts=False,  # 不生成图表以节省时间
                generate_reports=False   # 不生成报告以节省时间
            )

            # 验证结果
            self.assertIsNotNone(results)
            self.assertIn('summary', results)

            summary = results['summary']
            self.assertIn('data_summary', summary)
            self.assertIn('model_summary', summary)

            print("✅ 快速分析功能测试通过")

        except Exception as e:
            self.fail(f"快速分析功能测试失败: {str(e)}")

    def test_data_quality(self):
        """测试数据质量验证"""
        print("\n🧪 测试数据质量验证...")

        # 检查示例数据结构
        expected_columns = ['订单号', '产品码', '消费日期', '产品说明', '数量', '单价', '用户码', '城市']
        for col in expected_columns:
            self.assertIn(col, self.test_data.columns, f"缺少必要列: {col}")

        # 检查数据类型
        self.assertTrue(pd.api.types.is_numeric_dtype(self.test_data['订单号']))
        self.assertTrue(pd.api.types.is_numeric_dtype(self.test_data['数量']))
        self.assertTrue(pd.api.types.is_numeric_dtype(self.test_data['单价']))

        # 检查数据完整性
        self.assertFalse(self.test_data['订单号'].duplicated().any(), "存在重复订单号")
        self.assertTrue(self.test_data['消费日期'].notna().all(), "存在空消费日期")
        self.assertTrue(self.test_data['用户码'].notna().all(), "存在空用户码")

        # 检查数值合理性
        self.assertTrue((self.test_data['数量'] > 0).all(), "存在非正数量")
        self.assertTrue((self.test_data['单价'] > 0).all(), "存在非正单价")

        print("✅ 数据质量验证通过")

def run_performance_test():
    """运行性能测试"""
    print("\n🚀 运行性能测试...")

    import time

    sample_data_path = current_dir.parent / 'data' / 'sample_orders.csv'
    test_output_dir = current_dir.parent / 'examples' / 'performance_test'

    if not sample_data_path.exists():
        print("❌ 示例数据文件不存在，跳过性能测试")
        return

    # 测试快速分析性能
    start_time = time.time()

    try:
        results = quick_ltv_analysis(
            file_path=str(sample_data_path),
            feature_period_months=3,
            prediction_period_months=6,
            output_dir=str(test_output_dir),
            generate_charts=False,
            generate_reports=False
        )

        end_time = time.time()
        execution_time = end_time - start_time

        print(f"✅ 性能测试完成")
        print(f"   - 执行时间: {execution_time:.2f}秒")
        print(f"   - 处理数据: {len(pd.read_csv(sample_data_path))}行")
        print(f"   - 分析客户: {results['summary']['data_summary']['total_customers']}人")

        # 性能基准
        if execution_time < 30:
            print("🎉 性能表现优秀！")
        elif execution_time < 60:
            print("👍 性能表现良好！")
        else:
            print("⚠️ 性能有待优化")

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

def main():
    """主测试函数"""
    print("🔬 LTV预测技能全面测试")
    print("=" * 60)

    # 环境检查
    print("1️⃣ 环境检查...")
    print("-" * 30)

    # 检查依赖包
    required_packages = ['pandas', 'numpy', 'scikit-learn', 'matplotlib', 'seaborn']
    missing_packages = []

    for package in required_packages:
        try:
            __import__(package)
            print(f"✅ {package}")
        except ImportError:
            missing_packages.append(package)
            print(f"❌ {package}")

    if missing_packages:
        print(f"\n⚠️ 缺少依赖包: {', '.join(missing_packages)}")
        print("请安装缺少的包后重新运行测试")
        return

    # 检查文件
    sample_data_path = current_dir.parent / 'data' / 'sample_orders.csv'
    if sample_data_path.exists():
        print(f"✅ 示例数据: {sample_data_path}")
    else:
        print(f"❌ 示例数据不存在: {sample_data_path}")
        return

    # 运行单元测试
    print("\n2️⃣ 运行单元测试...")
    print("-" * 30)

    # 创建测试套件
    test_suite = unittest.TestLoader().loadTestsFromTestCase(TestLTVPredictor)

    # 运行测试
    runner = unittest.TextTestRunner(verbosity=2)
    test_result = runner.run(test_suite)

    # 输出测试结果摘要
    print(f"\n📊 测试结果摘要:")
    print(f"   - 总测试数: {test_result.testsRun}")
    print(f"   - 成功: {test_result.testsRun - len(test_result.failures) - len(test_result.errors)}")
    print(f"   - 失败: {len(test_result.failures)}")
    print(f"   - 错误: {len(test_result.errors)}")

    if test_result.failures:
        print("\n❌ 失败的测试:")
        for test, traceback in test_result.failures:
            print(f"   - {test}: {traceback.split('AssertionError:')[-1].strip()}")

    if test_result.errors:
        print("\n❌ 错误的测试:")
        for test, traceback in test_result.errors:
            print(f"   - {test}: {traceback.split('Exception:')[-1].strip()}")

    # 运行性能测试
    run_performance_test()

    # 最终总结
    print("\n" + "=" * 60)
    if test_result.wasSuccessful():
        print("🎉 所有测试通过！LTV预测技能功能正常")
    else:
        print("⚠️ 部分测试失败，请检查相关功能")
    print("=" * 60)

if __name__ == "__main__":
    main()

pandas>=1.3.0
numpy>=1.21.0
scikit-learn>=1.0.0
matplotlib>=3.5.0
seaborn>=0.11.0
openpyxl>=3.0.0
flask>=2.0.0

#!/usr/bin/env python3
"""
高级分析模块
提供客户行为分析、流失预测、聚类分析等高级功能
"""

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.ensemble import IsolationForest
from sklearn.decomposition import PCA
import warnings
warnings.filterwarnings('ignore')

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False

class AdvancedAnalytics:
    """高级分析类"""

    def __init__(self):
        self.scaler = StandardScaler()
        self.cluster_model = None
        self.anomaly_detector = None

    def customer_behavior_analysis(self, rfm_data, output_dir='./analysis_results'):
        """
        客户行为深度分析

        Args:
            rfm_data: RFM特征数据
            output_dir: 输出目录

        Returns:
            分析结果字典
        """
        print("🔍 开始客户行为分析...")

        results = {}

        # 1. 购买模式分析
        results['purchase_patterns'] = self._analyze_purchase_patterns(rfm_data)

        # 2. 客户生命周期阶段分析
        results['lifecycle_stages'] = self._analyze_lifecycle_stages(rfm_data)

        # 3. 价值分布分析
        results['value_distribution'] = self._analyze_value_distribution(rfm_data)

        # 4. 活跃度分析
        results['activity_analysis'] = self._analyze_activity_patterns(rfm_data)

        # 生成可视化
        self._plot_behavior_analysis(rfm_data, results, output_dir)

        print("✅ 客户行为分析完成")
        return results

    def _analyze_purchase_patterns(self, rfm_data):
        """分析购买模式"""
        print("  分析购买模式...")

        patterns = {}

        # 频率分布
        freq_dist = rfm_data['F值'].value_counts().sort_index()
        patterns['frequency_distribution'] = freq_dist.to_dict()

        # 金额分布
        amount_stats = {
            'mean': rfm_data['M值'].mean(),
            'median': rfm_data['M值'].median(),
            'std': rfm_data['M值'].std(),
            'min': rfm_data['M值'].min(),
            'max': rfm_data['M值'].max()
        }
        patterns['amount_statistics'] = amount_stats

        # 最近购买时间分布
        recency_stats = {
            'mean_days': rfm_data['R值'].mean(),
            'median_days': rfm_data['R值'].median(),
            'recent_customers': (rfm_data['R值'] <= 30).sum(),
            'inactive_customers': (rfm_data['R值'] > 90).sum()
        }
        patterns['recency_analysis'] = recency_stats

        return patterns

    def _analyze_lifecycle_stages(self, rfm_data):
        """分析客户生命周期阶段"""
        print("  分析生命周期阶段...")

        # 定义生命周期阶段
        def classify_lifecycle_stage(row):
            r, f, m = row['R值'], row['F值'], row['M值']

            if r <= 30 and f >= 3 and m >= m * 0.8:  # 高R值、高F值、高M值
                return "成熟期"
            elif r <= 60 and f >= 2:
                return "成长期"
            elif r <= 30 and f == 1:
                return "新客户期"
            elif r > 90 and f <= 2:
                return "衰退期"
            elif r > 180:
                return "流失期"
            else:
                return "稳定期"

        rfm_data['生命周期阶段'] = rfm_data.apply(classify_lifecycle_stage, axis=1)

        stage_counts = rfm_data['生命周期阶段'].value_counts()
        stage_percentages = (stage_counts / len(rfm_data) * 100).round(2)

        return {
            'stage_counts': stage_counts.to_dict(),
            'stage_percentages': stage_percentages.to_dict(),
            'stage_distribution': rfm_data.groupby('生命周期阶段')['年度LTV'].mean().to_dict()
        }

    def _analyze_value_distribution(self, rfm_data):
        """分析价值分布"""
        print("  分析价值分布...")

        ltv_stats = {
            'mean': rfm_data['年度LTV'].mean(),
            'median': rfm_data['年度LTV'].median(),
            'std': rfm_data['年度LTV'].std(),
            'percentiles': {
                '25%': rfm_data['年度LTV'].quantile(0.25),
                '50%': rfm_data['年度LTV'].quantile(0.50),
                '75%': rfm_data['年度LTV'].quantile(0.75),
                '90%': rfm_data['年度LTV'].quantile(0.90),
                '95%': rfm_data['年度LTV'].quantile(0.95)
            }
        }

        # 帕累托分析（80/20法则）
        sorted_ltv = rfm_data['年度LTV'].sort_values(ascending=False)
        total_ltv = sorted_ltv.sum()
        cumulative_ltv = sorted_ltv.cumsum() / total_ltv

        # 找到贡献80%价值的客户比例
        eighty_percent_idx = (cumulative_ltv >= 0.8).idxmax()
        top_customer_percentage = (eighty_percent_idx + 1) / len(rfm_data) * 100

        ltv_stats['pareto_analysis'] = {
            'top_20_percent_customers_contribute': cumulative_ltv.iloc[int(len(rfm_data) * 0.2) - 1] * 100,
            'customers_for_80_percent_value': top_customer_percentage
        }

        return ltv_stats

    def _analyze_activity_patterns(self, rfm_data):
        """分析活跃度模式"""
        print("  分析活跃度模式...")

        # 活跃度分类
        def classify_activity(row):
            r, f = row['R值'], row['F值']

            if r <= 30 and f >= 3:
                return "高活跃"
            elif r <= 60 and f >= 2:
                return "中等活跃"
            elif r <= 90 and f >= 1:
                return "低活跃"
            else:
                return "非活跃"

        rfm_data['活跃度'] = rfm_data.apply(classify_activity, axis=1)

        activity_counts = rfm_data['活跃度'].value_counts()
        activity_stats = rfm_data.groupby('活跃度')['年度LTV'].agg(['mean', 'count'])

        return {
            'activity_distribution': activity_counts.to_dict(),
            'activity_value_stats': activity_stats.to_dict()
        }

    def _plot_behavior_analysis(self, rfm_data, results, output_dir):
        """绘制行为分析图表"""
        import os
        os.makedirs(output_dir, exist_ok=True)

        print("  生成行为分析图表...")

        # 1. RFM分布图
        fig, axes = plt.subplots(2, 2, figsize=(15, 12))

        # R值分布
        axes[0, 0].hist(rfm_data['R值'], bins=20, alpha=0.7, color='skyblue')
        axes[0, 0].set_title('最近购买时间分布 (R值)')
        axes[0, 0].set_xlabel('距离上次购买天数')
        axes[0, 0].set_ylabel('客户数')

        # F值分布
        axes[0, 1].hist(rfm_data['F值'], bins=10, alpha=0.7, color='lightgreen')
        axes[0, 1].set_title('购买频率分布 (F值)')
        axes[0, 1].set_xlabel('购买次数')
        axes[0, 1].set_ylabel('客户数')

        # M值分布
        axes[1, 0].hist(rfm_data['M值'], bins=15, alpha=0.7, color='salmon')
        axes[1, 0].set_title('消费金额分布 (M值)')
        axes[1, 0].set_xlabel('总消费金额')
        axes[1, 0].set_ylabel('客户数')

        # LTV分布
        axes[1, 1].hist(rfm_data['年度LTV'], bins=15, alpha=0.7, color='gold')
        axes[1, 1].set_title('年度LTV分布')
        axes[1, 1].set_xlabel('年度LTV')
        axes[1, 1].set_ylabel('客户数')

        plt.tight_layout()
        plt.savefig(f'{output_dir}/behavior_distributions.png', dpi=300, bbox_inches='tight')
        plt.close()

        # 2. 生命周期阶段分布
        if '生命周期阶段' in rfm_data.columns:
            plt.figure(figsize=(10, 6))
            stage_counts = rfm_data['生命周期阶段'].value_counts()
            plt.pie(stage_counts.values, labels=stage_counts.index, autopct='%1.1f%%')
            plt.title('客户生命周期阶段分布')
            plt.savefig(f'{output_dir}/lifecycle_stages.png', dpi=300, bbox_inches='tight')
            plt.close()

        # 3. 活跃度 vs LTV
        if '活跃度' in rfm_data.columns:
            plt.figure(figsize=(10, 6))
            sns.boxplot(data=rfm_data, x='活跃度', y='年度LTV')
            plt.title('不同活跃度客户的LTV分布')
            plt.ylabel('年度LTV')
            plt.savefig(f'{output_dir}/activity_vs_ltv.png', dpi=300, bbox_inches='tight')
            plt.close()

    def advanced_customer_segmentation(self, rfm_data, n_clusters=5, output_dir='./analysis_results'):
        """
        高级客户细分（基于聚类算法）

        Args:
            rfm_data: RFM特征数据
            n_clusters: 聚类数量
            output_dir: 输出目录

        Returns:
            聚类结果
        """
        print("🎯 开始高级客户细分...")

        # 准备特征数据
        features = ['R值', 'F值', 'M值']
        X = rfm_data[features].copy()

        # 数据标准化
        X_scaled = self.scaler.fit_transform(X)

        # 寻找最佳聚类数量
        best_k = self._find_optimal_clusters(X_scaled, max_k=10)

        print(f"  最佳聚类数量: {best_k}")

        # 执行K-means聚类
        self.cluster_model = KMeans(n_clusters=best_k, random_state=42)
        cluster_labels = self.cluster_model.fit_predict(X_scaled)

        # 添加聚类标签到数据
        rfm_data_copy = rfm_data.copy()
        rfm_data_copy['聚类标签'] = cluster_labels

        # 分析聚类结果
        cluster_analysis = self._analyze_clusters(rfm_data_copy, features)

        # 生成可视化
        self._plot_clustering_results(rfm_data_copy, features, output_dir)

        print(f"✅ 客户细分完成，共识别{best_k}个客户群体")
        return {
            'cluster_labels': cluster_labels,
            'cluster_analysis': cluster_analysis,
            'optimal_clusters': best_k,
            'data_with_clusters': rfm_data_copy
        }

    def _find_optimal_clusters(self, X_scaled, max_k=10):
        """使用肘部法则和轮廓系数找最佳聚类数量"""
        print("  寻找最佳聚类数量...")

        inertias = []
        silhouette_scores = []

        for k in range(2, max_k + 1):
            kmeans = KMeans(n_clusters=k, random_state=42)
            labels = kmeans.fit_predict(X_scaled)

            inertias.append(kmeans.inertia_)
            silhouette_scores.append(silhouette_score(X_scaled, labels))

        # 综合考虑肘部法则和轮廓系数
        # 选择轮廓系数最高的k值
        best_k = np.argmax(silhouette_scores) + 2

        return best_k

    def _analyze_clusters(self, data, features):
        """分析聚类特征"""
        print("  分析聚类特征...")

        cluster_analysis = {}

        for cluster_id in sorted(data['聚类标签'].unique()):
            cluster_data = data[data['聚类标签'] == cluster_id]

            analysis = {
                'size': len(cluster_data),
                'percentage': len(cluster_data) / len(data) * 100,
                'feature_means': {},
                'ltv_stats': {
                    'mean': cluster_data['年度LTV'].mean(),
                    'median': cluster_data['年度LTV'].median(),
                    'std': cluster_data['年度LTV'].std()
                }
            }

            for feature in features:
                analysis['feature_means'][feature] = cluster_data[feature].mean()

            # 为聚类命名
            r_mean = analysis['feature_means']['R值']
            f_mean = analysis['feature_means']['F值']
            m_mean = analysis['feature_means']['M值']

            if r_mean <= 30 and f_mean >= 3 and m_mean >= 500:
                cluster_name = "高价值活跃客户"
            elif r_mean <= 60 and f_mean >= 2:
                cluster_name = "中价值潜力客户"
            elif r_mean > 90 and f_mean <= 2:
                cluster_name = "低价值流失风险客户"
            elif r_mean <= 30 and f_mean == 1:
                cluster_name = "新客户"
            else:
                cluster_name = f"客户群体{cluster_id + 1}"

            analysis['cluster_name'] = cluster_name
            cluster_analysis[cluster_id] = analysis

        return cluster_analysis

    def _plot_clustering_results(self, data, features, output_dir):
        """绘制聚类结果"""
        import os
        os.makedirs(output_dir, exist_ok=True)

        print("  生成聚类可视化...")

        # 1. 聚类散点图 (使用PCA降维)
        X = data[features]
        X_scaled = self.scaler.transform(X)

        pca = PCA(n_components=2)
        X_pca = pca.fit_transform(X_scaled)

        plt.figure(figsize=(12, 8))
        scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=data['聚类标签'],
                            cmap='viridis', alpha=0.6, s=100)
        plt.colorbar(scatter)
        plt.xlabel(f'主成分1 (解释方差: {pca.explained_variance_ratio_[0]:.2%})')
        plt.ylabel(f'主成分2 (解释方差: {pca.explained_variance_ratio_[1]:.2%})')
        plt.title('客户聚类结果 (PCA降维)')
        plt.savefig(f'{output_dir}/customer_clusters_pca.png', dpi=300, bbox_inches='tight')
        plt.close()

        # 2. 聚类特征雷达图
        self._plot_cluster_radar_chart(data, features, output_dir)

        # 3. 聚类大小分布
        plt.figure(figsize=(10, 6))
        cluster_counts = data['聚类标签'].value_counts().sort_index()
        plt.bar(range(len(cluster_counts)), cluster_counts.values)
        plt.xlabel('聚类标签')
        plt.ylabel('客户数')
        plt.title('各聚类客户数量分布')
        plt.xticks(range(len(cluster_counts)), [f'聚类{i}' for i in cluster_counts.index])
        plt.savefig(f'{output_dir}/cluster_sizes.png', dpi=300, bbox_inches='tight')
        plt.close()

    def _plot_cluster_radar_chart(self, data, features, output_dir):
        """绘制聚类特征雷达图"""
        from math import pi

        # 计算各聚类的平均特征值
        cluster_means = data.groupby('聚类标签')[features].mean()

        # 归一化到0-1范围
        normalized_means = (cluster_means - cluster_means.min()) / (cluster_means.max() - cluster_means.min())

        # 雷达图设置
        angles = [n / float(len(features)) * 2 * pi for n in range(len(features))]
        angles += angles[:1]  # 闭合图形

        plt.figure(figsize=(10, 10))
        ax = plt.subplot(111, polar=True)

        # 为每个聚类绘制雷达图
        colors = plt.cm.Set3(np.linspace(0, 1, len(cluster_means)))

        for i, (cluster_id, row) in enumerate(normalized_means.iterrows()):
            values = row.values.tolist()
            values += values[:1]  # 闭合图形

            ax.plot(angles, values, 'o-', linewidth=2, label=f'聚类{cluster_id}', color=colors[i])
            ax.fill(angles, values, alpha=0.25, color=colors[i])

        # 设置标签
        plt.xticks(angles[:-1], features)
        plt.yticks([0.2, 0.4, 0.6, 0.8, 1.0], ['0.2', '0.4', '0.6', '0.8', '1.0'])
        plt.title('客户聚类特征雷达图', size=16, y=1.08)
        plt.legend(loc='upper right', bbox_to_anchor=(1.3, 1.0))
        plt.savefig(f'{output_dir}/cluster_radar_chart.png', dpi=300, bbox_inches='tight')
        plt.close()

    def churn_prediction(self, rfm_data, output_dir='./analysis_results'):
        """
        客户流失预测分析

        Args:
            rfm_data: RFM特征数据
            output_dir: 输出目录

        Returns:
            流失预测结果
        """
        print("⚠️ 开始流失预测分析...")

        # 定义流失标签
        def define_churn(row):
            # 基于R值定义流失：90天未购买为流失
            return 1 if row['R值'] > 90 else 0

        rfm_data_copy = rfm_data.copy()
        rfm_data_copy['流失标签'] = rfm_data_copy.apply(define_churn, axis=1)

        # 流失统计分析
        churn_rate = rfm_data_copy['流失标签'].mean()
        print(f"  当前流失率: {churn_rate:.2%}")

        # 流失特征分析
        churn_features = self._analyze_churn_features(rfm_data_copy)

        # 高风险流失客户识别
        high_risk_customers = self._identify_high_risk_customers(rfm_data_copy)

        # 生成可视化
        self._plot_churn_analysis(rfm_data_copy, output_dir)

        print("✅ 流失预测分析完成")
        return {
            'churn_rate': churn_rate,
            'churn_features': churn_features,
            'high_risk_customers': high_risk_customers,
            'data_with_churn_labels': rfm_data_copy
        }

    def _analyze_churn_features(self, data):
        """分析流失相关特征"""
        churn_group = data.groupby('流失标签')[['R值', 'F值', 'M值']].mean()
        return churn_group.to_dict()

    def _identify_high_risk_customers(self, data, risk_threshold=0.7):
        """识别高风险流失客户"""
        # 基于R值和F值识别高风险客户
        high_risk = data[
            (data['R值'] > 60) |  # 60天未购买
            (data['F值'] <= 1)     # 只购买过一次
        ].sort_values('R值', ascending=False)

        return high_risk.head(20)  # 返回前20个高风险客户

    def _plot_churn_analysis(self, data, output_dir):
        """绘制流失分析图表"""
        import os
        os.makedirs(output_dir, exist_ok=True)

        # 1. 流失vs非流失客户特征对比
        fig, axes = plt.subplots(1, 3, figsize=(15, 5))

        features = ['R值', 'F值', 'M值']
        feature_names = ['最近购买', '购买频率', '消费金额']

        for i, (feature, name) in enumerate(zip(features, feature_names)):
            churn_0 = data[data['流失标签'] == 0][feature]
            churn_1 = data[data['流失标签'] == 1][feature]

            axes[i].hist([churn_0, churn_1], bins=20, alpha=0.7,
                        label=['非流失', '流失'], color=['green', 'red'])
            axes[i].set_title(f'{name}分布')
            axes[i].set_xlabel(name)
            axes[i].set_ylabel('客户数')
            axes[i].legend()

        plt.tight_layout()
        plt.savefig(f'{output_dir}/churn_feature_comparison.png', dpi=300, bbox_inches='tight')
        plt.close()

        # 2. 流失风险散点图
        plt.figure(figsize=(10, 6))
        scatter = plt.scatter(data['R值'], data['F值'], c=data['流失标签'],
                            cmap='RdYlGn', alpha=0.6, s=100)
        plt.colorbar(scatter)
        plt.xlabel('最近购买天数 (R值)')
        plt.ylabel('购买频率 (F值)')
        plt.title('客户流失风险分布')
        plt.savefig(f'{output_dir}/churn_risk_scatter.png', dpi=300, bbox_inches='tight')
        plt.close()

    def generate_comprehensive_insights(self, rfm_data, behavior_results,
                                      segmentation_results, churn_results,
                                      output_path='comprehensive_insights.md'):
        """生成综合洞察报告"""
        print("📋 生成综合洞察报告...")

        report = "# 客户生命周期价值综合洞察报告\n\n"
        report += f"生成时间: {pd.Timestamp.now()}\n\n"

        # 客户概览
        report += "## 客户概览\n\n"
        report += f"- 总客户数: {len(rfm_data):,}\n"
        report += f"- 平均年度LTV: {rfm_data['年度LTV'].mean():,.0f}\n"
        report += f"- LTV中位数: {rfm_data['年度LTV'].median():,.0f}\n"
        report += f"- 平均购买频率: {rfm_data['F值'].mean():.1f}次\n"
        report += f"- 平均最近购买: {rfm_data['R值'].mean():.0f}天前\n\n"

        # 行为分析洞察
        if behavior_results:
            report += "## 客户行为洞察\n\n"

            # 生命周期阶段
            if 'lifecycle_stages' in behavior_results:
                stages = behavior_results['lifecycle_stages']
                report += "### 生命周期阶段分布\n\n"
                for stage, percentage in stages['stage_percentages'].items():
                    report += f"- {stage}: {percentage}%\n"
                report += "\n"

        # 细分分析洞察
        if segmentation_results:
            report += "## 客户细分洞察\n\n"
            clusters = segmentation_results['cluster_analysis']

            for cluster_id, analysis in clusters.items():
                report += f"### {analysis['cluster_name']}\n\n"
                report += f"- 客户数量: {analysis['size']} ({analysis['percentage']:.1f}%)\n"
                report += f"- 平均LTV: {analysis['ltv_stats']['mean']:,.0f}\n"
                report += f"- 特征特征: R值{analysis['feature_means']['R值']:.1f}, "
                report += f"F值{analysis['feature_means']['F值']:.1f}, "
                report += f"M值{analysis['feature_means']['M值']:.0f}\n\n"

        # 流失分析洞察
        if churn_results:
            report += "## 流失风险洞察\n\n"
            report += f"当前流失率: {churn_results['churn_rate']:.1%}\n\n"

            high_risk = churn_results['high_risk_customers']
            if not high_risk.empty:
                report += f"高风险客户数: {len(high_risk)}\n"
                report += "主要风险因素:\n"
                report += "- 长时间未购买 (R值 > 60天)\n"
                report += "- 购买频率低 (F值 ≤ 1)\n\n"

        # 策略建议
        report += "## 营销策略建议\n\n"
        report += "基于上述分析，建议采取以下策略:\n\n"

        if segmentation_results:
            # 基于聚类结果的建议
            clusters = segmentation_results['cluster_analysis']
            for cluster_id, analysis in clusters.items():
                cluster_name = analysis['cluster_name']

                if '高价值' in cluster_name:
                    report += f"### {cluster_name}\n"
                    report += "- 提供VIP专属服务\n"
                    report += "- 安排客户经理专人对接\n"
                    report += "- 定制个性化营销方案\n\n"
                elif '潜力' in cluster_name:
                    report += f"### {cluster_name}\n"
                    report += "- 推荐升级产品和套餐\n"
                    report += "- 提供会员激励计划\n"
                    report += "- 增加互动频率\n\n"
                elif '流失风险' in cluster_name:
                    report += f"### {cluster_name}\n"
                    report += "- 发放召回优惠券\n"
                    report += "- 推荐性价比高的产品\n"
                    report += "- 主动关怀和沟通\n\n"

        if churn_results and churn_results['churn_rate'] > 0.2:
            report += "### 流失预防策略\n"
            report += "- 建立流失预警机制\n"
            report += "- 实施客户关怀计划\n"
            report += "- 优化产品和服务体验\n\n"

        # 保存报告
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(report)

        print(f"✅ 综合洞察报告已保存: {output_path}")
        return output_path