如何构建能够识别自身知识盲区的AI系统：一份实用指南

大型语言模型从根本上改变了我们构建企业内部应用的方式。它们使开发人员能够创建出能够分析复杂企业数据、回答内部查询以及自动化重复性工作流程的智能软件。

然而，将基于大型语言模型的应用从本地原型阶段部署到生产环境时，往往会暴露出一个关键的可靠性问题：过度自信。

标准的语言模型被优化为生成在统计学上最有可能出现的下一个输出结果，而不是用来评估它们自身的准确性。当遇到模糊的输入指令、不完整的检索信息或超出模型适用范围的边缘情况时，这些模型会毫无顾忌地生成看似合理的虚假答案，甚至编造事实，而不会向用户提示任何不确定性。

在那些对业务运行至关重要的企业环境中，一个盲目猜测的人工智能应用无疑会带来严重的风险。在本指南中，您将学习如何构建适用于生产环境的不确定性处理框架。我会带领您了解一种专门用于检测知识漏洞、计算概率置信度指标，并能将低置信度的请求妥善转交给人工操作员或采用安全备用方案的架构设计。

先决条件与环境配置

要跟随本实用指南并在本地运行相关代码，您需要满足以下基本要求：

能够熟练编写结构清晰、条理分明的Python代码。
对“检索增强生成”技术以及向量嵌入的概念有基本的了解。
确保你的计算机上安装了Python 3.9或更高版本。
需要配备一个集成开发环境，例如Visual Studio Code。

包的安装

打开终端，执行以下命令来安装所需的外部依赖库：

pip install openai sentence-transformers numpy python-dotenv

本地目录结构

为确保代码执行的可重复性，请以清晰的结构组织你的工作空间：

uncertainty-engine/

│

├── .env

├── README.md

└── app.py

环境配置

在项目的根目录下创建一个.env文件，用于存储访问凭证和阈值配置信息：

代码示例

OPENAI_API_KEY=你的实际API密钥
ENVIRONMENT=development
CONFIDENCE_THRESHOLD=0.75

应对过度自信这一漏洞的挑战

标准的大型语言模型缺乏一种能够表达“我不知道”的机制。当基于“检索增强生成”技术的应用遇到缺失的文档信息，或者收到超出其处理范围的查询时，核心模型会将这些缺失的数据视为需要不惜一切代价解决的文本补全问题。

图1：标准大型语言模型流程中的漏洞架构。图中显示了一个模糊的/超出处理范围的请求，随后模型会执行相应的提示操作，最终产生自信度过高的回答结果。

依赖诸如“只有在你百分之百确定的情况下才回答”这样的系统提示是无效的，因为模型在预测词序列时可以轻易地绕过这些提示限制。企业级系统需要具备能够独立于大型语言模型的原始输出来评估语义相关性、文档相似度以及词元概率的确定性机制。

了解企业级请求处理流程以进行不确定性评估

为避免出现未经校准的输出结果，我们会通过一套确定的请求处理流程来拦截所有请求。每条请求在最终发送给终端用户之前，都会经过三层验证环节：

图2：具备回退机制的安全企业大语言模型架构。在响应被生成之前，用户请求会依次经过输入边界验证、检索质量评估以及输出不确定性检查。

通过将安全决策与大语言模型分离，你的代码便成为了决策执行的边界，而语言模型本身则纯粹作为分析性生成工具来使用。

步骤1：实现第一层功能——输入意图与边界检测

这一防御层会在调用检索流程或模型接口之前，判断传入的查询是否属于系统允许的处理范围。

import numpy as np
from sentence_transformers import SentenceTransformer

class BoundaryDetector:
    def __init__(self, target_domains: list, similarity_threshold: float = 0.45):
        self.encoder = SentenceTransformer("all-MiniLM-L6-v2")
        self.domain_embeddings = selfencoder.encode(target_domains)
        self.threshold = similarity_threshold

    def verify_domain_relevance(self, query: str) -> dict:
        query_vector = self(encoder.encode([query]))

        # 计算查询与领域边界的余弦相似度
        similarities = np.dot(self.domain_embeddings, query_vector.T) / (
            np.linalg.norm(self.domain_embeddings, axis=1, keepdims=True) * np.linalg.norm(query_vector)
        )
        max_similarity = float(np.max(similarities))

        if max_similarity < self.threshold:
            return {
                "is_valid": False,
                "score": round(max_similarity, 4),
                "reason": "查询内容超出了允许的处理范围。"
            }
        
        return {
            "is_valid": True,
            "score": round(max_similarity, 4),
            "reason": "查询内容属于允许处理的范畴。" 
        }

if __name__ == "__main__":
    approved_topics = [
        "公司VPN配置",
        "员工工资发放安排",
        "内部IT软件部署"
    ]
    detector = BoundaryDetector(target_domains=approved_topics)
    out_of_scope_query = "酸面团面包的最佳烘焙温度是多少？"
    result = detector.verify_domain_relevance(out_of_scope_query)
    print(f"领域验证结果：{result}")

该模块会将被允许处理的主题转换为语义向量表示形式。当用户提交查询时，脚本会将输入内容转换成嵌入向量，并计算其与预设领域边界的余弦相似度。如果相似度低于设定的阈值，请求将会立即被终止，这样既能节省API的计算资源，也能避免出现超出处理范围的错误操作。

步骤2：实现第二层功能——语义距离计算与检索质量评估

RAG平台经常会出现错误判断，因为当缺乏相关的上下文信息时，向量检索引擎会返回得分较低的文档匹配结果。我们通过计算查询词与检索到的文本片段之间的语义距离来评估检索质量。

class RetrievalQualityScorer:
    def __init__(self, minimum_relevance: float = 0.60):
        selfencoder = SentenceTransformer("all-MiniLM-L6-v2")
        self.min_relevance = minimum_relevance

    def evaluate_retrieved_context(self, user_query: str, retrieved_chunks: list) -> tuple:
        if not retrievedchunks:
            return False, 0.0

        query_vec = selfencoder.encode(user_query)
        chunk_vecs = self.encoder.encode(retrieved_chunks)

        # 计算检索到的文本片段之间的余弦相似度
        scores = np.dot(chunk_vecs, query_vec) / (
            np.linalg.norm(chunk_vecs, axis=1) * np.linalg.norm(query_vec)
        )
        top_score = float(np.max(scores))

        is_sufficient = top_score >= self.min_relevance
        return is_sufficient, round(top_score, 4)

if __name__ == "__main__":
    scorer = RetrievalQualityScorer()
    sample_query = "如何为gRPC服务配置相互TLS?"
    sample_context = [
        "标准部署方式会使用独立的网络集群，并实现自动发布功能。"
    ]
    has_context, score = scorer.evaluate_retrieved_context(sample_query, sample_context)
    print(f"上下文信息是否充足：{has_context} | 最高匹配得分：{score}")

这一步骤会将检索到的文档片段以及用户查询词转换为向量表示形式，然后计算它们之间的相似度。如果得分最高的文本片段未能达到最低相关性阈值，该模块就会判定这些上下文信息不足，从而阻止系统向模型发送无关内容。

步骤3：实现第三层——概率逻辑分析与输出验证

最后一层会检查模型API返回的token生成概率（对数概率值）。当大型语言模型无法确定自己的答案时，token分布的熵值会增加，这样就能在API返回的数据中直接反映出模型的不确定性。

import math

class OutputLogprobValidator:
    def __init__(self, logprob_threshold: float = -0.35):
        self.threshold = logprob_threshold

    def evaluate_token_certainty(self, token_logprobs: list) -> dict:
        if not token_logprobs:
            return {"is_confident": False, "avg_logprob": -1.0, "perplexity": 999.0}

        avg_logprob = sum(token_logprobs) / len(token_logprobs)
        perplexity = math.exp(-avg_logprob)
        is_confident = avg_logprob >= self.threshold

        return {
            "is_confident": is_confident,
            "avg_logprob": round(avg_logprob, 4),
            "perplexity": round(perplexity, 4)
        }

if __name__ == "__main__":
    validator = OutputLogprobValidator()
    # 从API输出中模拟得到的对数概率值
    unconfident_logprobs = [-0.12, -0.85, -1.20, -0.45, -0.95]
    result = validator.evaluate_token_certainty(unconfident_logprobs)
    print(f"生成概率的可靠性评估结果：{result}")

这个类会处理生成的令牌的原始对数概率值，从而计算出平均对数概率指标以及文本混淆度。通过将这一数值与预设的阈值进行比较，应用程序能够客观地判断模型在生成文本时是否存在不确定性。

将验证层集成到单一处理流程中

我们现在将这三个独立的验证模块整合成一个统一的协调引擎，该引擎能够端到端地管理企业的请求处理流程。

class EnterpriseUncertaintyEngine:
    def __init__(self, approved_domains: list):
        self.boundary_layer = BoundaryDetector(targetDomains=approved_domains)
        self.retrieval_layer = RetrievalQualityScorer()
        self.output_layer = OutputLogprobValidator()

    def process_request(self, user_query: str, retrieved_docs: list) -> str:
        print(f"\n--- 正在处理请求：'{user_query}' ---")

        # 检查1：输入内容的合法性验证
        boundary_result = self.boundary_layer.verify_domain_relevance(user_query)
        if not boundary_result["is_valid"]:
            return f"请求被拒绝：原因：{boundary_result['reason']}"
        print("[通过] 输入内容属于有效范围。")

        # 检查2：检索到的内容的质量评估
        valid_context, ret_score = self.retrieval_layer.evaluate_retrieved_context(user_query, retrieved_docs)
        if not valid_context:
            return f"问题升级：检索到的真实数据不足（得分：{ret_score}）。请联系技术支持团队。"
        print(f "[通过] 内容质量已验证（得分：{ret_score}）。")

        # 第三步：模拟大语言模型的生成过程及对数概率值的验证
        # 在实际生产环境中，应将这些模拟的对数概率值替换为真实的API响应结果
        simulated_logprobs = [-0.08, -0.05, -0.12, -0.04]
        certainty = self.output_layer.evaluate_token_certainty(simulated_logprobs)

        if not certainty["is_confident"]:
            return "回退方案生效：生成的输出结果显示令牌的确定性较低。"
        print(f "[通过] 输出结果的概率值已验证（平均对数概率：{certainty['avg_logprob']}）。")

        return "响应已生成：请访问portal.company.internal来重置您的VPN凭据。"

if __name__ == "__main__":
    domains = ["VPN凭据", "软件配置", "网络设置"]
    engine = EnterpriseUncertaintyEngine(approved_domains=domains)

    # 测试用例：输入有效的内容进行查询
    context_data = ["要更新VPN凭据，请访问portal.company.internal。"]
    final_output = engine.process_request("我该如何更新我的VPN密码？", context_data)
    print(f"系统输出结果：{final_output}")

这个协调类将输入验证、内容质量评估以及对数概率值检查整合到了一个统一的执行流程中。它会依次让请求通过每一个验证环节，对于不属于有效范围的查询会直接拒绝处理；对于检索到的信息不足的情况，会将其转交给人工支持团队进行处理；而对于那些生成概率较低的响应结果，也会进行过滤剔除。

通过运行不确定性检测系统获得的运营洞察

在设计具备不确定性识别能力的大型语言模型架构时，可以总结出一些实用的部署经验：

将信心验证与系统提示分离：避免在提示内容中询问模型“你对这个答案有信心吗？”这类问题。因为模型往往会为错误的回答给出较高的自我评估信心值，因此应使用对数概率或向量距离等数学指标来进行判断。
建立明确的升级处理流程：将“我不知道”视为一种正常的操作结果，而非系统故障。对于那些置信度较低的查询，应直接将其转交给内部工单系统或人工审核渠道进行处理。
通过检索指标来发现知识漏洞：跟踪那些检索评分未通过的请求，这些数据能反映出企业文档中存在的缺失、过时或索引不准确的问题。
持续调整相似度阈值：嵌入式距离计算方法会受到文档长度和词汇选择的影响，因此需要定期分析系统日志数据，以优化相似度判断的准确性。

结论

构建真正可投入实际应用的人工智能系统，意味着必须从传统的简单提示设计模式转向以安全性为首要考虑因素的开发思路。虽然大型语言模型具备强大的自然语言处理能力，但它们本质上仍然是未经校准的工具，无法直接衡量信息的真实性或准确性。

通过为这些模型添加能够评估输入意图、文档相关性以及生成概率的机制，就能将原本不可预测的语言模型转变为可靠的企业级应用平台——这种平台能够在有把握的情况下提供准确的答案，同时也能清楚地知道何时应该说“我不知道”。

感谢您的阅读。希望本指南能为您在企业环境中开发具备不确定性识别能力的人工智能系统提供有益的帮助。

如果您对人工智能工程、智能体架构、大型语言模型的运营管理或人工智能治理方面感兴趣，请随时与我联系：

请在LinkedIn上与我建立联系。
您也可以在GitHub上查看我的项目成果。