Files
AgentLab/backend/app/chat/questions.py
T
ThearchyHelios d0082b4645 问题聚类的向量只取一次:评测页「口径命中与重复度」不再按窗口把问题重发给向量模型(复核 W4R-14)
为什么:这个页签一次打开,/api/evals/signals 按窗口调 compute_stats(缺省 6 个窗口,每个都聚一次问题),页面另调
/api/ledger/stats,一共聚 8 遍;chat/questions.cluster_questions 每遍都把窗口里的问题原文整批发给 embed_texts,
一次里重复的问法也照发。配了远程向量模型时每打开一次就是几百到几千次向量调用,慢、花钱。复现:本地 3 句问题各问 3 次,
一次打开每句被取了 9 次向量。

做法(改在全站唯一的取问题、聚类处 app/chat/questions.py,不动 ledger/stats 的统计口径):
- 问题原文 → 向量在进程里留一份(_vectors,最多 VECTOR_CACHE_MAX=1000 句、最近用到的留着),同一句话只取一次,
  一次里重复的问法去重后只发一句;/signals、/ledger/stats、认证队列、治理页的探索问题聚类都走它;
- 缓存认「哪一个 embedder、哪一个取向量的函数」算的:设置页换了向量模型(configure 换了对象)整份丢掉,不把两个
  向量空间的坐标混着比;取的这一会儿换了的,这一批照用、不留;
- 取向量按事件循环串行(每个循环一把锁,同项目里别处的写法):页面并行取的两个接口不把同一批问题各发一遍。

测试:test_evals_ui_api 新增「一次打开每句问题只取一次向量、再打开一次都不取、两个接口并行也一样」;
新文件 tests/test_question_vectors.py(去重、换模型丢缓存、取到一半换模型、上限与最近使用、并行只发一批)。
去掉缓存回跑:每句 9 次;去掉换模型的核对:2 条失败;去掉共用的锁:并行那条失败。
2026-10-16 21:41:30 +08:00

180 lines
9.0 KiB
Python

"""问过的问题和它们的聚类:全站只有这一份(docs/design/next-round/00-总方案.md X2)。
同一个问题被反复问,就该长成模板里的固定一节、沉淀成口径——探索问题聚类(/governance/exploratory-clusters)、以后口径
账本的「可沉淀的问题」、评测的问题重复度(E3)量的都是这件事,各算一份的话几个数对不上,所以取问题和聚类只写在这里。
**取什么。** 只取问题原文,不取整份输入:以前把运行的整份 input(含 history)拿去聚,同一段对话里前几轮的问答会把不同的
问题聚成一类,重复度偏高。
- 问数据:一轮一条(conversation_turns.question,用户原本问的那句话)。同一轮里的自动重来、用户点的「重试」只是换了这一轮
挂着的运行,不多出一条——按运行数的话,答坏了自动重来一次就被算成问了两遍。没挂运行的轮次(只回了一句、助手反问)
也算:问题照样被问过。
- 别的探索运行(画布试跑、蓝图试运行、接口……):输入里有 question 这个字段的取它;没有的不收(输入里别的字段不是问题)。
问数据的运行由上面一轮一条代表,这里不再数。
**不收什么。** 系统派生的运行(评测、口径对账、口径召回:engine/origin.counted_runs)不收,评测题不能把聚类刷高;
这个人读不了的只给拥有者的运行(auth/access.hidden_runs)不收;正式运行不收(探索才谈得上「沉淀」)。
聚类用 memory/embeddings 的向量贪心聚:按时间从新到旧,和某一类的种子足够像就并进去,否则自立一类。本地向量是词频
哈希、语义能力弱,结果是下限——调用方据 embedder 照实写明用的是哪个向量模型。
**向量只取一次。** 同一批问题会被聚很多遍:评测页「口径命中与重复度」一次打开,/api/evals/signals 按窗口调 compute_stats
(缺省 6 个窗口,每个都聚一次),页面另调 /api/ledger/stats;认证队列、治理页的探索问题聚类也各聚一遍。配了远程向量模型时
每聚一遍都把几百句问题重新发一次,页面慢、还花钱。所以问题原文 → 向量在进程里留一份(_vectors:最多 VECTOR_CACHE_MAX 句,
最近用到的留着),同一句话只取一次;一次里重复的问法(聚类量的正是这个)也只发一句。缓存认的是「哪一个 embedder、哪一个取向量
的函数」算的:设置页换了向量模型(memory/embeddings.configure 换了对象)就整份丢掉,不把两个向量空间的坐标混着比。取向量按事件
循环串行:页面并行取的两个接口不会把同一批问题各发一遍。
"""
from __future__ import annotations
import asyncio
import weakref
from collections import OrderedDict
from collections.abc import Sequence
from dataclasses import dataclass, field
from datetime import datetime
from typing import Any
from sqlalchemy import func, not_, select
from sqlalchemy.ext.asyncio import AsyncSession
#: 缺省的相似度阈值(同治理接口一直以来的 0.62)
DEFAULT_THRESHOLD = 0.62
#: 进程里最多留几句问题的向量:取问题的地方一次最多 500 句(ledger/stats、治理接口的上限),留两批的量,窗口来回切不用重取
VECTOR_CACHE_MAX = 1000
@dataclass(frozen=True)
class Question:
"""问过的一个问题。turn_id 是问数据的那一轮(别的探索运行没有);run_id 是它挂着的运行(只回了一句的轮次没有)。"""
text: str
at: datetime | None
run_id: str | None = None
turn_id: str | None = None
workflow: str | None = None
origin: str | None = None
@dataclass
class QuestionCluster:
"""一类问题:members 按时间从新到旧,第一个是种子。"""
members: list[Question] = field(default_factory=list)
@property
def count(self) -> int:
return len(self.members)
async def recent_questions(session: AsyncSession, principal: Any, *, limit: int) -> list[Question]:
"""最近问过的问题,从新到旧,最多 limit 条(取法见模块开头)。principal 用来去掉这个人读不了的只给拥有者的运行。"""
from app.auth.access import hidden_runs
from app.db.models import Conversation, ConversationTurn, Run
from app.engine.origin import counted_runs
hidden = hidden_runs(principal)
turns = (await session.execute(
select(ConversationTurn.id, ConversationTurn.question, ConversationTurn.created_at, ConversationTurn.run_id,
Run.workflow_name)
.join(Conversation, Conversation.id == ConversationTurn.conversation_id)
.outerjoin(Run, Run.id == ConversationTurn.run_id)
.where(Conversation.kind == "chat", func.trim(ConversationTurn.question) != "", counted_runs(), not_(hidden))
.order_by(ConversationTurn.created_at.desc()).limit(limit)
)).all()
runs = (await session.execute(
select(Run.id, Run.input, Run.workflow_name, Run.created_at, Run.origin_kind)
.where(Run.run_class != "formal", func.coalesce(Run.origin_kind, "") != "chat", counted_runs(), not_(hidden),
func.json_type(Run.input, "$.question") == "text")
.order_by(Run.created_at.desc()).limit(limit)
)).all()
out = [Question(text=question.strip(), at=at, run_id=run_id, turn_id=turn_id, workflow=workflow, origin="chat")
for turn_id, question, at, run_id, workflow in turns]
for run_id, payload, workflow, at, origin in runs:
text = (payload or {}).get("question") if isinstance(payload, dict) else None
if isinstance(text, str) and text.strip():
out.append(Question(text=text.strip(), at=at, run_id=run_id, workflow=workflow, origin=origin))
out.sort(key=lambda q: q.at.timestamp() if q.at is not None else 0.0, reverse=True)
return out[:limit]
#: 问题原文 → 向量(最近用到的在后)和它们是谁算的(见模块说明「向量只取一次」)
_VECTORS: "OrderedDict[str, Any]" = OrderedDict()
_VECTORS_OF: tuple[Any, Any] | None = None
_VECTOR_LOCKS: "weakref.WeakKeyDictionary[asyncio.AbstractEventLoop, asyncio.Lock]" = weakref.WeakKeyDictionary()
def _vector_lock() -> asyncio.Lock:
"""取向量的锁,按事件循环各一把(asyncio.Lock 不能跨循环用)。"""
loop = asyncio.get_running_loop()
lock = _VECTOR_LOCKS.get(loop)
if lock is None:
lock = _VECTOR_LOCKS[loop] = asyncio.Lock()
return lock
def _owner() -> tuple[Any, Any]:
from app.memory import embeddings
return embeddings.get_embedder(), embeddings.embed_texts
def _same_owner(a: tuple[Any, Any] | None, b: tuple[Any, Any]) -> bool:
return a is not None and a[0] is b[0] and a[1] is b[1]
async def _vectors(texts: Sequence[str]) -> list[Any]:
"""这些问题的向量(顺序同 texts):进程里有的直接用,没有的去重后一次取齐、留下来。"""
global _VECTORS_OF
async with _vector_lock():
owner = _owner()
if not _same_owner(_VECTORS_OF, owner):
_VECTORS.clear()
_VECTORS_OF = owner
got = {t: _VECTORS[t] for t in texts if t in _VECTORS}
missing = [t for t in dict.fromkeys(texts) if t not in got]
if missing:
fresh = await owner[1](missing)
got.update(zip(missing, fresh))
# 取的这一会儿设置页换了向量模型:这一批照用(同一次聚类里坐标是一致的),不留给下一次
if not _same_owner(_VECTORS_OF, _owner()):
return [got[t] for t in texts]
for t in missing:
_VECTORS[t] = got[t]
for t in dict.fromkeys(texts):
_VECTORS.move_to_end(t)
while len(_VECTORS) > VECTOR_CACHE_MAX:
_VECTORS.popitem(last=False)
return [got[t] for t in texts]
async def cluster_questions(questions: Sequence[Question], *, threshold: float = DEFAULT_THRESHOLD,
) -> list[QuestionCluster]:
"""向量贪心聚类(顺序同 questions:从新到旧)。向量取自 _vectors:同一句话在进程里只取一次。"""
from app.memory import embeddings
if not questions:
return []
vectors = await _vectors([q.text for q in questions])
clusters: list[tuple[int, QuestionCluster]] = []
for i, question in enumerate(questions):
for seed, cluster in clusters:
if embeddings.cosine(vectors[i], vectors[seed]) >= threshold:
cluster.members.append(question)
break
else:
clusters.append((i, QuestionCluster(members=[question])))
return [cluster for _, cluster in clusters]
def embedder() -> str:
"""聚类用的是哪个向量模型(memory/embeddings.embedder_id):本地哈希的结果只是下限,调用方照实写出来。"""
from app.memory import embeddings
return embeddings.embedder_id()
__all__ = ["DEFAULT_THRESHOLD", "VECTOR_CACHE_MAX", "Question", "QuestionCluster", "cluster_questions", "embedder",
"recent_questions"]