Week 2 Day 13：Error Analysis - 苏格拉底教学#

// evals/error_analyzer.go
package main

import (
	"context"
	"encoding/json"
	"fmt"
)

// FailureMode 错误类型
type FailureMode string

const (
	FailureNone             FailureMode = "none"
	FailureNoRelevantChunk  FailureMode = "retrieval_no_relevant_chunk"
	FailureChunkRankedLow   FailureMode = "retrieval_chunk_ranked_low"
	FailureVocabMismatch    FailureMode = "retrieval_vocab_mismatch"
	FailureMultiHop         FailureMode = "reasoning_multi_hop"
	FailureContextConfusion FailureMode = "reasoning_context_confusion"
	FailureHallucination    FailureMode = "reasoning_hallucination"
	FailureFormatWrong      FailureMode = "output_format_wrong"
	FailureIncomplete       FailureMode = "output_incomplete"
	FailureTooVerbose       FailureMode = "output_too_verbose"
)

// ErrorAnalysis 单个case的错误分析
type ErrorAnalysis struct {
	EvalResult
	PrimaryFailure   FailureMode   `json:"primary_failure"`
	SecondaryFailures []FailureMode `json:"secondary_failures"`
	RootCause        string        `json:"root_cause"`
	SuggestedFix     string        `json:"suggested_fix"`
}

// ErrorAnalyzer 错误分析器
type ErrorAnalyzer struct {
	llmClient LLMClient
	k         int
}

func NewErrorAnalyzer(llmClient LLMClient, k int) *ErrorAnalyzer {
	return &ErrorAnalyzer{llmClient: llmClient, k: k}
}

// Analyze 分析单个eval result的失败原因
func (a *ErrorAnalyzer) Analyze(ctx context.Context, result EvalResult) ErrorAnalysis {
	analysis := ErrorAnalysis{EvalResult: result}

	// Step 1: 判断是否是retrieval fail
	if result.PrecisionAt5 < 0.4 {
		// 检索质量差
		if result.RecallAt5 == 0 {
			// 根本没找到任何相关chunk
			analysis.PrimaryFailure = FailureNoRelevantChunk
			analysis.RootCause = "所有相关chunk都不在Top-K结果中"
			analysis.SuggestedFix = "检查chunk是否包含答案，考虑重新chunking或调大K值"
		} else {
			// 找到了部分，但排名靠后
			analysis.PrimaryFailure = FailureChunkRankedLow
			analysis.RootCause = fmt.Sprintf("相关chunk存在但MRR=%.3f，说明排名不够高", result.MRR)
			analysis.SuggestedFix = "考虑调整embedding模型或加入hybrid search"
		}
		return analysis
	}

	// Step 2: 检索还行，但答案质量差 → 推理或输出问题
	if result.PrecisionAt5 >= 0.4 && result.LLMScore < 3.0 {
		failure := a.classifyReasoningOrOutput(ctx, result)
		analysis.PrimaryFailure = failure
		analysis.RootCause = a.getRootCause(failure, result)
		analysis.SuggestedFix = a.getSuggestedFix(failure)
		return analysis
	}

	// Step 3: 没有明显问题
	analysis.PrimaryFailure = FailureNone
	return analysis
}

// classifyReasoningOrOutput 区分推理失败和输出失败
func (a *ErrorAnalyzer) classifyReasoningOrOutput(ctx context.Context, result EvalResult) FailureMode {
	prompt := fmt.Sprintf(`分析以下RAG系统的失败原因。

问题：%s
检索到的chunk IDs：%v
生成的答案：%s
参考答案：%s

问题是以下哪一类？
1. reasoning_hallucination：答案包含chunks中没有的内容
2. reasoning_multi_hop：需要多步推理，答案只回答了一部分
3. reasoning_context_confusion：混淆了多个文档的内容
4. output_incomplete：答案正确但不完整
5. output_too_verbose：答案过长，包含大量无关内容
6. output_format_wrong：内容正确但格式不对

只返回JSON：{"failure_mode": "上面的类别名", "explanation": "简短解释"}`,
		result.Query,
		result.RetrievedIDs,
		result.GeneratedAnswer,
		result.ExpectedAnswer,
	)

	resp, err := a.llmClient.Complete(ctx, prompt)
	if err != nil {
		return FailureReasoningHallucination() // 默认归类
	}

	var r struct {
		FailureMode string `json:"failure_mode"`
		Explanation string `json:"explanation"`
	}
	if err := json.Unmarshal([]byte(resp), &r); err != nil {
		return FailureHallucination
	}

	return FailureMode(r.FailureMode)
}

// FailureReasoningHallucination helper
func FailureReasoningHallucination() FailureMode { return FailureHallucination }

func (a *ErrorAnalyzer) getRootCause(f FailureMode, result EvalResult) string {
	switch f {
	case FailureHallucination:
		return "LLM生成了训练数据中的知识，而非基于检索结果"
	case FailureMultiHop:
		return "问题需要整合多个chunks的信息，LLM只处理了部分"
	case FailureContextConfusion:
		return "Prompt中多个chunks内容相似，LLM混淆了来源"
	case FailureIncomplete:
		return "Prompt可能缺少"请提供完整答案"的指令"
	case FailureTooVerbose:
		return "Prompt没有约束输出长度"
	default:
		return "未知原因"
	}
}

func (a *ErrorAnalyzer) getSuggestedFix(f FailureMode) string {
	switch f {
	case FailureHallucination:
		return "在prompt中强调：只使用提供的文档内容，不要使用外部知识"
	case FailureMultiHop:
		return "改用chain-of-thought prompt，或拆分问题为子问题"
	case FailureContextConfusion:
		return "在每个chunk前加上来源标识符，prompt中说明区分来源"
	case FailureIncomplete:
		return "prompt中加入：请提供完整答案，涵盖所有要点"
	case FailureTooVerbose:
		return "prompt中加入字数限制或格式要求"
	default:
		return "人工审查此case"
	}
}

// evals/error_report.go
package main

import (
	"context"
	"fmt"
	"sort"
)

// FailureBreakdown 错误分布
type FailureBreakdown struct {
	Mode        FailureMode `json:"mode"`
	Count       int         `json:"count"`
	Percentage  float64     `json:"percentage"`
	AvgLLMScore float64     `json:"avg_llm_score"`
	Examples    []string    `json:"examples"` // 前3个例子的query
}

// ErrorReport 完整错误报告
type ErrorReport struct {
	TotalAnalyzed  int                `json:"total_analyzed"`
	FailingCases   int                `json:"failing_cases"`
	FailRate       float64            `json:"fail_rate"`
	Breakdown      []FailureBreakdown `json:"breakdown"`
	TopIssues      []string           `json:"top_issues"`
	Recommendations []string          `json:"recommendations"`
}

// AnalyzeAll 批量分析所有失败的cases
func AnalyzeAll(ctx context.Context, results []EvalResult, analyzer *ErrorAnalyzer) *ErrorReport {
	report := &ErrorReport{TotalAnalyzed: len(results)}

	var analyses []ErrorAnalysis
	modeMap := make(map[FailureMode][]ErrorAnalysis)

	for _, result := range results {
		// 只分析低分的case（LLMScore < 3.5或Precision < 0.4）
		if result.LLMScore >= 3.5 && result.PrecisionAt5 >= 0.4 {
			continue
		}
		analysis := analyzer.Analyze(ctx, result)
		analyses = append(analyses, analysis)
		modeMap[analysis.PrimaryFailure] = append(modeMap[analysis.PrimaryFailure], analysis)
		report.FailingCases++
	}

	report.FailRate = float64(report.FailingCases) / float64(len(results))

	// 计算breakdown
	for mode, list := range modeMap {
		var totalScore float64
		var examples []string
		for i, a := range list {
			totalScore += a.LLMScore
			if i < 3 {
				examples = append(examples, a.Query)
			}
		}
		report.Breakdown = append(report.Breakdown, FailureBreakdown{
			Mode:        mode,
			Count:       len(list),
			Percentage:  float64(len(list)) / float64(report.FailingCases) * 100,
			AvgLLMScore: totalScore / float64(len(list)),
			Examples:    examples,
		})
	}

	// 按数量降序排列
	sort.Slice(report.Breakdown, func(i, j int) bool {
		return report.Breakdown[i].Count > report.Breakdown[j].Count
	})

	// 生成TopIssues和Recommendations
	report.TopIssues = generateTopIssues(report.Breakdown)
	report.Recommendations = generateRecommendations(report.Breakdown)

	return report
}

func generateTopIssues(breakdown []FailureBreakdown) []string {
	var issues []string
	for i, b := range breakdown {
		if i >= 3 {
			break
		}
		issues = append(issues, fmt.Sprintf(
			"%s：%d个case（%.1f%%），平均LLM评分%.2f",
			b.Mode, b.Count, b.Percentage, b.AvgLLMScore,
		))
	}
	return issues
}

func generateRecommendations(breakdown []FailureBreakdown) []string {
	var recs []string
	for _, b := range breakdown {
		switch b.Mode {
		case FailureNoRelevantChunk:
			recs = append(recs, "优先级：HIGH - 扩充文档库或检查是否有内容缺失")
		case FailureChunkRankedLow:
			recs = append(recs, "优先级：HIGH - 尝试hybrid search或更好的embedding模型")
		case FailureHallucination:
			recs = append(recs, "优先级：MEDIUM - 强化prompt中的grounding指令")
		case FailureIncomplete:
			recs = append(recs, "优先级：LOW - 优化prompt中的输出格式要求")
		}
	}
	return recs
}

// PrintReport 打印分析报告
func PrintReport(report *ErrorReport) {
	fmt.Println("\n========== 错误分析报告 ==========")
	fmt.Printf("分析总数：%d\n", report.TotalAnalyzed)
	fmt.Printf("失败案例：%d（%.1f%%）\n", report.FailingCases, report.FailRate*100)

	fmt.Println("\n---------- 错误分布 ----------")
	for _, b := range report.Breakdown {
		fmt.Printf("  %-40s %3d个  %.1f%%  LLM均分=%.2f\n",
			b.Mode, b.Count, b.Percentage, b.AvgLLMScore)
		for _, ex := range b.Examples {
			fmt.Printf("    - %s\n", ex)
		}
	}

	fmt.Println("\n---------- 主要问题 ----------")
	for i, issue := range report.TopIssues {
		fmt.Printf("  %d. %s\n", i+1, issue)
	}

	fmt.Println("\n---------- 改进建议 ----------")
	for _, rec := range report.Recommendations {
		fmt.Printf("  * %s\n", rec)
	}
}

// 改进策略1：调整Prompt减少幻觉
func buildGroundedPrompt(query string, chunks []string) string {
	context := ""
	for i, c := range chunks {
		context += fmt.Sprintf("[文档%d]\n%s\n\n", i+1, c)
	}

	return fmt.Sprintf(`你是一个严格基于文档的问答助手。

重要规则：
1. 只使用以下文档中的信息回答问题
2. 如果文档中没有相关信息，回答"根据现有文档，无法回答此问题"
3. 不要使用文档之外的任何知识
4. 回答简洁，不超过200字

参考文档：
%s

用户问题：%s

回答：`, context, query)
}

// 改进策略2：检测词汇鸿沟
func detectVocabMismatch(query string, chunkTexts []string) bool {
	// 简化实现：检查query中的关键词是否在chunks中出现
	queryWords := tokenize(query)
	allChunkText := ""
	for _, ct := range chunkTexts {
		allChunkText += ct + " "
	}

	matchCount := 0
	for _, word := range queryWords {
		if len(word) > 2 && contains(allChunkText, word) {
			matchCount++
		}
	}

	// 如果少于30%的关键词匹配，可能有词汇鸿沟
	return float64(matchCount)/float64(len(queryWords)) < 0.3
}

func tokenize(text string) []string {
	// 简化：按空格分词
	words := []string{}
	current := ""
	for _, ch := range text {
		if ch == ' ' || ch == '，' || ch == '。' || ch == '？' {
			if current != "" {
				words = append(words, current)
				current = ""
			}
		} else {
			current += string(ch)
		}
	}
	if current != "" {
		words = append(words, current)
	}
	return words
}

func contains(text, word string) bool {
	return len(text) > 0 && len(word) > 0 &&
		// 简单子字符串匹配
		(func() bool {
			for i := 0; i <= len(text)-len(word); i++ {
				if text[i:i+len(word)] == word {
					return true
				}
			}
			return false
		})()
}

// 改进策略3：Hybrid Search（向量+关键词）
type HybridSearchConfig struct {
	VectorWeight  float64 // 向量检索权重
	KeywordWeight float64 // 关键词检索权重
	K             int
}

// RRF (Reciprocal Rank Fusion) 合并两个排名列表
func RRF(vectorRanks, keywordRanks []string, k int) []string {
	scores := make(map[string]float64)

	for i, id := range vectorRanks {
		scores[id] += 1.0 / float64(60+i+1) // RRF标准公式
	}
	for i, id := range keywordRanks {
		scores[id] += 1.0 / float64(60+i+1)
	}

	// 按分数排序
	type kv struct {
		id    string
		score float64
	}
	var ranked []kv
	for id, score := range scores {
		ranked = append(ranked, kv{id, score})
	}
	sort.Slice(ranked, func(i, j int) bool {
		return ranked[i].score > ranked[j].score
	})

	result := make([]string, 0, k)
	for _, item := range ranked {
		if len(result) >= k {
			break
		}
		result = append(result, item.id)
	}
	return result
}

// evals/confusion_matrix.go
package main

import "fmt"

// ConfusionMatrix 二分类混淆矩阵（相关/不相关）
type ConfusionMatrix struct {
	TP int // True Positive：检索到且相关
	FP int // False Positive：检索到但不相关
	TN int // True Negative：未检索到且确实不相关
	FN int // False Negative：未检索到但应该相关
}

func BuildConfusionMatrix(results []EvalResult, k int) ConfusionMatrix {
	var cm ConfusionMatrix
	for _, r := range results {
		expectedSet := make(map[string]bool)
		for _, id := range r.ExpectedIDs {
			expectedSet[id] = true
		}

		retrievedSet := make(map[string]bool)
		top := r.RetrievedIDs
		if len(top) > k {
			top = r.RetrievedIDs[:k]
		}
		for _, id := range top {
			retrievedSet[id] = true
		}

		for id := range retrievedSet {
			if expectedSet[id] {
				cm.TP++
			} else {
				cm.FP++
			}
		}
		for id := range expectedSet {
			if !retrievedSet[id] {
				cm.FN++
			}
		}
	}
	return cm
}

func (cm ConfusionMatrix) Precision() float64 {
	if cm.TP+cm.FP == 0 {
		return 0
	}
	return float64(cm.TP) / float64(cm.TP+cm.FP)
}

func (cm ConfusionMatrix) Recall() float64 {
	if cm.TP+cm.FN == 0 {
		return 0
	}
	return float64(cm.TP) / float64(cm.TP+cm.FN)
}

func (cm ConfusionMatrix) F1() float64 {
	p, r := cm.Precision(), cm.Recall()
	if p+r == 0 {
		return 0
	}
	return 2 * p * r / (p + r)
}

func (cm ConfusionMatrix) Print() {
	fmt.Println("\n========== 混淆矩阵 ==========")
	fmt.Println("              预测相关    预测不相关")
	fmt.Printf("  实际相关：   TP=%-5d    FN=%-5d\n", cm.TP, cm.FN)
	fmt.Printf("  实际不相关： FP=%-5d    TN=%-5d\n", cm.FP, cm.TN)
	fmt.Println()
	fmt.Printf("  Precision = %.3f\n", cm.Precision())
	fmt.Printf("  Recall    = %.3f\n", cm.Recall())
	fmt.Printf("  F1 Score  = %.3f\n", cm.F1())
}

// 单调栈解法 O(n)
func dailyTemperatures(temps []int) []int {
	n := len(temps)
	result := make([]int, n)
	stack := []int{} // 存索引，维护单调递减栈

	for i := 0; i < n; i++ {
		// 当前温度比栈顶更高，弹出并计算距离
		for len(stack) > 0 && temps[i] > temps[stack[len(stack)-1]] {
			idx := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			result[idx] = i - idx
		}
		stack = append(stack, i)
	}
	// 栈中剩余的索引，等待天数为0（默认值）
	return result
}

/*
思路：
- 单调栈维护"还在等待更高温度"的日期索引
- 遍历时，如果今天比栈顶更暖，就更新栈顶的答案
- 每个元素最多进栈出栈一次 → O(n)

例子：[73, 74, 75, 71, 69, 72, 76, 73]
答案：[1,   1,  4,  2,  1,  1,  0,  0]
*/

type MinStack struct {
	stack    []int
	minStack []int // 辅助栈，存每个状态下的最小值
}

func NewMinStack() *MinStack {
	return &MinStack{}
}

func (s *MinStack) Push(val int) {
	s.stack = append(s.stack, val)
	// 辅助栈：如果新值更小（或辅助栈为空），压入新值；否则压入当前最小值
	if len(s.minStack) == 0 || val <= s.minStack[len(s.minStack)-1] {
		s.minStack = append(s.minStack, val)
	} else {
		s.minStack = append(s.minStack, s.minStack[len(s.minStack)-1])
	}
}

func (s *MinStack) Pop() {
	if len(s.stack) == 0 {
		return
	}
	s.stack = s.stack[:len(s.stack)-1]
	s.minStack = s.minStack[:len(s.minStack)-1]
}

func (s *MinStack) Top() int {
	return s.stack[len(s.stack)-1]
}

func (s *MinStack) GetMin() int {
	return s.minStack[len(s.minStack)-1]
}

/*
关键思路：
- 辅助栈和主栈保持同步（同时push/pop）
- 辅助栈每次存入"到目前为止的最小值"
- 所以GetMin()直接看辅助栈顶 → O(1)

面试追问：如果同一个最小值push了很多次，辅助栈会膨胀吗？
答：是的，但空间是O(n)，可以接受。
优化：只在新值<=当前最小值时才压辅助栈，pop时只有辅助栈顶=弹出值才同步pop。
*/