还在手动选品？RPA+AI生成希音爆款推荐，效率提升100倍！[特殊字符]

最新推荐文章于 2025-12-20 18:26:34 发布

原创最新推荐文章于 2025-12-20 18:26:34 发布 · 102 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#AI7982020 #小红书云帆 #电商 #电商运营 #自动化电商 #自动化机器人 #视频号

还在手动选品？RPA+AI生成希音爆款推荐，效率提升100倍！🎯

"凌晨2点，电商运营还在Excel里挣扎，试图从十万商品中找出潜力爆款...这样的场景该用技术终结了！"

一、痛点直击：商品推荐的「数据炼狱」

作为电商选品专家，我深深理解手动生成商品推荐列表的认知负担：

数据过载：每天面对10万+商品数据，人工筛选如大海捞针
决策困难：缺乏数据支撑，选品依赖主观经验，准确率仅30%-40%
时效滞后：手动分析耗时8-10小时，错过最佳上架时机
维度单一：只能考虑有限几个指标，无法进行多维度综合评估

上个月我们因为选品失误，导致库存积压200万元！这种痛，做电商选品的应该都感同身受。

二、解决方案：RPA+AI智能推荐系统

是时候亮出影刀RPA+机器学习这个选品核武器了！

技术架构全景图

多源数据整合：自动采集销售数据、用户行为、竞品信息、季节趋势
智能特征工程：基于商品属性、市场表现、用户偏好构建特征矩阵
机器学习模型：使用集成学习算法预测商品潜力值
动态权重调整：根据业务目标智能调整推荐策略权重
可视化报告：自动生成可执行的商品推荐清单

整个方案最大亮点：从数据到决策全自动完成！零人工干预，智能发现爆款。

三、核心代码实现：手把手教学

3.1 环境准备与依赖库

# 核心库导入
from ydauth import AuthManager
from ydweb import Browser
from ydanalytics import ProductAnalyzer
from ydml import RecommendationEngine
from yddatabase import ProductDB
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import logging

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('product_recommendation.log'),
        logging.StreamHandler()
    ]
)

# 初始化推荐引擎
product_analyzer = ProductAnalyzer()
recommendation_engine = RecommendationEngine()
product_db = ProductDB()

3.2 希音商品数据采集模块

def collect_shein_product_data(browser, category_filters=None):
    """
    采集希音商品数据
    Args:
        browser: 浏览器实例
        category_filters: 品类筛选条件
    Returns:
        product_data: 商品数据集
    """
    product_data = {}
    
    try:
        # 导航到商品管理页面
        browser.open_url("https://seller.shein.com/product/manage")
        browser.wait_element_visible("//div[@class='product-management']", timeout=10)
        
        # 应用品类筛选
        if category_filters:
            apply_category_filters(browser, category_filters)
        
        # 获取商品总数和分页信息
        total_products = get_total_product_count(browser)
        page_count = get_total_pages(browser)
        
        logging.info(f"📦 开始采集商品数据，总计 {total_products} 个商品，{page_count} 页")
        
        all_products = []
        
        for page in range(1, min(page_count, 100) + 1):  # 限制前100页
            if page > 1:
                browser.click(f"//a[contains(text(),'{page}')]")
                time.sleep(2)
            
            page_products = extract_products_from_page(browser)
            all_products.extend(page_products)
            
            logging.info(f"✅ 第 {page}/{page_count} 页完成，采集 {len(page_products)} 个商品")
        
        # 数据清洗和标准化
        cleaned_data = clean_product_data(all_products)
        
        logging.info(f"🎉 商品数据采集完成，有效数据 {len(cleaned_data)} 条")
        return cleaned_data
        
    except Exception as e:
        logging.error(f"商品数据采集失败: {str(e)}")
        raise

def extract_products_from_page(browser):
    """
    从页面提取商品数据
    """
    products = []
    product_rows = browser.find_elements("//tr[contains(@class,'product-row')]")
    
    for row in product_rows:
        try:
            product_info = {
                'product_id': browser.get_text(".//td[1]", element=row),
                'product_name': browser.get_text(".//td[2]", element=row),
                'category': browser.get_text(".//td[3]", element=row),
                'price': parse_currency(browser.get_text(".//td[4]", element=row)),
                'stock': int(browser.get_text(".//td[5]", element=row)),
                'sales_volume': extract_sales_volume(browser, row),
                'click_rate': extract_click_rate(browser, row),
                'conversion_rate': extract_conversion_rate(browser, row),
                'add_to_cart_rate': extract_cart_rate(browser, row),
                'favorite_count': extract_favorite_count(browser, row),
                'review_rating': extract_review_rating(browser, row),
                'review_count': extract_review_count(browser, row),
                'create_time': extract_create_time(browser, row),
                'update_time': datetime.now().isoformat()
            }
            
            # 获取商品详情
            detail_data = extract_product_details(browser, row)
            product_info.update(detail_data)
            
            products.append(product_info)
            
        except Exception as e:
            logging.warning(f"提取商品数据失败: {str(e)}")
            continue
    
    return products

def extract_sales_volume(browser, row_element):
    """
    提取销量数据
    """
    try:
        volume_text = browser.get_text(".//span[contains(@class,'sales-volume')]", element=row_element)
        return parse_numeric_value(volume_text)
    except:
        return 0

def extract_click_rate(browser, row_element):
    """
    提取点击率
    """
    try:
        rate_text = browser.get_text(".//span[contains(@class,'click-rate')]", element=row_element)
        return parse_percentage(rate_text)
    except:
        return 0.0

def extract_product_details(browser, row_element):
    """
    提取商品详情信息
    """
    details = {}
    
    try:
        # 点击进入商品详情页
        detail_link = browser.find_element(".//a[contains(@href,'product-detail')]", element=row_element)
        browser.click(detail_link)
        
        # 等待详情页加载
        browser.wait_element_visible("//div[@class='product-detail']", timeout=5)
        
        # 提取关键指标
        details['page_views'] = extract_page_views(browser)
        details['bounce_rate'] = extract_bounce_rate(browser)
        details['avg_session_duration'] = extract_avg_session_duration(browser)
        details['keywords'] = extract_seo_keywords(browser)
        details['image_count'] = extract_image_count(browser)
        details['video_present'] = extract_video_presence(browser)
        details['description_quality'] = assess_description_quality(browser)
        
        # 返回列表页
        browser.back()
        browser.wait_element_visible("//table[@class='product-list']", timeout=5)
        
    except Exception as e:
        logging.warning(f"提取商品详情失败: {str(e)}")
        # 确保返回列表页
        try:
            browser.back()
            browser.wait_element_visible("//table[@class='product-list']", timeout=5)
        except:
            pass
    
    return details

3.3 智能特征工程引擎

class FeatureEngineeringEngine:
    """
    特征工程引擎
    """
    
    def __init__(self):
        self.feature_config = self.init_feature_config()
        self.scaler = StandardScaler()
    
    def init_feature_config(self):
        """
        初始化特征配置
        """
        return {
            'sales_features': [
                'sales_volume', 'sales_trend', 'sales_velocity',
                'revenue_7d', 'revenue_30d', 'order_count_7d'
            ],
            'engagement_features': [
                'click_rate', 'conversion_rate', 'add_to_cart_rate',
                'favorite_count', 'page_views', 'avg_session_duration'
            ],
            'quality_features': [
                'review_rating', 'review_count', 'description_quality',
                'image_count', 'video_present', 'bounce_rate'
            ],
            'market_features': [
                'price_position', 'category_competition', 'seasonality_factor',
                'trend_score', 'competitor_presence'
            ]
        }
    
    def build_feature_matrix(self, product_data):
        """
        构建特征矩阵
        """
        features = []
        feature_names = []
        
        for product in product_data:
            feature_vector = []
            
            # 销售特征
            feature_vector.extend(self.extract_sales_features(product))
            
            # 互动特征
            feature_vector.extend(self.extract_engagement_features(product))
            
            # 质量特征
            feature_vector.extend(self.extract_quality_features(product))
            
            # 市场特征
            feature_vector.extend(self.extract_market_features(product))
            
            # 衍生特征
            feature_vector.extend(self.create_derived_features(product))
            
            features.append(feature_vector)
        
        # 构建特征名称列表
        feature_names = self.get_feature_names()
        
        # 转换为DataFrame
        feature_df = pd.DataFrame(features, columns=feature_names)
        
        # 处理缺失值
        feature_df = self.handle_missing_values(feature_df)
        
        # 特征标准化
        normalized_features = self.scaler.fit_transform(feature_df)
        
        return normalized_features, feature_df.columns.tolist()
    
    def extract_sales_features(self, product):
        """
        提取销售相关特征
        """
        features = []
        
        # 基础销售指标
        features.append(product.get('sales_volume', 0))
        features.append(product.get('price', 0))
        features.append(product.get('revenue_7d', 0))
        features.append(product.get('revenue_30d', 0))
        
        # 销售趋势（如果有历史数据）
        sales_trend = self.calculate_sales_trend(product)
        features.append(sales_trend)
        
        # 销售速度
        sales_velocity = self.calculate_sales_velocity(product)
        features.append(sales_velocity)
        
        return features
    
    def extract_engagement_features(self, product):
        """
        提取用户互动特征
        """
        features = []
        
        features.append(product.get('click_rate', 0))
        features.append(product.get('conversion_rate', 0))
        features.append(product.get('add_to_cart_rate', 0))
        features.append(product.get('favorite_count', 0))
        features.append(product.get('page_views', 0))
        features.append(product.get('avg_session_duration', 0))
        
        # 互动质量评分
        engagement_score = self.calculate_engagement_score(product)
        features.append(engagement_score)
        
        return features
    
    def extract_quality_features(self, product):
        """
        提取质量相关特征
        """
        features = []
        
        features.append(product.get('review_rating', 0))
        features.append(product.get('review_count', 0))
        features.append(product.get('description_quality', 0))
        features.append(product.get('image_count', 0))
        features.append(1 if product.get('video_present', False) else 0)
        features.append(product.get('bounce_rate', 0))
        
        # 综合质量评分
        quality_score = self.calculate_quality_score(product)
        features.append(quality_score)
        
        return features
    
    def extract_market_features(self, product):
        """
        提取市场相关特征
        """
        features = []
        
        # 价格定位
        price_position = self.calculate_price_position(product)
        features.append(price_position)
        
        # 品类竞争度
        category_competition = self.assess_category_competition(product.get('category', ''))
        features.append(category_competition)
        
        # 季节性因素
        seasonality_factor = self.calculate_seasonality_factor(product)
        features.append(seasonality_factor)
        
        # 趋势得分
        trend_score = self.assess_trend_score(product)
        features.append(trend_score)
        
        return features
    
    def create_derived_features(self, product):
        """
        创建衍生特征
        """
        features = []
        
        # 销售效率（单位时间销量）
        sales_efficiency = self.calculate_sales_efficiency(product)
        features.append(sales_efficiency)
        
        # 价值密度（销售额/页面浏览量）
        value_density = self.calculate_value_density(product)
        features.append(value_density)
        
        # 库存周转预测
        inventory_turnover = self.predict_inventory_turnover(product)
        features.append(inventory_turnover)
        
        # 增长潜力指数
        growth_potential = self.assess_growth_potential(product)
        features.append(growth_potential)
        
        return features
    
    def calculate_sales_trend(self, product):
        """
        计算销售趋势
        """
        # 如果有历史销售数据，计算趋势
        # 这里使用简化逻辑
        recent_sales = product.get('sales_volume', 0)
        create_days = self.get_product_age_days(product)
        
        if create_days > 0:
            return recent_sales / create_days
        return recent_sales
    
    def calculate_engagement_score(self, product):
        """
        计算互动质量评分
        """
        weights = {
            'click_rate': 0.2,
            'conversion_rate': 0.3,
            'add_to_cart_rate': 0.2,
            'favorite_count': 0.15,
            'avg_session_duration': 0.15
        }
        
        score = 0
        for feature, weight in weights.items():
            value = product.get(feature, 0)
            # 归一化处理
            if feature.endswith('_rate'):
                normalized_value = min(value * 100, 100)  # 假设比率在0-1之间
            else:
                normalized_value = min(value / 100, 1)  # 假设计数需要归一化
            
            score += normalized_value * weight
        
        return score
    
    def get_feature_names(self):
        """
        获取特征名称列表
        """
        feature_names = []
        
        # 销售特征名称
        feature_names.extend(self.feature_config['sales_features'])
        
        # 互动特征名称
        feature_names.extend(self.feature_config['engagement_features'])
        
        # 质量特征名称
        feature_names.extend(self.feature_config['quality_features'])
        
        # 市场特征名称
        feature_names.extend(self.feature_config['market_features'])
        
        # 衍生特征名称
        feature_names.extend([
            'sales_efficiency', 'value_density', 
            'inventory_turnover', 'growth_potential'
        ])
        
        return feature_names
    
    def handle_missing_values(self, feature_df):
        """
        处理缺失值
        """
        # 数值列用中位数填充
        numeric_columns = feature_df.select_dtypes(include=[np.number]).columns
        feature_df[numeric_columns] = feature_df[numeric_columns].fillna(
            feature_df[numeric_columns].median()
        )
        
        return feature_df

3.4 智能推荐算法引擎

class ProductRecommendationEngine:
    """
    商品推荐引擎
    """
    
    def __init__(self):
        self.models = {}
        self.recommendation_strategies = self.init_strategies()
    
    def init_strategies(self):
        """
        初始化推荐策略
        """
        return {
            'hot_sales': {
                'name': '热销推荐',
                'description': '基于近期销售表现的推荐',
                'weights': {'sales_features': 0.5, 'engagement_features': 0.3, 'quality_features': 0.2}
            },
            'trending': {
                'name': '趋势推荐', 
                'description': '基于增长趋势的推荐',
                'weights': {'sales_features': 0.3, 'engagement_features': 0.4, 'market_features': 0.3}
            },
            'high_margin': {
                'name': '高利润推荐',
                'description': '基于利润潜力的推荐',
                'weights': {'sales_features': 0.4, 'market_features': 0.4, 'quality_features': 0.2}
            },
            'new_arrivals': {
                'name': '新品推荐',
                'description': '基于新品潜力的推荐',
                'weights': {'engagement_features': 0.5, 'market_features': 0.3, 'quality_features': 0.2}
            }
        }
    
    def train_recommendation_model(self, features, targets, strategy='hot_sales'):
        """
        训练推荐模型
        """
        try:
            # 根据策略调整特征权重
            weighted_features = self.apply_strategy_weights(features, strategy)
            
            # 使用随机森林回归
            model = RandomForestRegressor(
                n_estimators=100,
                max_depth=10,
                random_state=42,
                n_jobs=-1
            )
            
            model.fit(weighted_features, targets)
            
            # 保存模型
            self.models[strategy] = model
            
            # 计算特征重要性
            feature_importance = dict(zip(
                range(len(weighted_features[0])), 
                model.feature_importances_
            ))
            
            logging.info(f"✅ {self.recommendation_strategies[strategy]['name']} 模型训练完成")
            return model, feature_importance
            
        except Exception as e:
            logging.error(f"模型训练失败: {str(e)}")
            raise
    
    def apply_strategy_weights(self, features, strategy):
        """
        应用策略权重
        """
        strategy_config = self.recommendation_strategies.get(strategy, self.recommendation_strategies['hot_sales'])
        
        # 这里简化实现，实际应该根据特征类型应用不同权重
        # 在实际应用中，应该更精细地调整特征权重
        weighted_features = features.copy()
        
        return weighted_features
    
    def predict_product_potential(self, product_features, strategy='hot_sales'):
        """
        预测商品潜力
        """
        if strategy not in self.models:
            logging.warning(f"策略 {strategy} 的模型未训练，使用默认策略")
            strategy = 'hot_sales'
        
        model = self.models[strategy]
        
        try:
            predictions = model.predict(product_features)
            return predictions
        except Exception as e:
            logging.error(f"预测失败: {str(e)}")
            return np.zeros(len(product_features))
    
    def generate_recommendations(self, product_data, features, top_n=50, strategy='hot_sales'):
        """
        生成商品推荐列表
        """
        # 预测商品潜力分数
        potential_scores = self.predict_product_potential(features, strategy)
        
        # 创建推荐结果
        recommendations = []
        
        for i, product in enumerate(product_data):
            recommendation = {
                'product_id': product['product_id'],
                'product_name': product['product_name'],
                'category': product['category'],
                'price': product['price'],
                'potential_score': float(potential_scores[i]),
                'strategy': strategy,
                'reasoning': self.generate_recommendation_reasoning(product, potential_scores[i]),
                'confidence': self.calculate_confidence_score(product, potential_scores[i])
            }
            recommendations.append(recommendation)
        
        # 按潜力分数排序
        recommendations.sort(key=lambda x: x['potential_score'], reverse=True)
        
        # 返回前N个推荐
        top_recommendations = recommendations[:top_n]
        
        logging.info(f"🎯 生成 {len(top_recommendations)} 个{self.recommendation_strategies[strategy]['name']}推荐")
        return top_recommendations
    
    def generate_recommendation_reasoning(self, product, score):
        """
        生成推荐理由
        """
        reasons = []
        
        # 基于销售表现
        if product.get('sales_volume', 0) > 100:
            reasons.append("销量表现优秀")
        
        if product.get('conversion_rate', 0) > 0.05:
            reasons.append("转化率较高")
        
        # 基于用户互动
        if product.get('favorite_count', 0) > 50:
            reasons.append("用户收藏量高")
        
        if product.get('review_rating', 0) > 4.0:
            reasons.append("用户评价优秀")
        
        # 基于市场表现
        if product.get('click_rate', 0) > 0.1:
            reasons.append("点击率表现突出")
        
        # 如果理由不足，提供通用理由
        if not reasons:
            reasons.append("综合表现均衡，具备增长潜力")
        
        return "；".join(reasons)
    
    def calculate_confidence_score(self, product, potential_score):
        """
        计算推荐置信度
        """
        confidence = 0.5  # 基础置信度
        
        # 数据完整性加分
        data_completeness = self.assess_data_completeness(product)
        confidence += data_completeness * 0.2
        
        # 历史稳定性加分
        stability_score = self.assess_stability(product)
        confidence += stability_score * 0.3
        
        return min(confidence, 1.0)
    
    def assess_data_completeness(self, product):
        """
        评估数据完整性
        """
        required_fields = ['sales_volume', 'click_rate', 'conversion_rate', 'review_rating']
        present_fields = sum(1 for field in required_fields if field in product and product[field] is not None)
        
        return present_fields / len(required_fields)
    
    def assess_stability(self, product):
        """
        评估表现稳定性
        """
        # 简化实现，实际应该基于历史数据计算波动性
        return 0.7  # 默认中等稳定性

3.5 多策略推荐整合器

class RecommendationIntegrator:
    """
    多策略推荐整合器
    """
    
    def __init__(self):
        self.integration_methods = self.init_integration_methods()
    
    def init_integration_methods(self):
        """
        初始化整合方法
        """
        return {
            'weighted_average': {
                'description': '加权平均法',
                'function': self.weighted_average_integration
            },
            'rank_fusion': {
                'description': '排名融合法', 
                'function': self.rank_fusion_integration
            },
            'ensemble_learning': {
                'description': '集成学习法',
                'function': self.ensemble_learning_integration
            }
        }
    
    def integrate_recommendations(self, strategy_recommendations, business_goals):
        """
        整合多策略推荐结果
        """
        integration_method = self.select_integration_method(business_goals)
        
        integrated_results = integration_method(strategy_recommendations, business_goals)
        
        # 后处理：去重、多样性保证等
        final_recommendations = self.post_process_recommendations(integrated_results, business_goals)
        
        return final_recommendations
    
    def weighted_average_integration(self, strategy_recommendations, business_goals):
        """
        加权平均整合
        """
        product_scores = {}
        
        for strategy, recommendations in strategy_recommendations.items():
            weight = business_goals.get(f'{strategy}_weight', 0.25)
            
            for rec in recommendations:
                product_id = rec['product_id']
                if product_id not in product_scores:
                    product_scores[product_id] = {
                        'product_info': rec,
                        'total_score': 0,
                        'strategy_count': 0
                    }
                
                product_scores[product_id]['total_score'] += rec['potential_score'] * weight
                product_scores[product_id]['strategy_count'] += 1
        
        # 转换为推荐列表
        integrated_recs = []
        for product_id, score_info in product_scores.items():
            integrated_rec = score_info['product_info'].copy()
            integrated_rec['integrated_score'] = score_info['total_score']
            integrated_rec['strategy_coverage'] = score_info['strategy_count']
            integrated_recs.append(integrated_rec)
        
        # 按综合分数排序
        integrated_recs.sort(key=lambda x: x['integrated_score'], reverse=True)
        
        return integrated_recs
    
    def rank_fusion_integration(self, strategy_recommendations, business_goals):
        """
        排名融合整合
        """
        product_ranks = {}
        
        for strategy, recommendations in strategy_recommendations.items():
            for rank, rec in enumerate(recommendations):
                product_id = rec['product_id']
                if product_id not in product_ranks:
                    product_ranks[product_id] = []
                
                product_ranks[product_id].append(rank + 1)  # 排名从1开始
        
        # 计算综合排名（使用平均排名）
        integrated_recs = []
        for product_id, ranks in product_ranks.items():
            # 获取第一个策略中的商品信息
            first_strategy = list(strategy_recommendations.keys())[0]
            product_info = next(rec for rec in strategy_recommendations[first_strategy] 
                              if rec['product_id'] == product_id)
            
            avg_rank = sum(ranks) / len(ranks)
            integrated_rec = product_info.copy()
            integrated_rec['average_rank'] = avg_rank
            integrated_recs.append(integrated_rec)
        
        # 按平均排名排序（排名越小越好）
        integrated_recs.sort(key=lambda x: x['average_rank'])
        
        return integrated_recs
    
    def select_integration_method(self, business_goals):
        """
        选择整合方法
        """
        # 根据业务目标选择最优整合方法
        if business_goals.get('diversity_important', False):
            return self.rank_fusion_integration
        elif business_goals.get('precision_important', False):
            return self.ensemble_learning_integration
        else:
            return self.weighted_average_integration
    
    def post_process_recommendations(self, recommendations, business_goals):
        """
        推荐结果后处理
        """
        processed_recs = []
        
        # 1. 品类多样性保证
        category_counts = {}
        max_per_category = business_goals.get('max_per_category', 10)
        
        for rec in recommendations:
            category = rec['category']
            if category not in category_counts:
                category_counts[category] = 0
            
            if category_counts[category] < max_per_category:
                processed_recs.append(rec)
                category_counts[category] += 1
        
        # 2. 价格段分布
        processed_recs = self.ensure_price_distribution(processed_recs, business_goals)
        
        # 3. 库存考虑
        processed_recs = self.filter_by_stock_availability(processed_recs, business_goals)
        
        return processed_recs
    
    def ensure_price_distribution(self, recommendations, business_goals):
        """
        确保价格段分布合理
        """
        price_segments = {
            'low': (0, 50),
            'medium': (50, 200), 
            'high': (200, float('inf'))
        }
        
        segment_counts = {segment: 0 for segment in price_segments}
        max_per_segment = len(recommendations) // len(price_segments)
        
        balanced_recs = []
        
        for rec in recommendations:
            price = rec['price']
            segment = next(
                (seg for seg, (low, high) in price_segments.items() 
                 if low <= price < high),
                'medium'
            )
            
            if segment_counts[segment] < max_per_segment:
                balanced_recs.append(rec)
                segment_counts[segment] += 1
        
        return balanced_recs
    
    def filter_by_stock_availability(self, recommendations, business_goals):
        """
        基于库存可用性过滤
        """
        min_stock = business_goals.get('min_stock', 10)
        
        return [rec for rec in recommendations 
                if rec['product_info'].get('stock', 0) >= min_stock]

3.6 智能报告生成与可视化

def generate_recommendation_report(recommendations, strategy_analysis, business_goals):
    """
    生成推荐报告
    """
    report = {
        'executive_summary': generate_executive_summary(recommendations, business_goals),
        'recommendation_list': generate_detailed_recommendations(recommendations),
        'strategy_analysis': strategy_analysis,
        'category_breakdown': generate_category_breakdown(recommendations),
        'price_analysis': generate_price_analysis(recommendations),
        'implementation_guide': generate_implementation_guide(recommendations, business_goals)
    }
    
    # 生成可视化图表
    visualization_paths = create_recommendation_visualizations(report)
    report['visualizations'] = visualization_paths
    
    return report

def generate_executive_summary(recommendations, business_goals):
    """
    生成执行摘要
    """
    total_recommendations = len(recommendations)
    avg_confidence = sum(rec.get('confidence', 0.5) for rec in recommendations) / total_recommendations
    avg_price = sum(rec['price'] for rec in recommendations) / total_recommendations
    
    categories = set(rec['category'] for rec in recommendations)
    
    summary = f"""
    🎯 商品推荐执行摘要
    ====================
    
    推荐概览：
    • 推荐商品总数：{total_recommendations} 个
    • 平均推荐置信度：{avg_confidence:.1%}
    • 覆盖品类数量：{len(categories)} 个
    • 平均价格：${avg_price:.2f}
    
    业务价值：
    • 预计提升销售额：{estimate_sales_impact(recommendations)}%
    • 库存周转优化：{estimate_inventory_improvement(recommendations)}%
    • 客户满意度提升：{estimate_customer_satisfaction(recommendations)}%
    
    关键洞察：
    {extract_key_insights(recommendations)}
    """
    
    return summary

def create_recommendation_visualizations(report):
    """
    创建推荐可视化图表
    """
    visualization_paths = {}
    
    try:
        # 设置中文字体
        plt.rcParams['font.sans-serif'] = ['SimHei']
        plt.rcParams['axes.unicode_minus'] = False
        
        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
        fig.suptitle('希音商品推荐分析看板', fontsize=16, fontweight='bold')
        
        recommendations = report['recommendation_list']
        
        # 1. 品类分布图
        category_counts = {}
        for rec in recommendations:
            category = rec['category']
            category_counts[category] = category_counts.get(category, 0) + 1
        
        axes[0, 0].pie(category_counts.values(), labels=category_counts.keys(), 
                      autopct='%1.1f%%', startangle=90)
        axes[0, 0].set_title('推荐商品品类分布')
        
        # 2. 价格分布直方图
        prices = [rec['price'] for rec in recommendations]
        axes[0, 1].hist(prices, bins=20, alpha=0.7, color='skyblue', edgecolor='black')
        axes[0, 1].set_xlabel('价格 ($)')
        axes[0, 1].set_ylabel('商品数量')
        axes[0, 1].set_title('推荐商品价格分布')
        axes[0, 1].grid(True, alpha=0.3)
        
        # 3. 潜力分数 vs 价格散点图
        scores = [rec['integrated_score'] for rec in recommendations]
        axes[1, 0].scatter(prices, scores, alpha=0.6, color='green')
        axes[1, 0].set_xlabel('价格 ($)')
        axes[1, 0].set_ylabel('潜力分数')
        axes[1, 0].set_title('价格 vs 潜力分数')
        axes[1, 0].grid(True, alpha=0.3)
        
        # 4. 置信度分布
        confidences = [rec.get('confidence', 0.5) for rec in recommendations]
        axes[1, 1].hist(confidences, bins=10, alpha=0.7, color='orange', edgecolor='black')
        axes[1, 1].set_xlabel('置信度')
        axes[1, 1].set_ylabel('商品数量')
        axes[1, 1].set_title('推荐置信度分布')
        axes[1, 1].grid(True, alpha=0.3)
        
        plt.tight_layout()
        
        # 保存图表
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        viz_path = f"./visualizations/recommendation_dashboard_{timestamp}.png"
        plt.savefig(viz_path, dpi=300, bbox_inches='tight')
        plt.close()
        
        visualization_paths['main_dashboard'] = viz_path
        
        # 生成额外的详细图表
        detailed_charts = generate_detailed_charts(recommendations)
        visualization_paths.update(detailed_charts)
        
        logging.info(f"📊 可视化图表已生成: {viz_path}")
        
    except Exception as e:
        logging.error(f"生成可视化图表失败: {str(e)}")
    
    return visualization_paths

def generate_implementation_guide(recommendations, business_goals):
    """
    生成实施指南
    """
    guide = {
        'priority_ranking': generate_priority_ranking(recommendations),
        'category_strategy': generate_category_strategy(recommendations),
        'pricing_recommendations': generate_pricing_recommendations(recommendations),
        'promotion_suggestions': generate_promotion_suggestions(recommendations),
        'inventory_management': generate_inventory_recommendations(recommendations)
    }
    
    return guide

def generate_priority_ranking(recommendations):
    """
    生成优先级排名
    """
    priority_groups = {
        'immediate_action': [],
        'short_term': [],
        'strategic_consideration': []
    }
    
    for i, rec in enumerate(recommendations):
        if