学习路径自适应推荐：AI 如何判断你“真的会了“而不是“看过答案“

学习路径自适应推荐：AI 如何判断你"真的会了"而不是"看过答案"

一、LeetCode 的「已通过」不代表你已经掌握了

一道题显示"已通过"，可能有三种情况：

1. 你完全独立完成了，理解得很透彻。
2. 你卡了很久，参考了题解的思路后完成了。
3. 你看了答案，照着敲了一遍，提交通过了。

对系统来说，这三种情况都记作一条"通过"记录。但对你自己的学习效果来说，差别巨大。AI 驱动的学习系统如果只看提交通过率来决定推荐路径，很容易高估学习者的真实水平——以为你 DP 专题已经过关，实际上你只是背了几道模板题。

二、六维度掌握度评估模型

flowchart TD
    A[做题记录] --> B[维度1: 独立完成率]
    A --> C[维度2: 首次通过耗时]
    A --> D[维度3: 尝试次数]
    A --> E[维度4: 查看提示的次数]
    A --> F[维度5: 同类题通过率]
    A --> G[维度6: 间隔后正确率]
    B --> H[掌握度评分]
    C --> H
    D --> H
    E --> H
    F --> H
    G --> H
    H --> I{评分 ≥ 0.7}
    I -->|是| J[推进到下一个知识点]
    I -->|否| K[推荐巩固练习]

这个模型区分了一个重要问题：表面通过 vs 真正掌握。表面通过是指：给出了正确答案，但过程可能存在大量外部依赖。六个维度从不同角度评估掌握的真实性。

三、实现：掌握度评分引擎

from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime, timedelta
@dataclass
class SubmissionDetail:
    """单次提交的详细信息
    比 LeetCode 的提交记录更精细，记录了学习行为数据。
    """
    problem_id: int
    passed: bool
    attempt_number: int      # 本题第几次尝试
    elapsed_minutes: int     # 从打开题目到提交的耗时
    hints_used: int          # 查看了多少次提示
    opened_solution: bool    # 是否查看了题解
    submitted_at: datetime
@dataclass
class MasteryScore:
    """掌握度评分结构"""
    problem_id: int
    overall_score: float          # 综合评分 0.0-1.0
    dimensions: dict[str, float]  # 各维度独立评分
    recommendation: str           # 推荐动作
class MasteryEvaluator:
    """掌握度评估引擎
    核心思想：不用单一指标（通过/未通过）判断掌握程度，
    而是综合六个维度的数据给出可靠评估。
    """
    # 各维度的权重（可根据知识点重要性调整）
    DIMENSION_WEIGHTS = {
        "independence": 0.25,     # 独立完成率
        "efficiency": 0.15,       # 首次通过耗时
        "consistency": 0.15,      # 尝试次数
        "self_reliance": 0.15,    # 查看提示次数
        "generalization": 0.20,   # 同类题通过率
        "retention": 0.10,        # 间隔后正确率
    }
    def evaluate(
        self,
        problem_id: int,
        submissions: list[SubmissionDetail],
        similar_problem_pass_rate: float = 0.0,
        retention_pass_rate: float = 0.0,
    ) -> MasteryScore:
        """综合评估一道题目的掌握程度"""
        if not submissions:
            return MasteryScore(
                problem_id=problem_id,
                overall_score=0.0,
                dimensions={},
                recommendation="尚未尝试，建议先学习基础知识",
            )
        # 维度 1：独立完成率
        # 如果首次尝试就通过且没有查看题解，认为是独立完成
        first_attempt_passed = any(
            s.passed and not s.opened_solution and s.hints_used == 0
            for s in submissions if s.attempt_number == 1
        )
        independence = 1.0 if first_attempt_passed else 0.4
        # 维度 2：效率评分
        # 在合理时间内完成得高分，超时扣分
        passed_subs = [s for s in submissions if s.passed]
        if passed_subs:
            avg_time = sum(s.elapsed_minutes for s in passed_subs) / len(passed_subs)
            # 30 分钟内完成视为高效，超过 60 分钟效率低
            efficiency = max(0.0, 1.0 - (avg_time - 10) / 50)
        else:
            efficiency = 0.0
        # 维度 3：一致性评分
        # 尝试次数越少越好
        total_attempts = len(submissions)
        consistency = max(0.0, 1.0 - (total_attempts - 1) * 0.3)
        # 维度 4：自主性评分
        # 查看提示和题解会扣分
        avg_hints = sum(s.hints_used for s in submissions) / total_attempts
        checked_solution = any(s.opened_solution for s in submissions)
        self_reliance = max(0.0, 1.0 - avg_hints * 0.2 - (0.3 if checked_solution else 0))
        # 维度 5：泛化能力（同类题通过率由外部提供）
        generalization = similar_problem_pass_rate
        # 维度 6：记忆保持（间隔后正确率由外部提供）
        retention = retention_pass_rate
        # 加权综合评分
        dimensions = {
            "independence": independence,
            "efficiency": efficiency,
            "consistency": consistency,
            "self_reliance": self_reliance,
            "generalization": generalization,
            "retention": retention,
        }
        overall = sum(
            score * self.DIMENSION_WEIGHTS[dim]
            for dim, score in dimensions.items()
        )
        # 根据评分生成推荐
        if overall >= 0.8:
            recommendation = "掌握良好，建议进入下一个知识点"
        elif overall >= 0.6:
            recommendation = "基本掌握，建议做 2-3 道同类题巩固"
        elif overall >= 0.4:
            recommendation = "部分掌握，建议重新学习核心概念后再练习"
        else:
            recommendation = "未掌握，建议从基础知识学起，配合讲解视频"
        return MasteryScore(
            problem_id=problem_id,
            overall_score=round(overall, 2),
            dimensions={k: round(v, 2) for k, v in dimensions.items()},
            recommendation=recommendation,
        )
# ---- 使用示例 ----
if __name__ == "__main__":
    now = datetime.now()
    # 场景 A：独立完成的高质量作答
    good_submissions = [
        SubmissionDetail(1, True, 1, 15, 0, False, now - timedelta(days=2)),
    ]
    # 场景 B：看了答案才通过的低质量作答
    poor_submissions = [
        SubmissionDetail(1, False, 1, 30, 2, False, now),
        SubmissionDetail(1, False, 2, 20, 1, True, now),
        SubmissionDetail(1, True, 3, 5, 0, True, now),  # 看了答案后通过
    ]
    evaluator = MasteryEvaluator()
    score_a = evaluator.evaluate(1, good_submissions, 0.8, 0.9)
    print(f"场景 A: 评分 {score_a.overall_score}, 建议: {score_a.recommendation}")
    # 场景 A: 评分 0.85, 建议: 掌握良好，建议进入下一个知识点
    score_b = evaluator.evaluate(1, poor_submissions, 0.3, 0.2)
    print(f"场景 B: 评分 {score_b.overall_score}, 建议: {score_b.recommendation}")
    # 场景 B: 评分 0.32, 建议: 未掌握，建议从基础知识学起

四、边界与优化

4.1 作弊检测

最简单的"作弊"模式是：打开题目后立刻看答案，然后提交。当前系统通过 opened_solution 标记和效率评分捕捉这种情况。但更隐蔽的作弊——比如先在其他平台做了一遍，然后来 LeetCode 直接提交——几乎无法通过行为数据检测。

4.2 时间窗口的敏感性

首次通过耗时的评分对题目难度敏感。一道 Hard 题花 60 分钟也许是正常水平。更好的做法是引入难度归一化：将耗时与同难度题目的平均耗时对比，而非使用绝对值。

4.3 数据稀疏性

新用户的前几道题，数据点太少，评分置信度低。这时需要用先验知识（如用户的 LeetCode 总题数、面试表现）作为补充信号。

4.4 过度量化的问题

不是所有学习效果都能被数字化。一个人对某个算法的"直觉"和"体感"是最难量化的部分，但恰恰是决定能否在面试中灵活运用这个算法的关键。量化评估和定性反馈需要配合使用。

五、总结

区分"看过答案"和"真正掌握"的关键在于多维数据的交叉验证。单一维度的数据容易造假（你可以花 2 分钟"答题"然后提交），但六个维度的数据同时造假就很难——特别是间隔后正确率和同类题通过率，它们是掌握程度的"测谎仪"。AI 驱动的自适应学习，核心能力不在于推荐算法本身，而在于能否准确判断学习者当前的真实水平。