08 - 推荐系统设计

package main

import (
    "fmt"
    "math"
    "sort"
)

// ==================== 数据结构 ====================

// UserBehavior 用户行为
type UserBehavior struct {
    UserID    int64
    ItemID    int64
    BehaviorType string // "view" | "click" | "purchase"
    Score     float64   // 隐式评分
    Timestamp int64
}

// RecommendationItem 推荐物品
type RecommendationItem struct {
    ItemID int64
    Score  float64
    Reason string
}

// ==================== 协同过滤：User-based CF ====================

// UserBasedCF 基于用户的协同过滤
type UserBasedCF struct {
    // 用户-物品评分矩阵
    userItemMatrix map[int64]map[int64]float64
    
    // 用户相似度矩阵
    userSimilarity map[int64]map[int64]float64
}

// NewUserBasedCF 创建 User-based CF
func NewUserBasedCF() *UserBasedCF {
    return &UserBasedCF{
        userItemMatrix: make(map[int64]map[int64]float64),
        userSimilarity: make(map[int64]map[int64]float64),
    }
}

// AddBehavior 添加用户行为
func (cf *UserBasedCF) AddBehavior(behavior *UserBehavior) {
    if cf.userItemMatrix[behavior.UserID] == nil {
        cf.userItemMatrix[behavior.UserID] = make(map[int64]float64)
    }
    
    // 隐式评分：浏览=1, 点击=3, 购买=5
    score := map[string]float64{
        "view":     1.0,
        "click":    3.0,
        "purchase": 5.0,
    }[behavior.BehaviorType]
    
    // 累加评分
    cf.userItemMatrix[behavior.UserID][behavior.ItemID] += score
}

// CalculateUserSimilarity 计算用户相似度（余弦相似度）
func (cf *UserBasedCF) CalculateUserSimilarity() {
    users := make([]int64, 0)
    for userID := range cf.userItemMatrix {
        users = append(users, userID)
    }
    
    // 计算所有用户对之间的相似度
    for i := 0; i < len(users); i++ {
        userA := users[i]
        if cf.userSimilarity[userA] == nil {
            cf.userSimilarity[userA] = make(map[int64]float64)
        }
        
        for j := i + 1; j < len(users); j++ {
            userB := users[j]
            similarity := cf.cosineSimilarity(userA, userB)
            
            if similarity > 0 {
                cf.userSimilarity[userA][userB] = similarity
                if cf.userSimilarity[userB] == nil {
                    cf.userSimilarity[userB] = make(map[int64]float64)
                }
                cf.userSimilarity[userB][userA] = similarity
            }
        }
    }
}

// cosineSimilarity 余弦相似度
func (cf *UserBasedCF) cosineSimilarity(userA, userB int64) float64 {
    itemsA := cf.userItemMatrix[userA]
    itemsB := cf.userItemMatrix[userB]
    
    // 找出共同物品
    commonItems := make(map[int64]bool)
    for itemID := range itemsA {
        if _, exists := itemsB[itemID]; exists {
            commonItems[itemID] = true
        }
    }
    
    if len(commonItems) == 0 {
        return 0
    }
    
    // 计算余弦相似度
    var dotProduct, normA, normB float64
    
    for itemID := range commonItems {
        dotProduct += itemsA[itemID] * itemsB[itemID]
    }
    
    for _, score := range itemsA {
        normA += score * score
    }
    
    for _, score := range itemsB {
        normB += score * score
    }
    
    if normA == 0 || normB == 0 {
        return 0
    }
    
    return dotProduct / (math.Sqrt(normA) * math.Sqrt(normB))
}

// Recommend 生成推荐列表
func (cf *UserBasedCF) Recommend(userID int64, count int) []*RecommendationItem {
    // 1. 找到相似用户（Top K）
    similarUsers := cf.getTopKSimilarUsers(userID, 50)
    
    // 2. 聚合相似用户喜欢的物品
    candidateItems := make(map[int64]float64)
    userItems := cf.userItemMatrix[userID]
    
    for _, su := range similarUsers {
        similarUserID := su.UserID
        similarity := su.Similarity
        
        for itemID, score := range cf.userItemMatrix[similarUserID] {
            // 过滤用户已交互物品
            if _, exists := userItems[itemID]; exists {
                continue
            }
            
            // 加权累加
            candidateItems[itemID] += score * similarity
        }
    }
    
    // 3. 排序并返回 Top N
    items := make([]*RecommendationItem, 0)
    for itemID, score := range candidateItems {
        items = append(items, &RecommendationItem{
            ItemID: itemID,
            Score:  score,
            Reason: "猜你喜欢",
        })
    }
    
    sort.Slice(items, func(i, j int) bool {
        return items[i].Score > items[j].Score
    })
    
    if len(items) > count {
        items = items[:count]
    }
    
    return items
}

// getTopKSimilarUsers 获取最相似的 K 个用户
func (cf *UserBasedCF) getTopKSimilarUsers(userID int64, k int) []*SimilarUser {
    similarities := cf.userSimilarity[userID]
    
    users := make([]*SimilarUser, 0)
    for otherUserID, similarity := range similarities {
        users = append(users, &SimilarUser{
            UserID:     otherUserID,
            Similarity: similarity,
        })
    }
    
    sort.Slice(users, func(i, j int) bool {
        return users[i].Similarity > users[j].Similarity
    })
    
    if len(users) > k {
        users = users[:k]
    }
    
    return users
}

type SimilarUser struct {
    UserID     int64
    Similarity float64
}

// ==================== 协同过滤：Item-based CF ====================

// ItemBasedCF 基于物品的协同过滤
type ItemBasedCF struct {
    // 用户-物品评分矩阵
    userItemMatrix map[int64]map[int64]float64
    
    // 物品相似度矩阵
    itemSimilarity map[int64]map[int64]float64
}

// NewItemBasedCF 创建 Item-based CF
func NewItemBasedCF() *ItemBasedCF {
    return &ItemBasedCF{
        userItemMatrix: make(map[int64]map[int64]float64),
        itemSimilarity: make(map[int64]map[int64]float64),
    }
}

// AddBehavior 添加用户行为
func (cf *ItemBasedCF) AddBehavior(behavior *UserBehavior) {
    if cf.userItemMatrix[behavior.UserID] == nil {
        cf.userItemMatrix[behavior.UserID] = make(map[int64]float64)
    }
    
    score := map[string]float64{
        "view":     1.0,
        "click":    3.0,
        "purchase": 5.0,
    }[behavior.BehaviorType]
    
    cf.userItemMatrix[behavior.UserID][behavior.ItemID] += score
}

// CalculateItemSimilarity 计算物品相似度
func (cf *ItemBasedCF) CalculateItemSimilarity() {
    // 构建倒排索引：物品 -> 用户列表
    itemUsers := make(map[int64]map[int64]float64)
    
    for userID, items := range cf.userItemMatrix {
        for itemID, score := range items {
            if itemUsers[itemID] == nil {
                itemUsers[itemID] = make(map[int64]float64)
            }
            itemUsers[itemID][userID] = score
        }
    }
    
    // 计算物品相似度
    items := make([]int64, 0)
    for itemID := range itemUsers {
        items = append(items, itemID)
    }
    
    for i := 0; i < len(items); i++ {
        itemA := items[i]
        if cf.itemSimilarity[itemA] == nil {
            cf.itemSimilarity[itemA] = make(map[int64]float64)
        }
        
        for j := i + 1; j < len(items); j++ {
            itemB := items[j]
            
            // 使用 Jaccard 相似度（简化）
            usersA := itemUsers[itemA]
            usersB := itemUsers[itemB]
            
            commonUsers := 0
            for userID := range usersA {
                if _, exists := usersB[userID]; exists {
                    commonUsers++
                }
            }
            
            if commonUsers == 0 {
                continue
            }
            
            totalUsers := len(usersA) + len(usersB) - commonUsers
            similarity := float64(commonUsers) / float64(totalUsers)
            
            cf.itemSimilarity[itemA][itemB] = similarity
            if cf.itemSimilarity[itemB] == nil {
                cf.itemSimilarity[itemB] = make(map[int64]float64)
            }
            cf.itemSimilarity[itemB][itemA] = similarity
        }
    }
}

// Recommend 生成推荐列表
func (cf *ItemBasedCF) Recommend(userID int64, count int) []*RecommendationItem {
    // 1. 获取用户历史交互物品
    userItems := cf.userItemMatrix[userID]
    
    // 2. 找到相似物品
    candidateItems := make(map[int64]float64)
    
    for itemID, userScore := range userItems {
        similarItems := cf.itemSimilarity[itemID]
        
        for similarItemID, similarity := range similarItems {
            // 过滤已交互物品
            if _, exists := userItems[similarItemID]; exists {
                continue
            }
            
            // 加权累加
            candidateItems[similarItemID] += userScore * similarity
        }
    }
    
    // 3. 排序并返回 Top N
    items := make([]*RecommendationItem, 0)
    for itemID, score := range candidateItems {
        items = append(items, &RecommendationItem{
            ItemID: itemID,
            Score:  score,
            Reason: "看了还看",
        })
    }
    
    sort.Slice(items, func(i, j int) bool {
        return items[i].Score > items[j].Score
    })
    
    if len(items) > count {
        items = items[:count]
    }
    
    return items
}

// ==================== 测试代码 ====================

func main() {
    // 创建 User-based CF
    userCF := NewUserBasedCF()
    
    // 添加用户行为
    behaviors := []*UserBehavior{
        {UserID: 1, ItemID: 101, BehaviorType: "purchase"},
        {UserID: 1, ItemID: 102, BehaviorType: "click"},
        {UserID: 1, ItemID: 103, BehaviorType: "view"},
        
        {UserID: 2, ItemID: 101, BehaviorType: "purchase"},
        {UserID: 2, ItemID: 102, BehaviorType: "purchase"},
        {UserID: 2, ItemID: 104, BehaviorType: "click"},
        
        {UserID: 3, ItemID: 102, BehaviorType: "click"},
        {UserID: 3, ItemID: 103, BehaviorType: "purchase"},
        {UserID: 3, ItemID: 105, BehaviorType: "view"},
    }
    
    for _, behavior := range behaviors {
        userCF.AddBehavior(behavior)
    }
    
    // 计算相似度
    userCF.CalculateUserSimilarity()
    
    // 生成推荐
    recommendations := userCF.Recommend(1, 5)
    
    fmt.Println("=== User-based CF 推荐结果 ===")
    for i, item := range recommendations {
        fmt.Printf("%d. ItemID: %d, Score: %.2f, Reason: %s\n",
            i+1, item.ItemID, item.Score, item.Reason)
    }
    
    // 创建 Item-based CF
    itemCF := NewItemBasedCF()
    for _, behavior := range behaviors {
        itemCF.AddBehavior(behavior)
    }
    
    itemCF.CalculateItemSimilarity()
    recommendations = itemCF.Recommend(1, 5)
    
    fmt.Println("\n=== Item-based CF 推荐结果 ===")
    for i, item := range recommendations {
        fmt.Printf("%d. ItemID: %d, Score: %.2f, Reason: %s\n",
            i+1, item.ItemID, item.Score, item.Reason)
    }
}

// ==================== 多路召回 ====================

package recall

import (
    "sort"
)

// RecallStrategy 召回策略接口
type RecallStrategy interface {
    Recall(userID int64, count int) []*CandidateItem
    Name() string
}

// CandidateItem 候选物品
type CandidateItem struct {
    ItemID         int64
    Score          float64
    RecallStrategy string
    Features       map[string]float64 // 特征
}

// MultiRecallEngine 多路召回引擎
type MultiRecallEngine struct {
    strategies []RecallStrategy
}

// NewMultiRecallEngine 创建多路召回引擎
func NewMultiRecallEngine() *MultiRecallEngine {
    return &MultiRecallEngine{
        strategies: make([]RecallStrategy, 0),
    }
}

// AddStrategy 添加召回策略
func (e *MultiRecallEngine) AddStrategy(strategy RecallStrategy) {
    e.strategies = append(e.strategies, strategy)
}

// Recall 多路召回
func (e *MultiRecallEngine) Recall(userID int64, countPerStrategy int) []*CandidateItem {
    // 1. 并发召回
    resultChan := make(chan []*CandidateItem, len(e.strategies))
    
    for _, strategy := range e.strategies {
        go func(s RecallStrategy) {
            items := s.Recall(userID, countPerStrategy)
            resultChan <- items
        }(strategy)
    }
    
    // 2. 合并结果
    allItems := make([]*CandidateItem, 0)
    for i := 0; i < len(e.strategies); i++ {
        items := <-resultChan
        allItems = append(allItems, items...)
    }
    
    // 3. 去重
    itemMap := make(map[int64]*CandidateItem)
    for _, item := range allItems {
        if existing, exists := itemMap[item.ItemID]; exists {
            // 取最高分
            if item.Score > existing.Score {
                itemMap[item.ItemID] = item
            }
        } else {
            itemMap[item.ItemID] = item
        }
    }
    
    // 4. 转为列表
    uniqueItems := make([]*CandidateItem, 0)
    for _, item := range itemMap {
        uniqueItems = append(uniqueItems, item)
    }
    
    return uniqueItems
}

// ==================== 召回策略实现 ====================

// UserCFRecall 基于用户协同过滤的召回
type UserCFRecall struct {
    cf *UserBasedCF
}

func (r *UserCFRecall) Recall(userID int64, count int) []*CandidateItem {
    recommendations := r.cf.Recommend(userID, count)
    
    items := make([]*CandidateItem, 0)
    for _, rec := range recommendations {
        items = append(items, &CandidateItem{
            ItemID:         rec.ItemID,
            Score:          rec.Score,
            RecallStrategy: "user_cf",
            Features:       make(map[string]float64),
        })
    }
    return items
}

func (r *UserCFRecall) Name() string {
    return "user_cf"
}

// ItemCFRecall 基于物品协同过滤的召回
type ItemCFRecall struct {
    cf *ItemBasedCF
}

func (r *ItemCFRecall) Recall(userID int64, count int) []*CandidateItem {
    recommendations := r.cf.Recommend(userID, count)
    
    items := make([]*CandidateItem, 0)
    for _, rec := range recommendations {
        items = append(items, &CandidateItem{
            ItemID:         rec.ItemID,
            Score:          rec.Score,
            RecallStrategy: "item_cf",
            Features:       make(map[string]float64),
        })
    }
    return items
}

func (r *ItemCFRecall) Name() string {
    return "item_cf"
}

// HotRecall 热门召回
type HotRecall struct {
    hotItems []int64
}

func (r *HotRecall) Recall(userID int64, count int) []*CandidateItem {
    items := make([]*CandidateItem, 0)
    for i, itemID := range r.hotItems {
        if i >= count {
            break
        }
        items = append(items, &CandidateItem{
            ItemID:         itemID,
            Score:          float64(len(r.hotItems) - i), // 热度分
            RecallStrategy: "hot",
            Features:       make(map[string]float64),
        })
    }
    return items
}

func (r *HotRecall) Name() string {
    return "hot"
}

// ==================== 排序层 ====================

package ranking

// RankingModel 排序模型接口
type RankingModel interface {
    Predict(item *CandidateItem, userFeatures map[string]float64) float64
}

// LRModel 逻辑回归模型（简化）
type LRModel struct {
    weights map[string]float64
    bias    float64
}

// Predict 预测 CTR
func (m *LRModel) Predict(item *CandidateItem, userFeatures map[string]float64) float64 {
    // 特征拼接
    features := make(map[string]float64)
    
    // 用户特征
    for k, v := range userFeatures {
        features["user_"+k] = v
    }
    
    // 物品特征
    for k, v := range item.Features {
        features["item_"+k] = v
    }
    
    // 召回分数
    features["recall_score"] = item.Score
    
    // 线性加权
    score := m.bias
    for feature, value := range features {
        if weight, exists := m.weights[feature]; exists {
            score += weight * value
        }
    }
    
    // Sigmoid
    return 1.0 / (1.0 + math.Exp(-score))
}

// RankingService 排序服务
type RankingService struct {
    model RankingModel
}

// Rank 排序
func (s *RankingService) Rank(items []*CandidateItem, userFeatures map[string]float64) []*CandidateItem {
    // 1. 预测 CTR
    for _, item := range items {
        item.Score = s.model.Predict(item, userFeatures)
    }
    
    // 2. 排序
    sort.Slice(items, func(i, j int) bool {
        return items[i].Score > items[j].Score
    })
    
    return items
}

// ==================== 完整推荐流程 ====================

type RecommendationService struct {
    recallEngine  *MultiRecallEngine
    rankingService *RankingService
}

func (s *RecommendationService) Recommend(userID int64, count int) []*CandidateItem {
    // 1. 召回（每路召回 500 个）
    candidates := s.recallEngine.Recall(userID, 500)
    
    // 2. 粗排（筛选 Top 100）
    candidates = s.preRank(candidates, 100)
    
    // 3. 精排
    userFeatures := s.getUserFeatures(userID)
    rankedItems := s.rankingService.Rank(candidates, userFeatures)
    
    // 4. 重排（多样性、打散）
    finalItems := s.rerank(rankedItems, count)
    
    return finalItems
}

func (s *RecommendationService) preRank(items []*CandidateItem, count int) []*CandidateItem {
    // 简单规则排序
    sort.Slice(items, func(i, j int) bool {
        return items[i].Score > items[j].Score
    })
    
    if len(items) > count {
        items = items[:count]
    }
    return items
}

func (s *RecommendationService) rerank(items []*CandidateItem, count int) []*CandidateItem {
    // 去重、打散（避免同类物品连续出现）
    // 这里简化实现
    if len(items) > count {
        items = items[:count]
    }
    return items
}

func (s *RecommendationService) getUserFeatures(userID int64) map[string]float64 {
    // 从 Redis/DB 获取用户特征
    return map[string]float64{
        "age":          25,
        "gender":       1, // 0=女, 1=男
        "active_days":  180,
        "avg_price":    500,
    }
}

// ==================== Embedding 向量化 ====================

package embedding

import (
    "math"
)

// EmbeddingModel Embedding 模型
type EmbeddingModel struct {
    // 用户 Embedding
    userEmbeddings map[int64][]float64
    
    // 物品 Embedding
    itemEmbeddings map[int64][]float64
    
    // Embedding 维度
    dimension int
}

// NewEmbeddingModel 创建 Embedding 模型
func NewEmbeddingModel(dimension int) *EmbeddingModel {
    return &EmbeddingModel{
        userEmbeddings: make(map[int64][]float64),
        itemEmbeddings: make(map[int64][]float64),
        dimension:      dimension,
    }
}

// GetUserEmbedding 获取用户 Embedding
func (m *EmbeddingModel) GetUserEmbedding(userID int64) []float64 {
    if emb, exists := m.userEmbeddings[userID]; exists {
        return emb
    }
    
    // 新用户：随机初始化或零向量
    return make([]float64, m.dimension)
}

// GetItemEmbedding 获取物品 Embedding
func (m *EmbeddingModel) GetItemEmbedding(itemID int64) []float64 {
    if emb, exists := m.itemEmbeddings[itemID]; exists {
        return emb
    }
    return make([]float64, m.dimension)
}

// CosineSimilarity 计算余弦相似度
func CosineSimilarity(vec1, vec2 []float64) float64 {
    if len(vec1) != len(vec2) {
        return 0
    }
    
    var dotProduct, norm1, norm2 float64
    
    for i := 0; i < len(vec1); i++ {
        dotProduct += vec1[i] * vec2[i]
        norm1 += vec1[i] * vec1[i]
        norm2 += vec2[i] * vec2[i]
    }
    
    if norm1 == 0 || norm2 == 0 {
        return 0
    }
    
    return dotProduct / (math.Sqrt(norm1) * math.Sqrt(norm2))
}

// RecallByEmbedding 基于 Embedding 召回
func (m *EmbeddingModel) RecallByEmbedding(userID int64, count int) []int64 {
    userEmb := m.GetUserEmbedding(userID)
    
    // 计算与所有物品的相似度
    type ItemScore struct {
        ItemID int64
        Score  float64
    }
    
    scores := make([]ItemScore, 0)
    for itemID := range m.itemEmbeddings {
        itemEmb := m.GetItemEmbedding(itemID)
        similarity := CosineSimilarity(userEmb, itemEmb)
        scores = append(scores, ItemScore{ItemID: itemID, Score: similarity})
    }
    
    // 排序
    sort.Slice(scores, func(i, j int) bool {
        return scores[i].Score > scores[j].Score
    })
    
    // 返回 Top K
    result := make([]int64, 0)
    for i := 0; i < count && i < len(scores); i++ {
        result = append(result, scores[i].ItemID)
    }
    
    return result
}

// ==================== Wide & Deep 模型（概念）====================

// WideDeepModel Wide & Deep 模型
type WideDeepModel struct {
    // Wide 部分：线性模型
    wideWeights map[string]float64
    
    // Deep 部分：深度神经网络
    deepLayers [][]float64 // 简化：权重矩阵
}

// Predict 预测 CTR
func (m *WideDeepModel) Predict(features map[string]float64) float64 {
    // Wide 部分
    wideScore := 0.0
    for feature, value := range features {
        if weight, exists := m.wideWeights[feature]; exists {
            wideScore += weight * value
        }
    }
    
    // Deep 部分（简化：多层感知机）
    deepScore := 0.0
    // ... 这里需要实现前向传播 ...
    
    // 融合
    finalScore := 0.5*wideScore + 0.5*deepScore
    
    // Sigmoid
    return 1.0 / (1.0 + math.Exp(-finalScore))
}

// ==================== 实时特征更新 ====================

package realtime

import (
    "context"
    "time"
)

// RealtimeFeatureService 实时特征服务
type RealtimeFeatureService struct {
    redis *redis.Client
}

// UpdateUserBehavior 更新用户行为特征
func (s *RealtimeFeatureService) UpdateUserBehavior(userID int64, behavior *UserBehavior) {
    ctx := context.Background()
    
    // 1. 更新最近浏览列表（保留最近 100 个）
    key := fmt.Sprintf("user:%d:recent_items", userID)
    s.redis.LPush(ctx, key, behavior.ItemID)
    s.redis.LTrim(ctx, key, 0, 99)
    s.redis.Expire(ctx, key, 7*24*time.Hour)
    
    // 2. 更新物品交互次数
    itemKey := fmt.Sprintf("user:%d:item:%d:count", userID, behavior.ItemID)
    s.redis.Incr(ctx, itemKey)
    s.redis.Expire(ctx, itemKey, 30*24*time.Hour)
    
    // 3. 更新用户活跃时段
    hour := time.Now().Hour()
    hourKey := fmt.Sprintf("user:%d:active_hours", userID)
    s.redis.ZIncrBy(ctx, hourKey, 1, fmt.Sprintf("%d", hour))
    
    // 4. 发送到 Kafka 进行异步处理
    // kafka.Produce("user-behavior", behavior)
}

// GetUserRecentItems 获取用户最近浏览
func (s *RealtimeFeatureService) GetUserRecentItems(userID int64, count int) []int64 {
    ctx := context.Background()
    key := fmt.Sprintf("user:%d:recent_items", userID)
    
    items, err := s.redis.LRange(ctx, key, 0, int64(count-1)).Result()
    if err != nil {
        return []int64{}
    }
    
    itemIDs := make([]int64, 0)
    for _, item := range items {
        itemID, _ := strconv.ParseInt(item, 10, 64)
        itemIDs = append(itemIDs, itemID)
    }
    
    return itemIDs
}

// ColdStartHandler 冷启动处理器
type ColdStartHandler struct {
    hotItems      []int64                    // 热门物品
    categoryHot   map[string][]int64         // 分类热门
    demographicRec map[string][]int64         // 人口统计推荐
}

// HandleNewUser 处理新用户
func (h *ColdStartHandler) HandleNewUser(userProfile *UserProfile) []*RecommendationItem {
    items := make([]*RecommendationItem, 0)
    
    // 1. 基于人口属性推荐
    demographic := fmt.Sprintf("%s_%s_%s", 
        userProfile.Gender, userProfile.AgeRange, userProfile.City)
    
    if recs, exists := h.demographicRec[demographic]; exists {
        for _, itemID := range recs {
            items = append(items, &RecommendationItem{
                ItemID: itemID,
                Score:  0.8,
                Reason: "为你精选",
            })
        }
    }
    
    // 2. 全站热门
    for i, itemID := range h.hotItems {
        if i >= 10 {
            break
        }
        items = append(items, &RecommendationItem{
            ItemID: itemID,
            Score:  0.9 - float64(i)*0.05,
            Reason: "热门推荐",
        })
    }
    
    return items
}

// HandleNewItem 处理新物品
func (h *ColdStartHandler) HandleNewItem(itemID int64, features *ItemFeatures) {
    // 1. 基于内容相似度推荐
    // 找到相似物品，给相似物品的用户推荐新物品
    
    // 2. 小流量试探
    // 给一定比例的流量展示新物品，根据 CTR 决定是否继续推广
}

// DiversityReranker 多样性重排
type DiversityReranker struct {
    categoryService *CategoryService
}

// Rerank 重排（MMR 算法：Maximal Marginal Relevance）
func (r *DiversityReranker) Rerank(items []*RecommendationItem, count int, lambda float64) []*RecommendationItem {
    if len(items) <= count {
        return items
    }
    
    result := make([]*RecommendationItem, 0)
    remaining := make([]*RecommendationItem, len(items))
    copy(remaining, items)
    
    // 第一个：最高分
    result = append(result, remaining[0])
    remaining = remaining[1:]
    
    // 迭代选择
    for len(result) < count && len(remaining) > 0 {
        maxScore := -1.0
        maxIndex := 0
        
        for i, item := range remaining {
            // MMR = λ × Relevance - (1-λ) × Similarity
            relevance := item.Score
            
            // 计算与已选物品的最大相似度
            maxSimilarity := 0.0
            for _, selected := range result {
                similarity := r.calculateSimilarity(item, selected)
                if similarity > maxSimilarity {
                    maxSimilarity = similarity
                }
            }
            
            mmr := lambda*relevance - (1-lambda)*maxSimilarity
            
            if mmr > maxScore {
                maxScore = mmr
                maxIndex = i
            }
        }
        
        result = append(result, remaining[maxIndex])
        remaining = append(remaining[:maxIndex], remaining[maxIndex+1:]...)
    }
    
    return result
}

// calculateSimilarity 计算物品相似度（基于类目）
func (r *DiversityReranker) calculateSimilarity(item1, item2 *RecommendationItem) float64 {
    cat1 := r.categoryService.GetCategory(item1.ItemID)
    cat2 := r.categoryService.GetCategory(item2.ItemID)
    
    if cat1 == cat2 {
        return 1.0
    }
    return 0.0
}

// EpsilonGreedyStrategy ε-贪心策略
type EpsilonGreedyStrategy struct {
    epsilon float64 // 探索概率
}

// Select 选择推荐策略
func (s *EpsilonGreedyStrategy) Select(items []*RecommendationItem) []*RecommendationItem {
    result := make([]*RecommendationItem, 0)
    
    for _, item := range items {
        random := rand.Float64()
        
        if random < s.epsilon {
            // 探索：随机选择
            result = append(result, s.randomItem())
        } else {
            // 利用：选择高分物品
            result = append(result, item)
        }
    }
    
    return result
}

// UCBStrategy UCB（Upper Confidence Bound）策略
type UCBStrategy struct {
    itemStats map[int64]*ItemStats
}

type ItemStats struct {
    Impressions int
    Clicks      int
    CTR         float64
}

// CalculateUCB 计算 UCB 分数
func (s *UCBStrategy) CalculateUCB(itemID int64, totalImpressions int) float64 {
    stats := s.itemStats[itemID]
    if stats == nil || stats.Impressions == 0 {
        return math.MaxFloat64 // 未曝光物品优先
    }
    
    // UCB = CTR + sqrt(2 * ln(总曝光) / 物品曝光)
    ucb := stats.CTR + math.Sqrt(2*math.Log(float64(totalImpressions))/float64(stats.Impressions))
    
    return ucb
}

// ANN (Approximate Nearest Neighbor) 近似最近邻
// 使用 FAISS、Annoy 等库加速向量检索

import "github.com/spotify/annoy-go"

type ANNRecallService struct {
    index *annoy.AnnoyIndex
}

func (s *ANNRecallService) BuildIndex(embeddings map[int64][]float64, dimension int) {
    s.index = annoy.NewAnnoyIndex(dimension, "euclidean")
    
    for itemID, emb := range embeddings {
        s.index.AddItem(int(itemID), emb)
    }
    
    s.index.Build(10) // 10 trees
}

func (s *ANNRecallService) Recall(userEmbedding []float64, count int) []int64 {
    results, _ := s.index.GetNnsByVector(userEmbedding, count, -1)
    
    itemIDs := make([]int64, len(results))
    for i, id := range results {
        itemIDs[i] = int64(id)
    }
    
    return itemIDs
}

type FeatureCacheService struct {
    redis *redis.Client
}

// GetUserFeatures 获取用户特征（带缓存）
func (s *FeatureCacheService) GetUserFeatures(userID int64) map[string]float64 {
    ctx := context.Background()
    cacheKey := fmt.Sprintf("features:user:%d", userID)
    
    // 1. 查询缓存
    cached, err := s.redis.Get(ctx, cacheKey).Result()
    if err == nil {
        var features map[string]float64
        json.Unmarshal([]byte(cached), &features)
        return features
    }
    
    // 2. 查询数据库
    features := s.loadUserFeaturesFromDB(userID)
    
    // 3. 写入缓存
    data, _ := json.Marshal(features)
    s.redis.Set(ctx, cacheKey, data, 10*time.Minute)
    
    return features
}

// 离线预计算推荐结果
type OfflineRecommendationJob struct {
    db    *sql.DB
    redis *redis.Client
}

func (job *OfflineRecommendationJob) Run() {
    // 1. 获取所有活跃用户
    users := job.getActiveUsers()
    
    // 2. 批量计算推荐
    for _, userID := range users {
        recommendations := job.calculateRecommendations(userID)
        
        // 3. 存储到 Redis
        key := fmt.Sprintf("rec:user:%d:offline", userID)
        data, _ := json.Marshal(recommendations)
        job.redis.Set(context.Background(), key, data, 24*time.Hour)
    }
}

// RecommendationMetrics 推荐指标
type RecommendationMetrics struct {
    // 业务指标
    CTR         float64 // 点击率
    CVR         float64 // 转化率
    GMV         float64 // 成交金额
    
    // 用户体验指标
    Diversity   float64 // 多样性
    Coverage    float64 // 覆盖率
    Novelty     float64 // 新颖度
    
    // 系统指标
    LatencyP99  time.Duration // 延迟
    QPS         int
    ErrorRate   float64
}

// CalculateCTR 计算点击率
func CalculateCTR(impressions, clicks int) float64 {
    if impressions == 0 {
        return 0
    }
    return float64(clicks) / float64(impressions)
}

// CalculateCoverage 计算覆盖率
func CalculateCoverage(recommendedItems, totalItems int) float64 {
    return float64(recommendedItems) / float64(totalItems)
}

package abtest

type ABTestService struct {
    experiments map[string]*Experiment
}

type Experiment struct {
    Name        string
    Variants    []string  // ["control", "treatment_a", "treatment_b"]
    TrafficSplit map[string]float64 // {"control": 0.5, "treatment_a": 0.3, "treatment_b": 0.2}
}

// GetVariant 获取用户分组
func (s *ABTestService) GetVariant(experimentName string, userID int64) string {
    exp := s.experiments[experimentName]
    if exp == nil {
        return "control"
    }
    
    // 哈希分流
    hash := hashUserID(userID, experimentName)
    ratio := float64(hash%10000) / 10000.0
    
    cumulative := 0.0
    for variant, traffic := range exp.TrafficSplit {
        cumulative += traffic
        if ratio < cumulative {
            return variant
        }
    }
    
    return "control"
}

func hashUserID(userID int64, experimentName string) int {
    h := fnv.New32a()
    h.Write([]byte(fmt.Sprintf("%d_%s", userID, experimentName)))
    return int(h.Sum32())
}

// 使用示例
func (s *RecommendationService) Recommend(userID int64, count int) []*RecommendationItem {
    variant := s.abtestService.GetVariant("rec_algorithm_v2", userID)
    
    if variant == "treatment_a" {
        // 使用新算法
        return s.recommendV2(userID, count)
    } else {
        // 使用旧算法
        return s.recommendV1(userID, count)
    }
}

var (
    recommendationTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "recommendation_total",
            Help: "Total recommendation requests",
        },
        []string{"scene", "strategy"},
    )
    
    recommendationLatency = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "recommendation_latency_seconds",
            Help:    "Recommendation latency",
            Buckets: []float64{0.01, 0.05, 0.1, 0.5, 1},
        },
        []string{"scene"},
    )
    
    recommendationCTR = prometheus.NewGaugeVec(
        prometheus.GaugeOpts{
            Name: "recommendation_ctr",
            Help: "Recommendation CTR",
        },
        []string{"scene"},
    )
)

func (s *RecommendationService) RecordMetrics(scene string, strategy string, latency time.Duration) {
    recommendationTotal.WithLabelValues(scene, strategy).Inc()
    recommendationLatency.WithLabelValues(scene).Observe(latency.Seconds())
}

func (s *RecommendationService) HandleColdStart(userID int64) []*RecommendationItem {
    // 检查用户行为数
    behaviorCount := s.getUserBehaviorCount(userID)
    
    if behaviorCount < 10 {
        // 新用户：热门 + 人口属性
        return s.coldStartHandler.HandleNewUser(userProfile)
    } else {
        // 老用户：正常推荐
        return s.Recommend(userID, 20)
    }
}

// Precision@K
func PrecisionAtK(recommended, actual []int64, k int) float64 {
    if k > len(recommended) {
        k = len(recommended)
    }
    
    actualSet := make(map[int64]bool)
    for _, item := range actual {
        actualSet[item] = true
    }
    
    hit := 0
    for i := 0; i < k; i++ {
        if actualSet[recommended[i]] {
            hit++
        }
    }
    
    return float64(hit) / float64(k)
}