
模型刚部署的时候,回答精准、逻辑清晰、响应速度也很快,可随着会话次数变多、使用时间变长,模型就越来越笨。要么回答前后矛盾、逻辑混乱,要么响应延迟越来越高,偶尔还会出现无意义乱码、重复话术,甚至凭空生成错误信息。通常我们会觉得参数设置不合理,或是提示词写得不够优质,但其实绝大多数场景下,问题根源根本不在模型本身,而是推理阶段的脏数据污染。和训练阶段的数据集污染不同,大模型推理污染是发生在实时交互过程中的动态问题,用户每一次对话、每一轮上下文留存,都会产生大量无效、冗余、错误的数据,持续干扰模型的推理判断。
简单来说,大模型推理就像人的思考过程,干净的信息输入才能产出精准的结果,而上下文冗余、历史脏会话、无效Token这三类脏数据,就像杂乱的杂念,会不断扰乱模型的注意力、占用推理资源、扭曲输出逻辑。传统的清洗方案大多是人工筛查、简单截断,不仅效率极低,还无法适配实时推理场景,很容易丢失有效信息。今天我们仔细分析搞懂如何从源头治理推理污染,低成本提升大模型推理精度、速度与稳定性。

上下文冗余是大模型推理场景中最普遍、最易被忽视的脏数据类型,几乎所有长会话大模型应用都会存在这类问题,目前对话机器人、智能客服、企业知识库问答等主流大模型应用,均默认开启上下文记忆功能,用于实现连续对话交互。而上下文冗余指的是会话留存中,与当前提问无关、重复表述、过期失效的历史对话内容。比如用户连续多轮修改同一问题、反复追问同类内容、多次切换对话话题后残留的老旧话题内容,都属于典型的冗余上下文。这类脏数据是无差别留存上下文导致的必然结果,具备极强的隐蔽性。
很容易误以为上下文越多,模型理解越全面,这是核心错误认知。实际上,过量的冗余上下文不仅无法提升回答质量,反而会持续干扰模型推理,不会带来任何正向增益,是典型的无效数据累加问题,长此以往带来的核心业务危害:

上下文冗余属于良性脏数据,本身不包含错误、违规语义,仅存在无效累加、资源占用问题,无法通过常规风控、错误检测机制识别,必须依靠语义筛选、话题聚类等专项机制清洗。
历史脏会话是指大模型会话记录中,所有能够干扰模型正常推理、破坏输出准确性的劣质对话内容,具备极强的污染性和滞留性,是大模型越用越差的核心元凶。脏数据的危害最大、最易导致模型输出失真的恶性脏数据,区别于无危害的冗余数据,其本身包含错误、冲突、无效语义,会直接扭曲推理逻辑.
脏会话的核心类型:

大模型上下文推理具备天然记忆延续性,不会自动甄别历史内容的真伪与有效性,会默认所有留存会话均为有效参考依据。脏会话会持续参与每一轮推理的逻辑构建,让模型复刻错误、冲突的推理逻辑,形成固化的错误思维惯性。
在企业知识库问答、智能办公助手、政企客服等高精准需求场景中,历史脏会话的危害被无限放大。单次错误业务会话留存后,会持续污染后续所有同类推理结果,即便优化提示词、调整参数,也无法根治输出失真、逻辑混乱的问题,最终导致模型业务落地失效。
大模型无法直接识别自然文字、符号,所有输入输出、上下文内容,都会被分词器拆解为最小语义单元Token。模型的编码计算、注意力匹配、存储计费,全部以Token为最小单位执行,Token质量直接决定推理效率与精度。
无效Token是指不承载有效语义、无法为推理提供业务价值,仅占用算力、窗口空间、计费配额的Token单元,广泛分布在每一轮模型交互中,体量细碎、数量庞大、隐蔽性极强。无效Token是最底层、最细碎的基础脏数据单元,是引发上下文冗余、会话污染的底层诱因,极易忽略。
无效Token的核心类型:

无效Token对业务的影响:
上下文窗口是大模型推理的核心硬件与结构限制,也是脏数据产生危害的核心载体,无论是开源的Llama、Qwen模型,还是各种开放的API调用模型,均存在固定的上下文Token窗口上限。该上限由模型结构、训练参数、硬件部署条件决定,无法无限制扩容,是大模型推理的硬性边界。
上下文窗口总容量固定,遵循此消彼长原则:
脏数据占比大小也影响着模型的性能表现:
模型注意力计算的时间复杂度与窗口Token数量正相关,脏Token越多,矩阵计算量越大。大量无效计算会直接拉高推理延迟,高并发场景下极易出现接口超时、服务卡顿、甚至熔断问题,严重影响用户交互体验。
自注意力机制是大模型理解语义、关联上下文、精准输出的核心核心,脏数据通过干扰注意力权重分配,引发注意力偏移,最终破坏推理效果。
注意力机制核心逻辑:
上下文冗余、历史脏会话、无效Token的大量存在,会产生海量无效语义单元,持续分摊、稀释核心有效Token的权重,导致模型注意力无法聚焦核心需求,出现重点偏移、判断失准的问题:
通俗的理解该原理等同于人类思考时被持续杂音、错误提示干扰,思考速度变慢、判断失误。长期注意力干扰会大幅提升模型输出随机性,导致模型推理稳定性持续下降,出现“时准时不准”的疑难问题。
推理逻辑异化是脏数据最深度、最致命的隐性污染效果,区别于表层的性能、精度问题,该问题会永久扭曲模型实时推理逻辑。窗口挤占、注意力偏移属于表层性能问题,可通过简单优化快速修复;而逻辑异化属于深层逻辑缺陷,会改变模型的推理规则,形成固化错误惯性,修复难度极大、滞留性极强。
逻辑异化核心原理:

各类脏数据的异化表现:
很多企业落地后期,即便完成模型微调、提示词优化、知识库升级,模型性能依然无法恢复,核心原因就是推理逻辑已被长期脏数据污染,形成固化错误逻辑。问题根源不在模型参数,而在实时推理数据的持续污染。
针对这几类脏数据的污染特性,结合实际构建推理脏数据清洗机制,采用“三层递进、逐类清零”架构,无需修改大模型底层参数、无需重新微调模型、无额外算力消耗,可直接对接现有对话系统、模型接口、知识库应用,轻量化部署。

三层架构逐级递进、层层兜底,底层清理细碎脏数据,中层拦截恶性污染源,上层优化全局推理上下文,全程实时自动化执行,彻底解决传统人工清洗滞后、低效、易丢数据、误判率高的痛点。
针对无效Token隐蔽性强、数量庞大、碎片化分布的特点,机制采用“实时检测-智能过滤-自动修复”的毫秒级全自动清洗流程,具体流程说明:

实践可清理85%以上的底层无效脏Token,压缩输入输出Token总量20%-40%,大幅降低算力消耗与接口计费成本,彻底解决细碎Token挤占上下文窗口的问题。
针对历史脏会话的恶性污染问题,机制采用“语义编码-脏度评分-冲突甄别-自动剔除”全自动化流程,精准净化脏会话、保留有效会话,具体逻辑拆解说明:

针对上下文冗余累积、重点模糊、窗口挤占的痛点,机制采用“话题聚类-权重排序-时效筛选-智能精简”方案,在不丢失有效信息的前提下,实现上下文轻量化优化,具体流程说明:

可保留95%以上的核心有效信息,同时精简30%-50%的冗余上下文,彻底解决窗口挤占、注意力偏移问题,显著提升模型推理精准度与响应速度。
基于三层流水线清洗喂给大模型的多轮对话上下文:底层去无效字符与重复短句;中层按有效性、相关性、合规、兜底四维度逐轮打分过滤;上层KMeans聚类只留当前话题、再按时间排序与token截断,保证送进prompt的历史干净相关不超预算,最后接入腾讯混元 hy3-preview 实答验证,完整呈现“脏数据进、干净上下文出、回答更聚焦”的效果;
"""
全自动清洗大模型推理污染 —— 三层流水线
底层 TokenCleaner :无效字符 / 冗余短句清洗,保证进入历史的每段文本本身干净
中层 SessionPurifier :四维度脏度打分,把灌水、跑题、违规、模型兜底句挡在上下文外
上层 ContextReducer :话题聚类保留当前话题 + 按时间排序 + token 截断,喂给模型前最后瘦身
入口:LLMDirtyDataCleanPipeline.run(raw_chat_history, latest_user_msg)
"""
import re
import tiktoken
from modelscope import snapshot_download
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.cluster import KMeans
from dataclasses import dataclass
from typing import List, Dict
# ===================== 配置项 =====================
MAX_CONTEXT_TOKEN = 2048 # 上下文窗口上限
DIRTY_SCORE_THRESHOLD = 60 # 脏会话阈值,低于60判定脏会话(逐轮打分,有一轮脏就丢一轮)
TOPIC_SIM_THRESHOLD = 0.2 # 与最新提问的语义相关度低于此值 → 视为跑题扣分
ENCODER = tiktoken.get_encoding("cl100k_base")
cache_dir = "D:\\modelscope\\hub"
embedding_model_dir = snapshot_download(
model_id="sentence-transformers/all-MiniLM-L6-v2",
cache_dir=cache_dir,
revision="master"
)
EMBED_MODEL = SentenceTransformer(embedding_model_dir)
# ===================== 腾讯混元大模型接入(TokenHub平台) =====================
from openai import OpenAI
api_key = os.environ.get('TENCENT_API_KEY')
llm_client = OpenAI(
api_key=api_key,
base_url="https://tokenhub.tencentmaas.com/v1",
)
model_name = "hy3-preview"
def llm_invoke(prompt: str, system_prompt: str = "你是一个专业的AI Agent评测裁判。请严格按照评测规则输出JSON格式结果,不要输出任何多余内容。") -> str:
"""调用腾讯混元大模型(LLM-as-Judge / 上下文精简 / 业务问答通用入口)"""
import time as _time
from openai import APIStatusError
last_err = None
for attempt in range(1, 4):
try:
response = llm_client.chat.completions.create(
model=model_name,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
return response.choices[0].message.content
except APIStatusError as e:
last_err = e
status = getattr(e, "status_code", None)
# 429 限流 / 5xx 网关是瞬态错误,指数退避重试;确定性错误立即抛出
if status in (429, 500, 502, 503, 504) and attempt < 3:
wait = 3.0 * (2 ** (attempt - 1))
print(f"[llm] 第{attempt}次被限流/繁忙(status={status}),{wait:.0f}s 后重试")
_time.sleep(wait)
continue
raise
raise last_err
# 会话数据结构
@dataclass
class ChatTurn:
role: str # user / assistant
content: str
timestamp: float
dirty_score: float = 100.0
embedding: List[float] = None
# ===================== 底层:无效Token清洗层 =====================
class TokenCleaner:
# 清理空白、重复换行、乱码、无效符号
PATTERN_INVALID_CHAR = re.compile(r"(\s{2,})|([^\u4e00-\u9fa5a-zA-Z0-9\.,;:!?,。;:?!\n])")
PATTERN_MULTI_NEWLINE = re.compile(r"\n{2,}")
@staticmethod
def clean_text(raw_text: str) -> str:
# 1. 清理特殊无效字符
text = TokenCleaner.PATTERN_INVALID_CHAR.sub("", raw_text)
# 2. 合并多个换行
text = TokenCleaner.PATTERN_MULTI_NEWLINE.sub("\n", text)
return text.strip()
@staticmethod
def count_token(text: str) -> int:
tokens = ENCODER.encode(text)
return len(tokens)
@staticmethod
def remove_redundant_tokens(raw_text: str) -> str:
"""删除重复冗余短句(简单去重,可替换LLM摘要)"""
lines = [line.strip() for line in raw_text.split("\n") if len(line.strip())>3]
unique_lines = []
seen = set()
for line in lines:
if line not in seen:
seen.add(line)
unique_lines.append(line)
return "\n".join(unique_lines)
# ===================== 中层:历史脏会话净化层 =====================
class SessionPurifier:
# 模型兜底/拒答类句子:内容上没错误,但对后续推理毫无价值,属于"隐性污染"
FALLBACK_MARKS = ["我不知道", "无法回答", "作为AI", "抱歉,我", "对不起,我不能"]
# 违规词表(业务可按需扩充,这里只做演示)
BAD_WORDS = ["乱码测试", "破解", "非法"]
@staticmethod
def calc_dirty_score(turn: ChatTurn, latest_query: str) -> float:
"""四维度脏度打分:有效性 / 相关性 / 合规性 / 信息量,满分100,低分即脏"""
score = 100.0
content = turn.content
# ① 有效性扣分:内容太短无业务价值("好的""嗯"这类)
if len(content) < 10:
score -= 30
# ② 相关性扣分:与最新用户提问语义对立/无关(历史话题已切换,旧话题硬留着只会带偏模型)
emb_latest = EMBED_MODEL.encode(latest_query)
emb_turn = EMBED_MODEL.encode(content)
sim = cosine_similarity([emb_latest], [emb_turn])[0][0]
if sim < TOPIC_SIM_THRESHOLD:
score -= 25
# ③ 合规性扣分:违规关键词,一票重扣
for w in SessionPurifier.BAD_WORDS:
if w in content:
score -= 40
# ④ 信息量扣分:模型兜底句 / 高度重复(连续多轮"我不知道"会污染后续回复风格)
if any(m in content for m in SessionPurifier.FALLBACK_MARKS):
score -= 35
return max(0, score)
@staticmethod
def filter_dirty_chat(chat_list: List[ChatTurn], latest_query: str) -> List[ChatTurn]:
"""逐轮打分过滤:>= 阈值保留。只丢"脏轮",脏轮前后的好轮不受牵连"""
valid_turns = []
for turn in chat_list:
turn.dirty_score = SessionPurifier.calc_dirty_score(turn, latest_query)
if turn.dirty_score >= DIRTY_SCORE_THRESHOLD:
valid_turns.append(turn)
return valid_turns
# ===================== 上层:上下文冗余智能精简层 =====================
class ContextReducer:
@staticmethod
def topic_cluster(chat_list: List[ChatTurn]):
"""话题聚类:KMeans 把历史按语义分组,只保留与"最后一轮"同簇的当前话题。
中间话题被切换掉后,留在上下文里只会稀释模型对当前任务的注意力。"""
if len(chat_list) <= 1:
return chat_list
embeds = [EMBED_MODEL.encode(t.content) for t in chat_list]
kmeans = KMeans(n_clusters=min(3, len(chat_list)), random_state=42)
labels = kmeans.fit_predict(embeds)
latest_label = labels[-1]
current_topic_turns = [chat_list[i] for i, lab in enumerate(labels) if lab == latest_label]
return current_topic_turns
@staticmethod
def weight_sort(turns: List[ChatTurn]) -> List[ChatTurn]:
"""按时间权重排序(旧→新):多轮对话讲究时序,乱序喂模型会答非所问"""
return sorted(turns, key=lambda x: x.timestamp, reverse=False)
@staticmethod
def shrink_context(turns: List[ChatTurn], max_token: int):
"""token 截断:按顺序累加,超预算立即停(后面更晚的轮次宁可整段不要,也不截半句产生残缺上下文)"""
final_ctx = []
total_tok = 0
for t in turns:
cnt = TokenCleaner.count_token(t.content)
if total_tok + cnt <= max_token:
final_ctx.append(t)
total_tok += cnt
else:
break
return final_ctx
# ===================== LLM 智能精简层(可选,混元) =====================
class LLMRefiner:
"""用混元 LLM 替代 TokenCleaner 的简单去重(那句注释说的'可替换LLM摘要'):
对清洗后仍啰嗦/重复的历史轮次,让模型改写成简洁版,进一步压 token、留信息。"""
COMPRESS_SYSTEM_PROMPT = (
"你是对话压缩器。把给定的对话文本改写得更简洁:去掉重复啰嗦的表述,"
"保留全部事实信息(数字、名称、结论)。直接输出改写结果,不要解释。"
)
@staticmethod
def compress_turn(turn: ChatTurn) -> ChatTurn:
"""单轮压缩:LLM 改写;失败或无收益则原样返回(不影响主流程)"""
try:
before_tok = TokenCleaner.count_token(turn.content)
if before_tok < 15: # 太短不值得花一次 LLM 调用
return turn
rewritten = llm_invoke(turn.content,
system_prompt=LLMRefiner.COMPRESS_SYSTEM_PROMPT)
rewritten = (rewritten or "").strip()
if not rewritten or rewritten == turn.content:
return turn
after_tok = TokenCleaner.count_token(rewritten)
if after_tok < before_tok: # 只有真压短了才采用
t = ChatTurn(role=turn.role, content=rewritten,
timestamp=turn.timestamp, dirty_score=turn.dirty_score)
print(f"[llm-refine] {before_tok} → {after_tok} tok(省 {before_tok - after_tok})")
return t
return turn
except Exception as e:
print("[llm-refine] 压缩失败,保留原文:", type(e).__name__)
return turn
@classmethod
def compress_history(cls, turns: List[ChatTurn]) -> List[ChatTurn]:
return [cls.compress_turn(t) for t in turns]
# ===================== 全链路清洗入口 =====================
class LLMDirtyDataCleanPipeline:
"""串起三层:文本清洗 → 脏轮过滤 → 话题聚焦 + token 瘦身。
输出可直接拼进 prompt 的多轮 messages,附带各层过滤统计方便观测。"""
def run(self, raw_chat_history: List[ChatTurn], latest_user_msg: str,
use_llm_refine: bool = False) -> List[ChatTurn]:
# Step1 Token清洗:逐轮清洗无效字符、去掉重复冗余短句
cleaned_history = []
for turn in raw_chat_history:
clean_content = TokenCleaner.clean_text(turn.content)
clean_content = TokenCleaner.remove_redundant_tokens(clean_content)
turn.content = clean_content
cleaned_history.append(turn)
# Step2 脏会话过滤:灌水 / 跑题 / 违规 / 兜底句在这里被丢弃
valid_history = SessionPurifier.filter_dirty_chat(cleaned_history, latest_user_msg)
# Step3 话题聚类:只保留与最新一轮同话题的历史
topic_history = ContextReducer.topic_cluster(valid_history)
# Step4 按时间排序 + Token截断,控制最终上下文不超预算
sorted_history = ContextReducer.weight_sort(topic_history)
final_history = ContextReducer.shrink_context(sorted_history, MAX_CONTEXT_TOKEN)
# Step5(可选)LLM 智能精简:混元把啰嗦轮次改写成简洁版,只真压短才采用
if use_llm_refine:
final_history = LLMRefiner.compress_history(final_history)
print(f"[pipeline] 原始 {len(raw_chat_history)} 轮 → 清洗 {len(cleaned_history)} 轮 "
f"→ 过脏后 {len(valid_history)} 轮 → 聚类后 {len(topic_history)} 轮 "
f"→ 最终 {len(final_history)} 轮"
+ ("(含 LLM 精简)" if use_llm_refine else ""))
return final_history
# ============ 测试Demo:把 4 步逐层拆开打印 ============
if __name__ == "__main__":
import time
from sklearn.cluster import KMeans
def banner(s):
print("\n" + "=" * 64 + "\n " + s + "\n" + "=" * 64)
latest_input = "现在帮我写一份产品使用手册"
test_chat = [
ChatTurn(role="user", content=" 帮我写一个营销文案\n\n\n", timestamp=time.time()-120),
ChatTurn(role="assistant", content="下面给你文案。下面给你文案。", timestamp=time.time()-110),
ChatTurn(role="user", content="乱码测试,随便灌水闲聊", timestamp=time.time()-60),
ChatTurn(role="assistant", content="我不知道你在说什么。", timestamp=time.time()-50), # 兜底句
# 长啰嗦轮:简单去重/字符清洗对付不了(没有完全重复的行),留给 LLM 精简层演示
ChatTurn(role="assistant", content="好的,我来帮你写产品使用手册。写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。", timestamp=time.time()-40),
ChatTurn(role="user", content="现在帮我写一份产品使用手册", timestamp=time.time()),
]
# ───── Step 1 ─────
banner("Step 1 · 文本清洗(去重/去无效字符)")
cleaned = []
for t in test_chat:
before = t.content
t.content = TokenCleaner.clean_text(t.content)
t.content = TokenCleaner.remove_redundant_tokens(t.content)
cleaned.append(t)
print(f" [{t.role:<9}] {before!r:34s} → {t.content!r}")
# ───── Step 2 ─────
banner("Step 2 · 四维度脏度打分(满 100,< 60 丢弃)")
scored = []
for t in cleaned:
score, why = 100.0, []
# ① 有效性:长度
if len(t.content) < 10:
score -= 30; why.append("①短 -30")
# ② 相关性
sim = float(cosine_similarity(
[EMBED_MODEL.encode(latest_input)],
[EMBED_MODEL.encode(t.content)]
)[0][0])
if sim < TOPIC_SIM_THRESHOLD:
score -= 25; why.append(f"②跑题 -25(sim={sim:.2f})")
else:
why.append(f"②相关 sim={sim:.2f}")
# ③ 合规
hit_bad = [w for w in SessionPurifier.BAD_WORDS if w in t.content]
if hit_bad:
score -= 40; why.append(f"③违规 -40({hit_bad[0]})")
# ④ 兜底句
hit_fb = [m for m in SessionPurifier.FALLBACK_MARKS if m in t.content]
if hit_fb:
score -= 35; why.append(f"④兜底 -35({hit_fb[0]})")
t.dirty_score = max(0, score)
keep = t.dirty_score >= DIRTY_SCORE_THRESHOLD
scored.append((t, keep))
flag = "✅ 留" if keep else "❌ 丢"
print(f" [{t.role:<9}] score={t.dirty_score:>5.0f} {flag} {t.content!r:34s} [{' | '.join(why)}]")
valid = [t for t, k in scored if k]
print(f"\n → 过脏后剩 {len(valid)} 轮 / 丢 {len(scored)-len(valid)} 轮")
# ───── Step 3 ─────
banner("Step 3 · 话题聚类(只留与最后一轮同话题)")
if len(valid) > 1:
embeds = [EMBED_MODEL.encode(t.content) for t in valid]
labels = KMeans(n_clusters=min(3, len(valid)), random_state=42, n_init=10).fit_predict(embeds)
for t, lab in zip(valid, labels):
print(f" [{t.role:<9}] cluster={lab} {t.content!r}")
current_topic = [valid[i] for i, lab in enumerate(labels) if lab == labels[-1]]
else:
labels = [0] * len(valid)
current_topic = valid
for t in valid:
print(f" [{t.role:<9}] cluster=0 {t.content!r}")
print(f"\n → 最后一轮 label={labels[-1]},同簇保留 {len(current_topic)} 轮")
# ───── Step 4 ─────
banner("Step 4 · 时间排序 + token 截断(不超 2048)")
sorted_h = sorted(current_topic, key=lambda x: x.timestamp)
total, final = 0, []
for t in sorted_h:
cnt = TokenCleaner.count_token(t.content)
if total + cnt <= MAX_CONTEXT_TOKEN:
final.append(t); total += cnt
print(f" ✅ [{t.role:<9}] +{cnt:>3}tok 累计{total:>4}/{MAX_CONTEXT_TOKEN} {t.content!r}")
else:
print(f" ❌ [{t.role:<9}] +{cnt:>3}tok 超预算停")
break
# ───── 汇总 ─────
banner("送进 prompt 的最终上下文")
for t in final:
print(f" [{t.role:<9}] score={t.dirty_score:.0f} {t.content}")
print(f"\n 漏斗:原始 {len(test_chat)} → 清洗 {len(cleaned)} → 过脏 {len(valid)} "
f"→ 聚类 {len(current_topic)} → 最终 {len(final)} 轮")
print(f" 最终 token:{sum(TokenCleaner.count_token(t.content) for t in final)} / {MAX_CONTEXT_TOKEN}")
# ───── Step 5 · 混元实调:清洗后的上下文直接喂给大模型 ─────
if final:
banner("Step 5 · 混元实调(清洗后上下文 → 正式回答)")
ctx = "\n".join(f"[{t.role}] {t.content}" for t in final)
prompt = f"历史对话:\n{ctx}\n\n用户当前问题:{latest_input}"
try:
answer = llm_invoke(
prompt,
system_prompt="你是企业的智能助手,请根据上下文准确回答用户问题。",
)
print(" 混元回答:")
for line in (answer or "").splitlines():
print(" " + line)
except Exception as e:
print(f" [warn] 混元调用失败(不影响清洗演示):{type(e).__name__}: {e}")
# ───── Step 6 ·(可选)LLM 智能精简层演示 ─────
banner("Step 6 · LLM 智能精简(混元改写啰嗦轮次)")
before_tok = sum(TokenCleaner.count_token(t.content) for t in final)
refined = LLMRefiner.compress_history(final)
after_tok = sum(TokenCleaner.count_token(t.content) for t in refined)
for t in refined:
print(f" [{t.role:<9}] {t.content!r}")
print(f"\n 精简效果:{before_tok} → {after_tok} tok(省 {before_tok - after_tok})")代码说明:
运行输出
Downloading Model from modelscope to directory: D:\modelscope\hub\sentence-transformers\all-MiniLM-L6-v2 ================================================================ Step 1 · 文本清洗(去重/去无效字符) ================================================================ [user ] ' 帮我写一个营销文案\n\n\n' → '帮我写一个营销文案' [assistant] '下面给你文案。下面给你文案。' → '下面给你文案。下面给你文案。' [user ] '乱码测试,随便灌水闲聊' → '乱码测试,随便灌水闲聊' [assistant] '我不知道你在说什么。' → '我不知道你在说什么。' [assistant] '好的,我来帮你写产品使用手册。写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。' → '好的,我来帮你写产品使用手册。写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。' [user ] '现在帮我写一份产品使用手册' → '现在帮我写一份产品使用手册' ================================================================ Step 2 · 四维度脏度打分(满 100,< 60 丢弃) ================================================================ [user ] score= 70 ✅ 留 '帮我写一个营销文案' [①短 -30 | ②相关 sim=0.78] [assistant] score= 100 ✅ 留 '下面给你文案。下面给你文案。' [②相关 sim=0.33] [user ] score= 60 ✅ 留 '乱码测试,随便灌水闲聊' [②相关 sim=0.50 | ③违规 -40(乱码测试)] [assistant] score= 65 ✅ 留 '我不知道你在说什么。' [②相关 sim=0.68 | ④兜底 -35(我不知道)] [assistant] score= 100 ✅ 留 '好的,我来帮你写产品使用手册。写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。' [②相关 sim=0.70] [user ] score= 100 ✅ 留 '现在帮我写一份产品使用手册' [②相关 sim=1.00] → 过脏后剩 6 轮 / 丢 0 轮 ================================================================ Step 3 · 话题聚类(只留与最后一轮同话题) ================================================================ [user ] cluster=0 '帮我写一个营销文案' [assistant] cluster=2 '下面给你文案。下面给你文案。' [user ] cluster=1 '乱码测试,随便灌水闲聊' [assistant] cluster=0 '我不知道你在说什么。' [assistant] cluster=0 '好的,我来帮你写产品使用手册。写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。' [user ] cluster=0 '现在帮我写一份产品使用手册' → 最后一轮 label=0,同簇保留 4 轮 ================================================================ Step 4 · 时间排序 + token 截断(不超 2048) ================================================================ ✅ [user ] + 10tok 累计 10/2048 '帮我写一个营销文案' ✅ [assistant] + 11tok 累计 21/2048 '我不知道你在说什么。' ✅ [assistant] + 70tok 累计 91/2048 '好的,我来帮你写产品使用手册。写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。' ✅ [user ] + 12tok 累计 103/2048 '现在帮我写一份产品使用手册' ================================================================ 送进 prompt 的最终上下文 ================================================================ [user ] score=70 帮我写一个营销文案 [assistant] score=65 我不知道你在说什么。 [assistant] score=100 好的,我来帮你写产品使用手册。写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。 [user ] score=100 现在帮我写一份产品使用手册 漏斗:原始 6 → 清洗 6 → 过脏 6 → 聚类 4 → 最终 4 轮 最终 token:103 / 2048 ================================================================ Step 5 · 混元实调(清洗后上下文 → 正式回答) ================================================================ 混元回答: 根据历史对话中已有的信息,之前助手提到:“写产品使用手册要先明确产品定位,写产品使用手册还要梳理核心功能,写产品使用手册最后要组织章节结构,这样写产品使用手册才完整。” 由于您当前仅说“现在帮我写一份产品使用手册”,但未提供具体产品名称、定位、核心功能等细节,按照上述方法,一份完整产品使用手册的通用编写框架如下: 1. **明确产品定位** 说明产品是什么、面向哪些用户、解决什么需求(需您补充具体产品信息)。 2. **梳理核心功能** 列出产品的主要功能和用途(需您补充具体功能点)。 3. **组织章节结构** 通常包含: - 产品简介 - 安装与注册 - 功能详解 - 常见问题 - 联系方式 请您提供产品的具体名称、定位及核心功能,我可以据此为您撰写一份完整的产品使用手册。 ================================================================ Step 6 · LLM 智能精简(混元改写啰嗦轮次) ================================================================ [llm-refine] 70 → 34 tok(省 36) [user ] '帮我写一个营销文案' [assistant] '我不知道你在说什么。' [assistant] '写产品使用手册需:明确产品定位,梳理核心功能,组织章节结构,以保完整。' [user ] '现在帮我写一份产品使用手册' 精简效果:103 → 67 tok(省 36)
大模型推理性能衰退、输出不稳定、响应慢、成本高的核心隐性元凶,就是三类容易被忽略的脏数据:上下文冗余、历史脏会话、无效Token。不同于训练阶段的数据集优化、模型参数调优、提示词工程优化,推理脏数据治理是大模型落地运维中最基础、最高效、最低成本的优化手段,也是绝大多数新手和企业容易遗漏的关键环节。
在性能层面,彻底解决脏数据引发的注意力偏移、逻辑异化、窗口挤占问题,大幅提升大模型推理精准度、逻辑连贯性和稳定性,杜绝模型越用越笨的问题;在效率层面,大幅减少无效算力消耗,降低推理延迟,提升接口响应速度,优化用户交互体验;在成本层面,有效精简无效Token数量,降低大模型接口调用计费和服务器算力成本,为企业降本增效。
未来大模型的应用是精细化运维、数据质量、推理稳定性的适配。做好推理脏数据全自动清洗,是大模型长效稳定落地的基础保障,也是从源头解决大模型推理污染难题,让大模型始终保持高效、精准、稳定的输出状态,最大化发挥大模型的业务价值。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。