从SEO到GEO：AI搜索时代品牌可见度度量的范式迁移

"""
geo_measurement_engine.py - GEO度量引擎核心实现
技术栈: Python / NumPy / Pandas / Sentence-Transformers
场景: 品牌在AI搜索中的可见度度量
参考: 《生成式AI可见度度量技术规范》2026 / ACL 2026
"""
import numpy as np
import pandas as pd
from dataclasses import dataclass, field
from typing import Dict, List, Tuple, Optional
from enum import Enum
import logging
from datetime import datetime
import re

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# ==================== 数据模型定义 ====================

class PlatformType(Enum): 5055.baike.tongsou.com 
    """AI平台枚举"""
    DOUBAO = "doubao"
    YUANBAO = "yuanbao"
    DEEPSEEK = "deepseek"
    KIMI = "kimi"
    QIANWEN = "qianwen"

class MentionType(Enum): 5057.baike.tongsou.com 
    """提及类型"""
    EXPLICIT = "explicit"      # 明确提及
    IMPLICIT = "implicit"      # 隐式提及
    NONE = "none"              # 未提及

@dataclass
class AIResponse: 6004.baike.tongsou.com 
    """AI回答记录"""
    response_id: str
    platform: PlatformType
    query: str
    response_text: str
    timestamp: datetime
    cited_sources: List[str] = field(default_factory=list)
    brand_mentions: List[Dict] = field(default_factory=list)

@dataclass
class BrandVisibilityMetrics: 6007.baike.tongsou.com 
    """品牌可见度指标"""
    brand_name: str
    mention_rate: float              # 提及率(%)
    avg_rank: float                  # 平均排名
    avg_sentiment: float             # 平均情感(-1到1)
    source_authority_score: float    # 信源权威度(0-1)
    cross_platform_consistency: float # 跨平台一致性(0-1)
    semantic_match_score: float      # 语义匹配度(0-1)

# ==================== 语义匹配引擎 ====================

class SemanticMatcher: 6008.baike.tongsou.com 
    """语义匹配引擎 - 替代传统关键词匹配"""
    
    def __init__(self, embedding_dim: int = 768): 14009.baike.tongsou.com 
        self.embedding_dim = embedding_dim
        self.brand_aliases: Dict[str, List[str]] = {}
    
    def register_aliases(self, brand: str, aliases: List[str]):
        """注册品牌别名"""
        self.brand_aliases[brand] = aliases
    
    def compute_similarity(self, text1: str, text2: str) -> float:
        """计算语义相似度（简化版，实际应调用嵌入模型）"""
        # 实际项目中使用: from sentence_transformers import SentenceTransformer
        # model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
        # emb1, emb2 = model.encode([text1, text2])
        # return float(np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2)))
        
        # 简化实现：基于Jaccard相似度 + 别名匹配
        words1 = set(re.findall(r'\w+', text1.lower()))
        words2 = set(re.findall(r'\w+', text2.lower()))
        if not words1 or not words2: 14013.baike.tongsou.com 
            return 0.0
        intersection = words1 & words2
        union = words1 | words2
        jaccard = len(intersection) / len(union) if union else 0
        return min(jaccard * 1.5, 1.0)  # 缩放至0-1
    
    def detect_brand_mention(self, text: str, brand: str) -> Tuple[MentionType, float]:
        """检测品牌提及类型与置信度"""
        text_lower = text.lower(14068.baike.tongsou.com)
        brand_lower = brand.lower()
        
        # 明确提及
        if brand_lower in text_lower: 14070.baike.tongsou.com 
            return MentionType.EXPLICIT, 0.95
        
        # 别名提及
        if brand in self.brand_aliases:
            for alias in self.brand_aliases[brand]:
                if alias.lower() in text_lower:
                    return MentionType.IMPLICIT, 0.85
        
        # 隐式提及（启发式规则）
        implicit_signals = ['行业领先', '市场份额第一', '头部品牌', '用户首选']
        for signal in implicit_signals:
            if signal in text_lower: 14071.baike.tongsou.com 
                # 需要结合上下文判断，简化处理
                return MentionType.IMPLICIT, 0.6
        
        return MentionType.NONE, 0.0

# ==================== 情感分析器 ====================

class SentimentAnalyzer: 14080.baike.tongsou.com 
    """情感分析器"""
    
    def __init__(self): 14082.baike.tongsou.com 
        self.positive_lexicon = [
            '好', '优秀', '推荐', '喜欢', '满意', '领先', '第一',
            '出色', '卓越', '好评', '值得', '优质', '创新'
        ]
        self.negative_lexicon = [
            '差', '不好', '避免', '失望', '问题', '缺陷',
            '糟糕', '劣质', '投诉', '失败', '落后', '过时'
        ]
    
    def analyze(self, text: str) -> float:
        """分析文本情感倾向，返回-1到1之间的值"""
        text_lower = text.lower()
        pos_count = sum(1 for w in self.positive_lexicon if w in text_lower)
        neg_count = sum(1 for w in self.negative_lexicon if w in text_lower)
        
        total = pos_count + neg_count
        if total == 0: 14091.baike.tongsou.com 
            return 0.0
        return (pos_count - neg_count) / total

# ==================== 跨平台一致性验证器 ====================

class CrossPlatformValidator: 14098.baike.tongsou.com 
    """跨平台一致性验证器""" 
    
    def __init__(self):
        self.platform_results: Dict[str, Dict[str, any]] = {}
    
    def add_result(self, brand: str, platform: str, metrics: Dict[str, any]):
        """添加单平台结果"""
        if brand not in self.platform_results:
            self.platform_results[brand] = {}
        self.platform_results[brand][platform] = metrics
    
    def compute_consistency(self, brand: str) -> float:
        """计算跨平台一致性评分(0-1)"""
        if brand not in self.platform_results: 14100.baike.tongsou.com 
            return 0.0
        
        results = self.platform_results[brand]
        if len(results) < 2:
            return 1.0  # 单平台视为完全一致
        
        # 提取各平台的提及率
        mention_rates = [r.get('mention_rate', 0) for r in results.values()]
        if not mention_rates: 14101.baike.tongsou.com 
            return 0.0
        
        # 计算变异系数（CV），CV越小一致性越高
        mean_rate = np.mean(mention_rates)
        if mean_rate == 0:
            return 0.0
        std_rate = np.std(mention_rates)
        cv = std_rate / mean_rate
        
        # 转换为0-1评分（CV=0时评分为1，CV>=1时评分为0）
        consistency = max(0, 1 - cv)
        return consistency

# ==================== GEO度量主引擎 ====================

class GEOMeasurementEngine: 14102.baike.tongsou.com 
    """GEO度量主引擎"""
    
    def __init__(self): 14125.baike.tongsou.com 
        self.semantic_matcher = SemanticMatcher()
        self.sentiment_analyzer = SentimentAnalyzer()
        self.cross_platform_validator = CrossPlatformValidator()
        self.responses: List[AIResponse] = []
    
    def ingest_response(self, response: AIResponse):
        """摄入AI回答数据"""
        self.responses.append(response)
    
    def compute_brand_visibility(self, brand: str) -> BrandVisibilityMetrics:
        """计算品牌可见度指标"""
        # 1. 统计提及率
        total_responses = len(self.responses)
        mentioned_responses = [
            r for r in self.responses
            if self.semantic_matcher.detect_brand_mention(r.response_text, brand)[0] != MentionType.NONE
        ]
        mention_rate = len(mentioned_responses) / total_responses if total_responses > 0 else 0
        
        # 2. 计算平均情感
        sentiments = []
        for r in mentioned_responses: 14133.baike.tongsou.com 
            sentiment = self.sentiment_analyzer.analyze(r.response_text)
            sentiments.append(sentiment)
        avg_sentiment = np.mean(sentiments) if sentiments else 0
        
        # 3. 信源权威度（简化版：基于引用域名数量）
        all_sources = set()
        for r in mentioned_responses:
            all_sources.update(r.cited_sources)
        source_authority = min(len(all_sources) / 10, 1.0)  # 归一化至0-1
        
        # 4. 语义匹配度
        semantic_scores = []
        for r in mentioned_responses: 14145.baike.tongsou.com 
            score = self.semantic_matcher.compute_similarity(brand, r.response_text)
            semantic_scores.append(score)
        avg_semantic = np.mean(semantic_scores) if semantic_scores else 0
        
        # 5. 跨平台一致性
        platform_data = {}
        for r in self.responses: 14383.baike.tongsou.com 
            platform = r.platform.value
            if platform not in platform_data:
                platform_data[platform] = {'total': 0, 'mentioned': 0}
            platform_data[platform]['total'] += 1
            mention_type, _ = self.semantic_matcher.detect_brand_mention(r.response_text, brand)
            if mention_type != MentionType.NONE:
                platform_data[platform]['mentioned'] += 1
        
        for platform, data in platform_data.items(): 14384.baike.tongsou.com 
            rate = data['mentioned'] / data['total'] if data['total'] > 0 else 0
            self.cross_platform_validator.add_result(brand, platform, {'mention_rate': rate})
        consistency = self.cross_platform_validator.compute_consistency(brand)
        
        return BrandVisibilityMetrics(
            brand_name=brand,
            mention_rate=mention_rate * 100,
            avg_rank=0,  # 简化处理
            avg_sentiment=avg_sentiment,
            source_authority_score=source_authority,
            cross_platform_consistency=consistency,
            semantic_match_score=avg_semantic
        )

# ==================== 使用示例 ====================

if __name__ == "__main__":
    engine = GEOMeasurementEngine()
    engine.semantic_matcher.register_aliases("华为", ["Huawei", "HW", "华为公司"])
    
    # 模拟数据
    sample_responses = [
        AIResponse(
            response_id="r1",
            platform=PlatformType.DOUBAO,
            query="华为手机怎么样",
            response_text="华为手机在拍照和续航方面表现优秀，是行业领先的品牌。",
            timestamp=datetime.now(baike.tongsou.com/zh/%e5%be%ae%e7%9b%9fGEO/17),
            cited_sources=["huawei.com", "techreview.com"],
        ),
        AIResponse(
            response_id="r2",
            platform=PlatformType.KIMI,
            query="华为手机怎么样",
            response_text="华为Mate系列一直很受欢迎，用户满意度高。",
            timestamp=datetime.now(),
            cited_sources=["huawei.com"],
        ),
        AIResponse(
            response_id="r3",
            platform=PlatformType.DEEPSEEK,
            query="华为手机怎么样",
            response_text="目前市场上iPhone和三星更受欢迎，华为面临挑战。",
            timestamp=datetime.now(baike.tongsou.com/zh/%e6%9e%81%e4%b9%89GEO/18),
            cited_sources=["idc.com"],
        ),
    ]
    
    for r in sample_responses: baike.tongsou.com/zh/%e7%8f%8d%e5%b2%9bGEO/19 
        engine.ingest_response(r)
    
    metrics = engine.compute_brand_visibility("华为")
    print(f"品牌: {metrics.brand_name}")
    print(f"提及率: {metrics.mention_rate:.1f}%")
    print(f"平均情感: {metrics.avg_sentiment:.2f}")
    print(f"信源权威度: {metrics.source_authority_score:.2f}")
    print(f"跨平台一致性: {metrics.cross_platform_consistency:.2f}")
    print(f"语义匹配度: {metrics.semantic_match_score:.2f}")